1
/*****************************************************************************
3
Copyright (c) 1997, 2009, Innobase Oy. All Rights Reserved.
4
Copyright (c) 2008, Google Inc.
6
Portions of this file contain modifications contributed and copyrighted by
7
Google, Inc. Those modifications are gratefully acknowledged and are described
8
briefly in the InnoDB documentation. The contributions by Google are
9
incorporated with their permission, and subject to the conditions contained in
10
the file COPYING.Google.
12
This program is free software; you can redistribute it and/or modify it under
13
the terms of the GNU General Public License as published by the Free Software
14
Foundation; version 2 of the License.
16
This program is distributed in the hope that it will be useful, but WITHOUT
17
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
18
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
20
You should have received a copy of the GNU General Public License along with
21
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
22
Place, Suite 330, Boston, MA 02111-1307 USA
24
*****************************************************************************/
26
/***************************************************//**
30
Created 12/19/1997 Heikki Tuuri
31
*******************************************************/
39
#include "dict0dict.h"
40
#include "dict0boot.h"
46
#include "mach0data.h"
52
#include "lock0lock.h"
53
#include "eval0eval.h"
55
#include "pars0pars.h"
56
#include "row0mysql.h"
57
#include "read0read.h"
59
#include "ha_prototypes.h"
61
/* Maximum number of rows to prefetch; MySQL interface has another parameter */
62
#define SEL_MAX_N_PREFETCH 16
64
/* Number of rows fetched, after which to start prefetching; MySQL interface
65
has another parameter */
66
#define SEL_PREFETCH_LIMIT 1
68
/* When a select has accessed about this many pages, it returns control back
69
to que_run_threads: this is to allow canceling runaway queries */
71
#define SEL_COST_LIMIT 100
73
/* Flags for search shortcut */
75
#define SEL_EXHAUSTED 1
78
/********************************************************************//**
79
Returns TRUE if the user-defined column in a secondary index record
80
is alphabetically the same as the corresponding BLOB column in the clustered
82
NOTE: the comparison is NOT done as a binary comparison, but character
83
fields are compared with collation!
84
@return TRUE if the columns are equal */
87
row_sel_sec_rec_is_for_blob(
88
/*========================*/
89
ulint mtype, /*!< in: main type */
90
ulint prtype, /*!< in: precise type */
91
ulint mbminlen, /*!< in: minimum length of a
92
multi-byte character */
93
ulint mbmaxlen, /*!< in: maximum length of a
94
multi-byte character */
95
const byte* clust_field, /*!< in: the locally stored part of
96
the clustered index column, including
97
the BLOB pointer; the clustered
98
index record must be covered by
99
a lock or a page latch to protect it
100
against deletion (rollback or purge) */
101
ulint clust_len, /*!< in: length of clust_field */
102
const byte* sec_field, /*!< in: column in secondary index */
103
ulint sec_len, /*!< in: length of sec_field */
104
ulint zip_size) /*!< in: compressed page size, or 0 */
107
byte buf[DICT_MAX_INDEX_COL_LEN];
109
len = btr_copy_externally_stored_field_prefix(buf, sizeof buf,
111
clust_field, clust_len);
113
if (UNIV_UNLIKELY(len == 0)) {
114
/* The BLOB was being deleted as the server crashed.
115
There should not be any secondary index records
116
referring to this clustered index record, because
117
btr_free_externally_stored_field() is called after all
118
secondary index entries of the row have been purged. */
122
len = dtype_get_at_most_n_mbchars(prtype, mbminlen, mbmaxlen,
123
sec_len, len, (const char*) buf);
125
return(!cmp_data_data(mtype, prtype, buf, len, sec_field, sec_len));
128
/********************************************************************//**
129
Returns TRUE if the user-defined column values in a secondary index record
130
are alphabetically the same as the corresponding columns in the clustered
132
NOTE: the comparison is NOT done as a binary comparison, but character
133
fields are compared with collation!
134
@return TRUE if the secondary record is equal to the corresponding
135
fields in the clustered record, when compared with collation */
138
row_sel_sec_rec_is_for_clust_rec(
139
/*=============================*/
140
const rec_t* sec_rec, /*!< in: secondary index record */
141
dict_index_t* sec_index, /*!< in: secondary index */
142
const rec_t* clust_rec, /*!< in: clustered index record;
143
must be protected by a lock or
144
a page latch against deletion
145
in rollback or purge */
146
dict_index_t* clust_index) /*!< in: clustered index */
148
const byte* sec_field;
150
const byte* clust_field;
153
mem_heap_t* heap = NULL;
154
ulint clust_offsets_[REC_OFFS_NORMAL_SIZE];
155
ulint sec_offsets_[REC_OFFS_SMALL_SIZE];
156
ulint* clust_offs = clust_offsets_;
157
ulint* sec_offs = sec_offsets_;
158
ibool is_equal = TRUE;
160
rec_offs_init(clust_offsets_);
161
rec_offs_init(sec_offsets_);
163
if (rec_get_deleted_flag(clust_rec,
164
dict_table_is_comp(clust_index->table))) {
166
/* The clustered index record is delete-marked;
167
it is not visible in the read view. Besides,
168
if there are any externally stored columns,
169
some of them may have already been purged. */
173
clust_offs = rec_get_offsets(clust_rec, clust_index, clust_offs,
174
ULINT_UNDEFINED, &heap);
175
sec_offs = rec_get_offsets(sec_rec, sec_index, sec_offs,
176
ULINT_UNDEFINED, &heap);
178
n = dict_index_get_n_ordering_defined_by_user(sec_index);
180
for (i = 0; i < n; i++) {
181
const dict_field_t* ifield;
182
const dict_col_t* col;
187
ifield = dict_index_get_nth_field(sec_index, i);
188
col = dict_field_get_col(ifield);
189
clust_pos = dict_col_get_clust_pos(col, clust_index);
191
clust_field = rec_get_nth_field(
192
clust_rec, clust_offs, clust_pos, &clust_len);
193
sec_field = rec_get_nth_field(sec_rec, sec_offs, i, &sec_len);
197
if (ifield->prefix_len > 0 && len != UNIV_SQL_NULL) {
199
if (rec_offs_nth_extern(clust_offs, clust_pos)) {
200
len -= BTR_EXTERN_FIELD_REF_SIZE;
203
len = dtype_get_at_most_n_mbchars(
204
col->prtype, col->mbminlen, col->mbmaxlen,
205
ifield->prefix_len, len, (char*) clust_field);
207
if (rec_offs_nth_extern(clust_offs, clust_pos)
209
if (!row_sel_sec_rec_is_for_blob(
210
col->mtype, col->prtype,
211
col->mbminlen, col->mbmaxlen,
212
clust_field, clust_len,
215
clust_index->table))) {
223
if (0 != cmp_data_data(col->mtype, col->prtype,
225
sec_field, sec_len)) {
233
if (UNIV_LIKELY_NULL(heap)) {
239
/*********************************************************************//**
240
Creates a select node struct.
241
@return own: select node struct */
246
mem_heap_t* heap) /*!< in: memory heap where created */
250
node = mem_heap_alloc(heap, sizeof(sel_node_t));
251
node->common.type = QUE_NODE_SELECT;
252
node->state = SEL_NODE_OPEN;
259
/*********************************************************************//**
260
Frees the memory private to a select node when a query graph is freed,
261
does not free the heap where the node was originally created. */
264
sel_node_free_private(
265
/*==================*/
266
sel_node_t* node) /*!< in: select node struct */
271
if (node->plans != NULL) {
272
for (i = 0; i < node->n_tables; i++) {
273
plan = sel_node_get_nth_plan(node, i);
275
btr_pcur_close(&(plan->pcur));
276
btr_pcur_close(&(plan->clust_pcur));
278
if (plan->old_vers_heap) {
279
mem_heap_free(plan->old_vers_heap);
285
/*********************************************************************//**
286
Evaluates the values in a select list. If there are aggregate functions,
287
their argument value is added to the aggregate total. */
290
sel_eval_select_list(
291
/*=================*/
292
sel_node_t* node) /*!< in: select node */
296
exp = node->select_list;
301
exp = que_node_get_next(exp);
305
/*********************************************************************//**
306
Assigns the values in the select list to the possible into-variables in
307
SELECT ... INTO ... */
310
sel_assign_into_var_values(
311
/*=======================*/
312
sym_node_t* var, /*!< in: first variable in a list of variables */
313
sel_node_t* node) /*!< in: select node */
322
exp = node->select_list;
327
eval_node_copy_val(var->alias, exp);
329
exp = que_node_get_next(exp);
330
var = que_node_get_next(var);
334
/*********************************************************************//**
335
Resets the aggregate value totals in the select list of an aggregate type
339
sel_reset_aggregate_vals(
340
/*=====================*/
341
sel_node_t* node) /*!< in: select node */
343
func_node_t* func_node;
345
ut_ad(node->is_aggregate);
347
func_node = node->select_list;
350
eval_node_set_int_val(func_node, 0);
352
func_node = que_node_get_next(func_node);
355
node->aggregate_already_fetched = FALSE;
358
/*********************************************************************//**
359
Copies the input variable values when an explicit cursor is opened. */
362
row_sel_copy_input_variable_vals(
363
/*=============================*/
364
sel_node_t* node) /*!< in: select node */
368
var = UT_LIST_GET_FIRST(node->copy_variables);
371
eval_node_copy_val(var, var->alias);
373
var->indirection = NULL;
375
var = UT_LIST_GET_NEXT(col_var_list, var);
379
/*********************************************************************//**
380
Fetches the column values from a record. */
383
row_sel_fetch_columns(
384
/*==================*/
385
dict_index_t* index, /*!< in: record index */
386
const rec_t* rec, /*!< in: record in a clustered or non-clustered
387
index; must be protected by a page latch */
388
const ulint* offsets,/*!< in: rec_get_offsets(rec, index) */
389
sym_node_t* column) /*!< in: first column in a column list, or
398
ut_ad(rec_offs_validate(rec, index, offsets));
400
if (dict_index_is_clust(index)) {
401
index_type = SYM_CLUST_FIELD_NO;
403
index_type = SYM_SEC_FIELD_NO;
407
mem_heap_t* heap = NULL;
410
field_no = column->field_nos[index_type];
412
if (field_no != ULINT_UNDEFINED) {
414
if (UNIV_UNLIKELY(rec_offs_nth_extern(offsets,
417
/* Copy an externally stored field to the
420
heap = mem_heap_create(1);
422
data = btr_rec_copy_externally_stored_field(
424
dict_table_zip_size(index->table),
425
field_no, &len, heap);
427
ut_a(len != UNIV_SQL_NULL);
431
data = rec_get_nth_field(rec, offsets,
434
if (len == UNIV_SQL_NULL) {
438
needs_copy = column->copy_val;
442
eval_node_copy_and_alloc_val(column, data,
445
val = que_node_get_val(column);
446
dfield_set_data(val, data, len);
449
if (UNIV_LIKELY_NULL(heap)) {
454
column = UT_LIST_GET_NEXT(col_var_list, column);
458
/*********************************************************************//**
459
Allocates a prefetch buffer for a column when prefetch is first time done. */
462
sel_col_prefetch_buf_alloc(
463
/*=======================*/
464
sym_node_t* column) /*!< in: symbol table node for a column */
469
ut_ad(que_node_get_type(column) == QUE_NODE_SYMBOL);
471
column->prefetch_buf = mem_alloc(SEL_MAX_N_PREFETCH
472
* sizeof(sel_buf_t));
473
for (i = 0; i < SEL_MAX_N_PREFETCH; i++) {
474
sel_buf = column->prefetch_buf + i;
476
sel_buf->data = NULL;
478
sel_buf->val_buf_size = 0;
482
/*********************************************************************//**
483
Frees a prefetch buffer for a column, including the dynamically allocated
484
memory for data stored there. */
487
sel_col_prefetch_buf_free(
488
/*======================*/
489
sel_buf_t* prefetch_buf) /*!< in, own: prefetch buffer */
494
for (i = 0; i < SEL_MAX_N_PREFETCH; i++) {
495
sel_buf = prefetch_buf + i;
497
if (sel_buf->val_buf_size > 0) {
499
mem_free(sel_buf->data);
504
/*********************************************************************//**
505
Pops the column values for a prefetched, cached row from the column prefetch
506
buffers and places them to the val fields in the column nodes. */
509
sel_pop_prefetched_row(
510
/*===================*/
511
plan_t* plan) /*!< in: plan node for a table */
520
ut_ad(plan->n_rows_prefetched > 0);
522
column = UT_LIST_GET_FIRST(plan->columns);
525
val = que_node_get_val(column);
527
if (!column->copy_val) {
528
/* We did not really push any value for the
531
ut_ad(!column->prefetch_buf);
532
ut_ad(que_node_get_val_buf_size(column) == 0);
533
ut_d(dfield_set_null(val));
538
ut_ad(column->prefetch_buf);
539
ut_ad(!dfield_is_ext(val));
541
sel_buf = column->prefetch_buf + plan->first_prefetched;
543
data = sel_buf->data;
545
val_buf_size = sel_buf->val_buf_size;
547
/* We must keep track of the allocated memory for
548
column values to be able to free it later: therefore
549
we swap the values for sel_buf and val */
551
sel_buf->data = dfield_get_data(val);
552
sel_buf->len = dfield_get_len(val);
553
sel_buf->val_buf_size = que_node_get_val_buf_size(column);
555
dfield_set_data(val, data, len);
556
que_node_set_val_buf_size(column, val_buf_size);
558
column = UT_LIST_GET_NEXT(col_var_list, column);
561
plan->n_rows_prefetched--;
563
plan->first_prefetched++;
566
/*********************************************************************//**
567
Pushes the column values for a prefetched, cached row to the column prefetch
568
buffers from the val fields in the column nodes. */
571
sel_push_prefetched_row(
572
/*====================*/
573
plan_t* plan) /*!< in: plan node for a table */
583
if (plan->n_rows_prefetched == 0) {
585
plan->first_prefetched = 0;
587
pos = plan->n_rows_prefetched;
589
/* We have the convention that pushing new rows starts only
590
after the prefetch stack has been emptied: */
592
ut_ad(plan->first_prefetched == 0);
595
plan->n_rows_prefetched++;
597
ut_ad(pos < SEL_MAX_N_PREFETCH);
599
column = UT_LIST_GET_FIRST(plan->columns);
602
if (!column->copy_val) {
603
/* There is no sense to push pointers to database
604
page fields when we do not keep latch on the page! */
609
if (!column->prefetch_buf) {
610
/* Allocate a new prefetch buffer */
612
sel_col_prefetch_buf_alloc(column);
615
sel_buf = column->prefetch_buf + pos;
617
val = que_node_get_val(column);
619
data = dfield_get_data(val);
620
len = dfield_get_len(val);
621
val_buf_size = que_node_get_val_buf_size(column);
623
/* We must keep track of the allocated memory for
624
column values to be able to free it later: therefore
625
we swap the values for sel_buf and val */
627
dfield_set_data(val, sel_buf->data, sel_buf->len);
628
que_node_set_val_buf_size(column, sel_buf->val_buf_size);
630
sel_buf->data = data;
632
sel_buf->val_buf_size = val_buf_size;
634
column = UT_LIST_GET_NEXT(col_var_list, column);
638
/*********************************************************************//**
639
Builds a previous version of a clustered index record for a consistent read
640
@return DB_SUCCESS or error code */
643
row_sel_build_prev_vers(
644
/*====================*/
645
read_view_t* read_view, /*!< in: read view */
646
dict_index_t* index, /*!< in: plan node for table */
647
rec_t* rec, /*!< in: record in a clustered index */
648
ulint** offsets, /*!< in/out: offsets returned by
649
rec_get_offsets(rec, plan->index) */
650
mem_heap_t** offset_heap, /*!< in/out: memory heap from which
651
the offsets are allocated */
652
mem_heap_t** old_vers_heap, /*!< out: old version heap to use */
653
rec_t** old_vers, /*!< out: old version, or NULL if the
654
record does not exist in the view:
655
i.e., it was freshly inserted
657
mtr_t* mtr) /*!< in: mtr */
661
if (*old_vers_heap) {
662
mem_heap_empty(*old_vers_heap);
664
*old_vers_heap = mem_heap_create(512);
667
err = row_vers_build_for_consistent_read(
668
rec, mtr, index, offsets, read_view, offset_heap,
669
*old_vers_heap, old_vers);
673
/*********************************************************************//**
674
Builds the last committed version of a clustered index record for a
675
semi-consistent read.
676
@return DB_SUCCESS or error code */
679
row_sel_build_committed_vers_for_mysql(
680
/*===================================*/
681
dict_index_t* clust_index, /*!< in: clustered index */
682
row_prebuilt_t* prebuilt, /*!< in: prebuilt struct */
683
const rec_t* rec, /*!< in: record in a clustered index */
684
ulint** offsets, /*!< in/out: offsets returned by
685
rec_get_offsets(rec, clust_index) */
686
mem_heap_t** offset_heap, /*!< in/out: memory heap from which
687
the offsets are allocated */
688
const rec_t** old_vers, /*!< out: old version, or NULL if the
689
record does not exist in the view:
690
i.e., it was freshly inserted
692
mtr_t* mtr) /*!< in: mtr */
696
if (prebuilt->old_vers_heap) {
697
mem_heap_empty(prebuilt->old_vers_heap);
699
prebuilt->old_vers_heap = mem_heap_create(200);
702
err = row_vers_build_for_semi_consistent_read(
703
rec, mtr, clust_index, offsets, offset_heap,
704
prebuilt->old_vers_heap, old_vers);
708
/*********************************************************************//**
709
Tests the conditions which determine when the index segment we are searching
710
through has been exhausted.
711
@return TRUE if row passed the tests */
714
row_sel_test_end_conds(
715
/*===================*/
716
plan_t* plan) /*!< in: plan for the table; the column values must
717
already have been retrieved and the right sides of
718
comparisons evaluated */
722
/* All conditions in end_conds are comparisons of a column to an
725
cond = UT_LIST_GET_FIRST(plan->end_conds);
728
/* Evaluate the left side of the comparison, i.e., get the
729
column value if there is an indirection */
731
eval_sym(cond->args);
733
/* Do the comparison */
735
if (!eval_cmp(cond)) {
740
cond = UT_LIST_GET_NEXT(cond_list, cond);
746
/*********************************************************************//**
747
Tests the other conditions.
748
@return TRUE if row passed the tests */
751
row_sel_test_other_conds(
752
/*=====================*/
753
plan_t* plan) /*!< in: plan for the table; the column values must
754
already have been retrieved */
758
cond = UT_LIST_GET_FIRST(plan->other_conds);
763
if (!eval_node_get_ibool_val(cond)) {
768
cond = UT_LIST_GET_NEXT(cond_list, cond);
774
/*********************************************************************//**
775
Retrieves the clustered index record corresponding to a record in a
776
non-clustered index. Does the necessary locking.
777
@return DB_SUCCESS or error code */
780
row_sel_get_clust_rec(
781
/*==================*/
782
sel_node_t* node, /*!< in: select_node */
783
plan_t* plan, /*!< in: plan node for table */
784
rec_t* rec, /*!< in: record in a non-clustered index */
785
que_thr_t* thr, /*!< in: query thread */
786
rec_t** out_rec,/*!< out: clustered record or an old version of
787
it, NULL if the old version did not exist
788
in the read view, i.e., it was a fresh
790
mtr_t* mtr) /*!< in: mtr used to get access to the
791
non-clustered record; the same mtr is used to
792
access the clustered index */
798
mem_heap_t* heap = NULL;
799
ulint offsets_[REC_OFFS_NORMAL_SIZE];
800
ulint* offsets = offsets_;
801
rec_offs_init(offsets_);
805
offsets = rec_get_offsets(rec,
806
btr_pcur_get_btr_cur(&plan->pcur)->index,
807
offsets, ULINT_UNDEFINED, &heap);
809
row_build_row_ref_fast(plan->clust_ref, plan->clust_map, rec, offsets);
811
index = dict_table_get_first_index(plan->table);
813
btr_pcur_open_with_no_init(index, plan->clust_ref, PAGE_CUR_LE,
814
BTR_SEARCH_LEAF, &plan->clust_pcur,
817
clust_rec = btr_pcur_get_rec(&(plan->clust_pcur));
819
/* Note: only if the search ends up on a non-infimum record is the
820
low_match value the real match to the search tuple */
822
if (!page_rec_is_user_rec(clust_rec)
823
|| btr_pcur_get_low_match(&(plan->clust_pcur))
824
< dict_index_get_n_unique(index)) {
826
ut_a(rec_get_deleted_flag(rec,
827
dict_table_is_comp(plan->table)));
828
ut_a(node->read_view);
830
/* In a rare case it is possible that no clust rec is found
831
for a delete-marked secondary index record: if in row0umod.c
832
in row_undo_mod_remove_clust_low() we have already removed
833
the clust rec, while purge is still cleaning and removing
834
secondary index records associated with earlier versions of
835
the clustered index record. In that case we know that the
836
clustered index record did not exist in the read view of
842
offsets = rec_get_offsets(clust_rec, index, offsets,
843
ULINT_UNDEFINED, &heap);
845
if (!node->read_view) {
846
/* Try to place a lock on the index record */
848
/* If innodb_locks_unsafe_for_binlog option is used
849
or this session is using READ COMMITTED isolation level
850
we lock only the record, i.e., next-key locking is
855
trx = thr_get_trx(thr);
857
if (srv_locks_unsafe_for_binlog
858
|| trx->isolation_level == TRX_ISO_READ_COMMITTED) {
859
lock_type = LOCK_REC_NOT_GAP;
861
lock_type = LOCK_ORDINARY;
864
err = lock_clust_rec_read_check_and_lock(
865
0, btr_pcur_get_block(&plan->clust_pcur),
866
clust_rec, index, offsets,
867
node->row_lock_mode, lock_type, thr);
869
if (err != DB_SUCCESS) {
874
/* This is a non-locking consistent read: if necessary, fetch
875
a previous version of the record */
879
if (!lock_clust_rec_cons_read_sees(clust_rec, index, offsets,
882
err = row_sel_build_prev_vers(
883
node->read_view, index, clust_rec,
884
&offsets, &heap, &plan->old_vers_heap,
887
if (err != DB_SUCCESS) {
892
clust_rec = old_vers;
894
if (clust_rec == NULL) {
899
/* If we had to go to an earlier version of row or the
900
secondary index record is delete marked, then it may be that
901
the secondary index record corresponding to clust_rec
902
(or old_vers) is not rec; in that case we must ignore
903
such row because in our snapshot rec would not have existed.
904
Remember that from rec we cannot see directly which transaction
905
id corresponds to it: we have to go to the clustered index
906
record. A query where we want to fetch all rows where
907
the secondary index value is in some interval would return
908
a wrong result if we would not drop rows which we come to
909
visit through secondary index records that would not really
910
exist in our snapshot. */
913
|| rec_get_deleted_flag(rec, dict_table_is_comp(
915
&& !row_sel_sec_rec_is_for_clust_rec(rec, plan->index,
921
/* Fetch the columns needed in test conditions. The clustered
922
index record is protected by a page latch that was acquired
923
when plan->clust_pcur was positioned. The latch will not be
924
released until mtr_commit(mtr). */
926
row_sel_fetch_columns(index, clust_rec, offsets,
927
UT_LIST_GET_FIRST(plan->columns));
928
*out_rec = clust_rec;
932
if (UNIV_LIKELY_NULL(heap)) {
938
/*********************************************************************//**
939
Sets a lock on a record.
940
@return DB_SUCCESS or error code */
945
const buf_block_t* block, /*!< in: buffer block of rec */
946
const rec_t* rec, /*!< in: record */
947
dict_index_t* index, /*!< in: index */
948
const ulint* offsets,/*!< in: rec_get_offsets(rec, index) */
949
ulint mode, /*!< in: lock mode */
950
ulint type, /*!< in: LOCK_ORDINARY, LOCK_GAP, or
952
que_thr_t* thr) /*!< in: query thread */
957
trx = thr_get_trx(thr);
959
if (UT_LIST_GET_LEN(trx->trx_locks) > 10000) {
960
if (buf_LRU_buf_pool_running_out()) {
962
return(DB_LOCK_TABLE_FULL);
966
if (dict_index_is_clust(index)) {
967
err = lock_clust_rec_read_check_and_lock(
968
0, block, rec, index, offsets, mode, type, thr);
970
err = lock_sec_rec_read_check_and_lock(
971
0, block, rec, index, offsets, mode, type, thr);
977
/*********************************************************************//**
978
Opens a pcur to a table index. */
983
plan_t* plan, /*!< in: table plan */
984
ibool search_latch_locked,
985
/*!< in: TRUE if the thread currently
986
has the search latch locked in
988
mtr_t* mtr) /*!< in: mtr */
994
ulint has_search_latch = 0; /* RW_S_LATCH or 0 */
997
if (search_latch_locked) {
998
has_search_latch = RW_S_LATCH;
1001
index = plan->index;
1003
/* Calculate the value of the search tuple: the exact match columns
1004
get their expressions evaluated when we evaluate the right sides of
1007
cond = UT_LIST_GET_FIRST(plan->end_conds);
1010
eval_exp(que_node_get_next(cond->args));
1012
cond = UT_LIST_GET_NEXT(cond_list, cond);
1016
n_fields = dtuple_get_n_fields(plan->tuple);
1018
if (plan->n_exact_match < n_fields) {
1019
/* There is a non-exact match field which must be
1020
evaluated separately */
1022
eval_exp(plan->tuple_exps[n_fields - 1]);
1025
for (i = 0; i < n_fields; i++) {
1026
exp = plan->tuple_exps[i];
1028
dfield_copy_data(dtuple_get_nth_field(plan->tuple, i),
1029
que_node_get_val(exp));
1032
/* Open pcur to the index */
1034
btr_pcur_open_with_no_init(index, plan->tuple, plan->mode,
1035
BTR_SEARCH_LEAF, &plan->pcur,
1036
has_search_latch, mtr);
1038
/* Open the cursor to the start or the end of the index
1041
btr_pcur_open_at_index_side(plan->asc, index, BTR_SEARCH_LEAF,
1042
&(plan->pcur), FALSE, mtr);
1045
ut_ad(plan->n_rows_prefetched == 0);
1046
ut_ad(plan->n_rows_fetched == 0);
1047
ut_ad(plan->cursor_at_end == FALSE);
1049
plan->pcur_is_open = TRUE;
1052
/*********************************************************************//**
1053
Restores a stored pcur position to a table index.
1054
@return TRUE if the cursor should be moved to the next record after we
1055
return from this function (moved to the previous, in the case of a
1056
descending cursor) without processing again the current cursor
1060
row_sel_restore_pcur_pos(
1061
/*=====================*/
1062
plan_t* plan, /*!< in: table plan */
1063
mtr_t* mtr) /*!< in: mtr */
1065
ibool equal_position;
1066
ulint relative_position;
1068
ut_ad(!plan->cursor_at_end);
1070
relative_position = btr_pcur_get_rel_pos(&(plan->pcur));
1072
equal_position = btr_pcur_restore_position(BTR_SEARCH_LEAF,
1073
&(plan->pcur), mtr);
1075
/* If the cursor is traveling upwards, and relative_position is
1077
(1) BTR_PCUR_BEFORE: this is not allowed, as we did not have a lock
1078
yet on the successor of the page infimum;
1079
(2) BTR_PCUR_AFTER: btr_pcur_restore_position placed the cursor on the
1080
first record GREATER than the predecessor of a page supremum; we have
1081
not yet processed the cursor record: no need to move the cursor to the
1083
(3) BTR_PCUR_ON: btr_pcur_restore_position placed the cursor on the
1084
last record LESS or EQUAL to the old stored user record; (a) if
1085
equal_position is FALSE, this means that the cursor is now on a record
1086
less than the old user record, and we must move to the next record;
1087
(b) if equal_position is TRUE, then if
1088
plan->stored_cursor_rec_processed is TRUE, we must move to the next
1089
record, else there is no need to move the cursor. */
1092
if (relative_position == BTR_PCUR_ON) {
1094
if (equal_position) {
1096
return(plan->stored_cursor_rec_processed);
1102
ut_ad(relative_position == BTR_PCUR_AFTER
1103
|| relative_position == BTR_PCUR_AFTER_LAST_IN_TREE);
1108
/* If the cursor is traveling downwards, and relative_position is
1110
(1) BTR_PCUR_BEFORE: btr_pcur_restore_position placed the cursor on
1111
the last record LESS than the successor of a page infimum; we have not
1112
processed the cursor record: no need to move the cursor;
1113
(2) BTR_PCUR_AFTER: btr_pcur_restore_position placed the cursor on the
1114
first record GREATER than the predecessor of a page supremum; we have
1115
processed the cursor record: we should move the cursor to the previous
1117
(3) BTR_PCUR_ON: btr_pcur_restore_position placed the cursor on the
1118
last record LESS or EQUAL to the old stored user record; (a) if
1119
equal_position is FALSE, this means that the cursor is now on a record
1120
less than the old user record, and we need not move to the previous
1121
record; (b) if equal_position is TRUE, then if
1122
plan->stored_cursor_rec_processed is TRUE, we must move to the previous
1123
record, else there is no need to move the cursor. */
1125
if (relative_position == BTR_PCUR_BEFORE
1126
|| relative_position == BTR_PCUR_BEFORE_FIRST_IN_TREE) {
1131
if (relative_position == BTR_PCUR_ON) {
1133
if (equal_position) {
1135
return(plan->stored_cursor_rec_processed);
1141
ut_ad(relative_position == BTR_PCUR_AFTER
1142
|| relative_position == BTR_PCUR_AFTER_LAST_IN_TREE);
1147
/*********************************************************************//**
1148
Resets a plan cursor to a closed state. */
1153
plan_t* plan) /*!< in: plan */
1155
plan->pcur_is_open = FALSE;
1156
plan->cursor_at_end = FALSE;
1157
plan->n_rows_fetched = 0;
1158
plan->n_rows_prefetched = 0;
1161
/*********************************************************************//**
1162
Tries to do a shortcut to fetch a clustered index record with a unique key,
1163
using the hash index if possible (not always).
1164
@return SEL_FOUND, SEL_EXHAUSTED, SEL_RETRY */
1167
row_sel_try_search_shortcut(
1168
/*========================*/
1169
sel_node_t* node, /*!< in: select node for a consistent read */
1170
plan_t* plan, /*!< in: plan for a unique search in clustered
1172
mtr_t* mtr) /*!< in: mtr */
1174
dict_index_t* index;
1176
mem_heap_t* heap = NULL;
1177
ulint offsets_[REC_OFFS_NORMAL_SIZE];
1178
ulint* offsets = offsets_;
1180
rec_offs_init(offsets_);
1182
index = plan->index;
1184
ut_ad(node->read_view);
1185
ut_ad(plan->unique_search);
1186
ut_ad(!plan->must_get_clust);
1187
#ifdef UNIV_SYNC_DEBUG
1188
ut_ad(rw_lock_own(&btr_search_latch, RW_LOCK_SHARED));
1189
#endif /* UNIV_SYNC_DEBUG */
1191
row_sel_open_pcur(plan, TRUE, mtr);
1193
rec = btr_pcur_get_rec(&(plan->pcur));
1195
if (!page_rec_is_user_rec(rec)) {
1200
ut_ad(plan->mode == PAGE_CUR_GE);
1202
/* As the cursor is now placed on a user record after a search with
1203
the mode PAGE_CUR_GE, the up_match field in the cursor tells how many
1204
fields in the user record matched to the search tuple */
1206
if (btr_pcur_get_up_match(&(plan->pcur)) < plan->n_exact_match) {
1208
return(SEL_EXHAUSTED);
1211
/* This is a non-locking consistent read: if necessary, fetch
1212
a previous version of the record */
1214
offsets = rec_get_offsets(rec, index, offsets, ULINT_UNDEFINED, &heap);
1216
if (dict_index_is_clust(index)) {
1217
if (!lock_clust_rec_cons_read_sees(rec, index, offsets,
1222
} else if (!lock_sec_rec_cons_read_sees(rec, node->read_view)) {
1228
/* Test the deleted flag. */
1230
if (rec_get_deleted_flag(rec, dict_table_is_comp(plan->table))) {
1232
ret = SEL_EXHAUSTED;
1236
/* Fetch the columns needed in test conditions. The index
1237
record is protected by a page latch that was acquired when
1238
plan->pcur was positioned. The latch will not be released
1239
until mtr_commit(mtr). */
1241
row_sel_fetch_columns(index, rec, offsets,
1242
UT_LIST_GET_FIRST(plan->columns));
1244
/* Test the rest of search conditions */
1246
if (!row_sel_test_other_conds(plan)) {
1248
ret = SEL_EXHAUSTED;
1252
ut_ad(plan->pcur.latch_mode == BTR_SEARCH_LEAF);
1254
plan->n_rows_fetched++;
1257
if (UNIV_LIKELY_NULL(heap)) {
1258
mem_heap_free(heap);
1263
/*********************************************************************//**
1264
Performs a select step.
1265
@return DB_SUCCESS or error code */
1270
sel_node_t* node, /*!< in: select node */
1271
que_thr_t* thr) /*!< in: query thread */
1273
dict_index_t* index;
1280
ibool search_latch_locked;
1281
ibool consistent_read;
1283
/* The following flag becomes TRUE when we are doing a
1284
consistent read from a non-clustered index and we must look
1285
at the clustered index to find out the previous delete mark
1286
state of the non-clustered record: */
1288
ibool cons_read_requires_clust_rec = FALSE;
1289
ulint cost_counter = 0;
1290
ibool cursor_just_opened;
1291
ibool must_go_to_next;
1292
ibool mtr_has_extra_clust_latch = FALSE;
1293
/* TRUE if the search was made using
1294
a non-clustered index, and we had to
1295
access the clustered record: now &mtr
1296
contains a clustered index latch, and
1297
&mtr must be committed before we move
1298
to the next non-clustered record */
1301
mem_heap_t* heap = NULL;
1302
ulint offsets_[REC_OFFS_NORMAL_SIZE];
1303
ulint* offsets = offsets_;
1304
rec_offs_init(offsets_);
1306
ut_ad(thr->run_node == node);
1308
search_latch_locked = FALSE;
1310
if (node->read_view) {
1311
/* In consistent reads, we try to do with the hash index and
1312
not to use the buffer page get. This is to reduce memory bus
1313
load resulting from semaphore operations. The search latch
1314
will be s-locked when we access an index with a unique search
1315
condition, but not locked when we access an index with a
1316
less selective search condition. */
1318
consistent_read = TRUE;
1320
consistent_read = FALSE;
1326
This is the outer major loop in calculating a join. We come here when
1327
node->fetch_table changes, and after adding a row to aggregate totals
1328
and, of course, when this function is called. */
1330
ut_ad(mtr_has_extra_clust_latch == FALSE);
1332
plan = sel_node_get_nth_plan(node, node->fetch_table);
1333
index = plan->index;
1335
if (plan->n_rows_prefetched > 0) {
1336
sel_pop_prefetched_row(plan);
1338
goto next_table_no_mtr;
1341
if (plan->cursor_at_end) {
1342
/* The cursor has already reached the result set end: no more
1343
rows to process for this table cursor, as also the prefetch
1346
ut_ad(plan->pcur_is_open);
1348
goto table_exhausted_no_mtr;
1351
/* Open a cursor to index, or restore an open cursor position */
1355
if (consistent_read && plan->unique_search && !plan->pcur_is_open
1356
&& !plan->must_get_clust
1357
&& !plan->table->big_rows) {
1358
if (!search_latch_locked) {
1359
rw_lock_s_lock(&btr_search_latch);
1361
search_latch_locked = TRUE;
1362
} else if (rw_lock_get_writer(&btr_search_latch) == RW_LOCK_WAIT_EX) {
1364
/* There is an x-latch request waiting: release the
1365
s-latch for a moment; as an s-latch here is often
1366
kept for some 10 searches before being released,
1367
a waiting x-latch request would block other threads
1368
from acquiring an s-latch for a long time, lowering
1369
performance significantly in multiprocessors. */
1371
rw_lock_s_unlock(&btr_search_latch);
1372
rw_lock_s_lock(&btr_search_latch);
1375
found_flag = row_sel_try_search_shortcut(node, plan, &mtr);
1377
if (found_flag == SEL_FOUND) {
1381
} else if (found_flag == SEL_EXHAUSTED) {
1383
goto table_exhausted;
1386
ut_ad(found_flag == SEL_RETRY);
1388
plan_reset_cursor(plan);
1394
if (search_latch_locked) {
1395
rw_lock_s_unlock(&btr_search_latch);
1397
search_latch_locked = FALSE;
1400
if (!plan->pcur_is_open) {
1401
/* Evaluate the expressions to build the search tuple and
1404
row_sel_open_pcur(plan, search_latch_locked, &mtr);
1406
cursor_just_opened = TRUE;
1408
/* A new search was made: increment the cost counter */
1411
/* Restore pcur position to the index */
1413
must_go_to_next = row_sel_restore_pcur_pos(plan, &mtr);
1415
cursor_just_opened = FALSE;
1417
if (must_go_to_next) {
1418
/* We have already processed the cursor record: move
1428
In this loop we use pcur and try to fetch a qualifying row, and
1429
also fill the prefetch buffer for this table if n_rows_fetched has
1430
exceeded a threshold. While we are inside this loop, the following
1432
(1) &mtr is started,
1433
(2) pcur is positioned and open.
1435
NOTE that if cursor_just_opened is TRUE here, it means that we came
1436
to this point right after row_sel_open_pcur. */
1438
ut_ad(mtr_has_extra_clust_latch == FALSE);
1440
rec = btr_pcur_get_rec(&(plan->pcur));
1442
/* PHASE 1: Set a lock if specified */
1444
if (!node->asc && cursor_just_opened
1445
&& !page_rec_is_supremum(rec)) {
1447
/* When we open a cursor for a descending search, we must set
1448
a next-key lock on the successor record: otherwise it would
1449
be possible to insert new records next to the cursor position,
1450
and it might be that these new records should appear in the
1451
search result set, resulting in the phantom problem. */
1453
if (!consistent_read) {
1455
/* If innodb_locks_unsafe_for_binlog option is used
1456
or this session is using READ COMMITTED isolation
1457
level, we lock only the record, i.e., next-key
1458
locking is not used. */
1460
rec_t* next_rec = page_rec_get_next(rec);
1464
trx = thr_get_trx(thr);
1466
offsets = rec_get_offsets(next_rec, index, offsets,
1467
ULINT_UNDEFINED, &heap);
1469
if (srv_locks_unsafe_for_binlog
1470
|| trx->isolation_level
1471
== TRX_ISO_READ_COMMITTED) {
1473
if (page_rec_is_supremum(next_rec)) {
1478
lock_type = LOCK_REC_NOT_GAP;
1480
lock_type = LOCK_ORDINARY;
1483
err = sel_set_rec_lock(btr_pcur_get_block(&plan->pcur),
1484
next_rec, index, offsets,
1485
node->row_lock_mode,
1488
if (err != DB_SUCCESS) {
1489
/* Note that in this case we will store in pcur
1490
the PREDECESSOR of the record we are waiting
1493
goto lock_wait_or_error;
1499
if (page_rec_is_infimum(rec)) {
1501
/* The infimum record on a page cannot be in the result set,
1502
and neither can a record lock be placed on it: we skip such
1503
a record. We also increment the cost counter as we may have
1504
processed yet another page of index. */
1511
if (!consistent_read) {
1512
/* Try to place a lock on the index record */
1514
/* If innodb_locks_unsafe_for_binlog option is used
1515
or this session is using READ COMMITTED isolation level,
1516
we lock only the record, i.e., next-key locking is
1522
offsets = rec_get_offsets(rec, index, offsets,
1523
ULINT_UNDEFINED, &heap);
1525
trx = thr_get_trx(thr);
1527
if (srv_locks_unsafe_for_binlog
1528
|| trx->isolation_level == TRX_ISO_READ_COMMITTED) {
1530
if (page_rec_is_supremum(rec)) {
1535
lock_type = LOCK_REC_NOT_GAP;
1537
lock_type = LOCK_ORDINARY;
1540
err = sel_set_rec_lock(btr_pcur_get_block(&plan->pcur),
1541
rec, index, offsets,
1542
node->row_lock_mode, lock_type, thr);
1544
if (err != DB_SUCCESS) {
1546
goto lock_wait_or_error;
1550
if (page_rec_is_supremum(rec)) {
1552
/* A page supremum record cannot be in the result set: skip
1553
it now when we have placed a possible lock on it */
1558
ut_ad(page_rec_is_user_rec(rec));
1560
if (cost_counter > SEL_COST_LIMIT) {
1562
/* Now that we have placed the necessary locks, we can stop
1563
for a while and store the cursor position; NOTE that if we
1564
would store the cursor position BEFORE placing a record lock,
1565
it might happen that the cursor would jump over some records
1566
that another transaction could meanwhile insert adjacent to
1567
the cursor: this would result in the phantom problem. */
1569
goto stop_for_a_while;
1572
/* PHASE 2: Check a mixed index mix id if needed */
1574
if (plan->unique_search && cursor_just_opened) {
1576
ut_ad(plan->mode == PAGE_CUR_GE);
1578
/* As the cursor is now placed on a user record after a search
1579
with the mode PAGE_CUR_GE, the up_match field in the cursor
1580
tells how many fields in the user record matched to the search
1583
if (btr_pcur_get_up_match(&(plan->pcur))
1584
< plan->n_exact_match) {
1585
goto table_exhausted;
1588
/* Ok, no need to test end_conds or mix id */
1592
/* We are ready to look at a possible new index entry in the result
1593
set: the cursor is now placed on a user record */
1595
/* PHASE 3: Get previous version in a consistent read */
1597
cons_read_requires_clust_rec = FALSE;
1598
offsets = rec_get_offsets(rec, index, offsets, ULINT_UNDEFINED, &heap);
1600
if (consistent_read) {
1601
/* This is a non-locking consistent read: if necessary, fetch
1602
a previous version of the record */
1604
if (dict_index_is_clust(index)) {
1606
if (!lock_clust_rec_cons_read_sees(rec, index, offsets,
1609
err = row_sel_build_prev_vers(
1610
node->read_view, index, rec,
1611
&offsets, &heap, &plan->old_vers_heap,
1614
if (err != DB_SUCCESS) {
1616
goto lock_wait_or_error;
1619
if (old_vers == NULL) {
1620
offsets = rec_get_offsets(
1621
rec, index, offsets,
1622
ULINT_UNDEFINED, &heap);
1624
/* Fetch the columns needed in
1625
test conditions. The clustered
1626
index record is protected by a
1627
page latch that was acquired
1628
by row_sel_open_pcur() or
1629
row_sel_restore_pcur_pos().
1630
The latch will not be released
1631
until mtr_commit(mtr). */
1633
row_sel_fetch_columns(
1634
index, rec, offsets,
1638
if (!row_sel_test_end_conds(plan)) {
1640
goto table_exhausted;
1648
} else if (!lock_sec_rec_cons_read_sees(rec,
1650
cons_read_requires_clust_rec = TRUE;
1654
/* PHASE 4: Test search end conditions and deleted flag */
1656
/* Fetch the columns needed in test conditions. The record is
1657
protected by a page latch that was acquired by
1658
row_sel_open_pcur() or row_sel_restore_pcur_pos(). The latch
1659
will not be released until mtr_commit(mtr). */
1661
row_sel_fetch_columns(index, rec, offsets,
1662
UT_LIST_GET_FIRST(plan->columns));
1664
/* Test the selection end conditions: these can only contain columns
1665
which already are found in the index, even though the index might be
1668
if (plan->unique_search && cursor_just_opened) {
1670
/* No test necessary: the test was already made above */
1672
} else if (!row_sel_test_end_conds(plan)) {
1674
goto table_exhausted;
1677
if (rec_get_deleted_flag(rec, dict_table_is_comp(plan->table))
1678
&& !cons_read_requires_clust_rec) {
1680
/* The record is delete marked: we can skip it if this is
1681
not a consistent read which might see an earlier version
1682
of a non-clustered index record */
1684
if (plan->unique_search) {
1686
goto table_exhausted;
1692
/* PHASE 5: Get the clustered index record, if needed and if we did
1693
not do the search using the clustered index */
1695
if (plan->must_get_clust || cons_read_requires_clust_rec) {
1697
/* It was a non-clustered index and we must fetch also the
1698
clustered index record */
1700
err = row_sel_get_clust_rec(node, plan, rec, thr, &clust_rec,
1702
mtr_has_extra_clust_latch = TRUE;
1704
if (err != DB_SUCCESS) {
1706
goto lock_wait_or_error;
1709
/* Retrieving the clustered record required a search:
1710
increment the cost counter */
1714
if (clust_rec == NULL) {
1715
/* The record did not exist in the read view */
1716
ut_ad(consistent_read);
1721
if (rec_get_deleted_flag(clust_rec,
1722
dict_table_is_comp(plan->table))) {
1724
/* The record is delete marked: we can skip it */
1729
if (node->can_get_updated) {
1731
btr_pcur_store_position(&(plan->clust_pcur), &mtr);
1735
/* PHASE 6: Test the rest of search conditions */
1737
if (!row_sel_test_other_conds(plan)) {
1739
if (plan->unique_search) {
1741
goto table_exhausted;
1747
/* PHASE 7: We found a new qualifying row for the current table; push
1748
the row if prefetch is on, or move to the next table in the join */
1750
plan->n_rows_fetched++;
1752
ut_ad(plan->pcur.latch_mode == BTR_SEARCH_LEAF);
1754
if ((plan->n_rows_fetched <= SEL_PREFETCH_LIMIT)
1755
|| plan->unique_search || plan->no_prefetch
1756
|| plan->table->big_rows) {
1758
/* No prefetch in operation: go to the next table */
1763
sel_push_prefetched_row(plan);
1765
if (plan->n_rows_prefetched == SEL_MAX_N_PREFETCH) {
1767
/* The prefetch buffer is now full */
1769
sel_pop_prefetched_row(plan);
1775
ut_ad(!search_latch_locked);
1777
if (mtr_has_extra_clust_latch) {
1779
/* We must commit &mtr if we are moving to the next
1780
non-clustered index record, because we could break the
1781
latching order if we would access a different clustered
1782
index page right away without releasing the previous. */
1784
goto commit_mtr_for_a_while;
1788
moved = btr_pcur_move_to_next(&(plan->pcur), &mtr);
1790
moved = btr_pcur_move_to_prev(&(plan->pcur), &mtr);
1795
goto table_exhausted;
1798
cursor_just_opened = FALSE;
1800
/* END OF RECORD LOOP
1801
------------------ */
1805
/* We found a record which satisfies the conditions: we can move to
1806
the next table or return a row in the result set */
1808
ut_ad(btr_pcur_is_on_user_rec(&plan->pcur));
1810
if (plan->unique_search && !node->can_get_updated) {
1812
plan->cursor_at_end = TRUE;
1814
ut_ad(!search_latch_locked);
1816
plan->stored_cursor_rec_processed = TRUE;
1818
btr_pcur_store_position(&(plan->pcur), &mtr);
1823
mtr_has_extra_clust_latch = FALSE;
1826
/* If we use 'goto' to this label, it means that the row was popped
1827
from the prefetched rows stack, and &mtr is already committed */
1829
if (node->fetch_table + 1 == node->n_tables) {
1831
sel_eval_select_list(node);
1833
if (node->is_aggregate) {
1838
sel_assign_into_var_values(node->into_list, node);
1840
thr->run_node = que_node_get_parent(node);
1846
node->fetch_table++;
1848
/* When we move to the next table, we first reset the plan cursor:
1849
we do not care about resetting it when we backtrack from a table */
1851
plan_reset_cursor(sel_node_get_nth_plan(node, node->fetch_table));
1856
/* The table cursor pcur reached the result set end: backtrack to the
1857
previous table in the join if we do not have cached prefetched rows */
1859
plan->cursor_at_end = TRUE;
1863
mtr_has_extra_clust_latch = FALSE;
1865
if (plan->n_rows_prefetched > 0) {
1866
/* The table became exhausted during a prefetch */
1868
sel_pop_prefetched_row(plan);
1870
goto next_table_no_mtr;
1873
table_exhausted_no_mtr:
1874
if (node->fetch_table == 0) {
1877
if (node->is_aggregate && !node->aggregate_already_fetched) {
1879
node->aggregate_already_fetched = TRUE;
1881
sel_assign_into_var_values(node->into_list, node);
1883
thr->run_node = que_node_get_parent(node);
1885
node->state = SEL_NODE_NO_MORE_ROWS;
1887
thr->run_node = que_node_get_parent(node);
1893
node->fetch_table--;
1898
/* Return control for a while to que_run_threads, so that runaway
1899
queries can be canceled. NOTE that when we come here, we must, in a
1900
locking read, have placed the necessary (possibly waiting request)
1901
record lock on the cursor record or its successor: when we reposition
1902
the cursor, this record lock guarantees that nobody can meanwhile have
1903
inserted new records which should have appeared in the result set,
1904
which would result in the phantom problem. */
1906
ut_ad(!search_latch_locked);
1908
plan->stored_cursor_rec_processed = FALSE;
1909
btr_pcur_store_position(&(plan->pcur), &mtr);
1913
#ifdef UNIV_SYNC_DEBUG
1914
ut_ad(sync_thread_levels_empty_gen(TRUE));
1915
#endif /* UNIV_SYNC_DEBUG */
1919
commit_mtr_for_a_while:
1920
/* Stores the cursor position and commits &mtr; this is used if
1921
&mtr may contain latches which would break the latching order if
1922
&mtr would not be committed and the latches released. */
1924
plan->stored_cursor_rec_processed = TRUE;
1926
ut_ad(!search_latch_locked);
1927
btr_pcur_store_position(&(plan->pcur), &mtr);
1931
mtr_has_extra_clust_latch = FALSE;
1933
#ifdef UNIV_SYNC_DEBUG
1934
ut_ad(sync_thread_levels_empty_gen(TRUE));
1935
#endif /* UNIV_SYNC_DEBUG */
1940
/* See the note at stop_for_a_while: the same holds for this case */
1942
ut_ad(!btr_pcur_is_before_first_on_page(&plan->pcur) || !node->asc);
1943
ut_ad(!search_latch_locked);
1945
plan->stored_cursor_rec_processed = FALSE;
1946
btr_pcur_store_position(&(plan->pcur), &mtr);
1950
#ifdef UNIV_SYNC_DEBUG
1951
ut_ad(sync_thread_levels_empty_gen(TRUE));
1952
#endif /* UNIV_SYNC_DEBUG */
1955
if (search_latch_locked) {
1956
rw_lock_s_unlock(&btr_search_latch);
1958
if (UNIV_LIKELY_NULL(heap)) {
1959
mem_heap_free(heap);
1964
/**********************************************************************//**
1965
Performs a select step. This is a high-level function used in SQL execution
1967
@return query thread to run next or NULL */
1972
que_thr_t* thr) /*!< in: query thread */
1975
sym_node_t* table_node;
1981
node = thr->run_node;
1983
ut_ad(que_node_get_type(node) == QUE_NODE_SELECT);
1985
/* If this is a new time this node is executed (or when execution
1986
resumes after wait for a table intention lock), set intention locks
1987
on the tables, or assign a read view */
1989
if (node->into_list && (thr->prev_node == que_node_get_parent(node))) {
1991
node->state = SEL_NODE_OPEN;
1994
if (node->state == SEL_NODE_OPEN) {
1996
/* It may be that the current session has not yet started
1997
its transaction, or it has been committed: */
1999
trx_start_if_not_started(thr_get_trx(thr));
2001
plan_reset_cursor(sel_node_get_nth_plan(node, 0));
2003
if (node->consistent_read) {
2004
/* Assign a read view for the query */
2005
node->read_view = trx_assign_read_view(
2008
if (node->set_x_locks) {
2009
i_lock_mode = LOCK_IX;
2011
i_lock_mode = LOCK_IS;
2014
table_node = node->table_list;
2016
while (table_node) {
2017
err = lock_table(0, table_node->table,
2019
if (err != DB_SUCCESS) {
2020
thr_get_trx(thr)->error_state = err;
2025
table_node = que_node_get_next(table_node);
2029
/* If this is an explicit cursor, copy stored procedure
2030
variable values, so that the values cannot change between
2031
fetches (currently, we copy them also for non-explicit
2034
if (node->explicit_cursor
2035
&& UT_LIST_GET_FIRST(node->copy_variables)) {
2037
row_sel_copy_input_variable_vals(node);
2040
node->state = SEL_NODE_FETCH;
2041
node->fetch_table = 0;
2043
if (node->is_aggregate) {
2044
/* Reset the aggregate total values */
2045
sel_reset_aggregate_vals(node);
2049
err = row_sel(node, thr);
2051
/* NOTE! if queries are parallelized, the following assignment may
2052
have problems; the assignment should be made only if thr is the
2053
only top-level thr in the graph: */
2055
thr->graph->last_sel_node = node;
2057
if (err != DB_SUCCESS) {
2058
thr_get_trx(thr)->error_state = err;
2066
/**********************************************************************//**
2067
Performs a fetch for a cursor.
2068
@return query thread to run next or NULL */
2073
que_thr_t* thr) /*!< in: query thread */
2075
sel_node_t* sel_node;
2080
node = thr->run_node;
2081
sel_node = node->cursor_def;
2083
ut_ad(que_node_get_type(node) == QUE_NODE_FETCH);
2085
if (thr->prev_node != que_node_get_parent(node)) {
2087
if (sel_node->state != SEL_NODE_NO_MORE_ROWS) {
2089
if (node->into_list) {
2090
sel_assign_into_var_values(node->into_list,
2093
void* ret = (*node->func->func)(
2094
sel_node, node->func->arg);
2098
= SEL_NODE_NO_MORE_ROWS;
2103
thr->run_node = que_node_get_parent(node);
2108
/* Make the fetch node the parent of the cursor definition for
2109
the time of the fetch, so that execution knows to return to this
2110
fetch node after a row has been selected or we know that there is
2113
sel_node->common.parent = node;
2115
if (sel_node->state == SEL_NODE_CLOSED) {
2117
"InnoDB: Error: fetch called on a closed cursor\n");
2119
thr_get_trx(thr)->error_state = DB_ERROR;
2124
thr->run_node = sel_node;
2129
/****************************************************************//**
2130
Sample callback function for fetch that prints each row.
2131
@return always returns non-NULL */
2136
void* row, /*!< in: sel_node_t* */
2137
void* user_arg) /*!< in: not used */
2139
sel_node_t* node = row;
2143
UT_NOT_USED(user_arg);
2145
fprintf(stderr, "row_fetch_print: row %p\n", row);
2147
exp = node->select_list;
2150
dfield_t* dfield = que_node_get_val(exp);
2151
const dtype_t* type = dfield_get_type(dfield);
2153
fprintf(stderr, " column %lu:\n", (ulong)i);
2158
if (dfield_get_len(dfield) != UNIV_SQL_NULL) {
2159
ut_print_buf(stderr, dfield_get_data(dfield),
2160
dfield_get_len(dfield));
2163
fputs(" <NULL>;\n", stderr);
2166
exp = que_node_get_next(exp);
2173
/****************************************************************//**
2174
Callback function for fetch that stores an unsigned 4 byte integer to the
2175
location pointed. The column's type must be DATA_INT, DATA_UNSIGNED, length
2177
@return always returns NULL */
2180
row_fetch_store_uint4(
2181
/*==================*/
2182
void* row, /*!< in: sel_node_t* */
2183
void* user_arg) /*!< in: data pointer */
2185
sel_node_t* node = row;
2186
ib_uint32_t* val = user_arg;
2189
dfield_t* dfield = que_node_get_val(node->select_list);
2190
const dtype_t* type = dfield_get_type(dfield);
2191
ulint len = dfield_get_len(dfield);
2193
ut_a(dtype_get_mtype(type) == DATA_INT);
2194
ut_a(dtype_get_prtype(type) & DATA_UNSIGNED);
2197
tmp = mach_read_from_4(dfield_get_data(dfield));
2198
*val = (ib_uint32_t) tmp;
2203
/***********************************************************//**
2204
Prints a row in a select result.
2205
@return query thread to run next or NULL */
2210
que_thr_t* thr) /*!< in: query thread */
2212
row_printf_node_t* node;
2213
sel_node_t* sel_node;
2218
node = thr->run_node;
2220
sel_node = node->sel_node;
2222
ut_ad(que_node_get_type(node) == QUE_NODE_ROW_PRINTF);
2224
if (thr->prev_node == que_node_get_parent(node)) {
2226
/* Reset the cursor */
2227
sel_node->state = SEL_NODE_OPEN;
2229
/* Fetch next row to print */
2231
thr->run_node = sel_node;
2236
if (sel_node->state != SEL_NODE_FETCH) {
2238
ut_ad(sel_node->state == SEL_NODE_NO_MORE_ROWS);
2240
/* No more rows to print */
2242
thr->run_node = que_node_get_parent(node);
2247
arg = sel_node->select_list;
2250
dfield_print_also_hex(que_node_get_val(arg));
2252
fputs(" ::: ", stderr);
2254
arg = que_node_get_next(arg);
2259
/* Fetch next row to print */
2261
thr->run_node = sel_node;
2266
/****************************************************************//**
2267
Converts a key value stored in MySQL format to an Innobase dtuple. The last
2268
field of the key value may be just a prefix of a fixed length field: hence
2269
the parameter key_len. But currently we do not allow search keys where the
2270
last field is only a prefix of the full key field len and print a warning if
2271
such appears. A counterpart of this function is
2272
ha_innobase::store_key_val_for_row() in ha_innodb.cc. */
2275
row_sel_convert_mysql_key_to_innobase(
2276
/*==================================*/
2277
dtuple_t* tuple, /*!< in/out: tuple where to build;
2278
NOTE: we assume that the type info
2279
in the tuple is already according
2281
byte* buf, /*!< in: buffer to use in field
2283
ulint buf_len, /*!< in: buffer length */
2284
dict_index_t* index, /*!< in: index of the key value */
2285
const byte* key_ptr, /*!< in: MySQL key value */
2286
ulint key_len, /*!< in: MySQL key value length */
2287
trx_t* trx) /*!< in: transaction */
2289
byte* original_buf = buf;
2290
const byte* original_key_ptr = key_ptr;
2291
dict_field_t* field;
2295
ulint data_field_len;
2297
const byte* key_end;
2300
/* For documentation of the key value storage format in MySQL, see
2301
ha_innobase::store_key_val_for_row() in ha_innodb.cc. */
2303
key_end = key_ptr + key_len;
2305
/* Permit us to access any field in the tuple (ULINT_MAX): */
2307
dtuple_set_n_fields(tuple, ULINT_MAX);
2309
dfield = dtuple_get_nth_field(tuple, 0);
2310
field = dict_index_get_nth_field(index, 0);
2312
if (UNIV_UNLIKELY(dfield_get_type(dfield)->mtype == DATA_SYS)) {
2313
/* A special case: we are looking for a position in the
2314
generated clustered index which InnoDB automatically added
2315
to a table with no primary key: the first and the only
2316
ordering column is ROW_ID which InnoDB stored to the key_ptr
2319
ut_a(key_len == DATA_ROW_ID_LEN);
2321
dfield_set_data(dfield, key_ptr, DATA_ROW_ID_LEN);
2323
dtuple_set_n_fields(tuple, 1);
2328
while (key_ptr < key_end) {
2330
ulint type = dfield_get_type(dfield)->mtype;
2331
ut_a(field->col->mtype == type);
2336
if (!(dfield_get_type(dfield)->prtype & DATA_NOT_NULL)) {
2337
/* The first byte in the field tells if this is
2338
an SQL NULL value */
2342
if (*key_ptr != 0) {
2343
dfield_set_null(dfield);
2349
/* Calculate data length and data field total length */
2351
if (type == DATA_BLOB) {
2352
/* The key field is a column prefix of a BLOB or
2355
ut_a(field->prefix_len > 0);
2357
/* MySQL stores the actual data length to the first 2
2358
bytes after the optional SQL NULL marker byte. The
2359
storage format is little-endian, that is, the most
2360
significant byte at a higher address. In UTF-8, MySQL
2361
seems to reserve field->prefix_len bytes for
2362
storing this field in the key value buffer, even
2363
though the actual value only takes data_len bytes
2366
data_len = key_ptr[data_offset]
2367
+ 256 * key_ptr[data_offset + 1];
2368
data_field_len = data_offset + 2 + field->prefix_len;
2372
/* Now that we know the length, we store the column
2373
value like it would be a fixed char field */
2375
} else if (field->prefix_len > 0) {
2376
/* Looks like MySQL pads unused end bytes in the
2377
prefix with space. Therefore, also in UTF-8, it is ok
2378
to compare with a prefix containing full prefix_len
2379
bytes, and no need to take at most prefix_len / 3
2380
UTF-8 characters from the start.
2381
If the prefix is used as the upper end of a LIKE
2382
'abc%' query, then MySQL pads the end with chars
2383
0xff. TODO: in that case does it any harm to compare
2384
with the full prefix_len bytes. How do characters
2385
0xff in UTF-8 behave? */
2387
data_len = field->prefix_len;
2388
data_field_len = data_offset + data_len;
2390
data_len = dfield_get_type(dfield)->len;
2391
data_field_len = data_offset + data_len;
2395
(dtype_get_mysql_type(dfield_get_type(dfield))
2396
== DATA_MYSQL_TRUE_VARCHAR)
2397
&& UNIV_LIKELY(type != DATA_INT)) {
2398
/* In a MySQL key value format, a true VARCHAR is
2399
always preceded by 2 bytes of a length field.
2400
dfield_get_type(dfield)->len returns the maximum
2401
'payload' len in bytes. That does not include the
2402
2 bytes that tell the actual data length.
2404
We added the check != DATA_INT to make sure we do
2405
not treat MySQL ENUM or SET as a true VARCHAR! */
2408
data_field_len += 2;
2411
/* Storing may use at most data_len bytes of buf */
2413
if (UNIV_LIKELY(!is_null)) {
2414
row_mysql_store_col_in_innobase_format(
2416
FALSE, /* MySQL key value format col */
2417
key_ptr + data_offset, data_len,
2418
dict_table_is_comp(index->table));
2422
key_ptr += data_field_len;
2424
if (UNIV_UNLIKELY(key_ptr > key_end)) {
2425
/* The last field in key was not a complete key field
2428
Print a warning about this! HA_READ_PREFIX_LAST does
2429
not currently work in InnoDB with partial-field key
2430
value prefixes. Since MySQL currently uses a padding
2431
trick to calculate LIKE 'abc%' type queries there
2432
should never be partial-field prefixes in searches. */
2434
ut_print_timestamp(stderr);
2436
fputs(" InnoDB: Warning: using a partial-field"
2437
" key prefix in search.\n"
2438
"InnoDB: ", stderr);
2439
dict_index_name_print(stderr, trx, index);
2440
fprintf(stderr, ". Last data field length %lu bytes,\n"
2441
"InnoDB: key ptr now exceeds"
2442
" key end by %lu bytes.\n"
2443
"InnoDB: Key value in the MySQL format:\n",
2444
(ulong) data_field_len,
2445
(ulong) (key_ptr - key_end));
2447
ut_print_buf(stderr, original_key_ptr, key_len);
2451
ulint len = dfield_get_len(dfield);
2452
dfield_set_len(dfield, len
2453
- (ulint) (key_ptr - key_end));
2462
ut_a(buf <= original_buf + buf_len);
2464
/* We set the length of tuple to n_fields: we assume that the memory
2465
area allocated for it is big enough (usually bigger than n_fields). */
2467
dtuple_set_n_fields(tuple, n_fields);
2470
/**************************************************************//**
2471
Stores the row id to the prebuilt struct. */
2474
row_sel_store_row_id_to_prebuilt(
2475
/*=============================*/
2476
row_prebuilt_t* prebuilt, /*!< in/out: prebuilt */
2477
const rec_t* index_rec, /*!< in: record */
2478
const dict_index_t* index, /*!< in: index of the record */
2479
const ulint* offsets) /*!< in: rec_get_offsets
2480
(index_rec, index) */
2485
ut_ad(rec_offs_validate(index_rec, index, offsets));
2487
data = rec_get_nth_field(
2489
dict_index_get_sys_col_pos(index, DATA_ROW_ID), &len);
2491
if (UNIV_UNLIKELY(len != DATA_ROW_ID_LEN)) {
2493
"InnoDB: Error: Row id field is"
2494
" wrong length %lu in ", (ulong) len);
2495
dict_index_name_print(stderr, prebuilt->trx, index);
2496
fprintf(stderr, "\n"
2497
"InnoDB: Field number %lu, record:\n",
2498
(ulong) dict_index_get_sys_col_pos(index,
2500
rec_print_new(stderr, index_rec, offsets);
2505
ut_memcpy(prebuilt->row_id, data, len);
2508
/**************************************************************//**
2509
Stores a non-SQL-NULL field in the MySQL format. The counterpart of this
2510
function is row_mysql_store_col_in_innobase_format() in row0mysql.c. */
2513
row_sel_field_store_in_mysql_format(
2514
/*================================*/
2515
byte* dest, /*!< in/out: buffer where to store; NOTE
2516
that BLOBs are not in themselves
2517
stored here: the caller must allocate
2518
and copy the BLOB into buffer before,
2519
and pass the pointer to the BLOB in
2521
const mysql_row_templ_t* templ,
2522
/*!< in: MySQL column template.
2523
Its following fields are referenced:
2524
type, is_unsigned, mysql_col_len,
2525
mbminlen, mbmaxlen */
2526
const byte* data, /*!< in: data to store */
2527
ulint len) /*!< in: length of the data */
2533
ut_ad(len != UNIV_SQL_NULL);
2535
switch (templ->type) {
2537
/* Convert integer data from Innobase to a little-endian
2538
format, sign bit restored to normal */
2551
if (!templ->is_unsigned) {
2552
dest[len - 1] = (byte) (dest[len - 1] ^ 128);
2555
ut_ad(templ->mysql_col_len == len);
2561
field_end = dest + templ->mysql_col_len;
2563
if (templ->mysql_type == DATA_MYSQL_TRUE_VARCHAR) {
2564
/* This is a >= 5.0.3 type true VARCHAR. Store the
2565
length of the data to the first byte or the first
2566
two bytes of dest. */
2568
dest = row_mysql_store_true_var_len(
2569
dest, len, templ->mysql_length_bytes);
2572
/* Copy the actual data */
2573
ut_memcpy(dest, data, len);
2575
/* Pad with trailing spaces. We pad with spaces also the
2576
unused end of a >= 5.0.3 true VARCHAR column, just in case
2577
MySQL expects its contents to be deterministic. */
2579
pad_ptr = dest + len;
2581
ut_ad(templ->mbminlen <= templ->mbmaxlen);
2583
/* We handle UCS2 charset strings differently. */
2584
if (templ->mbminlen == 2) {
2585
/* A space char is two bytes, 0x0020 in UCS2 */
2588
/* A 0x20 has been stripped from the column.
2591
if (pad_ptr < field_end) {
2597
/* Pad the rest of the string with 0x0020 */
2599
while (pad_ptr < field_end) {
2606
ut_ad(templ->mbminlen == 1);
2609
memset(pad_ptr, 0x20, field_end - pad_ptr);
2614
/* Store a pointer to the BLOB buffer to dest: the BLOB was
2615
already copied to the buffer in row_sel_store_mysql_rec */
2617
row_mysql_store_blob_ref(dest, templ->mysql_col_len, data,
2622
memcpy(dest, data, len);
2624
ut_ad(templ->mysql_col_len >= len);
2625
ut_ad(templ->mbmaxlen >= templ->mbminlen);
2627
ut_ad(templ->mbmaxlen > templ->mbminlen
2628
|| templ->mysql_col_len == len);
2629
/* The following assertion would fail for old tables
2630
containing UTF-8 ENUM columns due to Bug #9526. */
2631
ut_ad(!templ->mbmaxlen
2632
|| !(templ->mysql_col_len % templ->mbmaxlen));
2633
ut_ad(len * templ->mbmaxlen >= templ->mysql_col_len);
2635
if (templ->mbminlen != templ->mbmaxlen) {
2636
/* Pad with spaces. This undoes the stripping
2637
done in row0mysql.ic, function
2638
row_mysql_store_col_in_innobase_format(). */
2640
memset(dest + len, 0x20, templ->mysql_col_len - len);
2646
case DATA_SYS_CHILD:
2648
/* These column types should never be shipped to MySQL. */
2652
case DATA_FIXBINARY:
2656
/* Above are the valid column types for MySQL data. */
2657
#endif /* UNIV_DEBUG */
2658
ut_ad(templ->mysql_col_len == len);
2659
memcpy(dest, data, len);
2663
/**************************************************************//**
2664
Convert a row in the Innobase format to a row in the MySQL format.
2665
Note that the template in prebuilt may advise us to copy only a few
2666
columns to mysql_rec, other columns are left blank. All columns may not
2667
be needed in the query.
2668
@return TRUE if success, FALSE if could not allocate memory for a BLOB
2669
(though we may also assert in that case) */
2672
row_sel_store_mysql_rec(
2673
/*====================*/
2674
byte* mysql_rec, /*!< out: row in the MySQL format */
2675
row_prebuilt_t* prebuilt, /*!< in: prebuilt struct */
2676
const rec_t* rec, /*!< in: Innobase record in the index
2677
which was described in prebuilt's
2678
template; must be protected by
2680
const ulint* offsets) /*!< in: array returned by
2681
rec_get_offsets() */
2683
mysql_row_templ_t* templ;
2684
mem_heap_t* extern_field_heap = NULL;
2690
ut_ad(prebuilt->mysql_template);
2691
ut_ad(prebuilt->default_rec);
2692
ut_ad(rec_offs_validate(rec, NULL, offsets));
2694
if (UNIV_LIKELY_NULL(prebuilt->blob_heap)) {
2695
mem_heap_free(prebuilt->blob_heap);
2696
prebuilt->blob_heap = NULL;
2699
for (i = 0; i < prebuilt->n_template; i++) {
2701
templ = prebuilt->mysql_template + i;
2703
if (UNIV_UNLIKELY(rec_offs_nth_extern(offsets,
2704
templ->rec_field_no))) {
2706
/* Copy an externally stored field to the temporary
2709
ut_a(!prebuilt->trx->has_search_latch);
2711
if (UNIV_UNLIKELY(templ->type == DATA_BLOB)) {
2712
if (prebuilt->blob_heap == NULL) {
2713
prebuilt->blob_heap = mem_heap_create(
2717
heap = prebuilt->blob_heap;
2720
= mem_heap_create(UNIV_PAGE_SIZE);
2722
heap = extern_field_heap;
2725
/* NOTE: if we are retrieving a big BLOB, we may
2726
already run out of memory in the next call, which
2729
data = btr_rec_copy_externally_stored_field(
2731
dict_table_zip_size(prebuilt->table),
2732
templ->rec_field_no, &len, heap);
2734
ut_a(len != UNIV_SQL_NULL);
2736
/* Field is stored in the row. */
2738
data = rec_get_nth_field(rec, offsets,
2739
templ->rec_field_no, &len);
2741
if (UNIV_UNLIKELY(templ->type == DATA_BLOB)
2742
&& len != UNIV_SQL_NULL) {
2744
/* It is a BLOB field locally stored in the
2745
InnoDB record: we MUST copy its contents to
2746
prebuilt->blob_heap here because later code
2747
assumes all BLOB values have been copied to a
2750
if (prebuilt->blob_heap == NULL) {
2751
prebuilt->blob_heap = mem_heap_create(
2755
data = memcpy(mem_heap_alloc(
2756
prebuilt->blob_heap, len),
2761
if (len != UNIV_SQL_NULL) {
2762
row_sel_field_store_in_mysql_format(
2763
mysql_rec + templ->mysql_col_offset,
2767
if (extern_field_heap) {
2768
mem_heap_free(extern_field_heap);
2769
extern_field_heap = NULL;
2772
if (templ->mysql_null_bit_mask) {
2773
/* It is a nullable column with a non-NULL
2775
mysql_rec[templ->mysql_null_byte_offset]
2776
&= ~(byte) templ->mysql_null_bit_mask;
2779
/* MySQL assumes that the field for an SQL
2780
NULL value is set to the default value. */
2782
mysql_rec[templ->mysql_null_byte_offset]
2783
|= (byte) templ->mysql_null_bit_mask;
2784
memcpy(mysql_rec + templ->mysql_col_offset,
2785
(const byte*) prebuilt->default_rec
2786
+ templ->mysql_col_offset,
2787
templ->mysql_col_len);
2794
/*********************************************************************//**
2795
Builds a previous version of a clustered index record for a consistent read
2796
@return DB_SUCCESS or error code */
2799
row_sel_build_prev_vers_for_mysql(
2800
/*==============================*/
2801
read_view_t* read_view, /*!< in: read view */
2802
dict_index_t* clust_index, /*!< in: clustered index */
2803
row_prebuilt_t* prebuilt, /*!< in: prebuilt struct */
2804
const rec_t* rec, /*!< in: record in a clustered index */
2805
ulint** offsets, /*!< in/out: offsets returned by
2806
rec_get_offsets(rec, clust_index) */
2807
mem_heap_t** offset_heap, /*!< in/out: memory heap from which
2808
the offsets are allocated */
2809
rec_t** old_vers, /*!< out: old version, or NULL if the
2810
record does not exist in the view:
2811
i.e., it was freshly inserted
2813
mtr_t* mtr) /*!< in: mtr */
2817
if (prebuilt->old_vers_heap) {
2818
mem_heap_empty(prebuilt->old_vers_heap);
2820
prebuilt->old_vers_heap = mem_heap_create(200);
2823
err = row_vers_build_for_consistent_read(
2824
rec, mtr, clust_index, offsets, read_view, offset_heap,
2825
prebuilt->old_vers_heap, old_vers);
2829
/*********************************************************************//**
2830
Retrieves the clustered index record corresponding to a record in a
2831
non-clustered index. Does the necessary locking. Used in the MySQL
2833
@return DB_SUCCESS or error code */
2836
row_sel_get_clust_rec_for_mysql(
2837
/*============================*/
2838
row_prebuilt_t* prebuilt,/*!< in: prebuilt struct in the handle */
2839
dict_index_t* sec_index,/*!< in: secondary index where rec resides */
2840
const rec_t* rec, /*!< in: record in a non-clustered index; if
2841
this is a locking read, then rec is not
2842
allowed to be delete-marked, and that would
2843
not make sense either */
2844
que_thr_t* thr, /*!< in: query thread */
2845
const rec_t** out_rec,/*!< out: clustered record or an old version of
2846
it, NULL if the old version did not exist
2847
in the read view, i.e., it was a fresh
2849
ulint** offsets,/*!< in: offsets returned by
2850
rec_get_offsets(rec, sec_index);
2851
out: offsets returned by
2852
rec_get_offsets(out_rec, clust_index) */
2853
mem_heap_t** offset_heap,/*!< in/out: memory heap from which
2854
the offsets are allocated */
2855
mtr_t* mtr) /*!< in: mtr used to get access to the
2856
non-clustered record; the same mtr is used to
2857
access the clustered index */
2859
dict_index_t* clust_index;
2860
const rec_t* clust_rec;
2866
trx = thr_get_trx(thr);
2868
row_build_row_ref_in_tuple(prebuilt->clust_ref, rec,
2869
sec_index, *offsets, trx);
2871
clust_index = dict_table_get_first_index(sec_index->table);
2873
btr_pcur_open_with_no_init(clust_index, prebuilt->clust_ref,
2874
PAGE_CUR_LE, BTR_SEARCH_LEAF,
2875
prebuilt->clust_pcur, 0, mtr);
2877
clust_rec = btr_pcur_get_rec(prebuilt->clust_pcur);
2879
prebuilt->clust_pcur->trx_if_known = trx;
2881
/* Note: only if the search ends up on a non-infimum record is the
2882
low_match value the real match to the search tuple */
2884
if (!page_rec_is_user_rec(clust_rec)
2885
|| btr_pcur_get_low_match(prebuilt->clust_pcur)
2886
< dict_index_get_n_unique(clust_index)) {
2888
/* In a rare case it is possible that no clust rec is found
2889
for a delete-marked secondary index record: if in row0umod.c
2890
in row_undo_mod_remove_clust_low() we have already removed
2891
the clust rec, while purge is still cleaning and removing
2892
secondary index records associated with earlier versions of
2893
the clustered index record. In that case we know that the
2894
clustered index record did not exist in the read view of
2897
if (!rec_get_deleted_flag(rec,
2898
dict_table_is_comp(sec_index->table))
2899
|| prebuilt->select_lock_type != LOCK_NONE) {
2900
ut_print_timestamp(stderr);
2901
fputs(" InnoDB: error clustered record"
2902
" for sec rec not found\n"
2903
"InnoDB: ", stderr);
2904
dict_index_name_print(stderr, trx, sec_index);
2906
"InnoDB: sec index record ", stderr);
2907
rec_print(stderr, rec, sec_index);
2909
"InnoDB: clust index record ", stderr);
2910
rec_print(stderr, clust_rec, clust_index);
2912
trx_print(stderr, trx, 600);
2915
"InnoDB: Submit a detailed bug report"
2916
" to http://bugs.mysql.com\n", stderr);
2924
*offsets = rec_get_offsets(clust_rec, clust_index, *offsets,
2925
ULINT_UNDEFINED, offset_heap);
2927
if (prebuilt->select_lock_type != LOCK_NONE) {
2928
/* Try to place a lock on the index record; we are searching
2929
the clust rec with a unique condition, hence
2930
we set a LOCK_REC_NOT_GAP type lock */
2932
err = lock_clust_rec_read_check_and_lock(
2933
0, btr_pcur_get_block(prebuilt->clust_pcur),
2934
clust_rec, clust_index, *offsets,
2935
prebuilt->select_lock_type, LOCK_REC_NOT_GAP, thr);
2936
if (err != DB_SUCCESS) {
2941
/* This is a non-locking consistent read: if necessary, fetch
2942
a previous version of the record */
2946
/* If the isolation level allows reading of uncommitted data,
2947
then we never look for an earlier version */
2949
if (trx->isolation_level > TRX_ISO_READ_UNCOMMITTED
2950
&& !lock_clust_rec_cons_read_sees(
2951
clust_rec, clust_index, *offsets,
2954
/* The following call returns 'offsets' associated with
2956
err = row_sel_build_prev_vers_for_mysql(
2957
trx->read_view, clust_index, prebuilt,
2958
clust_rec, offsets, offset_heap, &old_vers,
2961
if (err != DB_SUCCESS || old_vers == NULL) {
2966
clust_rec = old_vers;
2969
/* If we had to go to an earlier version of row or the
2970
secondary index record is delete marked, then it may be that
2971
the secondary index record corresponding to clust_rec
2972
(or old_vers) is not rec; in that case we must ignore
2973
such row because in our snapshot rec would not have existed.
2974
Remember that from rec we cannot see directly which transaction
2975
id corresponds to it: we have to go to the clustered index
2976
record. A query where we want to fetch all rows where
2977
the secondary index value is in some interval would return
2978
a wrong result if we would not drop rows which we come to
2979
visit through secondary index records that would not really
2980
exist in our snapshot. */
2984
|| rec_get_deleted_flag(rec, dict_table_is_comp(
2986
&& !row_sel_sec_rec_is_for_clust_rec(
2987
rec, sec_index, clust_rec, clust_index)) {
2989
#ifdef UNIV_SEARCH_DEBUG
2991
ut_a(clust_rec == NULL
2992
|| row_sel_sec_rec_is_for_clust_rec(
2993
rec, sec_index, clust_rec, clust_index));
2999
*out_rec = clust_rec;
3001
if (prebuilt->select_lock_type != LOCK_NONE) {
3002
/* We may use the cursor in update or in unlock_row():
3003
store its position */
3005
btr_pcur_store_position(prebuilt->clust_pcur, mtr);
3013
/********************************************************************//**
3014
Restores cursor position after it has been stored. We have to take into
3015
account that the record cursor was positioned on may have been deleted.
3016
Then we may have to move the cursor one step up or down.
3017
@return TRUE if we may need to process the record the cursor is now
3018
positioned on (i.e. we should not go to the next record yet) */
3021
sel_restore_position_for_mysql(
3022
/*===========================*/
3023
ibool* same_user_rec, /*!< out: TRUE if we were able to restore
3024
the cursor on a user record with the
3025
same ordering prefix in in the
3027
ulint latch_mode, /*!< in: latch mode wished in
3029
btr_pcur_t* pcur, /*!< in: cursor whose position
3031
ibool moves_up, /*!< in: TRUE if the cursor moves up
3033
mtr_t* mtr) /*!< in: mtr; CAUTION: may commit
3037
ulint relative_position;
3039
relative_position = pcur->rel_pos;
3041
success = btr_pcur_restore_position(latch_mode, pcur, mtr);
3043
*same_user_rec = success;
3045
if (relative_position == BTR_PCUR_ON) {
3051
btr_pcur_move_to_next(pcur, mtr);
3057
if (relative_position == BTR_PCUR_AFTER
3058
|| relative_position == BTR_PCUR_AFTER_LAST_IN_TREE) {
3064
if (btr_pcur_is_on_user_rec(pcur)) {
3065
btr_pcur_move_to_prev(pcur, mtr);
3071
ut_ad(relative_position == BTR_PCUR_BEFORE
3072
|| relative_position == BTR_PCUR_BEFORE_FIRST_IN_TREE);
3074
if (moves_up && btr_pcur_is_on_user_rec(pcur)) {
3075
btr_pcur_move_to_next(pcur, mtr);
3081
/********************************************************************//**
3082
Pops a cached row for MySQL from the fetch cache. */
3085
row_sel_pop_cached_row_for_mysql(
3086
/*=============================*/
3087
byte* buf, /*!< in/out: buffer where to copy the
3089
row_prebuilt_t* prebuilt) /*!< in: prebuilt struct */
3092
mysql_row_templ_t* templ;
3094
ut_ad(prebuilt->n_fetch_cached > 0);
3095
ut_ad(prebuilt->mysql_prefix_len <= prebuilt->mysql_row_len);
3097
if (UNIV_UNLIKELY(prebuilt->keep_other_fields_on_keyread)) {
3098
/* Copy cache record field by field, don't touch fields that
3099
are not covered by current key */
3100
cached_rec = prebuilt->fetch_cache[
3101
prebuilt->fetch_cache_first];
3103
for (i = 0; i < prebuilt->n_template; i++) {
3104
templ = prebuilt->mysql_template + i;
3105
ut_memcpy(buf + templ->mysql_col_offset,
3106
cached_rec + templ->mysql_col_offset,
3107
templ->mysql_col_len);
3108
/* Copy NULL bit of the current field from cached_rec
3110
if (templ->mysql_null_bit_mask) {
3111
buf[templ->mysql_null_byte_offset]
3112
^= (buf[templ->mysql_null_byte_offset]
3113
^ cached_rec[templ->mysql_null_byte_offset])
3114
& (byte)templ->mysql_null_bit_mask;
3120
prebuilt->fetch_cache[prebuilt->fetch_cache_first],
3121
prebuilt->mysql_prefix_len);
3123
prebuilt->n_fetch_cached--;
3124
prebuilt->fetch_cache_first++;
3126
if (prebuilt->n_fetch_cached == 0) {
3127
prebuilt->fetch_cache_first = 0;
3131
/********************************************************************//**
3132
Pushes a row for MySQL to the fetch cache. */
3135
row_sel_push_cache_row_for_mysql(
3136
/*=============================*/
3137
row_prebuilt_t* prebuilt, /*!< in: prebuilt struct */
3138
const rec_t* rec, /*!< in: record to push; must
3139
be protected by a page latch */
3140
const ulint* offsets) /*!< in: rec_get_offsets() */
3145
ut_ad(prebuilt->n_fetch_cached < MYSQL_FETCH_CACHE_SIZE);
3146
ut_ad(rec_offs_validate(rec, NULL, offsets));
3147
ut_a(!prebuilt->templ_contains_blob);
3149
if (prebuilt->fetch_cache[0] == NULL) {
3150
/* Allocate memory for the fetch cache */
3152
for (i = 0; i < MYSQL_FETCH_CACHE_SIZE; i++) {
3154
/* A user has reported memory corruption in these
3155
buffers in Linux. Put magic numbers there to help
3156
to track a possible bug. */
3158
buf = mem_alloc(prebuilt->mysql_row_len + 8);
3160
prebuilt->fetch_cache[i] = buf + 4;
3162
mach_write_to_4(buf, ROW_PREBUILT_FETCH_MAGIC_N);
3163
mach_write_to_4(buf + 4 + prebuilt->mysql_row_len,
3164
ROW_PREBUILT_FETCH_MAGIC_N);
3168
ut_ad(prebuilt->fetch_cache_first == 0);
3170
if (UNIV_UNLIKELY(!row_sel_store_mysql_rec(
3171
prebuilt->fetch_cache[
3172
prebuilt->n_fetch_cached],
3173
prebuilt, rec, offsets))) {
3177
prebuilt->n_fetch_cached++;
3180
/*********************************************************************//**
3181
Tries to do a shortcut to fetch a clustered index record with a unique key,
3182
using the hash index if possible (not always). We assume that the search
3183
mode is PAGE_CUR_GE, it is a consistent read, there is a read view in trx,
3184
btr search latch has been locked in S-mode.
3185
@return SEL_FOUND, SEL_EXHAUSTED, SEL_RETRY */
3188
row_sel_try_search_shortcut_for_mysql(
3189
/*==================================*/
3190
const rec_t** out_rec,/*!< out: record if found */
3191
row_prebuilt_t* prebuilt,/*!< in: prebuilt struct */
3192
ulint** offsets,/*!< in/out: for rec_get_offsets(*out_rec) */
3193
mem_heap_t** heap, /*!< in/out: heap for rec_get_offsets() */
3194
mtr_t* mtr) /*!< in: started mtr */
3196
dict_index_t* index = prebuilt->index;
3197
const dtuple_t* search_tuple = prebuilt->search_tuple;
3198
btr_pcur_t* pcur = prebuilt->pcur;
3199
trx_t* trx = prebuilt->trx;
3202
ut_ad(dict_index_is_clust(index));
3203
ut_ad(!prebuilt->templ_contains_blob);
3205
btr_pcur_open_with_no_init(index, search_tuple, PAGE_CUR_GE,
3206
BTR_SEARCH_LEAF, pcur,
3207
#ifndef UNIV_SEARCH_DEBUG
3213
rec = btr_pcur_get_rec(pcur);
3215
if (!page_rec_is_user_rec(rec)) {
3220
/* As the cursor is now placed on a user record after a search with
3221
the mode PAGE_CUR_GE, the up_match field in the cursor tells how many
3222
fields in the user record matched to the search tuple */
3224
if (btr_pcur_get_up_match(pcur) < dtuple_get_n_fields(search_tuple)) {
3226
return(SEL_EXHAUSTED);
3229
/* This is a non-locking consistent read: if necessary, fetch
3230
a previous version of the record */
3232
*offsets = rec_get_offsets(rec, index, *offsets,
3233
ULINT_UNDEFINED, heap);
3235
if (!lock_clust_rec_cons_read_sees(rec, index,
3236
*offsets, trx->read_view)) {
3241
if (rec_get_deleted_flag(rec, dict_table_is_comp(index->table))) {
3243
return(SEL_EXHAUSTED);
3251
/********************************************************************//**
3252
Searches for rows in the database. This is used in the interface to
3253
MySQL. This function opens a cursor, and also implements fetch next
3254
and fetch prev. NOTE that if we do a search with a full key value
3255
from a unique index (ROW_SEL_EXACT), then we will not store the cursor
3256
position and fetch next or fetch prev must not be tried to the cursor!
3257
@return DB_SUCCESS, DB_RECORD_NOT_FOUND, DB_END_OF_INDEX, DB_DEADLOCK,
3258
DB_LOCK_TABLE_FULL, DB_CORRUPTION, or DB_TOO_BIG_RECORD */
3261
row_search_for_mysql(
3262
/*=================*/
3263
byte* buf, /*!< in/out: buffer for the fetched
3264
row in the MySQL format */
3265
ulint mode, /*!< in: search mode PAGE_CUR_L, ... */
3266
row_prebuilt_t* prebuilt, /*!< in: prebuilt struct for the
3267
table handle; this contains the info
3268
of search_tuple, index; if search
3269
tuple contains 0 fields then we
3270
position the cursor at the start or
3271
the end of the index, depending on
3273
ulint match_mode, /*!< in: 0 or ROW_SEL_EXACT or
3274
ROW_SEL_EXACT_PREFIX */
3275
ulint direction) /*!< in: 0 or ROW_SEL_NEXT or
3276
ROW_SEL_PREV; NOTE: if this is != 0,
3277
then prebuilt must have a pcur
3278
with stored position! In opening of a
3279
cursor 'direction' should be 0. */
3281
dict_index_t* index = prebuilt->index;
3282
ibool comp = dict_table_is_comp(index->table);
3283
const dtuple_t* search_tuple = prebuilt->search_tuple;
3284
btr_pcur_t* pcur = prebuilt->pcur;
3285
trx_t* trx = prebuilt->trx;
3286
dict_index_t* clust_index;
3289
const rec_t* result_rec;
3290
const rec_t* clust_rec;
3291
ulint err = DB_SUCCESS;
3292
ibool unique_search = FALSE;
3293
ibool unique_search_from_clust_index = FALSE;
3294
ibool mtr_has_extra_clust_latch = FALSE;
3295
ibool moves_up = FALSE;
3296
ibool set_also_gap_locks = TRUE;
3297
/* if the query is a plain locking SELECT, and the isolation level
3298
is <= TRX_ISO_READ_COMMITTED, then this is set to FALSE */
3299
ibool did_semi_consistent_read = FALSE;
3300
/* if the returned record was locked and we did a semi-consistent
3301
read (fetch the newest committed version), then this is set to
3303
#ifdef UNIV_SEARCH_DEBUG
3305
#endif /* UNIV_SEARCH_DEBUG */
3307
ibool same_user_rec;
3309
mem_heap_t* heap = NULL;
3310
ulint offsets_[REC_OFFS_NORMAL_SIZE];
3311
ulint* offsets = offsets_;
3313
rec_offs_init(offsets_);
3315
ut_ad(index && pcur && search_tuple);
3316
ut_ad(trx->mysql_thread_id == os_thread_get_curr_id());
3318
if (UNIV_UNLIKELY(prebuilt->table->ibd_file_missing)) {
3319
ut_print_timestamp(stderr);
3320
fprintf(stderr, " InnoDB: Error:\n"
3321
"InnoDB: MySQL is trying to use a table handle"
3322
" but the .ibd file for\n"
3323
"InnoDB: table %s does not exist.\n"
3324
"InnoDB: Have you deleted the .ibd file"
3325
" from the database directory under\n"
3326
"InnoDB: the MySQL datadir, or have you used"
3327
" DISCARD TABLESPACE?\n"
3328
"InnoDB: Look from\n"
3329
"InnoDB: " REFMAN "innodb-troubleshooting.html\n"
3330
"InnoDB: how you can resolve the problem.\n",
3331
prebuilt->table->name);
3336
if (UNIV_UNLIKELY(!prebuilt->index_usable)) {
3338
return(DB_MISSING_HISTORY);
3341
if (UNIV_UNLIKELY(prebuilt->magic_n != ROW_PREBUILT_ALLOCATED)) {
3343
"InnoDB: Error: trying to free a corrupt\n"
3344
"InnoDB: table handle. Magic n %lu, table name ",
3345
(ulong) prebuilt->magic_n);
3346
ut_print_name(stderr, trx, TRUE, prebuilt->table->name);
3349
mem_analyze_corruption(prebuilt);
3355
/* August 19, 2005 by Heikki: temporarily disable this error
3356
print until the cursor lock count is done correctly.
3357
See bugs #12263 and #12456!*/
3359
if (trx->n_mysql_tables_in_use == 0
3360
&& UNIV_UNLIKELY(prebuilt->select_lock_type == LOCK_NONE)) {
3361
/* Note that if MySQL uses an InnoDB temp table that it
3362
created inside LOCK TABLES, then n_mysql_tables_in_use can
3363
be zero; in that case select_lock_type is set to LOCK_X in
3366
fputs("InnoDB: Error: MySQL is trying to perform a SELECT\n"
3367
"InnoDB: but it has not locked"
3368
" any tables in ::external_lock()!\n",
3370
trx_print(stderr, trx, 600);
3371
fputc('\n', stderr);
3376
fprintf(stderr, "Match mode %lu\n search tuple ",
3377
(ulong) match_mode);
3378
dtuple_print(search_tuple);
3379
fprintf(stderr, "N tables locked %lu\n",
3380
(ulong) trx->mysql_n_tables_locked);
3382
/*-------------------------------------------------------------*/
3383
/* PHASE 0: Release a possible s-latch we are holding on the
3384
adaptive hash index latch if there is someone waiting behind */
3386
if (UNIV_UNLIKELY(rw_lock_get_writer(&btr_search_latch) != RW_LOCK_NOT_LOCKED)
3387
&& trx->has_search_latch) {
3389
/* There is an x-latch request on the adaptive hash index:
3390
release the s-latch to reduce starvation and wait for
3391
BTR_SEA_TIMEOUT rounds before trying to keep it again over
3394
rw_lock_s_unlock(&btr_search_latch);
3395
trx->has_search_latch = FALSE;
3397
trx->search_latch_timeout = BTR_SEA_TIMEOUT;
3400
/* Reset the new record lock info if srv_locks_unsafe_for_binlog
3401
is set or session is using a READ COMMITED isolation level. Then
3402
we are able to remove the record locks set here on an individual
3404
prebuilt->new_rec_locks = 0;
3406
/*-------------------------------------------------------------*/
3407
/* PHASE 1: Try to pop the row from the prefetch cache */
3409
if (UNIV_UNLIKELY(direction == 0)) {
3410
trx->op_info = "starting index read";
3412
prebuilt->n_rows_fetched = 0;
3413
prebuilt->n_fetch_cached = 0;
3414
prebuilt->fetch_cache_first = 0;
3416
if (prebuilt->sel_graph == NULL) {
3417
/* Build a dummy select query graph */
3418
row_prebuild_sel_graph(prebuilt);
3421
trx->op_info = "fetching rows";
3423
if (prebuilt->n_rows_fetched == 0) {
3424
prebuilt->fetch_direction = direction;
3427
if (UNIV_UNLIKELY(direction != prebuilt->fetch_direction)) {
3428
if (UNIV_UNLIKELY(prebuilt->n_fetch_cached > 0)) {
3430
/* TODO: scrollable cursor: restore cursor to
3431
the place of the latest returned row,
3432
or better: prevent caching for a scroll
3436
prebuilt->n_rows_fetched = 0;
3437
prebuilt->n_fetch_cached = 0;
3438
prebuilt->fetch_cache_first = 0;
3440
} else if (UNIV_LIKELY(prebuilt->n_fetch_cached > 0)) {
3441
row_sel_pop_cached_row_for_mysql(buf, prebuilt);
3443
prebuilt->n_rows_fetched++;
3450
if (prebuilt->fetch_cache_first > 0
3451
&& prebuilt->fetch_cache_first < MYSQL_FETCH_CACHE_SIZE) {
3453
/* The previous returned row was popped from the fetch
3454
cache, but the cache was not full at the time of the
3455
popping: no more rows can exist in the result set */
3457
err = DB_RECORD_NOT_FOUND;
3461
prebuilt->n_rows_fetched++;
3463
if (prebuilt->n_rows_fetched > 1000000000) {
3464
/* Prevent wrap-over */
3465
prebuilt->n_rows_fetched = 500000000;
3468
mode = pcur->search_mode;
3471
/* In a search where at most one record in the index may match, we
3472
can use a LOCK_REC_NOT_GAP type record lock when locking a
3473
non-delete-marked matching record.
3475
Note that in a unique secondary index there may be different
3476
delete-marked versions of a record where only the primary key
3477
values differ: thus in a secondary index we must use next-key
3478
locks when locking delete-marked records. */
3480
if (match_mode == ROW_SEL_EXACT
3481
&& dict_index_is_unique(index)
3482
&& dtuple_get_n_fields(search_tuple)
3483
== dict_index_get_n_unique(index)
3484
&& (dict_index_is_clust(index)
3485
|| !dtuple_contains_null(search_tuple))) {
3487
/* Note above that a UNIQUE secondary index can contain many
3488
rows with the same key value if one of the columns is the SQL
3489
null. A clustered index under MySQL can never contain null
3490
columns because we demand that all the columns in primary key
3493
unique_search = TRUE;
3495
/* Even if the condition is unique, MySQL seems to try to
3496
retrieve also a second row if a primary key contains more than
3497
1 column. Return immediately if this is not a HANDLER
3500
if (UNIV_UNLIKELY(direction != 0
3501
&& !prebuilt->used_in_HANDLER)) {
3503
err = DB_RECORD_NOT_FOUND;
3510
/*-------------------------------------------------------------*/
3511
/* PHASE 2: Try fast adaptive hash index search if possible */
3513
/* Next test if this is the special case where we can use the fast
3514
adaptive hash index to try the search. Since we must release the
3515
search system latch when we retrieve an externally stored field, we
3516
cannot use the adaptive hash index in a search in the case the row
3517
may be long and there may be externally stored fields */
3519
if (UNIV_UNLIKELY(direction == 0)
3521
&& dict_index_is_clust(index)
3522
&& !prebuilt->templ_contains_blob
3523
&& !prebuilt->used_in_HANDLER
3524
&& (prebuilt->mysql_row_len < UNIV_PAGE_SIZE / 8)) {
3528
unique_search_from_clust_index = TRUE;
3530
if (trx->mysql_n_tables_locked == 0
3531
&& prebuilt->select_lock_type == LOCK_NONE
3532
&& trx->isolation_level > TRX_ISO_READ_UNCOMMITTED
3533
&& trx->read_view) {
3535
/* This is a SELECT query done as a consistent read,
3536
and the read view has already been allocated:
3537
let us try a search shortcut through the hash
3539
NOTE that we must also test that
3540
mysql_n_tables_locked == 0, because this might
3541
also be INSERT INTO ... SELECT ... or
3542
CREATE TABLE ... SELECT ... . Our algorithm is
3543
NOT prepared to inserts interleaved with the SELECT,
3544
and if we try that, we can deadlock on the adaptive
3545
hash index semaphore! */
3547
#ifndef UNIV_SEARCH_DEBUG
3548
if (!trx->has_search_latch) {
3549
rw_lock_s_lock(&btr_search_latch);
3550
trx->has_search_latch = TRUE;
3553
switch (row_sel_try_search_shortcut_for_mysql(
3554
&rec, prebuilt, &offsets, &heap,
3557
#ifdef UNIV_SEARCH_DEBUG
3558
ut_a(0 == cmp_dtuple_rec(search_tuple,
3561
/* At this point, rec is protected by
3562
a page latch that was acquired by
3563
row_sel_try_search_shortcut_for_mysql().
3564
The latch will not be released until
3565
mtr_commit(&mtr). */
3567
if (!row_sel_store_mysql_rec(buf, prebuilt,
3569
err = DB_TOO_BIG_RECORD;
3571
/* We let the main loop to do the
3573
goto shortcut_fails_too_big_rec;
3578
/* ut_print_name(stderr, index->name);
3579
fputs(" shortcut\n", stderr); */
3584
goto release_search_latch_if_needed;
3589
/* ut_print_name(stderr, index->name);
3590
fputs(" record not found 2\n", stderr); */
3592
err = DB_RECORD_NOT_FOUND;
3593
release_search_latch_if_needed:
3594
if (trx->search_latch_timeout > 0
3595
&& trx->has_search_latch) {
3597
trx->search_latch_timeout--;
3599
rw_lock_s_unlock(&btr_search_latch);
3600
trx->has_search_latch = FALSE;
3603
/* NOTE that we do NOT store the cursor
3613
shortcut_fails_too_big_rec:
3619
/*-------------------------------------------------------------*/
3620
/* PHASE 3: Open or restore index cursor position */
3622
if (trx->has_search_latch) {
3623
rw_lock_s_unlock(&btr_search_latch);
3624
trx->has_search_latch = FALSE;
3627
trx_start_if_not_started(trx);
3629
if (trx->isolation_level <= TRX_ISO_READ_COMMITTED
3630
&& prebuilt->select_lock_type != LOCK_NONE
3631
&& trx->mysql_thd != NULL
3632
&& thd_is_select(trx->mysql_thd)) {
3633
/* It is a plain locking SELECT and the isolation
3634
level is low: do not lock gaps */
3636
set_also_gap_locks = FALSE;
3639
/* Note that if the search mode was GE or G, then the cursor
3640
naturally moves upward (in fetch next) in alphabetical order,
3641
otherwise downward */
3643
if (UNIV_UNLIKELY(direction == 0)) {
3644
if (mode == PAGE_CUR_GE || mode == PAGE_CUR_G) {
3647
} else if (direction == ROW_SEL_NEXT) {
3651
thr = que_fork_get_first_thr(prebuilt->sel_graph);
3653
que_thr_move_to_run_state_for_mysql(thr, trx);
3655
clust_index = dict_table_get_first_index(index->table);
3657
if (UNIV_LIKELY(direction != 0)) {
3658
ibool need_to_process = sel_restore_position_for_mysql(
3659
&same_user_rec, BTR_SEARCH_LEAF,
3660
pcur, moves_up, &mtr);
3662
if (UNIV_UNLIKELY(need_to_process)) {
3663
if (UNIV_UNLIKELY(prebuilt->row_read_type
3664
== ROW_READ_DID_SEMI_CONSISTENT)) {
3665
/* We did a semi-consistent read,
3666
but the record was removed in
3668
prebuilt->row_read_type
3669
= ROW_READ_TRY_SEMI_CONSISTENT;
3671
} else if (UNIV_LIKELY(prebuilt->row_read_type
3672
!= ROW_READ_DID_SEMI_CONSISTENT)) {
3674
/* The cursor was positioned on the record
3675
that we returned previously. If we need
3676
to repeat a semi-consistent read as a
3677
pessimistic locking read, the record
3678
cannot be skipped. */
3683
} else if (dtuple_get_n_fields(search_tuple) > 0) {
3685
btr_pcur_open_with_no_init(index, search_tuple, mode,
3689
pcur->trx_if_known = trx;
3691
rec = btr_pcur_get_rec(pcur);
3694
&& !page_rec_is_supremum(rec)
3695
&& set_also_gap_locks
3696
&& !(srv_locks_unsafe_for_binlog
3697
|| trx->isolation_level == TRX_ISO_READ_COMMITTED)
3698
&& prebuilt->select_lock_type != LOCK_NONE) {
3700
/* Try to place a gap lock on the next index record
3701
to prevent phantoms in ORDER BY ... DESC queries */
3702
const rec_t* next = page_rec_get_next_const(rec);
3704
offsets = rec_get_offsets(next, index, offsets,
3705
ULINT_UNDEFINED, &heap);
3706
err = sel_set_rec_lock(btr_pcur_get_block(pcur),
3707
next, index, offsets,
3708
prebuilt->select_lock_type,
3711
if (err != DB_SUCCESS) {
3713
goto lock_wait_or_error;
3717
if (mode == PAGE_CUR_G) {
3718
btr_pcur_open_at_index_side(
3719
TRUE, index, BTR_SEARCH_LEAF, pcur, FALSE,
3721
} else if (mode == PAGE_CUR_L) {
3722
btr_pcur_open_at_index_side(
3723
FALSE, index, BTR_SEARCH_LEAF, pcur, FALSE,
3728
if (!prebuilt->sql_stat_start) {
3729
/* No need to set an intention lock or assign a read view */
3731
if (trx->read_view == NULL
3732
&& prebuilt->select_lock_type == LOCK_NONE) {
3734
fputs("InnoDB: Error: MySQL is trying to"
3735
" perform a consistent read\n"
3736
"InnoDB: but the read view is not assigned!\n",
3738
trx_print(stderr, trx, 600);
3739
fputc('\n', stderr);
3742
} else if (prebuilt->select_lock_type == LOCK_NONE) {
3743
/* This is a consistent read */
3744
/* Assign a read view for the query */
3746
trx_assign_read_view(trx);
3747
prebuilt->sql_stat_start = FALSE;
3750
if (prebuilt->select_lock_type == LOCK_S) {
3751
lock_mode = LOCK_IS;
3753
lock_mode = LOCK_IX;
3755
err = lock_table(0, index->table, lock_mode, thr);
3757
if (err != DB_SUCCESS) {
3759
goto lock_wait_or_error;
3761
prebuilt->sql_stat_start = FALSE;
3765
/*-------------------------------------------------------------*/
3766
/* PHASE 4: Look for matching records in a loop */
3768
rec = btr_pcur_get_rec(pcur);
3769
ut_ad(!!page_rec_is_comp(rec) == comp);
3770
#ifdef UNIV_SEARCH_DEBUG
3772
fputs("Using ", stderr);
3773
dict_index_name_print(stderr, index);
3774
fprintf(stderr, " cnt %lu ; Page no %lu\n", cnt,
3775
page_get_page_no(page_align(rec)));
3778
#endif /* UNIV_SEARCH_DEBUG */
3780
if (page_rec_is_infimum(rec)) {
3782
/* The infimum record on a page cannot be in the result set,
3783
and neither can a record lock be placed on it: we skip such
3789
if (page_rec_is_supremum(rec)) {
3791
if (set_also_gap_locks
3792
&& !(srv_locks_unsafe_for_binlog
3793
|| trx->isolation_level == TRX_ISO_READ_COMMITTED)
3794
&& prebuilt->select_lock_type != LOCK_NONE) {
3796
/* Try to place a lock on the index record */
3798
/* If innodb_locks_unsafe_for_binlog option is used
3799
or this session is using a READ COMMITTED isolation
3800
level we do not lock gaps. Supremum record is really
3801
a gap and therefore we do not set locks there. */
3803
offsets = rec_get_offsets(rec, index, offsets,
3804
ULINT_UNDEFINED, &heap);
3805
err = sel_set_rec_lock(btr_pcur_get_block(pcur),
3806
rec, index, offsets,
3807
prebuilt->select_lock_type,
3808
LOCK_ORDINARY, thr);
3810
if (err != DB_SUCCESS) {
3812
goto lock_wait_or_error;
3815
/* A page supremum record cannot be in the result set: skip
3816
it now that we have placed a possible lock on it */
3821
/*-------------------------------------------------------------*/
3822
/* Do sanity checks in case our cursor has bumped into page
3826
next_offs = rec_get_next_offs(rec, TRUE);
3827
if (UNIV_UNLIKELY(next_offs < PAGE_NEW_SUPREMUM)) {
3832
next_offs = rec_get_next_offs(rec, FALSE);
3833
if (UNIV_UNLIKELY(next_offs < PAGE_OLD_SUPREMUM)) {
3839
if (UNIV_UNLIKELY(next_offs >= UNIV_PAGE_SIZE - PAGE_DIR)) {
3842
if (srv_force_recovery == 0 || moves_up == FALSE) {
3843
ut_print_timestamp(stderr);
3844
buf_page_print(page_align(rec), 0);
3846
"\nInnoDB: rec address %p,"
3847
" buf block fix count %lu\n",
3848
(void*) rec, (ulong)
3849
btr_cur_get_block(btr_pcur_get_btr_cur(pcur))
3850
->page.buf_fix_count);
3852
"InnoDB: Index corruption: rec offs %lu"
3853
" next offs %lu, page no %lu,\n"
3855
(ulong) page_offset(rec),
3857
(ulong) page_get_page_no(page_align(rec)));
3858
dict_index_name_print(stderr, trx, index);
3859
fputs(". Run CHECK TABLE. You may need to\n"
3860
"InnoDB: restore from a backup, or"
3861
" dump + drop + reimport the table.\n",
3864
err = DB_CORRUPTION;
3866
goto lock_wait_or_error;
3868
/* The user may be dumping a corrupt table. Jump
3869
over the corruption to recover as much as possible. */
3872
"InnoDB: Index corruption: rec offs %lu"
3873
" next offs %lu, page no %lu,\n"
3875
(ulong) page_offset(rec),
3877
(ulong) page_get_page_no(page_align(rec)));
3878
dict_index_name_print(stderr, trx, index);
3879
fputs(". We try to skip the rest of the page.\n",
3882
btr_pcur_move_to_last_on_page(pcur, &mtr);
3887
/*-------------------------------------------------------------*/
3889
/* Calculate the 'offsets' associated with 'rec' */
3891
offsets = rec_get_offsets(rec, index, offsets, ULINT_UNDEFINED, &heap);
3893
if (UNIV_UNLIKELY(srv_force_recovery > 0)) {
3894
if (!rec_validate(rec, offsets)
3895
|| !btr_index_rec_validate(rec, index, FALSE)) {
3897
"InnoDB: Index corruption: rec offs %lu"
3898
" next offs %lu, page no %lu,\n"
3900
(ulong) page_offset(rec),
3902
(ulong) page_get_page_no(page_align(rec)));
3903
dict_index_name_print(stderr, trx, index);
3904
fputs(". We try to skip the record.\n",
3911
/* Note that we cannot trust the up_match value in the cursor at this
3912
place because we can arrive here after moving the cursor! Thus
3913
we have to recompare rec and search_tuple to determine if they
3916
if (match_mode == ROW_SEL_EXACT) {
3917
/* Test if the index record matches completely to search_tuple
3918
in prebuilt: if not, then we return with DB_RECORD_NOT_FOUND */
3920
/* fputs("Comparing rec and search tuple\n", stderr); */
3922
if (0 != cmp_dtuple_rec(search_tuple, rec, offsets)) {
3924
if (set_also_gap_locks
3925
&& !(srv_locks_unsafe_for_binlog
3926
|| trx->isolation_level
3927
== TRX_ISO_READ_COMMITTED)
3928
&& prebuilt->select_lock_type != LOCK_NONE) {
3930
/* Try to place a gap lock on the index
3931
record only if innodb_locks_unsafe_for_binlog
3932
option is not set or this session is not
3933
using a READ COMMITTED isolation level. */
3935
err = sel_set_rec_lock(
3936
btr_pcur_get_block(pcur),
3937
rec, index, offsets,
3938
prebuilt->select_lock_type, LOCK_GAP,
3941
if (err != DB_SUCCESS) {
3943
goto lock_wait_or_error;
3947
btr_pcur_store_position(pcur, &mtr);
3949
err = DB_RECORD_NOT_FOUND;
3950
/* ut_print_name(stderr, index->name);
3951
fputs(" record not found 3\n", stderr); */
3956
} else if (match_mode == ROW_SEL_EXACT_PREFIX) {
3958
if (!cmp_dtuple_is_prefix_of_rec(search_tuple, rec, offsets)) {
3960
if (set_also_gap_locks
3961
&& !(srv_locks_unsafe_for_binlog
3962
|| trx->isolation_level
3963
== TRX_ISO_READ_COMMITTED)
3964
&& prebuilt->select_lock_type != LOCK_NONE) {
3966
/* Try to place a gap lock on the index
3967
record only if innodb_locks_unsafe_for_binlog
3968
option is not set or this session is not
3969
using a READ COMMITTED isolation level. */
3971
err = sel_set_rec_lock(
3972
btr_pcur_get_block(pcur),
3973
rec, index, offsets,
3974
prebuilt->select_lock_type, LOCK_GAP,
3977
if (err != DB_SUCCESS) {
3979
goto lock_wait_or_error;
3983
btr_pcur_store_position(pcur, &mtr);
3985
err = DB_RECORD_NOT_FOUND;
3986
/* ut_print_name(stderr, index->name);
3987
fputs(" record not found 4\n", stderr); */
3993
/* We are ready to look at a possible new index entry in the result
3994
set: the cursor is now placed on a user record */
3996
if (prebuilt->select_lock_type != LOCK_NONE) {
3997
/* Try to place a lock on the index record; note that delete
3998
marked records are a special case in a unique search. If there
3999
is a non-delete marked record, then it is enough to lock its
4000
existence with LOCK_REC_NOT_GAP. */
4002
/* If innodb_locks_unsafe_for_binlog option is used
4003
or this session is using a READ COMMITED isolation
4004
level we lock only the record, i.e., next-key locking is
4009
if (!set_also_gap_locks
4010
|| srv_locks_unsafe_for_binlog
4011
|| trx->isolation_level == TRX_ISO_READ_COMMITTED
4013
&& !UNIV_UNLIKELY(rec_get_deleted_flag(rec, comp)))) {
4017
lock_type = LOCK_ORDINARY;
4020
/* If we are doing a 'greater or equal than a primary key
4021
value' search from a clustered index, and we find a record
4022
that has that exact primary key value, then there is no need
4023
to lock the gap before the record, because no insert in the
4024
gap can be in our search range. That is, no phantom row can
4027
An example: if col1 is the primary key, the search is WHERE
4028
col1 >= 100, and we find a record where col1 = 100, then no
4029
need to lock the gap before that record. */
4031
if (index == clust_index
4032
&& mode == PAGE_CUR_GE
4034
&& dtuple_get_n_fields_cmp(search_tuple)
4035
== dict_index_get_n_unique(index)
4036
&& 0 == cmp_dtuple_rec(search_tuple, rec, offsets)) {
4038
lock_type = LOCK_REC_NOT_GAP;
4041
err = sel_set_rec_lock(btr_pcur_get_block(pcur),
4042
rec, index, offsets,
4043
prebuilt->select_lock_type,
4047
const rec_t* old_vers;
4049
if (srv_locks_unsafe_for_binlog
4050
|| trx->isolation_level == TRX_ISO_READ_COMMITTED) {
4051
/* Note that a record of
4052
prebuilt->index was locked. */
4053
prebuilt->new_rec_locks = 1;
4057
if (UNIV_LIKELY(prebuilt->row_read_type
4058
!= ROW_READ_TRY_SEMI_CONSISTENT)
4059
|| index != clust_index) {
4061
goto lock_wait_or_error;
4064
/* The following call returns 'offsets'
4065
associated with 'old_vers' */
4066
err = row_sel_build_committed_vers_for_mysql(
4067
clust_index, prebuilt, rec,
4068
&offsets, &heap, &old_vers, &mtr);
4070
if (err != DB_SUCCESS) {
4072
goto lock_wait_or_error;
4075
mutex_enter(&kernel_mutex);
4076
if (trx->was_chosen_as_deadlock_victim) {
4077
mutex_exit(&kernel_mutex);
4080
goto lock_wait_or_error;
4082
if (UNIV_LIKELY(trx->wait_lock != NULL)) {
4083
lock_cancel_waiting_and_release(
4085
prebuilt->new_rec_locks = 0;
4087
mutex_exit(&kernel_mutex);
4089
/* The lock was granted while we were
4090
searching for the last committed version.
4091
Do a normal locking read. */
4093
offsets = rec_get_offsets(rec, index, offsets,
4097
/* Note that a record of
4098
prebuilt->index was locked. */
4099
prebuilt->new_rec_locks = 1;
4102
mutex_exit(&kernel_mutex);
4104
if (old_vers == NULL) {
4105
/* The row was not yet committed */
4110
did_semi_consistent_read = TRUE;
4115
goto lock_wait_or_error;
4118
/* This is a non-locking consistent read: if necessary, fetch
4119
a previous version of the record */
4121
if (trx->isolation_level == TRX_ISO_READ_UNCOMMITTED) {
4123
/* Do nothing: we let a non-locking SELECT read the
4124
latest version of the record */
4126
} else if (index == clust_index) {
4128
/* Fetch a previous version of the row if the current
4129
one is not visible in the snapshot; if we have a very
4130
high force recovery level set, we try to avoid crashes
4131
by skipping this lookup */
4133
if (UNIV_LIKELY(srv_force_recovery < 5)
4134
&& !lock_clust_rec_cons_read_sees(
4135
rec, index, offsets, trx->read_view)) {
4138
/* The following call returns 'offsets'
4139
associated with 'old_vers' */
4140
err = row_sel_build_prev_vers_for_mysql(
4141
trx->read_view, clust_index,
4142
prebuilt, rec, &offsets, &heap,
4145
if (err != DB_SUCCESS) {
4147
goto lock_wait_or_error;
4150
if (old_vers == NULL) {
4151
/* The row did not exist yet in
4159
} else if (!lock_sec_rec_cons_read_sees(rec, trx->read_view)) {
4160
/* We are looking into a non-clustered index,
4161
and to get the right version of the record we
4162
have to look also into the clustered index: this
4163
is necessary, because we can only get the undo
4164
information via the clustered index record. */
4166
ut_ad(index != clust_index);
4168
goto requires_clust_rec;
4172
/* NOTE that at this point rec can be an old version of a clustered
4173
index record built for a consistent read. We cannot assume after this
4174
point that rec is on a buffer pool page. Functions like
4175
page_rec_is_comp() cannot be used! */
4177
if (UNIV_UNLIKELY(rec_get_deleted_flag(rec, comp))) {
4179
/* The record is delete-marked: we can skip it */
4181
if ((srv_locks_unsafe_for_binlog
4182
|| trx->isolation_level == TRX_ISO_READ_COMMITTED)
4183
&& prebuilt->select_lock_type != LOCK_NONE
4184
&& !did_semi_consistent_read) {
4186
/* No need to keep a lock on a delete-marked record
4187
if we do not want to use next-key locking. */
4189
row_unlock_for_mysql(prebuilt, TRUE);
4192
/* This is an optimization to skip setting the next key lock
4193
on the record that follows this delete-marked record. This
4194
optimization works because of the unique search criteria
4195
which precludes the presence of a range lock between this
4196
delete marked record and the record following it.
4198
For now this is applicable only to clustered indexes while
4199
doing a unique search. There is scope for further optimization
4200
applicable to unique secondary indexes. Current behaviour is
4201
to widen the scope of a lock on an already delete marked record
4202
if the same record is deleted twice by the same transaction */
4203
if (index == clust_index && unique_search) {
4204
err = DB_RECORD_NOT_FOUND;
4212
/* Get the clustered index record if needed, if we did not do the
4213
search using the clustered index. */
4215
if (index != clust_index && prebuilt->need_to_access_clustered) {
4218
/* We use a 'goto' to the preceding label if a consistent
4219
read of a secondary index record requires us to look up old
4220
versions of the associated clustered index record. */
4222
ut_ad(rec_offs_validate(rec, index, offsets));
4224
/* It was a non-clustered index and we must fetch also the
4225
clustered index record */
4227
mtr_has_extra_clust_latch = TRUE;
4229
/* The following call returns 'offsets' associated with
4230
'clust_rec'. Note that 'clust_rec' can be an old version
4231
built for a consistent read. */
4233
err = row_sel_get_clust_rec_for_mysql(prebuilt, index, rec,
4235
&offsets, &heap, &mtr);
4236
if (err != DB_SUCCESS) {
4238
goto lock_wait_or_error;
4241
if (clust_rec == NULL) {
4242
/* The record did not exist in the read view */
4243
ut_ad(prebuilt->select_lock_type == LOCK_NONE);
4248
if ((srv_locks_unsafe_for_binlog
4249
|| trx->isolation_level == TRX_ISO_READ_COMMITTED)
4250
&& prebuilt->select_lock_type != LOCK_NONE) {
4251
/* Note that both the secondary index record
4252
and the clustered index record were locked. */
4253
ut_ad(prebuilt->new_rec_locks == 1);
4254
prebuilt->new_rec_locks = 2;
4257
if (UNIV_UNLIKELY(rec_get_deleted_flag(clust_rec, comp))) {
4259
/* The record is delete marked: we can skip it */
4261
if ((srv_locks_unsafe_for_binlog
4262
|| trx->isolation_level == TRX_ISO_READ_COMMITTED)
4263
&& prebuilt->select_lock_type != LOCK_NONE) {
4265
/* No need to keep a lock on a delete-marked
4266
record if we do not want to use next-key
4269
row_unlock_for_mysql(prebuilt, TRUE);
4275
if (prebuilt->need_to_access_clustered) {
4277
result_rec = clust_rec;
4279
ut_ad(rec_offs_validate(result_rec, clust_index,
4282
/* We used 'offsets' for the clust rec, recalculate
4284
offsets = rec_get_offsets(rec, index, offsets,
4285
ULINT_UNDEFINED, &heap);
4292
/* We found a qualifying record 'result_rec'. At this point,
4293
'offsets' are associated with 'result_rec'. */
4295
ut_ad(rec_offs_validate(result_rec,
4296
result_rec != rec ? clust_index : index,
4299
/* At this point, the clustered index record is protected
4300
by a page latch that was acquired when pcur was positioned.
4301
The latch will not be released until mtr_commit(&mtr). */
4303
if ((match_mode == ROW_SEL_EXACT
4304
|| prebuilt->n_rows_fetched >= MYSQL_FETCH_CACHE_THRESHOLD)
4305
&& prebuilt->select_lock_type == LOCK_NONE
4306
&& !prebuilt->templ_contains_blob
4307
&& !prebuilt->clust_index_was_generated
4308
&& !prebuilt->used_in_HANDLER
4309
&& prebuilt->template_type
4310
!= ROW_MYSQL_DUMMY_TEMPLATE) {
4312
/* Inside an update, for example, we do not cache rows,
4313
since we may use the cursor position to do the actual
4314
update, that is why we require ...lock_type == LOCK_NONE.
4315
Since we keep space in prebuilt only for the BLOBs of
4316
a single row, we cannot cache rows in the case there
4317
are BLOBs in the fields to be fetched. In HANDLER we do
4318
not cache rows because there the cursor is a scrollable
4321
row_sel_push_cache_row_for_mysql(prebuilt, result_rec,
4323
if (prebuilt->n_fetch_cached == MYSQL_FETCH_CACHE_SIZE) {
4330
if (prebuilt->template_type == ROW_MYSQL_DUMMY_TEMPLATE) {
4331
memcpy(buf + 4, result_rec
4332
- rec_offs_extra_size(offsets),
4333
rec_offs_size(offsets));
4334
mach_write_to_4(buf,
4335
rec_offs_extra_size(offsets) + 4);
4337
if (!row_sel_store_mysql_rec(buf, prebuilt,
4338
result_rec, offsets)) {
4339
err = DB_TOO_BIG_RECORD;
4341
goto lock_wait_or_error;
4345
if (prebuilt->clust_index_was_generated) {
4346
if (result_rec != rec) {
4347
offsets = rec_get_offsets(
4348
rec, index, offsets, ULINT_UNDEFINED,
4351
row_sel_store_row_id_to_prebuilt(prebuilt, rec,
4356
/* From this point on, 'offsets' are invalid. */
4359
/* We have an optimization to save CPU time: if this is a consistent
4360
read on a unique condition on the clustered index, then we do not
4361
store the pcur position, because any fetch next or prev will anyway
4362
return 'end of file'. Exceptions are locking reads and the MySQL
4363
HANDLER command where the user can move the cursor with PREV or NEXT
4364
even after a unique search. */
4366
if (!unique_search_from_clust_index
4367
|| prebuilt->select_lock_type != LOCK_NONE
4368
|| prebuilt->used_in_HANDLER) {
4370
/* Inside an update always store the cursor position */
4372
btr_pcur_store_position(pcur, &mtr);
4380
/* Reset the old and new "did semi-consistent read" flags. */
4381
if (UNIV_UNLIKELY(prebuilt->row_read_type
4382
== ROW_READ_DID_SEMI_CONSISTENT)) {
4383
prebuilt->row_read_type = ROW_READ_TRY_SEMI_CONSISTENT;
4385
did_semi_consistent_read = FALSE;
4386
prebuilt->new_rec_locks = 0;
4388
/*-------------------------------------------------------------*/
4389
/* PHASE 5: Move the cursor to the next index record */
4391
if (UNIV_UNLIKELY(mtr_has_extra_clust_latch)) {
4392
/* We must commit mtr if we are moving to the next
4393
non-clustered index record, because we could break the
4394
latching order if we would access a different clustered
4395
index page right away without releasing the previous. */
4397
btr_pcur_store_position(pcur, &mtr);
4400
mtr_has_extra_clust_latch = FALSE;
4403
if (sel_restore_position_for_mysql(&same_user_rec,
4405
pcur, moves_up, &mtr)) {
4406
#ifdef UNIV_SEARCH_DEBUG
4408
#endif /* UNIV_SEARCH_DEBUG */
4415
if (UNIV_UNLIKELY(!btr_pcur_move_to_next(pcur, &mtr))) {
4417
btr_pcur_store_position(pcur, &mtr);
4419
if (match_mode != 0) {
4420
err = DB_RECORD_NOT_FOUND;
4422
err = DB_END_OF_INDEX;
4428
if (UNIV_UNLIKELY(!btr_pcur_move_to_prev(pcur, &mtr))) {
4433
#ifdef UNIV_SEARCH_DEBUG
4435
#endif /* UNIV_SEARCH_DEBUG */
4440
/* Reset the old and new "did semi-consistent read" flags. */
4441
if (UNIV_UNLIKELY(prebuilt->row_read_type
4442
== ROW_READ_DID_SEMI_CONSISTENT)) {
4443
prebuilt->row_read_type = ROW_READ_TRY_SEMI_CONSISTENT;
4445
did_semi_consistent_read = FALSE;
4447
/*-------------------------------------------------------------*/
4449
btr_pcur_store_position(pcur, &mtr);
4452
mtr_has_extra_clust_latch = FALSE;
4454
trx->error_state = err;
4456
/* The following is a patch for MySQL */
4458
que_thr_stop_for_mysql(thr);
4460
thr->lock_state = QUE_THR_LOCK_ROW;
4462
if (row_mysql_handle_errors(&err, trx, thr, NULL)) {
4463
/* It was a lock wait, and it ended */
4465
thr->lock_state = QUE_THR_LOCK_NOLOCK;
4468
sel_restore_position_for_mysql(&same_user_rec,
4469
BTR_SEARCH_LEAF, pcur,
4472
if ((srv_locks_unsafe_for_binlog
4473
|| trx->isolation_level == TRX_ISO_READ_COMMITTED)
4474
&& !same_user_rec) {
4476
/* Since we were not able to restore the cursor
4477
on the same user record, we cannot use
4478
row_unlock_for_mysql() to unlock any records, and
4479
we must thus reset the new rec lock info. Since
4480
in lock0lock.c we have blocked the inheriting of gap
4481
X-locks, we actually do not have any new record locks
4484
Note that if we were able to restore on the 'same'
4485
user record, it is still possible that we were actually
4486
waiting on a delete-marked record, and meanwhile
4487
it was removed by purge and inserted again by some
4488
other user. But that is no problem, because in
4489
rec_loop we will again try to set a lock, and
4490
new_rec_lock_info in trx will be right at the end. */
4492
prebuilt->new_rec_locks = 0;
4495
mode = pcur->search_mode;
4500
thr->lock_state = QUE_THR_LOCK_NOLOCK;
4502
#ifdef UNIV_SEARCH_DEBUG
4503
/* fputs("Using ", stderr);
4504
dict_index_name_print(stderr, index);
4505
fprintf(stderr, " cnt %lu ret value %lu err\n", cnt, err); */
4506
#endif /* UNIV_SEARCH_DEBUG */
4510
/*-------------------------------------------------------------*/
4511
que_thr_stop_for_mysql_no_error(thr, trx);
4515
if (prebuilt->n_fetch_cached > 0) {
4516
row_sel_pop_cached_row_for_mysql(buf, prebuilt);
4521
#ifdef UNIV_SEARCH_DEBUG
4522
/* fputs("Using ", stderr);
4523
dict_index_name_print(stderr, index);
4524
fprintf(stderr, " cnt %lu ret value %lu err\n", cnt, err); */
4525
#endif /* UNIV_SEARCH_DEBUG */
4526
if (err == DB_SUCCESS) {
4532
if (UNIV_LIKELY_NULL(heap)) {
4533
mem_heap_free(heap);
4536
/* Set or reset the "did semi-consistent read" flag on return.
4537
The flag did_semi_consistent_read is set if and only if
4538
the record being returned was fetched with a semi-consistent read. */
4539
ut_ad(prebuilt->row_read_type != ROW_READ_WITH_LOCKS
4540
|| !did_semi_consistent_read);
4542
if (UNIV_UNLIKELY(prebuilt->row_read_type != ROW_READ_WITH_LOCKS)) {
4543
if (UNIV_UNLIKELY(did_semi_consistent_read)) {
4544
prebuilt->row_read_type = ROW_READ_DID_SEMI_CONSISTENT;
4546
prebuilt->row_read_type = ROW_READ_TRY_SEMI_CONSISTENT;
4552
/*******************************************************************//**
4553
Checks if MySQL at the moment is allowed for this table to retrieve a
4554
consistent read result, or store it to the query cache.
4555
@return TRUE if storing or retrieving from the query cache is permitted */
4558
row_search_check_if_query_cache_permitted(
4559
/*======================================*/
4560
trx_t* trx, /*!< in: transaction object */
4561
const char* norm_name) /*!< in: concatenation of database name,
4562
'/' char, table name */
4564
dict_table_t* table;
4567
table = dict_table_get(norm_name, FALSE);
4569
if (table == NULL) {
4574
mutex_enter(&kernel_mutex);
4576
/* Start the transaction if it is not started yet */
4578
trx_start_if_not_started_low(trx);
4580
/* If there are locks on the table or some trx has invalidated the
4581
cache up to our trx id, then ret = FALSE.
4582
We do not check what type locks there are on the table, though only
4583
IX type locks actually would require ret = FALSE. */
4585
if (UT_LIST_GET_LEN(table->locks) == 0
4586
&& ut_dulint_cmp(trx->id,
4587
table->query_cache_inv_trx_id) >= 0) {
4591
/* If the isolation level is high, assign a read view for the
4592
transaction if it does not yet have one */
4594
if (trx->isolation_level >= TRX_ISO_REPEATABLE_READ
4595
&& !trx->read_view) {
4597
trx->read_view = read_view_open_now(
4598
trx->id, trx->global_read_view_heap);
4599
trx->global_read_view = trx->read_view;
4603
mutex_exit(&kernel_mutex);
4608
/*******************************************************************//**
4609
Read the AUTOINC column from the current row. If the value is less than
4610
0 and the type is not unsigned then we reset the value to 0.
4611
@return value read from the column */
4614
row_search_autoinc_read_column(
4615
/*===========================*/
4616
dict_index_t* index, /*!< in: index to read from */
4617
const rec_t* rec, /*!< in: current rec */
4618
ulint col_no, /*!< in: column number */
4619
ibool unsigned_type) /*!< in: signed or unsigned flag */
4624
mem_heap_t* heap = NULL;
4625
ulint offsets_[REC_OFFS_NORMAL_SIZE];
4626
ulint* offsets = offsets_;
4628
rec_offs_init(offsets_);
4630
offsets = rec_get_offsets(rec, index, offsets, ULINT_UNDEFINED, &heap);
4632
data = rec_get_nth_field(rec, offsets, col_no, &len);
4634
ut_a(len != UNIV_SQL_NULL);
4635
ut_a(len <= sizeof value);
4637
/* we assume AUTOINC value cannot be negative */
4638
value = mach_read_int_type(data, len, unsigned_type);
4640
if (UNIV_LIKELY_NULL(heap)) {
4641
mem_heap_free(heap);
4644
if (!unsigned_type && (ib_int64_t) value < 0) {
4651
/*******************************************************************//**
4653
@return current rec or NULL */
4656
row_search_autoinc_get_rec(
4657
/*=======================*/
4658
btr_pcur_t* pcur, /*!< in: the current cursor */
4659
mtr_t* mtr) /*!< in: mini transaction */
4662
const rec_t* rec = btr_pcur_get_rec(pcur);
4664
if (page_rec_is_user_rec(rec)) {
4667
} while (btr_pcur_move_to_prev(pcur, mtr));
4672
/*******************************************************************//**
4673
Read the max AUTOINC value from an index.
4674
@return DB_SUCCESS if all OK else error code, DB_RECORD_NOT_FOUND if
4675
column name can't be found in index */
4678
row_search_max_autoinc(
4679
/*===================*/
4680
dict_index_t* index, /*!< in: index to search */
4681
const char* col_name, /*!< in: name of autoinc column */
4682
ib_uint64_t* value) /*!< out: AUTOINC value read */
4686
dict_field_t* dfield = NULL;
4687
ulint error = DB_SUCCESS;
4689
n_cols = dict_index_get_n_ordering_defined_by_user(index);
4691
/* Search the index for the AUTOINC column name */
4692
for (i = 0; i < n_cols; ++i) {
4693
dfield = dict_index_get_nth_field(index, i);
4695
if (strcmp(col_name, dfield->name) == 0) {
4702
/* Must find the AUTOINC column name */
4703
if (i < n_cols && dfield) {
4709
/* Open at the high/right end (FALSE), and INIT
4711
btr_pcur_open_at_index_side(
4712
FALSE, index, BTR_SEARCH_LEAF, &pcur, TRUE, &mtr);
4714
if (page_get_n_recs(btr_pcur_get_page(&pcur)) > 0) {
4717
rec = row_search_autoinc_get_rec(&pcur, &mtr);
4720
ibool unsigned_type = (
4721
dfield->col->prtype & DATA_UNSIGNED);
4723
*value = row_search_autoinc_read_column(
4724
index, rec, i, unsigned_type);
4728
btr_pcur_close(&pcur);
4732
error = DB_RECORD_NOT_FOUND;
added
removed
storage/innodb_plugin/row/row0sel.c
