← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/row/row0upd.cc

Merged vcol stuff.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/row/row0upd.cc
1
 
/*****************************************************************************
2
 
 
3
 
Copyright (C) 1996, 2010, Innobase Oy. All Rights Reserved.
4
 
 
5
 
This program is free software; you can redistribute it and/or modify it under
6
 
the terms of the GNU General Public License as published by the Free Software
7
 
Foundation; version 2 of the License.
8
 
 
9
 
This program is distributed in the hope that it will be useful, but WITHOUT
10
 
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11
 
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
12
 
 
13
 
You should have received a copy of the GNU General Public License along with
14
 
this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
15
 
St, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
*****************************************************************************/
18
 
 
19
 
/**************************************************//**
20
 
@file row/row0upd.c
21
 
Update of a row
22
 
 
23
 
Created 12/27/1996 Heikki Tuuri
24
 
*******************************************************/
25
 
 
26
 
#include "row0upd.h"
27
 
 
28
 
#ifdef UNIV_NONINL
29
 
#include "row0upd.ic"
30
 
#endif
31
 
 
32
 
#include "dict0dict.h"
33
 
#include "trx0undo.h"
34
 
#include "rem0rec.h"
35
 
#ifndef UNIV_HOTBACKUP
36
 
#include "dict0boot.h"
37
 
#include "dict0crea.h"
38
 
#include "mach0data.h"
39
 
#include "btr0btr.h"
40
 
#include "btr0cur.h"
41
 
#include "que0que.h"
42
 
#include "row0ext.h"
43
 
#include "row0ins.h"
44
 
#include "row0sel.h"
45
 
#include "row0row.h"
46
 
#include "rem0cmp.h"
47
 
#include "lock0lock.h"
48
 
#include "log0log.h"
49
 
#include "pars0sym.h"
50
 
#include "eval0eval.h"
51
 
#include "buf0lru.h"
52
 
 
53
 
 
54
 
/* What kind of latch and lock can we assume when the control comes to
55
 
   -------------------------------------------------------------------
56
 
an update node?
57
 
--------------
58
 
Efficiency of massive updates would require keeping an x-latch on a
59
 
clustered index page through many updates, and not setting an explicit
60
 
x-lock on clustered index records, as they anyway will get an implicit
61
 
x-lock when they are updated. A problem is that the read nodes in the
62
 
graph should know that they must keep the latch when passing the control
63
 
up to the update node, and not set any record lock on the record which
64
 
will be updated. Another problem occurs if the execution is stopped,
65
 
as the kernel switches to another query thread, or the transaction must
66
 
wait for a lock. Then we should be able to release the latch and, maybe,
67
 
acquire an explicit x-lock on the record.
68
 
        Because this seems too complicated, we conclude that the less
69
 
efficient solution of releasing all the latches when the control is
70
 
transferred to another node, and acquiring explicit x-locks, is better. */
71
 
 
72
 
/* How is a delete performed? If there is a delete without an
73
 
explicit cursor, i.e., a searched delete, there are at least
74
 
two different situations:
75
 
the implicit select cursor may run on (1) the clustered index or
76
 
on (2) a secondary index. The delete is performed by setting
77
 
the delete bit in the record and substituting the id of the
78
 
deleting transaction for the original trx id, and substituting a
79
 
new roll ptr for previous roll ptr. The old trx id and roll ptr
80
 
are saved in the undo log record. Thus, no physical changes occur
81
 
in the index tree structure at the time of the delete. Only
82
 
when the undo log is purged, the index records will be physically
83
 
deleted from the index trees.
84
 
 
85
 
The query graph executing a searched delete would consist of
86
 
a delete node which has as a subtree a select subgraph.
87
 
The select subgraph should return a (persistent) cursor
88
 
in the clustered index, placed on page which is x-latched.
89
 
The delete node should look for all secondary index records for
90
 
this clustered index entry and mark them as deleted. When is
91
 
the x-latch freed? The most efficient way for performing a
92
 
searched delete is obviously to keep the x-latch for several
93
 
steps of query graph execution. */
94
 
 
95
 
/*************************************************************************
96
 
IMPORTANT NOTE: Any operation that generates redo MUST check that there
97
 
is enough space in the redo log before for that operation. This is
98
 
done by calling log_free_check(). The reason for checking the
99
 
availability of the redo log space before the start of the operation is
100
 
that we MUST not hold any synchonization objects when performing the
101
 
check.
102
 
If you make a change in this module make sure that no codepath is
103
 
introduced where a call to log_free_check() is bypassed. */
104
 
 
105
 
/*************************************************************************
106
 
IMPORTANT NOTE: Any operation that generates redo MUST check that there
107
 
is enough space in the redo log before for that operation. This is
108
 
done by calling log_free_check(). The reason for checking the
109
 
availability of the redo log space before the start of the operation is
110
 
that we MUST not hold any synchonization objects when performing the
111
 
check.
112
 
If you make a change in this module make sure that no codepath is
113
 
introduced where a call to log_free_check() is bypassed. */
114
 
 
115
 
/***********************************************************//**
116
 
Checks if an update vector changes some of the first ordering fields of an
117
 
index record. This is only used in foreign key checks and we can assume
118
 
that index does not contain column prefixes.
119
 
@return TRUE if changes */
120
 
static
121
 
ibool
122
 
row_upd_changes_first_fields_binary(
123
 
/*================================*/
124
 
        dtuple_t*       entry,  /*!< in: old value of index entry */
125
 
        dict_index_t*   index,  /*!< in: index of entry */
126
 
        const upd_t*    update, /*!< in: update vector for the row */
127
 
        ulint           n);     /*!< in: how many first fields to check */
128
 
 
129
 
 
130
 
/*********************************************************************//**
131
 
Checks if index currently is mentioned as a referenced index in a foreign
132
 
key constraint.
133
 
 
134
 
NOTE that since we do not hold dict_operation_lock when leaving the
135
 
function, it may be that the referencing table has been dropped when
136
 
we leave this function: this function is only for heuristic use!
137
 
 
138
 
@return TRUE if referenced */
139
 
static
140
 
ibool
141
 
row_upd_index_is_referenced(
142
 
/*========================*/
143
 
        dict_index_t*   index,  /*!< in: index */
144
 
        trx_t*          trx)    /*!< in: transaction */
145
 
{
146
 
        dict_table_t*   table           = index->table;
147
 
        dict_foreign_t* foreign;
148
 
        ibool           froze_data_dict = FALSE;
149
 
        ibool           is_referenced   = FALSE;
150
 
 
151
 
        if (!UT_LIST_GET_FIRST(table->referenced_list)) {
152
 
 
153
 
                return(FALSE);
154
 
        }
155
 
 
156
 
        if (trx->dict_operation_lock_mode == 0) {
157
 
                row_mysql_freeze_data_dictionary(trx);
158
 
                froze_data_dict = TRUE;
159
 
        }
160
 
 
161
 
        foreign = UT_LIST_GET_FIRST(table->referenced_list);
162
 
 
163
 
        while (foreign) {
164
 
                if (foreign->referenced_index == index) {
165
 
 
166
 
                        is_referenced = TRUE;
167
 
                        goto func_exit;
168
 
                }
169
 
 
170
 
                foreign = UT_LIST_GET_NEXT(referenced_list, foreign);
171
 
        }
172
 
 
173
 
func_exit:
174
 
        if (froze_data_dict) {
175
 
                row_mysql_unfreeze_data_dictionary(trx);
176
 
        }
177
 
 
178
 
        return(is_referenced);
179
 
}
180
 
 
181
 
/*********************************************************************//**
182
 
Checks if possible foreign key constraints hold after a delete of the record
183
 
under pcur.
184
 
 
185
 
NOTE that this function will temporarily commit mtr and lose the
186
 
pcur position!
187
 
 
188
 
@return DB_SUCCESS or an error code */
189
 
static
190
 
ulint
191
 
row_upd_check_references_constraints(
192
 
/*=================================*/
193
 
        upd_node_t*     node,   /*!< in: row update node */
194
 
        btr_pcur_t*     pcur,   /*!< in: cursor positioned on a record; NOTE: the
195
 
                                cursor position is lost in this function! */
196
 
        dict_table_t*   table,  /*!< in: table in question */
197
 
        dict_index_t*   index,  /*!< in: index of the cursor */
198
 
        ulint*          offsets,/*!< in/out: rec_get_offsets(pcur.rec, index) */
199
 
        que_thr_t*      thr,    /*!< in: query thread */
200
 
        mtr_t*          mtr)    /*!< in: mtr */
201
 
{
202
 
        dict_foreign_t* foreign;
203
 
        mem_heap_t*     heap;
204
 
        dtuple_t*       entry;
205
 
        trx_t*          trx;
206
 
        const rec_t*    rec;
207
 
        ulint           n_ext;
208
 
        ulint           err;
209
 
        ibool           got_s_lock      = FALSE;
210
 
 
211
 
        if (UT_LIST_GET_FIRST(table->referenced_list) == NULL) {
212
 
 
213
 
                return(DB_SUCCESS);
214
 
        }
215
 
 
216
 
        trx = thr_get_trx(thr);
217
 
 
218
 
        rec = btr_pcur_get_rec(pcur);
219
 
        ut_ad(rec_offs_validate(rec, index, offsets));
220
 
 
221
 
        heap = mem_heap_create(500);
222
 
 
223
 
        entry = row_rec_to_index_entry(ROW_COPY_DATA, rec, index, offsets,
224
 
                                       &n_ext, heap);
225
 
 
226
 
        mtr_commit(mtr);
227
 
 
228
 
        mtr_start(mtr);
229
 
 
230
 
        if (trx->dict_operation_lock_mode == 0) {
231
 
                got_s_lock = TRUE;
232
 
 
233
 
                row_mysql_freeze_data_dictionary(trx);
234
 
        }
235
 
 
236
 
        foreign = UT_LIST_GET_FIRST(table->referenced_list);
237
 
 
238
 
        while (foreign) {
239
 
                /* Note that we may have an update which updates the index
240
 
                record, but does NOT update the first fields which are
241
 
                referenced in a foreign key constraint. Then the update does
242
 
                NOT break the constraint. */
243
 
 
244
 
                if (foreign->referenced_index == index
245
 
                    && (node->is_delete
246
 
                        || row_upd_changes_first_fields_binary(
247
 
                                entry, index, node->update,
248
 
                                foreign->n_fields))) {
249
 
 
250
 
                        if (foreign->foreign_table == NULL) {
251
 
                                dict_table_get(foreign->foreign_table_name,
252
 
                                               FALSE);
253
 
                        }
254
 
 
255
 
                        if (foreign->foreign_table) {
256
 
                                mutex_enter(&(dict_sys->mutex));
257
 
 
258
 
                                (foreign->foreign_table
259
 
                                 ->n_foreign_key_checks_running)++;
260
 
 
261
 
                                mutex_exit(&(dict_sys->mutex));
262
 
                        }
263
 
 
264
 
                        /* NOTE that if the thread ends up waiting for a lock
265
 
                        we will release dict_operation_lock temporarily!
266
 
                        But the counter on the table protects 'foreign' from
267
 
                        being dropped while the check is running. */
268
 
 
269
 
                        err = row_ins_check_foreign_constraint(
270
 
                                FALSE, foreign, table, entry, thr);
271
 
 
272
 
                        if (foreign->foreign_table) {
273
 
                                mutex_enter(&(dict_sys->mutex));
274
 
 
275
 
                                ut_a(foreign->foreign_table
276
 
                                     ->n_foreign_key_checks_running > 0);
277
 
 
278
 
                                (foreign->foreign_table
279
 
                                 ->n_foreign_key_checks_running)--;
280
 
 
281
 
                                mutex_exit(&(dict_sys->mutex));
282
 
                        }
283
 
 
284
 
                        if (err != DB_SUCCESS) {
285
 
 
286
 
                                goto func_exit;
287
 
                        }
288
 
                }
289
 
 
290
 
                foreign = UT_LIST_GET_NEXT(referenced_list, foreign);
291
 
        }
292
 
 
293
 
        err = DB_SUCCESS;
294
 
 
295
 
func_exit:
296
 
        if (got_s_lock) {
297
 
                row_mysql_unfreeze_data_dictionary(trx);
298
 
        }
299
 
 
300
 
        mem_heap_free(heap);
301
 
 
302
 
        return(err);
303
 
}
304
 
 
305
 
/*********************************************************************//**
306
 
Creates an update node for a query graph.
307
 
@return own: update node */
308
 
UNIV_INTERN
309
 
upd_node_t*
310
 
upd_node_create(
311
 
/*============*/
312
 
        mem_heap_t*     heap)   /*!< in: mem heap where created */
313
 
{
314
 
        upd_node_t*     node;
315
 
 
316
 
        node = static_cast<upd_node_t *>(mem_heap_alloc(heap, sizeof(upd_node_t)));
317
 
        node->common.type = QUE_NODE_UPDATE;
318
 
 
319
 
        node->state = UPD_NODE_UPDATE_CLUSTERED;
320
 
        node->in_mysql_interface = FALSE;
321
 
 
322
 
        node->row = NULL;
323
 
        node->ext = NULL;
324
 
        node->upd_row = NULL;
325
 
        node->upd_ext = NULL;
326
 
        node->index = NULL;
327
 
        node->update = NULL;
328
 
 
329
 
        node->foreign = NULL;
330
 
        node->cascade_heap = NULL;
331
 
        node->cascade_node = NULL;
332
 
 
333
 
        node->select = NULL;
334
 
 
335
 
        node->heap = mem_heap_create(128);
336
 
        node->magic_n = UPD_NODE_MAGIC_N;
337
 
 
338
 
        node->cmpl_info = 0;
339
 
 
340
 
        return(node);
341
 
}
342
 
#endif /* !UNIV_HOTBACKUP */
343
 
 
344
 
/*********************************************************************//**
345
 
Updates the trx id and roll ptr field in a clustered index record in database
346
 
recovery. */
347
 
UNIV_INTERN
348
 
void
349
 
row_upd_rec_sys_fields_in_recovery(
350
 
/*===============================*/
351
 
        rec_t*          rec,    /*!< in/out: record */
352
 
        page_zip_des_t* page_zip,/*!< in/out: compressed page, or NULL */
353
 
        const ulint*    offsets,/*!< in: array returned by rec_get_offsets() */
354
 
        ulint           pos,    /*!< in: TRX_ID position in rec */
355
 
        trx_id_t        trx_id, /*!< in: transaction id */
356
 
        roll_ptr_t      roll_ptr)/*!< in: roll ptr of the undo log record */
357
 
{
358
 
        ut_ad(rec_offs_validate(rec, NULL, offsets));
359
 
 
360
 
        if (UNIV_LIKELY_NULL(page_zip)) {
361
 
                page_zip_write_trx_id_and_roll_ptr(
362
 
                        page_zip, rec, offsets, pos, trx_id, roll_ptr);
363
 
        } else {
364
 
                byte*   field;
365
 
                ulint   len;
366
 
 
367
 
                field = rec_get_nth_field(rec, offsets, pos, &len);
368
 
                ut_ad(len == DATA_TRX_ID_LEN);
369
 
#if DATA_TRX_ID + 1 != DATA_ROLL_PTR
370
 
# error "DATA_TRX_ID + 1 != DATA_ROLL_PTR"
371
 
#endif
372
 
                trx_write_trx_id(field, trx_id);
373
 
                trx_write_roll_ptr(field + DATA_TRX_ID_LEN, roll_ptr);
374
 
        }
375
 
}
376
 
 
377
 
#ifndef UNIV_HOTBACKUP
378
 
/*********************************************************************//**
379
 
Sets the trx id or roll ptr field of a clustered index entry. */
380
 
UNIV_INTERN
381
 
void
382
 
row_upd_index_entry_sys_field(
383
 
/*==========================*/
384
 
        dtuple_t*       entry,  /*!< in/out: index entry, where the memory
385
 
                                buffers for sys fields are already allocated:
386
 
                                the function just copies the new values to
387
 
                                them */
388
 
        dict_index_t*   index,  /*!< in: clustered index */
389
 
        ulint           type,   /*!< in: DATA_TRX_ID or DATA_ROLL_PTR */
390
 
        ib_uint64_t     val)    /*!< in: value to write */
391
 
{
392
 
        dfield_t*       dfield;
393
 
        byte*           field;
394
 
        ulint           pos;
395
 
 
396
 
        ut_ad(dict_index_is_clust(index));
397
 
 
398
 
        pos = dict_index_get_sys_col_pos(index, type);
399
 
 
400
 
        dfield = dtuple_get_nth_field(entry, pos);
401
 
        field = static_cast<byte *>(dfield_get_data(dfield));
402
 
 
403
 
        if (type == DATA_TRX_ID) {
404
 
                trx_write_trx_id(field, val);
405
 
        } else {
406
 
                ut_ad(type == DATA_ROLL_PTR);
407
 
                trx_write_roll_ptr(field, val);
408
 
        }
409
 
}
410
 
 
411
 
/***********************************************************//**
412
 
Returns TRUE if row update changes size of some field in index or if some
413
 
field to be updated is stored externally in rec or update.
414
 
@return TRUE if the update changes the size of some field in index or
415
 
the field is external in rec or update */
416
 
UNIV_INTERN
417
 
ibool
418
 
row_upd_changes_field_size_or_external(
419
 
/*===================================*/
420
 
        dict_index_t*   index,  /*!< in: index */
421
 
        const ulint*    offsets,/*!< in: rec_get_offsets(rec, index) */
422
 
        const upd_t*    update) /*!< in: update vector */
423
 
{
424
 
        const upd_field_t*      upd_field;
425
 
        const dfield_t*         new_val;
426
 
        ulint                   old_len;
427
 
        ulint                   new_len;
428
 
        ulint                   n_fields;
429
 
        ulint                   i;
430
 
 
431
 
        ut_ad(rec_offs_validate(NULL, index, offsets));
432
 
        n_fields = upd_get_n_fields(update);
433
 
 
434
 
        for (i = 0; i < n_fields; i++) {
435
 
                upd_field = upd_get_nth_field(update, i);
436
 
 
437
 
                new_val = &(upd_field->new_val);
438
 
                new_len = dfield_get_len(new_val);
439
 
 
440
 
                if (dfield_is_null(new_val) && !rec_offs_comp(offsets)) {
441
 
                        /* A bug fixed on Dec 31st, 2004: we looked at the
442
 
                        SQL NULL size from the wrong field! We may backport
443
 
                        this fix also to 4.0. The merge to 5.0 will be made
444
 
                        manually immediately after we commit this to 4.1. */
445
 
 
446
 
                        new_len = dict_col_get_sql_null_size(
447
 
                                dict_index_get_nth_col(index,
448
 
                                                       upd_field->field_no),
449
 
                                0);
450
 
                }
451
 
 
452
 
                old_len = rec_offs_nth_size(offsets, upd_field->field_no);
453
 
 
454
 
                if (rec_offs_comp(offsets)
455
 
                    && rec_offs_nth_sql_null(offsets,
456
 
                                             upd_field->field_no)) {
457
 
                        /* Note that in the compact table format, for a
458
 
                        variable length field, an SQL NULL will use zero
459
 
                        bytes in the offset array at the start of the physical
460
 
                        record, but a zero-length value (empty string) will
461
 
                        use one byte! Thus, we cannot use update-in-place
462
 
                        if we update an SQL NULL varchar to an empty string! */
463
 
 
464
 
                        old_len = UNIV_SQL_NULL;
465
 
                }
466
 
 
467
 
                if (dfield_is_ext(new_val) || old_len != new_len
468
 
                    || rec_offs_nth_extern(offsets, upd_field->field_no)) {
469
 
 
470
 
                        return(TRUE);
471
 
                }
472
 
        }
473
 
 
474
 
        return(FALSE);
475
 
}
476
 
#endif /* !UNIV_HOTBACKUP */
477
 
 
478
 
/***********************************************************//**
479
 
Replaces the new column values stored in the update vector to the
480
 
record given. No field size changes are allowed. This function is
481
 
usually invoked on a clustered index. The only use case for a
482
 
secondary index is row_ins_sec_index_entry_by_modify() or its
483
 
counterpart in ibuf_insert_to_index_page(). */
484
 
UNIV_INTERN
485
 
void
486
 
row_upd_rec_in_place(
487
 
/*=================*/
488
 
        rec_t*          rec,    /*!< in/out: record where replaced */
489
 
        dict_index_t*   index,  /*!< in: the index the record belongs to */
490
 
        const ulint*    offsets,/*!< in: array returned by rec_get_offsets() */
491
 
        const upd_t*    update, /*!< in: update vector */
492
 
        page_zip_des_t* page_zip)/*!< in: compressed page with enough space
493
 
                                available, or NULL */
494
 
{
495
 
        const upd_field_t*      upd_field;
496
 
        const dfield_t*         new_val;
497
 
        ulint                   n_fields;
498
 
        ulint                   i;
499
 
 
500
 
        ut_ad(rec_offs_validate(rec, index, offsets));
501
 
 
502
 
        if (rec_offs_comp(offsets)) {
503
 
                rec_set_info_bits_new(rec, update->info_bits);
504
 
        } else {
505
 
                rec_set_info_bits_old(rec, update->info_bits);
506
 
        }
507
 
 
508
 
        n_fields = upd_get_n_fields(update);
509
 
 
510
 
        for (i = 0; i < n_fields; i++) {
511
 
                upd_field = upd_get_nth_field(update, i);
512
 
                new_val = &(upd_field->new_val);
513
 
                ut_ad(!dfield_is_ext(new_val) ==
514
 
                      !rec_offs_nth_extern(offsets, upd_field->field_no));
515
 
 
516
 
                rec_set_nth_field(rec, offsets, upd_field->field_no,
517
 
                                  dfield_get_data(new_val),
518
 
                                  dfield_get_len(new_val));
519
 
        }
520
 
 
521
 
        if (UNIV_LIKELY_NULL(page_zip)) {
522
 
                page_zip_write_rec(page_zip, rec, index, offsets, 0);
523
 
        }
524
 
}
525
 
 
526
 
#ifndef UNIV_HOTBACKUP
527
 
/*********************************************************************//**
528
 
Writes into the redo log the values of trx id and roll ptr and enough info
529
 
to determine their positions within a clustered index record.
530
 
@return new pointer to mlog */
531
 
UNIV_INTERN
532
 
byte*
533
 
row_upd_write_sys_vals_to_log(
534
 
/*==========================*/
535
 
        dict_index_t*   index,  /*!< in: clustered index */
536
 
        trx_t*          trx,    /*!< in: transaction */
537
 
        roll_ptr_t      roll_ptr,/*!< in: roll ptr of the undo log record */
538
 
        byte*           log_ptr,/*!< pointer to a buffer of size > 20 opened
539
 
                                in mlog */
540
 
        mtr_t*          /*mtr __attribute__((unused))*/) /*!< in: mtr */
541
 
{
542
 
        ut_ad(dict_index_is_clust(index));
543
 
        ut_ad(mtr);
544
 
 
545
 
        log_ptr += mach_write_compressed(log_ptr,
546
 
                                         dict_index_get_sys_col_pos(
547
 
                                                 index, DATA_TRX_ID));
548
 
 
549
 
        trx_write_roll_ptr(log_ptr, roll_ptr);
550
 
        log_ptr += DATA_ROLL_PTR_LEN;
551
 
 
552
 
        log_ptr += mach_ull_write_compressed(log_ptr, trx->id);
553
 
 
554
 
        return(log_ptr);
555
 
}
556
 
#endif /* !UNIV_HOTBACKUP */
557
 
 
558
 
/*********************************************************************//**
559
 
Parses the log data of system field values.
560
 
@return log data end or NULL */
561
 
UNIV_INTERN
562
 
byte*
563
 
row_upd_parse_sys_vals(
564
 
/*===================*/
565
 
        byte*           ptr,    /*!< in: buffer */
566
 
        byte*           end_ptr,/*!< in: buffer end */
567
 
        ulint*          pos,    /*!< out: TRX_ID position in record */
568
 
        trx_id_t*       trx_id, /*!< out: trx id */
569
 
        roll_ptr_t*     roll_ptr)/*!< out: roll ptr */
570
 
{
571
 
        ptr = mach_parse_compressed(ptr, end_ptr, pos);
572
 
 
573
 
        if (ptr == NULL) {
574
 
 
575
 
                return(NULL);
576
 
        }
577
 
 
578
 
        if (end_ptr < ptr + DATA_ROLL_PTR_LEN) {
579
 
 
580
 
                return(NULL);
581
 
        }
582
 
 
583
 
        *roll_ptr = trx_read_roll_ptr(ptr);
584
 
        ptr += DATA_ROLL_PTR_LEN;
585
 
 
586
 
        ptr = mach_ull_parse_compressed(ptr, end_ptr, trx_id);
587
 
 
588
 
        return(ptr);
589
 
}
590
 
 
591
 
#ifndef UNIV_HOTBACKUP
592
 
/***********************************************************//**
593
 
Writes to the redo log the new values of the fields occurring in the index. */
594
 
UNIV_INTERN
595
 
void
596
 
row_upd_index_write_log(
597
 
/*====================*/
598
 
        const upd_t*    update, /*!< in: update vector */
599
 
        byte*           log_ptr,/*!< in: pointer to mlog buffer: must
600
 
                                contain at least MLOG_BUF_MARGIN bytes
601
 
                                of free space; the buffer is closed
602
 
                                within this function */
603
 
        mtr_t*          mtr)    /*!< in: mtr into whose log to write */
604
 
{
605
 
        const upd_field_t*      upd_field;
606
 
        const dfield_t*         new_val;
607
 
        ulint                   len;
608
 
        ulint                   n_fields;
609
 
        byte*                   buf_end;
610
 
        ulint                   i;
611
 
 
612
 
        n_fields = upd_get_n_fields(update);
613
 
 
614
 
        buf_end = log_ptr + MLOG_BUF_MARGIN;
615
 
 
616
 
        mach_write_to_1(log_ptr, update->info_bits);
617
 
        log_ptr++;
618
 
        log_ptr += mach_write_compressed(log_ptr, n_fields);
619
 
 
620
 
        for (i = 0; i < n_fields; i++) {
621
 
 
622
 
#if MLOG_BUF_MARGIN <= 30
623
 
# error "MLOG_BUF_MARGIN <= 30"
624
 
#endif
625
 
 
626
 
                if (log_ptr + 30 > buf_end) {
627
 
                        mlog_close(mtr, log_ptr);
628
 
 
629
 
                        log_ptr = mlog_open(mtr, MLOG_BUF_MARGIN);
630
 
                        buf_end = log_ptr + MLOG_BUF_MARGIN;
631
 
                }
632
 
 
633
 
                upd_field = upd_get_nth_field(update, i);
634
 
 
635
 
                new_val = &(upd_field->new_val);
636
 
 
637
 
                len = dfield_get_len(new_val);
638
 
 
639
 
                log_ptr += mach_write_compressed(log_ptr, upd_field->field_no);
640
 
                log_ptr += mach_write_compressed(log_ptr, len);
641
 
 
642
 
                if (len != UNIV_SQL_NULL) {
643
 
                        if (log_ptr + len < buf_end) {
644
 
                                memcpy(log_ptr, dfield_get_data(new_val), len);
645
 
 
646
 
                                log_ptr += len;
647
 
                        } else {
648
 
                                mlog_close(mtr, log_ptr);
649
 
 
650
 
                                mlog_catenate_string(mtr,
651
 
                                                     static_cast<byte *>(dfield_get_data(new_val)),
652
 
                                                     len);
653
 
 
654
 
                                log_ptr = mlog_open(mtr, MLOG_BUF_MARGIN);
655
 
                                buf_end = log_ptr + MLOG_BUF_MARGIN;
656
 
                        }
657
 
                }
658
 
        }
659
 
 
660
 
        mlog_close(mtr, log_ptr);
661
 
}
662
 
#endif /* !UNIV_HOTBACKUP */
663
 
 
664
 
/*********************************************************************//**
665
 
Parses the log data written by row_upd_index_write_log.
666
 
@return log data end or NULL */
667
 
UNIV_INTERN
668
 
byte*
669
 
row_upd_index_parse(
670
 
/*================*/
671
 
        byte*           ptr,    /*!< in: buffer */
672
 
        byte*           end_ptr,/*!< in: buffer end */
673
 
        mem_heap_t*     heap,   /*!< in: memory heap where update vector is
674
 
                                built */
675
 
        upd_t**         update_out)/*!< out: update vector */
676
 
{
677
 
        upd_t*          update;
678
 
        upd_field_t*    upd_field;
679
 
        dfield_t*       new_val;
680
 
        ulint           len;
681
 
        ulint           n_fields;
682
 
        ulint           info_bits;
683
 
        ulint           i;
684
 
 
685
 
        if (end_ptr < ptr + 1) {
686
 
 
687
 
                return(NULL);
688
 
        }
689
 
 
690
 
        info_bits = mach_read_from_1(ptr);
691
 
        ptr++;
692
 
        ptr = mach_parse_compressed(ptr, end_ptr, &n_fields);
693
 
 
694
 
        if (ptr == NULL) {
695
 
 
696
 
                return(NULL);
697
 
        }
698
 
 
699
 
        update = upd_create(n_fields, heap);
700
 
        update->info_bits = info_bits;
701
 
 
702
 
        for (i = 0; i < n_fields; i++) {
703
 
                ulint   field_no;
704
 
                upd_field = upd_get_nth_field(update, i);
705
 
                new_val = &(upd_field->new_val);
706
 
 
707
 
                ptr = mach_parse_compressed(ptr, end_ptr, &field_no);
708
 
 
709
 
                if (ptr == NULL) {
710
 
 
711
 
                        return(NULL);
712
 
                }
713
 
 
714
 
                upd_field->field_no = field_no;
715
 
 
716
 
                ptr = mach_parse_compressed(ptr, end_ptr, &len);
717
 
 
718
 
                if (ptr == NULL) {
719
 
 
720
 
                        return(NULL);
721
 
                }
722
 
 
723
 
                if (len != UNIV_SQL_NULL) {
724
 
 
725
 
                        if (end_ptr < ptr + len) {
726
 
 
727
 
                                return(NULL);
728
 
                        }
729
 
 
730
 
                        dfield_set_data(new_val,
731
 
                                        mem_heap_dup(heap, ptr, len), len);
732
 
                        ptr += len;
733
 
                } else {
734
 
                        dfield_set_null(new_val);
735
 
                }
736
 
        }
737
 
 
738
 
        *update_out = update;
739
 
 
740
 
        return(ptr);
741
 
}
742
 
 
743
 
#ifndef UNIV_HOTBACKUP
744
 
/***************************************************************//**
745
 
Builds an update vector from those fields which in a secondary index entry
746
 
differ from a record that has the equal ordering fields. NOTE: we compare
747
 
the fields as binary strings!
748
 
@return own: update vector of differing fields */
749
 
UNIV_INTERN
750
 
upd_t*
751
 
row_upd_build_sec_rec_difference_binary(
752
 
/*====================================*/
753
 
        dict_index_t*   index,  /*!< in: index */
754
 
        const dtuple_t* entry,  /*!< in: entry to insert */
755
 
        const rec_t*    rec,    /*!< in: secondary index record */
756
 
        trx_t*          trx,    /*!< in: transaction */
757
 
        mem_heap_t*     heap)   /*!< in: memory heap from which allocated */
758
 
{
759
 
        upd_field_t*    upd_field;
760
 
        const dfield_t* dfield;
761
 
        const byte*     data;
762
 
        ulint           len;
763
 
        upd_t*          update;
764
 
        ulint           n_diff;
765
 
        ulint           i;
766
 
        ulint           offsets_[REC_OFFS_SMALL_SIZE];
767
 
        const ulint*    offsets;
768
 
        rec_offs_init(offsets_);
769
 
 
770
 
        /* This function is used only for a secondary index */
771
 
        ut_a(!dict_index_is_clust(index));
772
 
 
773
 
        update = upd_create(dtuple_get_n_fields(entry), heap);
774
 
 
775
 
        n_diff = 0;
776
 
        offsets = rec_get_offsets(rec, index, offsets_,
777
 
                                  ULINT_UNDEFINED, &heap);
778
 
 
779
 
        for (i = 0; i < dtuple_get_n_fields(entry); i++) {
780
 
 
781
 
                data = rec_get_nth_field(rec, offsets, i, &len);
782
 
 
783
 
                dfield = dtuple_get_nth_field(entry, i);
784
 
 
785
 
                /* NOTE that it may be that len != dfield_get_len(dfield) if we
786
 
                are updating in a character set and collation where strings of
787
 
                different length can be equal in an alphabetical comparison,
788
 
                and also in the case where we have a column prefix index
789
 
                and the last characters in the index field are spaces; the
790
 
                latter case probably caused the assertion failures reported at
791
 
                row0upd.c line 713 in versions 4.0.14 - 4.0.16. */
792
 
 
793
 
                /* NOTE: we compare the fields as binary strings!
794
 
                (No collation) */
795
 
 
796
 
                if (!dfield_data_is_binary_equal(dfield, len, data)) {
797
 
 
798
 
                        upd_field = upd_get_nth_field(update, n_diff);
799
 
 
800
 
                        dfield_copy(&(upd_field->new_val), dfield);
801
 
 
802
 
                        upd_field_set_field_no(upd_field, i, index, trx);
803
 
 
804
 
                        n_diff++;
805
 
                }
806
 
        }
807
 
 
808
 
        update->n_fields = n_diff;
809
 
 
810
 
        return(update);
811
 
}
812
 
 
813
 
/***************************************************************//**
814
 
Builds an update vector from those fields, excluding the roll ptr and
815
 
trx id fields, which in an index entry differ from a record that has
816
 
the equal ordering fields. NOTE: we compare the fields as binary strings!
817
 
@return own: update vector of differing fields, excluding roll ptr and
818
 
trx id */
819
 
UNIV_INTERN
820
 
upd_t*
821
 
row_upd_build_difference_binary(
822
 
/*============================*/
823
 
        dict_index_t*   index,  /*!< in: clustered index */
824
 
        const dtuple_t* entry,  /*!< in: entry to insert */
825
 
        const rec_t*    rec,    /*!< in: clustered index record */
826
 
        trx_t*          trx,    /*!< in: transaction */
827
 
        mem_heap_t*     heap)   /*!< in: memory heap from which allocated */
828
 
{
829
 
        upd_field_t*    upd_field;
830
 
        const dfield_t* dfield;
831
 
        const byte*     data;
832
 
        ulint           len;
833
 
        upd_t*          update;
834
 
        ulint           n_diff;
835
 
        ulint           roll_ptr_pos;
836
 
        ulint           trx_id_pos;
837
 
        ulint           i;
838
 
        ulint           offsets_[REC_OFFS_NORMAL_SIZE];
839
 
        const ulint*    offsets;
840
 
        rec_offs_init(offsets_);
841
 
 
842
 
        /* This function is used only for a clustered index */
843
 
        ut_a(dict_index_is_clust(index));
844
 
 
845
 
        update = upd_create(dtuple_get_n_fields(entry), heap);
846
 
 
847
 
        n_diff = 0;
848
 
 
849
 
        roll_ptr_pos = dict_index_get_sys_col_pos(index, DATA_ROLL_PTR);
850
 
        trx_id_pos = dict_index_get_sys_col_pos(index, DATA_TRX_ID);
851
 
 
852
 
        offsets = rec_get_offsets(rec, index, offsets_,
853
 
                                  ULINT_UNDEFINED, &heap);
854
 
 
855
 
        for (i = 0; i < dtuple_get_n_fields(entry); i++) {
856
 
 
857
 
                data = rec_get_nth_field(rec, offsets, i, &len);
858
 
 
859
 
                dfield = dtuple_get_nth_field(entry, i);
860
 
 
861
 
                /* NOTE: we compare the fields as binary strings!
862
 
                (No collation) */
863
 
 
864
 
                if (i == trx_id_pos || i == roll_ptr_pos) {
865
 
 
866
 
                        goto skip_compare;
867
 
                }
868
 
 
869
 
                if (UNIV_UNLIKELY(!dfield_is_ext(dfield)
870
 
                                  != !rec_offs_nth_extern(offsets, i))
871
 
                    || !dfield_data_is_binary_equal(dfield, len, data)) {
872
 
 
873
 
                        upd_field = upd_get_nth_field(update, n_diff);
874
 
 
875
 
                        dfield_copy(&(upd_field->new_val), dfield);
876
 
 
877
 
                        upd_field_set_field_no(upd_field, i, index, trx);
878
 
 
879
 
                        n_diff++;
880
 
                }
881
 
skip_compare:
882
 
                ;
883
 
        }
884
 
 
885
 
        update->n_fields = n_diff;
886
 
 
887
 
        return(update);
888
 
}
889
 
 
890
 
/***********************************************************//**
891
 
Fetch a prefix of an externally stored column.  This is similar
892
 
to row_ext_lookup(), but the row_ext_t holds the old values
893
 
of the column and must not be poisoned with the new values.
894
 
@return BLOB prefix */
895
 
static
896
 
byte*
897
 
row_upd_ext_fetch(
898
 
/*==============*/
899
 
        const byte*     data,           /*!< in: 'internally' stored part of the
900
 
                                        field containing also the reference to
901
 
                                        the external part */
902
 
        ulint           local_len,      /*!< in: length of data, in bytes */
903
 
        ulint           zip_size,       /*!< in: nonzero=compressed BLOB
904
 
                                        page size, zero for uncompressed
905
 
                                        BLOBs */
906
 
        ulint*          len,            /*!< in: length of prefix to fetch;
907
 
                                        out: fetched length of the prefix */
908
 
        mem_heap_t*     heap)           /*!< in: heap where to allocate */
909
 
{
910
 
        byte* buf = static_cast<byte *>(mem_heap_alloc(heap, *len));
911
 
 
912
 
        *len = btr_copy_externally_stored_field_prefix(buf, *len,
913
 
                                                       zip_size,
914
 
                                                       data, local_len);
915
 
        /* We should never update records containing a half-deleted BLOB. */
916
 
        ut_a(*len);
917
 
 
918
 
        return(buf);
919
 
}
920
 
 
921
 
/***********************************************************//**
922
 
Replaces the new column value stored in the update vector in
923
 
the given index entry field. */
924
 
static
925
 
void
926
 
row_upd_index_replace_new_col_val(
927
 
/*==============================*/
928
 
        dfield_t*               dfield, /*!< in/out: data field
929
 
                                        of the index entry */
930
 
        const dict_field_t*     field,  /*!< in: index field */
931
 
        const dict_col_t*       col,    /*!< in: field->col */
932
 
        const upd_field_t*      uf,     /*!< in: update field */
933
 
        mem_heap_t*             heap,   /*!< in: memory heap for allocating
934
 
                                        and copying the new value */
935
 
        ulint                   zip_size)/*!< in: compressed page
936
 
                                         size of the table, or 0 */
937
 
{
938
 
        ulint           len;
939
 
        const byte*     data;
940
 
 
941
 
        dfield_copy_data(dfield, &uf->new_val);
942
 
 
943
 
        if (dfield_is_null(dfield)) {
944
 
                return;
945
 
        }
946
 
 
947
 
        len = dfield_get_len(dfield);
948
 
        data = static_cast<const byte *>(dfield_get_data(dfield));
949
 
 
950
 
        if (field->prefix_len > 0) {
951
 
                ibool           fetch_ext = dfield_is_ext(dfield)
952
 
                        && len < (ulint) field->prefix_len
953
 
                        + BTR_EXTERN_FIELD_REF_SIZE;
954
 
 
955
 
                if (fetch_ext) {
956
 
                        ulint   l = len;
957
 
 
958
 
                        len = field->prefix_len;
959
 
 
960
 
                        data = row_upd_ext_fetch(data, l, zip_size,
961
 
                                                 &len, heap);
962
 
                }
963
 
 
964
 
                len = dtype_get_at_most_n_mbchars(col->prtype,
965
 
                                                  col->mbminmaxlen,
966
 
                                                  field->prefix_len, len,
967
 
                                                  (const char*) data);
968
 
 
969
 
                dfield_set_data(dfield, data, len);
970
 
 
971
 
                if (!fetch_ext) {
972
 
                        dfield_dup(dfield, heap);
973
 
                }
974
 
 
975
 
                return;
976
 
        }
977
 
 
978
 
        switch (uf->orig_len) {
979
 
                byte*   buf;
980
 
        case BTR_EXTERN_FIELD_REF_SIZE:
981
 
                /* Restore the original locally stored
982
 
                part of the column.  In the undo log,
983
 
                InnoDB writes a longer prefix of externally
984
 
                stored columns, so that column prefixes
985
 
                in secondary indexes can be reconstructed. */
986
 
                dfield_set_data(dfield,
987
 
                                data + len - BTR_EXTERN_FIELD_REF_SIZE,
988
 
                                BTR_EXTERN_FIELD_REF_SIZE);
989
 
                dfield_set_ext(dfield);
990
 
                /* fall through */
991
 
        case 0:
992
 
                dfield_dup(dfield, heap);
993
 
                break;
994
 
        default:
995
 
                /* Reconstruct the original locally
996
 
                stored part of the column.  The data
997
 
                will have to be copied. */
998
 
                ut_a(uf->orig_len > BTR_EXTERN_FIELD_REF_SIZE);
999
 
                buf = static_cast<byte *>(mem_heap_alloc(heap, uf->orig_len));
1000
 
                /* Copy the locally stored prefix. */
1001
 
                memcpy(buf, data,
1002
 
                       uf->orig_len - BTR_EXTERN_FIELD_REF_SIZE);
1003
 
                /* Copy the BLOB pointer. */
1004
 
                memcpy(buf + uf->orig_len - BTR_EXTERN_FIELD_REF_SIZE,
1005
 
                       data + len - BTR_EXTERN_FIELD_REF_SIZE,
1006
 
                       BTR_EXTERN_FIELD_REF_SIZE);
1007
 
 
1008
 
                dfield_set_data(dfield, buf, uf->orig_len);
1009
 
                dfield_set_ext(dfield);
1010
 
                break;
1011
 
        }
1012
 
}
1013
 
 
1014
 
/***********************************************************//**
1015
 
Replaces the new column values stored in the update vector to the index entry
1016
 
given. */
1017
 
UNIV_INTERN
1018
 
void
1019
 
row_upd_index_replace_new_col_vals_index_pos(
1020
 
/*=========================================*/
1021
 
        dtuple_t*       entry,  /*!< in/out: index entry where replaced;
1022
 
                                the clustered index record must be
1023
 
                                covered by a lock or a page latch to
1024
 
                                prevent deletion (rollback or purge) */
1025
 
        dict_index_t*   index,  /*!< in: index; NOTE that this may also be a
1026
 
                                non-clustered index */
1027
 
        const upd_t*    update, /*!< in: an update vector built for the index so
1028
 
                                that the field number in an upd_field is the
1029
 
                                index position */
1030
 
        ibool           order_only,
1031
 
                                /*!< in: if TRUE, limit the replacement to
1032
 
                                ordering fields of index; note that this
1033
 
                                does not work for non-clustered indexes. */
1034
 
        mem_heap_t*     heap)   /*!< in: memory heap for allocating and
1035
 
                                copying the new values */
1036
 
{
1037
 
        ulint           i;
1038
 
        ulint           n_fields;
1039
 
        const ulint     zip_size        = dict_table_zip_size(index->table);
1040
 
 
1041
 
        ut_ad(index);
1042
 
 
1043
 
        dtuple_set_info_bits(entry, update->info_bits);
1044
 
 
1045
 
        if (order_only) {
1046
 
                n_fields = dict_index_get_n_unique(index);
1047
 
        } else {
1048
 
                n_fields = dict_index_get_n_fields(index);
1049
 
        }
1050
 
 
1051
 
        for (i = 0; i < n_fields; i++) {
1052
 
                const dict_field_t*     field;
1053
 
                const dict_col_t*       col;
1054
 
                const upd_field_t*      uf;
1055
 
 
1056
 
                field = dict_index_get_nth_field(index, i);
1057
 
                col = dict_field_get_col(field);
1058
 
                uf = upd_get_field_by_field_no(update, i);
1059
 
 
1060
 
                if (uf) {
1061
 
                        row_upd_index_replace_new_col_val(
1062
 
                                dtuple_get_nth_field(entry, i),
1063
 
                                field, col, uf, heap, zip_size);
1064
 
                }
1065
 
        }
1066
 
}
1067
 
 
1068
 
/***********************************************************//**
1069
 
Replaces the new column values stored in the update vector to the index entry
1070
 
given. */
1071
 
UNIV_INTERN
1072
 
void
1073
 
row_upd_index_replace_new_col_vals(
1074
 
/*===============================*/
1075
 
        dtuple_t*       entry,  /*!< in/out: index entry where replaced;
1076
 
                                the clustered index record must be
1077
 
                                covered by a lock or a page latch to
1078
 
                                prevent deletion (rollback or purge) */
1079
 
        dict_index_t*   index,  /*!< in: index; NOTE that this may also be a
1080
 
                                non-clustered index */
1081
 
        const upd_t*    update, /*!< in: an update vector built for the
1082
 
                                CLUSTERED index so that the field number in
1083
 
                                an upd_field is the clustered index position */
1084
 
        mem_heap_t*     heap)   /*!< in: memory heap for allocating and
1085
 
                                copying the new values */
1086
 
{
1087
 
        ulint                   i;
1088
 
        const dict_index_t*     clust_index
1089
 
                = dict_table_get_first_index(index->table);
1090
 
        const ulint             zip_size
1091
 
                = dict_table_zip_size(index->table);
1092
 
 
1093
 
        dtuple_set_info_bits(entry, update->info_bits);
1094
 
 
1095
 
        for (i = 0; i < dict_index_get_n_fields(index); i++) {
1096
 
                const dict_field_t*     field;
1097
 
                const dict_col_t*       col;
1098
 
                const upd_field_t*      uf;
1099
 
 
1100
 
                field = dict_index_get_nth_field(index, i);
1101
 
                col = dict_field_get_col(field);
1102
 
                uf = upd_get_field_by_field_no(
1103
 
                        update, dict_col_get_clust_pos(col, clust_index));
1104
 
 
1105
 
                if (uf) {
1106
 
                        row_upd_index_replace_new_col_val(
1107
 
                                dtuple_get_nth_field(entry, i),
1108
 
                                field, col, uf, heap, zip_size);
1109
 
                }
1110
 
        }
1111
 
}
1112
 
 
1113
 
/***********************************************************//**
1114
 
Replaces the new column values stored in the update vector. */
1115
 
UNIV_INTERN
1116
 
void
1117
 
row_upd_replace(
1118
 
/*============*/
1119
 
        dtuple_t*               row,    /*!< in/out: row where replaced,
1120
 
                                        indexed by col_no;
1121
 
                                        the clustered index record must be
1122
 
                                        covered by a lock or a page latch to
1123
 
                                        prevent deletion (rollback or purge) */
1124
 
        row_ext_t**             ext,    /*!< out, own: NULL, or externally
1125
 
                                        stored column prefixes */
1126
 
        const dict_index_t*     index,  /*!< in: clustered index */
1127
 
        const upd_t*            update, /*!< in: an update vector built for the
1128
 
                                        clustered index */
1129
 
        mem_heap_t*             heap)   /*!< in: memory heap */
1130
 
{
1131
 
        ulint                   col_no;
1132
 
        ulint                   i;
1133
 
        ulint                   n_cols;
1134
 
        ulint                   n_ext_cols;
1135
 
        ulint*                  ext_cols;
1136
 
        const dict_table_t*     table;
1137
 
 
1138
 
        ut_ad(row);
1139
 
        ut_ad(ext);
1140
 
        ut_ad(index);
1141
 
        ut_ad(dict_index_is_clust(index));
1142
 
        ut_ad(update);
1143
 
        ut_ad(heap);
1144
 
 
1145
 
        n_cols = dtuple_get_n_fields(row);
1146
 
        table = index->table;
1147
 
        ut_ad(n_cols == dict_table_get_n_cols(table));
1148
 
 
1149
 
        ext_cols = static_cast<ulint *>(mem_heap_alloc(heap, n_cols * sizeof *ext_cols));
1150
 
        n_ext_cols = 0;
1151
 
 
1152
 
        dtuple_set_info_bits(row, update->info_bits);
1153
 
 
1154
 
        for (col_no = 0; col_no < n_cols; col_no++) {
1155
 
 
1156
 
                const dict_col_t*       col
1157
 
                        = dict_table_get_nth_col(table, col_no);
1158
 
                const ulint             clust_pos
1159
 
                        = dict_col_get_clust_pos(col, index);
1160
 
                dfield_t*               dfield;
1161
 
 
1162
 
                if (UNIV_UNLIKELY(clust_pos == ULINT_UNDEFINED)) {
1163
 
 
1164
 
                        continue;
1165
 
                }
1166
 
 
1167
 
                dfield = dtuple_get_nth_field(row, col_no);
1168
 
 
1169
 
                for (i = 0; i < upd_get_n_fields(update); i++) {
1170
 
 
1171
 
                        const upd_field_t*      upd_field
1172
 
                                = upd_get_nth_field(update, i);
1173
 
 
1174
 
                        if (upd_field->field_no != clust_pos) {
1175
 
 
1176
 
                                continue;
1177
 
                        }
1178
 
 
1179
 
                        dfield_copy_data(dfield, &upd_field->new_val);
1180
 
                        break;
1181
 
                }
1182
 
 
1183
 
                if (dfield_is_ext(dfield) && col->ord_part) {
1184
 
                        ext_cols[n_ext_cols++] = col_no;
1185
 
                }
1186
 
        }
1187
 
 
1188
 
        if (n_ext_cols) {
1189
 
                *ext = row_ext_create(n_ext_cols, ext_cols, row,
1190
 
                                      dict_table_zip_size(table), heap);
1191
 
        } else {
1192
 
                *ext = NULL;
1193
 
        }
1194
 
}
1195
 
 
1196
 
/***********************************************************//**
1197
 
Checks if an update vector changes an ordering field of an index record.
1198
 
 
1199
 
This function is fast if the update vector is short or the number of ordering
1200
 
fields in the index is small. Otherwise, this can be quadratic.
1201
 
NOTE: we compare the fields as binary strings!
1202
 
@return TRUE if update vector changes an ordering field in the index record */
1203
 
UNIV_INTERN
1204
 
ibool
1205
 
row_upd_changes_ord_field_binary(
1206
 
/*=============================*/
1207
 
        const dtuple_t* row,    /*!< in: old value of row, or NULL if the
1208
 
                                row and the data values in update are not
1209
 
                                known when this function is called, e.g., at
1210
 
                                compile time */
1211
 
        dict_index_t*   index,  /*!< in: index of the record */
1212
 
        const upd_t*    update) /*!< in: update vector for the row; NOTE: the
1213
 
                                field numbers in this MUST be clustered index
1214
 
                                positions! */
1215
 
{
1216
 
        ulint           n_unique;
1217
 
        ulint           n_upd_fields;
1218
 
        ulint           i, j;
1219
 
        dict_index_t*   clust_index;
1220
 
 
1221
 
        ut_ad(update && index);
1222
 
 
1223
 
        n_unique = dict_index_get_n_unique(index);
1224
 
        n_upd_fields = upd_get_n_fields(update);
1225
 
 
1226
 
        clust_index = dict_table_get_first_index(index->table);
1227
 
 
1228
 
        for (i = 0; i < n_unique; i++) {
1229
 
 
1230
 
                const dict_field_t*     ind_field;
1231
 
                const dict_col_t*       col;
1232
 
                ulint                   col_pos;
1233
 
                ulint                   col_no;
1234
 
 
1235
 
                ind_field = dict_index_get_nth_field(index, i);
1236
 
                col = dict_field_get_col(ind_field);
1237
 
                col_pos = dict_col_get_clust_pos(col, clust_index);
1238
 
                col_no = dict_col_get_no(col);
1239
 
 
1240
 
                for (j = 0; j < n_upd_fields; j++) {
1241
 
 
1242
 
                        const upd_field_t*      upd_field
1243
 
                                = upd_get_nth_field(update, j);
1244
 
 
1245
 
                        /* Note that if the index field is a column prefix
1246
 
                        then it may be that row does not contain an externally
1247
 
                        stored part of the column value, and we cannot compare
1248
 
                        the datas */
1249
 
 
1250
 
                        if (col_pos == upd_field->field_no
1251
 
                            && (row == NULL
1252
 
                                || ind_field->prefix_len > 0
1253
 
                                || !dfield_datas_are_binary_equal(
1254
 
                                        dtuple_get_nth_field(row, col_no),
1255
 
                                        &(upd_field->new_val)))) {
1256
 
 
1257
 
                                return(TRUE);
1258
 
                        }
1259
 
                }
1260
 
        }
1261
 
 
1262
 
        return(FALSE);
1263
 
}
1264
 
 
1265
 
/***********************************************************//**
1266
 
Checks if an update vector changes an ordering field of an index record.
1267
 
NOTE: we compare the fields as binary strings!
1268
 
@return TRUE if update vector may change an ordering field in an index
1269
 
record */
1270
 
UNIV_INTERN
1271
 
ibool
1272
 
row_upd_changes_some_index_ord_field_binary(
1273
 
/*========================================*/
1274
 
        const dict_table_t*     table,  /*!< in: table */
1275
 
        const upd_t*            update) /*!< in: update vector for the row */
1276
 
{
1277
 
        upd_field_t*    upd_field;
1278
 
        dict_index_t*   index;
1279
 
        ulint           i;
1280
 
 
1281
 
        index = dict_table_get_first_index(table);
1282
 
 
1283
 
        for (i = 0; i < upd_get_n_fields(update); i++) {
1284
 
 
1285
 
                upd_field = upd_get_nth_field(update, i);
1286
 
 
1287
 
                if (dict_field_get_col(dict_index_get_nth_field(
1288
 
                                               index, upd_field->field_no))
1289
 
                    ->ord_part) {
1290
 
 
1291
 
                        return(TRUE);
1292
 
                }
1293
 
        }
1294
 
 
1295
 
        return(FALSE);
1296
 
}
1297
 
 
1298
 
/***********************************************************//**
1299
 
Checks if an update vector changes some of the first ordering fields of an
1300
 
index record. This is only used in foreign key checks and we can assume
1301
 
that index does not contain column prefixes.
1302
 
@return TRUE if changes */
1303
 
static
1304
 
ibool
1305
 
row_upd_changes_first_fields_binary(
1306
 
/*================================*/
1307
 
        dtuple_t*       entry,  /*!< in: index entry */
1308
 
        dict_index_t*   index,  /*!< in: index of entry */
1309
 
        const upd_t*    update, /*!< in: update vector for the row */
1310
 
        ulint           n)      /*!< in: how many first fields to check */
1311
 
{
1312
 
        ulint           n_upd_fields;
1313
 
        ulint           i, j;
1314
 
        dict_index_t*   clust_index;
1315
 
 
1316
 
        ut_ad(update && index);
1317
 
        ut_ad(n <= dict_index_get_n_fields(index));
1318
 
 
1319
 
        n_upd_fields = upd_get_n_fields(update);
1320
 
        clust_index = dict_table_get_first_index(index->table);
1321
 
 
1322
 
        for (i = 0; i < n; i++) {
1323
 
 
1324
 
                const dict_field_t*     ind_field;
1325
 
                const dict_col_t*       col;
1326
 
                ulint                   col_pos;
1327
 
 
1328
 
                ind_field = dict_index_get_nth_field(index, i);
1329
 
                col = dict_field_get_col(ind_field);
1330
 
                col_pos = dict_col_get_clust_pos(col, clust_index);
1331
 
 
1332
 
                ut_a(ind_field->prefix_len == 0);
1333
 
 
1334
 
                for (j = 0; j < n_upd_fields; j++) {
1335
 
 
1336
 
                        upd_field_t*    upd_field
1337
 
                                = upd_get_nth_field(update, j);
1338
 
 
1339
 
                        if (col_pos == upd_field->field_no
1340
 
                            && !dfield_datas_are_binary_equal(
1341
 
                                    dtuple_get_nth_field(entry, i),
1342
 
                                    &(upd_field->new_val))) {
1343
 
 
1344
 
                                return(TRUE);
1345
 
                        }
1346
 
                }
1347
 
        }
1348
 
 
1349
 
        return(FALSE);
1350
 
}
1351
 
 
1352
 
/*********************************************************************//**
1353
 
Copies the column values from a record. */
1354
 
UNIV_INLINE
1355
 
void
1356
 
row_upd_copy_columns(
1357
 
/*=================*/
1358
 
        rec_t*          rec,    /*!< in: record in a clustered index */
1359
 
        const ulint*    offsets,/*!< in: array returned by rec_get_offsets() */
1360
 
        sym_node_t*     column) /*!< in: first column in a column list, or
1361
 
                                NULL */
1362
 
{
1363
 
        byte*   data;
1364
 
        ulint   len;
1365
 
 
1366
 
        while (column) {
1367
 
                data = rec_get_nth_field(rec, offsets,
1368
 
                                         column->field_nos[SYM_CLUST_FIELD_NO],
1369
 
                                         &len);
1370
 
                eval_node_copy_and_alloc_val(column, data, len);
1371
 
 
1372
 
                column = UT_LIST_GET_NEXT(col_var_list, column);
1373
 
        }
1374
 
}
1375
 
 
1376
 
/*********************************************************************//**
1377
 
Calculates the new values for fields to update. Note that row_upd_copy_columns
1378
 
must have been called first. */
1379
 
UNIV_INLINE
1380
 
void
1381
 
row_upd_eval_new_vals(
1382
 
/*==================*/
1383
 
        upd_t*  update) /*!< in/out: update vector */
1384
 
{
1385
 
        que_node_t*     exp;
1386
 
        upd_field_t*    upd_field;
1387
 
        ulint           n_fields;
1388
 
        ulint           i;
1389
 
 
1390
 
        n_fields = upd_get_n_fields(update);
1391
 
 
1392
 
        for (i = 0; i < n_fields; i++) {
1393
 
                upd_field = upd_get_nth_field(update, i);
1394
 
 
1395
 
                exp = upd_field->exp;
1396
 
 
1397
 
                eval_exp(exp);
1398
 
 
1399
 
                dfield_copy_data(&(upd_field->new_val), que_node_get_val(exp));
1400
 
        }
1401
 
}
1402
 
 
1403
 
/***********************************************************//**
1404
 
Stores to the heap the row on which the node->pcur is positioned. */
1405
 
static
1406
 
void
1407
 
row_upd_store_row(
1408
 
/*==============*/
1409
 
        upd_node_t*     node)   /*!< in: row update node */
1410
 
{
1411
 
        dict_index_t*   clust_index;
1412
 
        rec_t*          rec;
1413
 
        mem_heap_t*     heap            = NULL;
1414
 
        row_ext_t**     ext;
1415
 
        ulint           offsets_[REC_OFFS_NORMAL_SIZE];
1416
 
        const ulint*    offsets;
1417
 
        rec_offs_init(offsets_);
1418
 
 
1419
 
        ut_ad(node->pcur->latch_mode != BTR_NO_LATCHES);
1420
 
 
1421
 
        if (node->row != NULL) {
1422
 
                mem_heap_empty(node->heap);
1423
 
        }
1424
 
 
1425
 
        clust_index = dict_table_get_first_index(node->table);
1426
 
 
1427
 
        rec = btr_pcur_get_rec(node->pcur);
1428
 
 
1429
 
        offsets = rec_get_offsets(rec, clust_index, offsets_,
1430
 
                                  ULINT_UNDEFINED, &heap);
1431
 
 
1432
 
        if (dict_table_get_format(node->table) >= DICT_TF_FORMAT_ZIP) {
1433
 
                /* In DYNAMIC or COMPRESSED format, there is no prefix
1434
 
                of externally stored columns in the clustered index
1435
 
                record. Build a cache of column prefixes. */
1436
 
                ext = &node->ext;
1437
 
        } else {
1438
 
                /* REDUNDANT and COMPACT formats store a local
1439
 
                768-byte prefix of each externally stored column.
1440
 
                No cache is needed. */
1441
 
                ext = NULL;
1442
 
                node->ext = NULL;
1443
 
        }
1444
 
 
1445
 
        node->row = row_build(ROW_COPY_DATA, clust_index, rec, offsets,
1446
 
                              NULL, ext, node->heap);
1447
 
        if (node->is_delete) {
1448
 
                node->upd_row = NULL;
1449
 
                node->upd_ext = NULL;
1450
 
        } else {
1451
 
                node->upd_row = dtuple_copy(node->row, node->heap);
1452
 
                row_upd_replace(node->upd_row, &node->upd_ext,
1453
 
                                clust_index, node->update, node->heap);
1454
 
        }
1455
 
 
1456
 
        if (UNIV_LIKELY_NULL(heap)) {
1457
 
                mem_heap_free(heap);
1458
 
        }
1459
 
}
1460
 
 
1461
 
/***********************************************************//**
1462
 
Updates a secondary index entry of a row.
1463
 
@return DB_SUCCESS if operation successfully completed, else error
1464
 
code or DB_LOCK_WAIT */
1465
 
static
1466
 
ulint
1467
 
row_upd_sec_index_entry(
1468
 
/*====================*/
1469
 
        upd_node_t*     node,   /*!< in: row update node */
1470
 
        que_thr_t*      thr)    /*!< in: query thread */
1471
 
{
1472
 
        mtr_t                   mtr;
1473
 
        const rec_t*            rec;
1474
 
        btr_pcur_t              pcur;
1475
 
        mem_heap_t*             heap;
1476
 
        dtuple_t*               entry;
1477
 
        dict_index_t*           index;
1478
 
        btr_cur_t*              btr_cur;
1479
 
        ibool                   referenced;
1480
 
        ulint                   err     = DB_SUCCESS;
1481
 
        trx_t*                  trx     = thr_get_trx(thr);
1482
 
        ulint                   mode    = BTR_MODIFY_LEAF;
1483
 
        enum row_search_result  search_result;
1484
 
 
1485
 
        index = node->index;
1486
 
 
1487
 
        referenced = row_upd_index_is_referenced(index, trx);
1488
 
 
1489
 
        heap = mem_heap_create(1024);
1490
 
 
1491
 
        /* Build old index entry */
1492
 
        entry = row_build_index_entry(node->row, node->ext, index, heap);
1493
 
        ut_a(entry);
1494
 
 
1495
 
        mtr_start(&mtr);
1496
 
 
1497
 
        /* Set the query thread, so that ibuf_insert_low() will be
1498
 
        able to invoke thd_get_trx(). */
1499
 
        btr_pcur_get_btr_cur(&pcur)->thr = thr;
1500
 
 
1501
 
        /* We can only try to use the insert/delete buffer to buffer
1502
 
        delete-mark operations if the index we're modifying has no foreign
1503
 
        key constraints referring to it. */
1504
 
        if (!referenced) {
1505
 
                mode |= BTR_DELETE_MARK;
1506
 
        }
1507
 
 
1508
 
        search_result = row_search_index_entry(index, entry, mode,
1509
 
                                               &pcur, &mtr);
1510
 
 
1511
 
        btr_cur = btr_pcur_get_btr_cur(&pcur);
1512
 
 
1513
 
        rec = btr_cur_get_rec(btr_cur);
1514
 
 
1515
 
        switch (search_result) {
1516
 
        case ROW_NOT_DELETED_REF:       /* should only occur for BTR_DELETE */
1517
 
                ut_error;
1518
 
                break;
1519
 
        case ROW_BUFFERED:
1520
 
                /* Entry was delete marked already. */
1521
 
                break;
1522
 
 
1523
 
        case ROW_NOT_FOUND:
1524
 
                fputs("InnoDB: error in sec index entry update in\n"
1525
 
                      "InnoDB: ", stderr);
1526
 
                dict_index_name_print(stderr, trx, index);
1527
 
                fputs("\n"
1528
 
                      "InnoDB: tuple ", stderr);
1529
 
                dtuple_print(stderr, entry);
1530
 
                fputs("\n"
1531
 
                      "InnoDB: record ", stderr);
1532
 
                rec_print(stderr, rec, index);
1533
 
                putc('\n', stderr);
1534
 
 
1535
 
                trx_print(stderr, trx, 0);
1536
 
 
1537
 
                fputs("\n"
1538
 
                      "InnoDB: Submit a detailed bug report"
1539
 
                      " to http://bugs.mysql.com\n", stderr);
1540
 
                break;
1541
 
        case ROW_FOUND:
1542
 
                /* Delete mark the old index record; it can already be
1543
 
                delete marked if we return after a lock wait in
1544
 
                row_ins_index_entry below */
1545
 
 
1546
 
                if (!rec_get_deleted_flag(
1547
 
                        rec, dict_table_is_comp(index->table))) {
1548
 
 
1549
 
                        err = btr_cur_del_mark_set_sec_rec(
1550
 
                                0, btr_cur, TRUE, thr, &mtr);
1551
 
 
1552
 
                        if (err == DB_SUCCESS && referenced) {
1553
 
 
1554
 
                                ulint*  offsets;
1555
 
 
1556
 
                                offsets = rec_get_offsets(
1557
 
                                        rec, index, NULL, ULINT_UNDEFINED,
1558
 
                                        &heap);
1559
 
 
1560
 
                                /* NOTE that the following call loses
1561
 
                                the position of pcur ! */
1562
 
                                err = row_upd_check_references_constraints(
1563
 
                                        node, &pcur, index->table,
1564
 
                                        index, offsets, thr, &mtr);
1565
 
                        }
1566
 
                }
1567
 
                break;
1568
 
        }
1569
 
 
1570
 
        btr_pcur_close(&pcur);
1571
 
        mtr_commit(&mtr);
1572
 
 
1573
 
        if (node->is_delete || err != DB_SUCCESS) {
1574
 
 
1575
 
                goto func_exit;
1576
 
        }
1577
 
 
1578
 
        /* Build a new index entry */
1579
 
        entry = row_build_index_entry(node->upd_row, node->upd_ext,
1580
 
                                      index, heap);
1581
 
        ut_a(entry);
1582
 
 
1583
 
        /* Insert new index entry */
1584
 
        err = row_ins_index_entry(index, entry, 0, TRUE, thr);
1585
 
 
1586
 
func_exit:
1587
 
        mem_heap_free(heap);
1588
 
 
1589
 
        return(err);
1590
 
}
1591
 
 
1592
 
/***********************************************************//**
1593
 
Updates the secondary index record if it is changed in the row update or
1594
 
deletes it if this is a delete.
1595
 
@return DB_SUCCESS if operation successfully completed, else error
1596
 
code or DB_LOCK_WAIT */
1597
 
static
1598
 
ulint
1599
 
row_upd_sec_step(
1600
 
/*=============*/
1601
 
        upd_node_t*     node,   /*!< in: row update node */
1602
 
        que_thr_t*      thr)    /*!< in: query thread */
1603
 
{
1604
 
        ut_ad((node->state == UPD_NODE_UPDATE_ALL_SEC)
1605
 
              || (node->state == UPD_NODE_UPDATE_SOME_SEC));
1606
 
        ut_ad(!dict_index_is_clust(node->index));
1607
 
 
1608
 
        if (node->state == UPD_NODE_UPDATE_ALL_SEC
1609
 
            || row_upd_changes_ord_field_binary(node->row, node->index,
1610
 
                                                node->update)) {
1611
 
                return(row_upd_sec_index_entry(node, thr));
1612
 
        }
1613
 
 
1614
 
        return(DB_SUCCESS);
1615
 
}
1616
 
 
1617
 
/***********************************************************//**
1618
 
Marks the clustered index record deleted and inserts the updated version
1619
 
of the record to the index. This function should be used when the ordering
1620
 
fields of the clustered index record change. This should be quite rare in
1621
 
database applications.
1622
 
@return DB_SUCCESS if operation successfully completed, else error
1623
 
code or DB_LOCK_WAIT */
1624
 
static
1625
 
ulint
1626
 
row_upd_clust_rec_by_insert(
1627
 
/*========================*/
1628
 
        upd_node_t*     node,   /*!< in/out: row update node */
1629
 
        dict_index_t*   index,  /*!< in: clustered index of the record */
1630
 
        que_thr_t*      thr,    /*!< in: query thread */
1631
 
        ibool           referenced,/*!< in: TRUE if index may be referenced in
1632
 
                                a foreign key constraint */
1633
 
        mtr_t*          mtr)    /*!< in/out: mtr; gets committed here */
1634
 
{
1635
 
        mem_heap_t*     heap    = NULL;
1636
 
        btr_pcur_t*     pcur;
1637
 
        btr_cur_t*      btr_cur;
1638
 
        trx_t*          trx;
1639
 
        dict_table_t*   table;
1640
 
        dtuple_t*       entry;
1641
 
        ulint           err;
1642
 
        ibool           change_ownership = FALSE;
1643
 
 
1644
 
        ut_ad(node);
1645
 
        ut_ad(dict_index_is_clust(index));
1646
 
 
1647
 
        trx = thr_get_trx(thr);
1648
 
        table = node->table;
1649
 
        pcur = node->pcur;
1650
 
        btr_cur = btr_pcur_get_btr_cur(pcur);
1651
 
 
1652
 
        if (node->state != UPD_NODE_INSERT_CLUSTERED) {
1653
 
                rec_t*          rec;
1654
 
                dict_index_t*   node_index;
1655
 
                ulint           offsets_[REC_OFFS_NORMAL_SIZE];
1656
 
                ulint*          offsets;
1657
 
                rec_offs_init(offsets_);
1658
 
 
1659
 
                err = btr_cur_del_mark_set_clust_rec(BTR_NO_LOCKING_FLAG,
1660
 
                                                     btr_cur, TRUE, thr, mtr);
1661
 
                if (err != DB_SUCCESS) {
1662
 
                        mtr_commit(mtr);
1663
 
                        return(err);
1664
 
                }
1665
 
 
1666
 
                /* Mark as not-owned the externally stored fields which the new
1667
 
                row inherits from the delete marked record: purge should not
1668
 
                free those externally stored fields even if the delete marked
1669
 
                record is removed from the index tree, or updated. */
1670
 
 
1671
 
                rec = btr_cur_get_rec(btr_cur);
1672
 
                node_index = dict_table_get_first_index(table);
1673
 
                offsets = rec_get_offsets(rec, node_index, offsets_,
1674
 
                                          ULINT_UNDEFINED, &heap);
1675
 
                change_ownership = btr_cur_mark_extern_inherited_fields(
1676
 
                        btr_cur_get_page_zip(btr_cur), rec, node_index, offsets,
1677
 
                        node->update, mtr);
1678
 
                if (referenced) {
1679
 
                        /* NOTE that the following call loses
1680
 
                        the position of pcur ! */
1681
 
 
1682
 
                        err = row_upd_check_references_constraints(
1683
 
                                node, pcur, table, node_index, offsets, thr, mtr);
1684
 
 
1685
 
                        if (err != DB_SUCCESS) {
1686
 
 
1687
 
                                mtr_commit(mtr);
1688
 
 
1689
 
                                if (UNIV_LIKELY_NULL(heap)) {
1690
 
                                        mem_heap_free(heap);
1691
 
                                }
1692
 
 
1693
 
                                return(err);
1694
 
                        }
1695
 
                }
1696
 
        }
1697
 
 
1698
 
        mtr_commit(mtr);
1699
 
 
1700
 
        if (!heap) {
1701
 
                heap = mem_heap_create(500);
1702
 
        }
1703
 
        node->state = UPD_NODE_INSERT_CLUSTERED;
1704
 
 
1705
 
        entry = row_build_index_entry(node->upd_row, node->upd_ext,
1706
 
                                      index, heap);
1707
 
        ut_a(entry);
1708
 
 
1709
 
        row_upd_index_entry_sys_field(entry, index, DATA_TRX_ID, trx->id);
1710
 
 
1711
 
        if (change_ownership) {
1712
 
                /* If we return from a lock wait, for example, we may have
1713
 
                extern fields marked as not-owned in entry (marked in the
1714
 
                if-branch above). We must unmark them, take the ownership
1715
 
                back. */
1716
 
 
1717
 
                btr_cur_unmark_dtuple_extern_fields(entry);
1718
 
 
1719
 
                /* We must mark non-updated extern fields in entry as
1720
 
                inherited, so that a possible rollback will not free them. */
1721
 
 
1722
 
                btr_cur_mark_dtuple_inherited_extern(entry, node->update);
1723
 
        }
1724
 
 
1725
 
        err = row_ins_index_entry(index, entry,
1726
 
                                  node->upd_ext ? node->upd_ext->n_ext : 0,
1727
 
                                  TRUE, thr);
1728
 
        mem_heap_free(heap);
1729
 
 
1730
 
        return(err);
1731
 
}
1732
 
 
1733
 
/***********************************************************//**
1734
 
Updates a clustered index record of a row when the ordering fields do
1735
 
not change.
1736
 
@return DB_SUCCESS if operation successfully completed, else error
1737
 
code or DB_LOCK_WAIT */
1738
 
static
1739
 
ulint
1740
 
row_upd_clust_rec(
1741
 
/*==============*/
1742
 
        upd_node_t*     node,   /*!< in: row update node */
1743
 
        dict_index_t*   index,  /*!< in: clustered index */
1744
 
        que_thr_t*      thr,    /*!< in: query thread */
1745
 
        mtr_t*          mtr)    /*!< in: mtr; gets committed here */
1746
 
{
1747
 
        mem_heap_t*     heap    = NULL;
1748
 
        big_rec_t*      big_rec = NULL;
1749
 
        btr_pcur_t*     pcur;
1750
 
        btr_cur_t*      btr_cur;
1751
 
        ulint           err;
1752
 
 
1753
 
        ut_ad(node);
1754
 
        ut_ad(dict_index_is_clust(index));
1755
 
 
1756
 
        pcur = node->pcur;
1757
 
        btr_cur = btr_pcur_get_btr_cur(pcur);
1758
 
 
1759
 
        ut_ad(!rec_get_deleted_flag(btr_pcur_get_rec(pcur),
1760
 
                                    dict_table_is_comp(index->table)));
1761
 
 
1762
 
        /* Try optimistic updating of the record, keeping changes within
1763
 
        the page; we do not check locks because we assume the x-lock on the
1764
 
        record to update */
1765
 
 
1766
 
        if (node->cmpl_info & UPD_NODE_NO_SIZE_CHANGE) {
1767
 
                err = btr_cur_update_in_place(BTR_NO_LOCKING_FLAG,
1768
 
                                              btr_cur, node->update,
1769
 
                                              node->cmpl_info, thr, mtr);
1770
 
        } else {
1771
 
                err = btr_cur_optimistic_update(BTR_NO_LOCKING_FLAG,
1772
 
                                                btr_cur, node->update,
1773
 
                                                node->cmpl_info, thr, mtr);
1774
 
        }
1775
 
 
1776
 
        mtr_commit(mtr);
1777
 
 
1778
 
        if (UNIV_LIKELY(err == DB_SUCCESS)) {
1779
 
 
1780
 
                return(DB_SUCCESS);
1781
 
        }
1782
 
 
1783
 
        if (buf_LRU_buf_pool_running_out()) {
1784
 
 
1785
 
                return(DB_LOCK_TABLE_FULL);
1786
 
        }
1787
 
        /* We may have to modify the tree structure: do a pessimistic descent
1788
 
        down the index tree */
1789
 
 
1790
 
        mtr_start(mtr);
1791
 
 
1792
 
        /* NOTE: this transaction has an s-lock or x-lock on the record and
1793
 
        therefore other transactions cannot modify the record when we have no
1794
 
        latch on the page. In addition, we assume that other query threads of
1795
 
        the same transaction do not modify the record in the meantime.
1796
 
        Therefore we can assert that the restoration of the cursor succeeds. */
1797
 
 
1798
 
        ut_a(btr_pcur_restore_position(BTR_MODIFY_TREE, pcur, mtr));
1799
 
 
1800
 
        ut_ad(!rec_get_deleted_flag(btr_pcur_get_rec(pcur),
1801
 
                                    dict_table_is_comp(index->table)));
1802
 
 
1803
 
        err = btr_cur_pessimistic_update(BTR_NO_LOCKING_FLAG, btr_cur,
1804
 
                                         &heap, &big_rec, node->update,
1805
 
                                         node->cmpl_info, thr, mtr);
1806
 
        mtr_commit(mtr);
1807
 
 
1808
 
        if (err == DB_SUCCESS && big_rec) {
1809
 
                ulint           offsets_[REC_OFFS_NORMAL_SIZE];
1810
 
                rec_t*          rec;
1811
 
                rec_offs_init(offsets_);
1812
 
 
1813
 
                mtr_start(mtr);
1814
 
 
1815
 
                ut_a(btr_pcur_restore_position(BTR_MODIFY_TREE, pcur, mtr));
1816
 
                rec = btr_cur_get_rec(btr_cur);
1817
 
                err = btr_store_big_rec_extern_fields(
1818
 
                        index, btr_cur_get_block(btr_cur), rec,
1819
 
                        rec_get_offsets(rec, index, offsets_,
1820
 
                                        ULINT_UNDEFINED, &heap),
1821
 
                        big_rec, mtr);
1822
 
                mtr_commit(mtr);
1823
 
        }
1824
 
 
1825
 
        if (UNIV_LIKELY_NULL(heap)) {
1826
 
                mem_heap_free(heap);
1827
 
        }
1828
 
 
1829
 
        if (big_rec) {
1830
 
                dtuple_big_rec_free(big_rec);
1831
 
        }
1832
 
 
1833
 
        return(err);
1834
 
}
1835
 
 
1836
 
/***********************************************************//**
1837
 
Delete marks a clustered index record.
1838
 
@return DB_SUCCESS if operation successfully completed, else error code */
1839
 
static
1840
 
ulint
1841
 
row_upd_del_mark_clust_rec(
1842
 
/*=======================*/
1843
 
        upd_node_t*     node,   /*!< in: row update node */
1844
 
        dict_index_t*   index,  /*!< in: clustered index */
1845
 
        ulint*          offsets,/*!< in/out: rec_get_offsets() for the
1846
 
                                record under the cursor */
1847
 
        que_thr_t*      thr,    /*!< in: query thread */
1848
 
        ibool           referenced,
1849
 
                                /*!< in: TRUE if index may be referenced in
1850
 
                                a foreign key constraint */
1851
 
        mtr_t*          mtr)    /*!< in: mtr; gets committed here */
1852
 
{
1853
 
        btr_pcur_t*     pcur;
1854
 
        btr_cur_t*      btr_cur;
1855
 
        ulint           err;
1856
 
 
1857
 
        ut_ad(node);
1858
 
        ut_ad(dict_index_is_clust(index));
1859
 
        ut_ad(node->is_delete);
1860
 
 
1861
 
        pcur = node->pcur;
1862
 
        btr_cur = btr_pcur_get_btr_cur(pcur);
1863
 
 
1864
 
        /* Store row because we have to build also the secondary index
1865
 
        entries */
1866
 
 
1867
 
        row_upd_store_row(node);
1868
 
 
1869
 
        /* Mark the clustered index record deleted; we do not have to check
1870
 
        locks, because we assume that we have an x-lock on the record */
1871
 
 
1872
 
        err = btr_cur_del_mark_set_clust_rec(BTR_NO_LOCKING_FLAG,
1873
 
                                             btr_cur, TRUE, thr, mtr);
1874
 
        if (err == DB_SUCCESS && referenced) {
1875
 
                /* NOTE that the following call loses the position of pcur ! */
1876
 
 
1877
 
                err = row_upd_check_references_constraints(
1878
 
                        node, pcur, index->table, index, offsets, thr, mtr);
1879
 
        }
1880
 
 
1881
 
        mtr_commit(mtr);
1882
 
 
1883
 
        return(err);
1884
 
}
1885
 
 
1886
 
/***********************************************************//**
1887
 
Updates the clustered index record.
1888
 
@return DB_SUCCESS if operation successfully completed, DB_LOCK_WAIT
1889
 
in case of a lock wait, else error code */
1890
 
static
1891
 
ulint
1892
 
row_upd_clust_step(
1893
 
/*===============*/
1894
 
        upd_node_t*     node,   /*!< in: row update node */
1895
 
        que_thr_t*      thr)    /*!< in: query thread */
1896
 
{
1897
 
        dict_index_t*   index;
1898
 
        btr_pcur_t*     pcur;
1899
 
        ibool           success;
1900
 
        ulint           err;
1901
 
        mtr_t*          mtr;
1902
 
        mtr_t           mtr_buf;
1903
 
        rec_t*          rec;
1904
 
        mem_heap_t*     heap            = NULL;
1905
 
        ulint           offsets_[REC_OFFS_NORMAL_SIZE];
1906
 
        ulint*          offsets;
1907
 
        ibool           referenced;
1908
 
        rec_offs_init(offsets_);
1909
 
 
1910
 
        index = dict_table_get_first_index(node->table);
1911
 
 
1912
 
        referenced = row_upd_index_is_referenced(index, thr_get_trx(thr));
1913
 
 
1914
 
        pcur = node->pcur;
1915
 
 
1916
 
        /* We have to restore the cursor to its position */
1917
 
        mtr = &mtr_buf;
1918
 
 
1919
 
        mtr_start(mtr);
1920
 
 
1921
 
        /* If the restoration does not succeed, then the same
1922
 
        transaction has deleted the record on which the cursor was,
1923
 
        and that is an SQL error. If the restoration succeeds, it may
1924
 
        still be that the same transaction has successively deleted
1925
 
        and inserted a record with the same ordering fields, but in
1926
 
        that case we know that the transaction has at least an
1927
 
        implicit x-lock on the record. */
1928
 
 
1929
 
        ut_a(pcur->rel_pos == BTR_PCUR_ON);
1930
 
 
1931
 
        success = btr_pcur_restore_position(BTR_MODIFY_LEAF, pcur, mtr);
1932
 
 
1933
 
        if (!success) {
1934
 
                err = DB_RECORD_NOT_FOUND;
1935
 
 
1936
 
                mtr_commit(mtr);
1937
 
 
1938
 
                return(err);
1939
 
        }
1940
 
 
1941
 
        /* If this is a row in SYS_INDEXES table of the data dictionary,
1942
 
        then we have to free the file segments of the index tree associated
1943
 
        with the index */
1944
 
 
1945
 
        if (node->is_delete && node->table->id == DICT_INDEXES_ID) {
1946
 
 
1947
 
                dict_drop_index_tree(btr_pcur_get_rec(pcur), mtr);
1948
 
 
1949
 
                mtr_commit(mtr);
1950
 
 
1951
 
                mtr_start(mtr);
1952
 
 
1953
 
                success = btr_pcur_restore_position(BTR_MODIFY_LEAF, pcur,
1954
 
                                                    mtr);
1955
 
                if (!success) {
1956
 
                        err = DB_ERROR;
1957
 
 
1958
 
                        mtr_commit(mtr);
1959
 
 
1960
 
                        return(err);
1961
 
                }
1962
 
        }
1963
 
 
1964
 
        rec = btr_pcur_get_rec(pcur);
1965
 
        offsets = rec_get_offsets(rec, index, offsets_,
1966
 
                                  ULINT_UNDEFINED, &heap);
1967
 
 
1968
 
        if (!node->has_clust_rec_x_lock) {
1969
 
                err = lock_clust_rec_modify_check_and_lock(
1970
 
                        0, btr_pcur_get_block(pcur),
1971
 
                        rec, index, offsets, thr);
1972
 
                if (err != DB_SUCCESS) {
1973
 
                        mtr_commit(mtr);
1974
 
                        goto exit_func;
1975
 
                }
1976
 
        }
1977
 
 
1978
 
        /* NOTE: the following function calls will also commit mtr */
1979
 
 
1980
 
        if (node->is_delete) {
1981
 
                err = row_upd_del_mark_clust_rec(
1982
 
                        node, index, offsets, thr, referenced, mtr);
1983
 
 
1984
 
                if (err == DB_SUCCESS) {
1985
 
                        node->state = UPD_NODE_UPDATE_ALL_SEC;
1986
 
                        node->index = dict_table_get_next_index(index);
1987
 
                }
1988
 
exit_func:
1989
 
                if (UNIV_LIKELY_NULL(heap)) {
1990
 
                        mem_heap_free(heap);
1991
 
                }
1992
 
                return(err);
1993
 
        }
1994
 
 
1995
 
        /* If the update is made for MySQL, we already have the update vector
1996
 
        ready, else we have to do some evaluation: */
1997
 
 
1998
 
        if (UNIV_UNLIKELY(!node->in_mysql_interface)) {
1999
 
                /* Copy the necessary columns from clust_rec and calculate the
2000
 
                new values to set */
2001
 
                row_upd_copy_columns(rec, offsets,
2002
 
                                     UT_LIST_GET_FIRST(node->columns));
2003
 
                row_upd_eval_new_vals(node->update);
2004
 
        }
2005
 
 
2006
 
        if (UNIV_LIKELY_NULL(heap)) {
2007
 
                mem_heap_free(heap);
2008
 
        }
2009
 
 
2010
 
        if (node->cmpl_info & UPD_NODE_NO_ORD_CHANGE) {
2011
 
 
2012
 
                err = row_upd_clust_rec(node, index, thr, mtr);
2013
 
                return(err);
2014
 
        }
2015
 
 
2016
 
        row_upd_store_row(node);
2017
 
 
2018
 
        if (row_upd_changes_ord_field_binary(node->row, index, node->update)) {
2019
 
 
2020
 
                /* Update causes an ordering field (ordering fields within
2021
 
                the B-tree) of the clustered index record to change: perform
2022
 
                the update by delete marking and inserting.
2023
 
 
2024
 
                TODO! What to do to the 'Halloween problem', where an update
2025
 
                moves the record forward in index so that it is again
2026
 
                updated when the cursor arrives there? Solution: the
2027
 
                read operation must check the undo record undo number when
2028
 
                choosing records to update. MySQL solves now the problem
2029
 
                externally! */
2030
 
 
2031
 
                err = row_upd_clust_rec_by_insert(
2032
 
                        node, index, thr, referenced, mtr);
2033
 
 
2034
 
                if (err != DB_SUCCESS) {
2035
 
 
2036
 
                        return(err);
2037
 
                }
2038
 
 
2039
 
                node->state = UPD_NODE_UPDATE_ALL_SEC;
2040
 
        } else {
2041
 
                err = row_upd_clust_rec(node, index, thr, mtr);
2042
 
 
2043
 
                if (err != DB_SUCCESS) {
2044
 
 
2045
 
                        return(err);
2046
 
                }
2047
 
 
2048
 
                node->state = UPD_NODE_UPDATE_SOME_SEC;
2049
 
        }
2050
 
 
2051
 
        node->index = dict_table_get_next_index(index);
2052
 
 
2053
 
        return(err);
2054
 
}
2055
 
 
2056
 
/***********************************************************//**
2057
 
Updates the affected index records of a row. When the control is transferred
2058
 
to this node, we assume that we have a persistent cursor which was on a
2059
 
record, and the position of the cursor is stored in the cursor.
2060
 
@return DB_SUCCESS if operation successfully completed, else error
2061
 
code or DB_LOCK_WAIT */
2062
 
static
2063
 
ulint
2064
 
row_upd(
2065
 
/*====*/
2066
 
        upd_node_t*     node,   /*!< in: row update node */
2067
 
        que_thr_t*      thr)    /*!< in: query thread */
2068
 
{
2069
 
        ulint   err     = DB_SUCCESS;
2070
 
 
2071
 
        ut_ad(node && thr);
2072
 
 
2073
 
        if (UNIV_LIKELY(node->in_mysql_interface)) {
2074
 
 
2075
 
                /* We do not get the cmpl_info value from the MySQL
2076
 
                interpreter: we must calculate it on the fly: */
2077
 
 
2078
 
                if (node->is_delete
2079
 
                    || row_upd_changes_some_index_ord_field_binary(
2080
 
                            node->table, node->update)) {
2081
 
                        node->cmpl_info = 0;
2082
 
                } else {
2083
 
                        node->cmpl_info = UPD_NODE_NO_ORD_CHANGE;
2084
 
                }
2085
 
        }
2086
 
 
2087
 
        if (node->state == UPD_NODE_UPDATE_CLUSTERED
2088
 
            || node->state == UPD_NODE_INSERT_CLUSTERED) {
2089
 
 
2090
 
                log_free_check();
2091
 
                err = row_upd_clust_step(node, thr);
2092
 
 
2093
 
                if (err != DB_SUCCESS) {
2094
 
 
2095
 
                        goto function_exit;
2096
 
                }
2097
 
        }
2098
 
 
2099
 
        if (!node->is_delete && (node->cmpl_info & UPD_NODE_NO_ORD_CHANGE)) {
2100
 
 
2101
 
                goto function_exit;
2102
 
        }
2103
 
 
2104
 
        while (node->index != NULL) {
2105
 
 
2106
 
                log_free_check();
2107
 
                err = row_upd_sec_step(node, thr);
2108
 
 
2109
 
                if (err != DB_SUCCESS) {
2110
 
 
2111
 
                        goto function_exit;
2112
 
                }
2113
 
 
2114
 
                node->index = dict_table_get_next_index(node->index);
2115
 
        }
2116
 
 
2117
 
function_exit:
2118
 
        if (err == DB_SUCCESS) {
2119
 
                /* Do some cleanup */
2120
 
 
2121
 
                if (node->row != NULL) {
2122
 
                        node->row = NULL;
2123
 
                        node->ext = NULL;
2124
 
                        node->upd_row = NULL;
2125
 
                        node->upd_ext = NULL;
2126
 
                        mem_heap_empty(node->heap);
2127
 
                }
2128
 
 
2129
 
                node->state = UPD_NODE_UPDATE_CLUSTERED;
2130
 
        }
2131
 
 
2132
 
        return(err);
2133
 
}
2134
 
 
2135
 
/***********************************************************//**
2136
 
Updates a row in a table. This is a high-level function used in SQL execution
2137
 
graphs.
2138
 
@return query thread to run next or NULL */
2139
 
UNIV_INTERN
2140
 
que_thr_t*
2141
 
row_upd_step(
2142
 
/*=========*/
2143
 
        que_thr_t*      thr)    /*!< in: query thread */
2144
 
{
2145
 
        upd_node_t*     node;
2146
 
        sel_node_t*     sel_node;
2147
 
        que_node_t*     parent;
2148
 
        ulint           err             = DB_SUCCESS;
2149
 
        trx_t*          trx;
2150
 
 
2151
 
        ut_ad(thr);
2152
 
 
2153
 
        trx = thr_get_trx(thr);
2154
 
 
2155
 
        trx_start_if_not_started(trx);
2156
 
 
2157
 
        node = static_cast<upd_node_t *>(thr->run_node);
2158
 
 
2159
 
        sel_node = node->select;
2160
 
 
2161
 
        parent = que_node_get_parent(node);
2162
 
 
2163
 
        ut_ad(que_node_get_type(node) == QUE_NODE_UPDATE);
2164
 
 
2165
 
        if (thr->prev_node == parent) {
2166
 
                node->state = UPD_NODE_SET_IX_LOCK;
2167
 
        }
2168
 
 
2169
 
        if (node->state == UPD_NODE_SET_IX_LOCK) {
2170
 
 
2171
 
                if (!node->has_clust_rec_x_lock) {
2172
 
                        /* It may be that the current session has not yet
2173
 
                        started its transaction, or it has been committed: */
2174
 
 
2175
 
                        err = lock_table(0, node->table, LOCK_IX, thr);
2176
 
 
2177
 
                        if (err != DB_SUCCESS) {
2178
 
 
2179
 
                                goto error_handling;
2180
 
                        }
2181
 
                }
2182
 
 
2183
 
                node->state = UPD_NODE_UPDATE_CLUSTERED;
2184
 
 
2185
 
                if (node->searched_update) {
2186
 
                        /* Reset the cursor */
2187
 
                        sel_node->state = SEL_NODE_OPEN;
2188
 
 
2189
 
                        /* Fetch a row to update */
2190
 
 
2191
 
                        thr->run_node = sel_node;
2192
 
 
2193
 
                        return(thr);
2194
 
                }
2195
 
        }
2196
 
 
2197
 
        /* sel_node is NULL if we are in the MySQL interface */
2198
 
 
2199
 
        if (sel_node && (sel_node->state != SEL_NODE_FETCH)) {
2200
 
 
2201
 
                if (!node->searched_update) {
2202
 
                        /* An explicit cursor should be positioned on a row
2203
 
                        to update */
2204
 
 
2205
 
                        ut_error;
2206
 
 
2207
 
                        err = DB_ERROR;
2208
 
 
2209
 
                        goto error_handling;
2210
 
                }
2211
 
 
2212
 
                ut_ad(sel_node->state == SEL_NODE_NO_MORE_ROWS);
2213
 
 
2214
 
                /* No more rows to update, or the select node performed the
2215
 
                updates directly in-place */
2216
 
 
2217
 
                thr->run_node = parent;
2218
 
 
2219
 
                return(thr);
2220
 
        }
2221
 
 
2222
 
        /* DO THE CHECKS OF THE CONSISTENCY CONSTRAINTS HERE */
2223
 
 
2224
 
        err = row_upd(node, thr);
2225
 
 
2226
 
error_handling:
2227
 
        trx->error_state = err;
2228
 
 
2229
 
        if (err != DB_SUCCESS) {
2230
 
                return(NULL);
2231
 
        }
2232
 
 
2233
 
        /* DO THE TRIGGER ACTIONS HERE */
2234
 
 
2235
 
        if (node->searched_update) {
2236
 
                /* Fetch next row to update */
2237
 
 
2238
 
                thr->run_node = sel_node;
2239
 
        } else {
2240
 
                /* It was an explicit cursor update */
2241
 
 
2242
 
                thr->run_node = parent;
2243
 
        }
2244
 
 
2245
 
        node->state = UPD_NODE_UPDATE_CLUSTERED;
2246
 
 
2247
 
        return(thr);
2248
 
}
2249
 
#endif /* !UNIV_HOTBACKUP */