← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/include/btr0cur.h

  • Committer: Stewart Smith
  • Date: 2008-11-21 16:06:07 UTC
  • mto: This revision was merged to the branch mainline in revision 593.
  • Revision ID: stewart@flamingspork.com-20081121160607-n6gdlt013spuo54r
remove mysql_frm_type
and fix engines to return correct value from delete_table when table doesn't exist.
(it should be ENOENT).

Also fix up some tests that manipulated frm files by hand. These tests are no longer valid and will need to be rewritten in the not too distant future.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/include/btr0cur.h
1
 
/*****************************************************************************
2
 
 
3
 
Copyright (c) 1994, 2009, Innobase Oy. All Rights Reserved.
4
 
 
5
 
This program is free software; you can redistribute it and/or modify it under
6
 
the terms of the GNU General Public License as published by the Free Software
7
 
Foundation; version 2 of the License.
8
 
 
9
 
This program is distributed in the hope that it will be useful, but WITHOUT
10
 
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11
 
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
12
 
 
13
 
You should have received a copy of the GNU General Public License along with
14
 
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
15
 
Place, Suite 330, Boston, MA 02111-1307 USA
16
 
 
17
 
*****************************************************************************/
18
 
 
19
 
/**************************************************//**
20
 
@file include/btr0cur.h
21
 
The index tree cursor
22
 
 
23
 
Created 10/16/1994 Heikki Tuuri
24
 
*******************************************************/
25
 
 
26
 
#ifndef btr0cur_h
27
 
#define btr0cur_h
28
 
 
29
 
#include "univ.i"
30
 
#include "dict0dict.h"
31
 
#include "page0cur.h"
32
 
#include "btr0types.h"
33
 
 
34
 
/* Mode flags for btr_cur operations; these can be ORed */
35
 
#define BTR_NO_UNDO_LOG_FLAG    1       /* do no undo logging */
36
 
#define BTR_NO_LOCKING_FLAG     2       /* do no record lock checking */
37
 
#define BTR_KEEP_SYS_FLAG       4       /* sys fields will be found from the
38
 
                                        update vector or inserted entry */
39
 
 
40
 
#ifndef UNIV_HOTBACKUP
41
 
#include "que0types.h"
42
 
#include "row0types.h"
43
 
#include "ha0ha.h"
44
 
 
45
 
#define BTR_CUR_ADAPT
46
 
#define BTR_CUR_HASH_ADAPT
47
 
 
48
 
#ifdef UNIV_DEBUG
49
 
/*********************************************************//**
50
 
Returns the page cursor component of a tree cursor.
51
 
@return pointer to page cursor component */
52
 
UNIV_INLINE
53
 
page_cur_t*
54
 
btr_cur_get_page_cur(
55
 
/*=================*/
56
 
        const btr_cur_t*        cursor);/*!< in: tree cursor */
57
 
#else /* UNIV_DEBUG */
58
 
# define btr_cur_get_page_cur(cursor) (&(cursor)->page_cur)
59
 
#endif /* UNIV_DEBUG */
60
 
/*********************************************************//**
61
 
Returns the buffer block on which the tree cursor is positioned.
62
 
@return pointer to buffer block */
63
 
UNIV_INLINE
64
 
buf_block_t*
65
 
btr_cur_get_block(
66
 
/*==============*/
67
 
        btr_cur_t*      cursor);/*!< in: tree cursor */
68
 
/*********************************************************//**
69
 
Returns the record pointer of a tree cursor.
70
 
@return pointer to record */
71
 
UNIV_INLINE
72
 
rec_t*
73
 
btr_cur_get_rec(
74
 
/*============*/
75
 
        btr_cur_t*      cursor);/*!< in: tree cursor */
76
 
/*********************************************************//**
77
 
Returns the compressed page on which the tree cursor is positioned.
78
 
@return pointer to compressed page, or NULL if the page is not compressed */
79
 
UNIV_INLINE
80
 
page_zip_des_t*
81
 
btr_cur_get_page_zip(
82
 
/*=================*/
83
 
        btr_cur_t*      cursor);/*!< in: tree cursor */
84
 
/*********************************************************//**
85
 
Invalidates a tree cursor by setting record pointer to NULL. */
86
 
UNIV_INLINE
87
 
void
88
 
btr_cur_invalidate(
89
 
/*===============*/
90
 
        btr_cur_t*      cursor);/*!< in: tree cursor */
91
 
/*********************************************************//**
92
 
Returns the page of a tree cursor.
93
 
@return pointer to page */
94
 
UNIV_INLINE
95
 
page_t*
96
 
btr_cur_get_page(
97
 
/*=============*/
98
 
        btr_cur_t*      cursor);/*!< in: tree cursor */
99
 
/*********************************************************//**
100
 
Returns the index of a cursor.
101
 
@return index */
102
 
UNIV_INLINE
103
 
dict_index_t*
104
 
btr_cur_get_index(
105
 
/*==============*/
106
 
        btr_cur_t*      cursor);/*!< in: B-tree cursor */
107
 
/*********************************************************//**
108
 
Positions a tree cursor at a given record. */
109
 
UNIV_INLINE
110
 
void
111
 
btr_cur_position(
112
 
/*=============*/
113
 
        dict_index_t*   index,  /*!< in: index */
114
 
        rec_t*          rec,    /*!< in: record in tree */
115
 
        buf_block_t*    block,  /*!< in: buffer block of rec */
116
 
        btr_cur_t*      cursor);/*!< in: cursor */
117
 
/********************************************************************//**
118
 
Searches an index tree and positions a tree cursor on a given level.
119
 
NOTE: n_fields_cmp in tuple must be set so that it cannot be compared
120
 
to node pointer page number fields on the upper levels of the tree!
121
 
Note that if mode is PAGE_CUR_LE, which is used in inserts, then
122
 
cursor->up_match and cursor->low_match both will have sensible values.
123
 
If mode is PAGE_CUR_GE, then up_match will a have a sensible value. */
124
 
UNIV_INTERN
125
 
void
126
 
btr_cur_search_to_nth_level(
127
 
/*========================*/
128
 
        dict_index_t*   index,  /*!< in: index */
129
 
        ulint           level,  /*!< in: the tree level of search */
130
 
        const dtuple_t* tuple,  /*!< in: data tuple; NOTE: n_fields_cmp in
131
 
                                tuple must be set so that it cannot get
132
 
                                compared to the node ptr page number field! */
133
 
        ulint           mode,   /*!< in: PAGE_CUR_L, ...;
134
 
                                NOTE that if the search is made using a unique
135
 
                                prefix of a record, mode should be PAGE_CUR_LE,
136
 
                                not PAGE_CUR_GE, as the latter may end up on
137
 
                                the previous page of the record! Inserts
138
 
                                should always be made using PAGE_CUR_LE to
139
 
                                search the position! */
140
 
        ulint           latch_mode, /*!< in: BTR_SEARCH_LEAF, ..., ORed with
141
 
                                BTR_INSERT and BTR_ESTIMATE;
142
 
                                cursor->left_block is used to store a pointer
143
 
                                to the left neighbor page, in the cases
144
 
                                BTR_SEARCH_PREV and BTR_MODIFY_PREV;
145
 
                                NOTE that if has_search_latch
146
 
                                is != 0, we maybe do not have a latch set
147
 
                                on the cursor page, we assume
148
 
                                the caller uses his search latch
149
 
                                to protect the record! */
150
 
        btr_cur_t*      cursor, /*!< in/out: tree cursor; the cursor page is
151
 
                                s- or x-latched, but see also above! */
152
 
        ulint           has_search_latch,/*!< in: latch mode the caller
153
 
                                currently has on btr_search_latch:
154
 
                                RW_S_LATCH, or 0 */
155
 
        mtr_t*          mtr);   /*!< in: mtr */
156
 
/*****************************************************************//**
157
 
Opens a cursor at either end of an index. */
158
 
UNIV_INTERN
159
 
void
160
 
btr_cur_open_at_index_side(
161
 
/*=======================*/
162
 
        ibool           from_left,      /*!< in: TRUE if open to the low end,
163
 
                                        FALSE if to the high end */
164
 
        dict_index_t*   index,          /*!< in: index */
165
 
        ulint           latch_mode,     /*!< in: latch mode */
166
 
        btr_cur_t*      cursor,         /*!< in: cursor */
167
 
        mtr_t*          mtr);           /*!< in: mtr */
168
 
/**********************************************************************//**
169
 
Positions a cursor at a randomly chosen position within a B-tree. */
170
 
UNIV_INTERN
171
 
void
172
 
btr_cur_open_at_rnd_pos(
173
 
/*====================*/
174
 
        dict_index_t*   index,          /*!< in: index */
175
 
        ulint           latch_mode,     /*!< in: BTR_SEARCH_LEAF, ... */
176
 
        btr_cur_t*      cursor,         /*!< in/out: B-tree cursor */
177
 
        mtr_t*          mtr);           /*!< in: mtr */
178
 
/*************************************************************//**
179
 
Tries to perform an insert to a page in an index tree, next to cursor.
180
 
It is assumed that mtr holds an x-latch on the page. The operation does
181
 
not succeed if there is too little space on the page. If there is just
182
 
one record on the page, the insert will always succeed; this is to
183
 
prevent trying to split a page with just one record.
184
 
@return DB_SUCCESS, DB_WAIT_LOCK, DB_FAIL, or error number */
185
 
UNIV_INTERN
186
 
ulint
187
 
btr_cur_optimistic_insert(
188
 
/*======================*/
189
 
        ulint           flags,  /*!< in: undo logging and locking flags: if not
190
 
                                zero, the parameters index and thr should be
191
 
                                specified */
192
 
        btr_cur_t*      cursor, /*!< in: cursor on page after which to insert;
193
 
                                cursor stays valid */
194
 
        dtuple_t*       entry,  /*!< in/out: entry to insert */
195
 
        rec_t**         rec,    /*!< out: pointer to inserted record if
196
 
                                succeed */
197
 
        big_rec_t**     big_rec,/*!< out: big rec vector whose fields have to
198
 
                                be stored externally by the caller, or
199
 
                                NULL */
200
 
        ulint           n_ext,  /*!< in: number of externally stored columns */
201
 
        que_thr_t*      thr,    /*!< in: query thread or NULL */
202
 
        mtr_t*          mtr);   /*!< in: mtr; if this function returns
203
 
                                DB_SUCCESS on a leaf page of a secondary
204
 
                                index in a compressed tablespace, the
205
 
                                mtr must be committed before latching
206
 
                                any further pages */
207
 
/*************************************************************//**
208
 
Performs an insert on a page of an index tree. It is assumed that mtr
209
 
holds an x-latch on the tree and on the cursor page. If the insert is
210
 
made on the leaf level, to avoid deadlocks, mtr must also own x-latches
211
 
to brothers of page, if those brothers exist.
212
 
@return DB_SUCCESS or error number */
213
 
UNIV_INTERN
214
 
ulint
215
 
btr_cur_pessimistic_insert(
216
 
/*=======================*/
217
 
        ulint           flags,  /*!< in: undo logging and locking flags: if not
218
 
                                zero, the parameter thr should be
219
 
                                specified; if no undo logging is specified,
220
 
                                then the caller must have reserved enough
221
 
                                free extents in the file space so that the
222
 
                                insertion will certainly succeed */
223
 
        btr_cur_t*      cursor, /*!< in: cursor after which to insert;
224
 
                                cursor stays valid */
225
 
        dtuple_t*       entry,  /*!< in/out: entry to insert */
226
 
        rec_t**         rec,    /*!< out: pointer to inserted record if
227
 
                                succeed */
228
 
        big_rec_t**     big_rec,/*!< out: big rec vector whose fields have to
229
 
                                be stored externally by the caller, or
230
 
                                NULL */
231
 
        ulint           n_ext,  /*!< in: number of externally stored columns */
232
 
        que_thr_t*      thr,    /*!< in: query thread or NULL */
233
 
        mtr_t*          mtr);   /*!< in: mtr */
234
 
/*************************************************************//**
235
 
Updates a record when the update causes no size changes in its fields.
236
 
@return DB_SUCCESS or error number */
237
 
UNIV_INTERN
238
 
ulint
239
 
btr_cur_update_in_place(
240
 
/*====================*/
241
 
        ulint           flags,  /*!< in: undo logging and locking flags */
242
 
        btr_cur_t*      cursor, /*!< in: cursor on the record to update;
243
 
                                cursor stays valid and positioned on the
244
 
                                same record */
245
 
        const upd_t*    update, /*!< in: update vector */
246
 
        ulint           cmpl_info,/*!< in: compiler info on secondary index
247
 
                                updates */
248
 
        que_thr_t*      thr,    /*!< in: query thread */
249
 
        mtr_t*          mtr);   /*!< in: mtr; must be committed before
250
 
                                latching any further pages */
251
 
/*************************************************************//**
252
 
Tries to update a record on a page in an index tree. It is assumed that mtr
253
 
holds an x-latch on the page. The operation does not succeed if there is too
254
 
little space on the page or if the update would result in too empty a page,
255
 
so that tree compression is recommended.
256
 
@return DB_SUCCESS, or DB_OVERFLOW if the updated record does not fit,
257
 
DB_UNDERFLOW if the page would become too empty, or DB_ZIP_OVERFLOW if
258
 
there is not enough space left on the compressed page */
259
 
UNIV_INTERN
260
 
ulint
261
 
btr_cur_optimistic_update(
262
 
/*======================*/
263
 
        ulint           flags,  /*!< in: undo logging and locking flags */
264
 
        btr_cur_t*      cursor, /*!< in: cursor on the record to update;
265
 
                                cursor stays valid and positioned on the
266
 
                                same record */
267
 
        const upd_t*    update, /*!< in: update vector; this must also
268
 
                                contain trx id and roll ptr fields */
269
 
        ulint           cmpl_info,/*!< in: compiler info on secondary index
270
 
                                updates */
271
 
        que_thr_t*      thr,    /*!< in: query thread */
272
 
        mtr_t*          mtr);   /*!< in: mtr; must be committed before
273
 
                                latching any further pages */
274
 
/*************************************************************//**
275
 
Performs an update of a record on a page of a tree. It is assumed
276
 
that mtr holds an x-latch on the tree and on the cursor page. If the
277
 
update is made on the leaf level, to avoid deadlocks, mtr must also
278
 
own x-latches to brothers of page, if those brothers exist.
279
 
@return DB_SUCCESS or error code */
280
 
UNIV_INTERN
281
 
ulint
282
 
btr_cur_pessimistic_update(
283
 
/*=======================*/
284
 
        ulint           flags,  /*!< in: undo logging, locking, and rollback
285
 
                                flags */
286
 
        btr_cur_t*      cursor, /*!< in: cursor on the record to update */
287
 
        mem_heap_t**    heap,   /*!< in/out: pointer to memory heap, or NULL */
288
 
        big_rec_t**     big_rec,/*!< out: big rec vector whose fields have to
289
 
                                be stored externally by the caller, or NULL */
290
 
        const upd_t*    update, /*!< in: update vector; this is allowed also
291
 
                                contain trx id and roll ptr fields, but
292
 
                                the values in update vector have no effect */
293
 
        ulint           cmpl_info,/*!< in: compiler info on secondary index
294
 
                                updates */
295
 
        que_thr_t*      thr,    /*!< in: query thread */
296
 
        mtr_t*          mtr);   /*!< in: mtr; must be committed before
297
 
                                latching any further pages */
298
 
/***********************************************************//**
299
 
Marks a clustered index record deleted. Writes an undo log record to
300
 
undo log on this delete marking. Writes in the trx id field the id
301
 
of the deleting transaction, and in the roll ptr field pointer to the
302
 
undo log record created.
303
 
@return DB_SUCCESS, DB_LOCK_WAIT, or error number */
304
 
UNIV_INTERN
305
 
ulint
306
 
btr_cur_del_mark_set_clust_rec(
307
 
/*===========================*/
308
 
        ulint           flags,  /*!< in: undo logging and locking flags */
309
 
        btr_cur_t*      cursor, /*!< in: cursor */
310
 
        ibool           val,    /*!< in: value to set */
311
 
        que_thr_t*      thr,    /*!< in: query thread */
312
 
        mtr_t*          mtr);   /*!< in: mtr */
313
 
/***********************************************************//**
314
 
Sets a secondary index record delete mark to TRUE or FALSE.
315
 
@return DB_SUCCESS, DB_LOCK_WAIT, or error number */
316
 
UNIV_INTERN
317
 
ulint
318
 
btr_cur_del_mark_set_sec_rec(
319
 
/*=========================*/
320
 
        ulint           flags,  /*!< in: locking flag */
321
 
        btr_cur_t*      cursor, /*!< in: cursor */
322
 
        ibool           val,    /*!< in: value to set */
323
 
        que_thr_t*      thr,    /*!< in: query thread */
324
 
        mtr_t*          mtr);   /*!< in: mtr */
325
 
/***********************************************************//**
326
 
Clear a secondary index record's delete mark.  This function is only
327
 
used by the insert buffer insert merge mechanism. */
328
 
UNIV_INTERN
329
 
void
330
 
btr_cur_del_unmark_for_ibuf(
331
 
/*========================*/
332
 
        rec_t*          rec,            /*!< in/out: record to delete unmark */
333
 
        page_zip_des_t* page_zip,       /*!< in/out: compressed page
334
 
                                        corresponding to rec, or NULL
335
 
                                        when the tablespace is
336
 
                                        uncompressed */
337
 
        mtr_t*          mtr);           /*!< in: mtr */
338
 
/*************************************************************//**
339
 
Tries to compress a page of the tree if it seems useful. It is assumed
340
 
that mtr holds an x-latch on the tree and on the cursor page. To avoid
341
 
deadlocks, mtr must also own x-latches to brothers of page, if those
342
 
brothers exist. NOTE: it is assumed that the caller has reserved enough
343
 
free extents so that the compression will always succeed if done!
344
 
@return TRUE if compression occurred */
345
 
UNIV_INTERN
346
 
ibool
347
 
btr_cur_compress_if_useful(
348
 
/*=======================*/
349
 
        btr_cur_t*      cursor, /*!< in: cursor on the page to compress;
350
 
                                cursor does not stay valid if compression
351
 
                                occurs */
352
 
        mtr_t*          mtr);   /*!< in: mtr */
353
 
/*******************************************************//**
354
 
Removes the record on which the tree cursor is positioned. It is assumed
355
 
that the mtr has an x-latch on the page where the cursor is positioned,
356
 
but no latch on the whole tree.
357
 
@return TRUE if success, i.e., the page did not become too empty */
358
 
UNIV_INTERN
359
 
ibool
360
 
btr_cur_optimistic_delete(
361
 
/*======================*/
362
 
        btr_cur_t*      cursor, /*!< in: cursor on the record to delete;
363
 
                                cursor stays valid: if deletion succeeds,
364
 
                                on function exit it points to the successor
365
 
                                of the deleted record */
366
 
        mtr_t*          mtr);   /*!< in: mtr; if this function returns
367
 
                                TRUE on a leaf page of a secondary
368
 
                                index, the mtr must be committed
369
 
                                before latching any further pages */
370
 
/*************************************************************//**
371
 
Removes the record on which the tree cursor is positioned. Tries
372
 
to compress the page if its fillfactor drops below a threshold
373
 
or if it is the only page on the level. It is assumed that mtr holds
374
 
an x-latch on the tree and on the cursor page. To avoid deadlocks,
375
 
mtr must also own x-latches to brothers of page, if those brothers
376
 
exist.
377
 
@return TRUE if compression occurred */
378
 
UNIV_INTERN
379
 
ibool
380
 
btr_cur_pessimistic_delete(
381
 
/*=======================*/
382
 
        ulint*          err,    /*!< out: DB_SUCCESS or DB_OUT_OF_FILE_SPACE;
383
 
                                the latter may occur because we may have
384
 
                                to update node pointers on upper levels,
385
 
                                and in the case of variable length keys
386
 
                                these may actually grow in size */
387
 
        ibool           has_reserved_extents, /*!< in: TRUE if the
388
 
                                caller has already reserved enough free
389
 
                                extents so that he knows that the operation
390
 
                                will succeed */
391
 
        btr_cur_t*      cursor, /*!< in: cursor on the record to delete;
392
 
                                if compression does not occur, the cursor
393
 
                                stays valid: it points to successor of
394
 
                                deleted record on function exit */
395
 
        enum trx_rb_ctx rb_ctx, /*!< in: rollback context */
396
 
        mtr_t*          mtr);   /*!< in: mtr */
397
 
#endif /* !UNIV_HOTBACKUP */
398
 
/***********************************************************//**
399
 
Parses a redo log record of updating a record in-place.
400
 
@return end of log record or NULL */
401
 
UNIV_INTERN
402
 
byte*
403
 
btr_cur_parse_update_in_place(
404
 
/*==========================*/
405
 
        byte*           ptr,    /*!< in: buffer */
406
 
        byte*           end_ptr,/*!< in: buffer end */
407
 
        page_t*         page,   /*!< in/out: page or NULL */
408
 
        page_zip_des_t* page_zip,/*!< in/out: compressed page, or NULL */
409
 
        dict_index_t*   index); /*!< in: index corresponding to page */
410
 
/****************************************************************//**
411
 
Parses the redo log record for delete marking or unmarking of a clustered
412
 
index record.
413
 
@return end of log record or NULL */
414
 
UNIV_INTERN
415
 
byte*
416
 
btr_cur_parse_del_mark_set_clust_rec(
417
 
/*=================================*/
418
 
        byte*           ptr,    /*!< in: buffer */
419
 
        byte*           end_ptr,/*!< in: buffer end */
420
 
        page_t*         page,   /*!< in/out: page or NULL */
421
 
        page_zip_des_t* page_zip,/*!< in/out: compressed page, or NULL */
422
 
        dict_index_t*   index); /*!< in: index corresponding to page */
423
 
/****************************************************************//**
424
 
Parses the redo log record for delete marking or unmarking of a secondary
425
 
index record.
426
 
@return end of log record or NULL */
427
 
UNIV_INTERN
428
 
byte*
429
 
btr_cur_parse_del_mark_set_sec_rec(
430
 
/*===============================*/
431
 
        byte*           ptr,    /*!< in: buffer */
432
 
        byte*           end_ptr,/*!< in: buffer end */
433
 
        page_t*         page,   /*!< in/out: page or NULL */
434
 
        page_zip_des_t* page_zip);/*!< in/out: compressed page, or NULL */
435
 
#ifndef UNIV_HOTBACKUP
436
 
/*******************************************************************//**
437
 
Estimates the number of rows in a given index range.
438
 
@return estimated number of rows */
439
 
UNIV_INTERN
440
 
ib_int64_t
441
 
btr_estimate_n_rows_in_range(
442
 
/*=========================*/
443
 
        dict_index_t*   index,  /*!< in: index */
444
 
        const dtuple_t* tuple1, /*!< in: range start, may also be empty tuple */
445
 
        ulint           mode1,  /*!< in: search mode for range start */
446
 
        const dtuple_t* tuple2, /*!< in: range end, may also be empty tuple */
447
 
        ulint           mode2); /*!< in: search mode for range end */
448
 
/*******************************************************************//**
449
 
Estimates the number of different key values in a given index, for
450
 
each n-column prefix of the index where n <= dict_index_get_n_unique(index).
451
 
The estimates are stored in the array index->stat_n_diff_key_vals. */
452
 
UNIV_INTERN
453
 
void
454
 
btr_estimate_number_of_different_key_vals(
455
 
/*======================================*/
456
 
        dict_index_t*   index); /*!< in: index */
457
 
/*******************************************************************//**
458
 
Marks not updated extern fields as not-owned by this record. The ownership
459
 
is transferred to the updated record which is inserted elsewhere in the
460
 
index tree. In purge only the owner of externally stored field is allowed
461
 
to free the field. */
462
 
UNIV_INTERN
463
 
void
464
 
btr_cur_mark_extern_inherited_fields(
465
 
/*=================================*/
466
 
        page_zip_des_t* page_zip,/*!< in/out: compressed page whose uncompressed
467
 
                                part will be updated, or NULL */
468
 
        rec_t*          rec,    /*!< in/out: record in a clustered index */
469
 
        dict_index_t*   index,  /*!< in: index of the page */
470
 
        const ulint*    offsets,/*!< in: array returned by rec_get_offsets() */
471
 
        const upd_t*    update, /*!< in: update vector */
472
 
        mtr_t*          mtr);   /*!< in: mtr, or NULL if not logged */
473
 
/*******************************************************************//**
474
 
The complement of the previous function: in an update entry may inherit
475
 
some externally stored fields from a record. We must mark them as inherited
476
 
in entry, so that they are not freed in a rollback. */
477
 
UNIV_INTERN
478
 
void
479
 
btr_cur_mark_dtuple_inherited_extern(
480
 
/*=================================*/
481
 
        dtuple_t*       entry,          /*!< in/out: updated entry to be
482
 
                                        inserted to clustered index */
483
 
        const upd_t*    update);        /*!< in: update vector */
484
 
/*******************************************************************//**
485
 
Marks all extern fields in a dtuple as owned by the record. */
486
 
UNIV_INTERN
487
 
void
488
 
btr_cur_unmark_dtuple_extern_fields(
489
 
/*================================*/
490
 
        dtuple_t*       entry);         /*!< in/out: clustered index entry */
491
 
/*******************************************************************//**
492
 
Stores the fields in big_rec_vec to the tablespace and puts pointers to
493
 
them in rec.  The extern flags in rec will have to be set beforehand.
494
 
The fields are stored on pages allocated from leaf node
495
 
file segment of the index tree.
496
 
@return DB_SUCCESS or error */
497
 
UNIV_INTERN
498
 
ulint
499
 
btr_store_big_rec_extern_fields(
500
 
/*============================*/
501
 
        dict_index_t*   index,          /*!< in: index of rec; the index tree
502
 
                                        MUST be X-latched */
503
 
        buf_block_t*    rec_block,      /*!< in/out: block containing rec */
504
 
        rec_t*          rec,            /*!< in: record */
505
 
        const ulint*    offsets,        /*!< in: rec_get_offsets(rec, index);
506
 
                                        the "external storage" flags in offsets
507
 
                                        will not correspond to rec when
508
 
                                        this function returns */
509
 
        big_rec_t*      big_rec_vec,    /*!< in: vector containing fields
510
 
                                        to be stored externally */
511
 
        mtr_t*          local_mtr);     /*!< in: mtr containing the latch to
512
 
                                        rec and to the tree */
513
 
/*******************************************************************//**
514
 
Frees the space in an externally stored field to the file space
515
 
management if the field in data is owned the externally stored field,
516
 
in a rollback we may have the additional condition that the field must
517
 
not be inherited. */
518
 
UNIV_INTERN
519
 
void
520
 
btr_free_externally_stored_field(
521
 
/*=============================*/
522
 
        dict_index_t*   index,          /*!< in: index of the data, the index
523
 
                                        tree MUST be X-latched; if the tree
524
 
                                        height is 1, then also the root page
525
 
                                        must be X-latched! (this is relevant
526
 
                                        in the case this function is called
527
 
                                        from purge where 'data' is located on
528
 
                                        an undo log page, not an index
529
 
                                        page) */
530
 
        byte*           field_ref,      /*!< in/out: field reference */
531
 
        const rec_t*    rec,            /*!< in: record containing field_ref, for
532
 
                                        page_zip_write_blob_ptr(), or NULL */
533
 
        const ulint*    offsets,        /*!< in: rec_get_offsets(rec, index),
534
 
                                        or NULL */
535
 
        page_zip_des_t* page_zip,       /*!< in: compressed page corresponding
536
 
                                        to rec, or NULL if rec == NULL */
537
 
        ulint           i,              /*!< in: field number of field_ref;
538
 
                                        ignored if rec == NULL */
539
 
        enum trx_rb_ctx rb_ctx,         /*!< in: rollback context */
540
 
        mtr_t*          local_mtr);     /*!< in: mtr containing the latch to
541
 
                                        data an an X-latch to the index
542
 
                                        tree */
543
 
/*******************************************************************//**
544
 
Copies the prefix of an externally stored field of a record.  The
545
 
clustered index record must be protected by a lock or a page latch.
546
 
@return the length of the copied field, or 0 if the column was being
547
 
or has been deleted */
548
 
UNIV_INTERN
549
 
ulint
550
 
btr_copy_externally_stored_field_prefix(
551
 
/*====================================*/
552
 
        byte*           buf,    /*!< out: the field, or a prefix of it */
553
 
        ulint           len,    /*!< in: length of buf, in bytes */
554
 
        ulint           zip_size,/*!< in: nonzero=compressed BLOB page size,
555
 
                                zero for uncompressed BLOBs */
556
 
        const byte*     data,   /*!< in: 'internally' stored part of the
557
 
                                field containing also the reference to
558
 
                                the external part; must be protected by
559
 
                                a lock or a page latch */
560
 
        ulint           local_len);/*!< in: length of data, in bytes */
561
 
/*******************************************************************//**
562
 
Copies an externally stored field of a record to mem heap.
563
 
@return the field copied to heap */
564
 
UNIV_INTERN
565
 
byte*
566
 
btr_rec_copy_externally_stored_field(
567
 
/*=================================*/
568
 
        const rec_t*    rec,    /*!< in: record in a clustered index;
569
 
                                must be protected by a lock or a page latch */
570
 
        const ulint*    offsets,/*!< in: array returned by rec_get_offsets() */
571
 
        ulint           zip_size,/*!< in: nonzero=compressed BLOB page size,
572
 
                                zero for uncompressed BLOBs */
573
 
        ulint           no,     /*!< in: field number */
574
 
        ulint*          len,    /*!< out: length of the field */
575
 
        mem_heap_t*     heap);  /*!< in: mem heap */
576
 
/*******************************************************************//**
577
 
Flags the data tuple fields that are marked as extern storage in the
578
 
update vector.  We use this function to remember which fields we must
579
 
mark as extern storage in a record inserted for an update.
580
 
@return number of flagged external columns */
581
 
UNIV_INTERN
582
 
ulint
583
 
btr_push_update_extern_fields(
584
 
/*==========================*/
585
 
        dtuple_t*       tuple,  /*!< in/out: data tuple */
586
 
        const upd_t*    update, /*!< in: update vector */
587
 
        mem_heap_t*     heap)   /*!< in: memory heap */
588
 
        __attribute__((nonnull));
589
 
 
590
 
/*######################################################################*/
591
 
 
592
 
/** In the pessimistic delete, if the page data size drops below this
593
 
limit, merging it to a neighbor is tried */
594
 
#define BTR_CUR_PAGE_COMPRESS_LIMIT     (UNIV_PAGE_SIZE / 2)
595
 
 
596
 
/** A slot in the path array. We store here info on a search path down the
597
 
tree. Each slot contains data on a single level of the tree. */
598
 
 
599
 
typedef struct btr_path_struct  btr_path_t;
600
 
struct btr_path_struct{
601
 
        ulint   nth_rec;        /*!< index of the record
602
 
                                where the page cursor stopped on
603
 
                                this level (index in alphabetical
604
 
                                order); value ULINT_UNDEFINED
605
 
                                denotes array end */
606
 
        ulint   n_recs;         /*!< number of records on the page */
607
 
};
608
 
 
609
 
#define BTR_PATH_ARRAY_N_SLOTS  250     /*!< size of path array (in slots) */
610
 
 
611
 
/** Values for the flag documenting the used search method */
612
 
enum btr_cur_method {
613
 
        BTR_CUR_HASH = 1,       /*!< successful shortcut using
614
 
                                the hash index */
615
 
        BTR_CUR_HASH_FAIL,      /*!< failure using hash, success using
616
 
                                binary search: the misleading hash
617
 
                                reference is stored in the field
618
 
                                hash_node, and might be necessary to
619
 
                                update */
620
 
        BTR_CUR_BINARY,         /*!< success using the binary search */
621
 
        BTR_CUR_INSERT_TO_IBUF  /*!< performed the intended insert to
622
 
                                the insert buffer */
623
 
};
624
 
 
625
 
/** The tree cursor: the definition appears here only for the compiler
626
 
to know struct size! */
627
 
struct btr_cur_struct {
628
 
        dict_index_t*   index;          /*!< index where positioned */
629
 
        page_cur_t      page_cur;       /*!< page cursor */
630
 
        buf_block_t*    left_block;     /*!< this field is used to store
631
 
                                        a pointer to the left neighbor
632
 
                                        page, in the cases
633
 
                                        BTR_SEARCH_PREV and
634
 
                                        BTR_MODIFY_PREV */
635
 
        /*------------------------------*/
636
 
        que_thr_t*      thr;            /*!< this field is only used
637
 
                                        when btr_cur_search_to_nth_level
638
 
                                        is called for an index entry
639
 
                                        insertion: the calling query
640
 
                                        thread is passed here to be
641
 
                                        used in the insert buffer */
642
 
        /*------------------------------*/
643
 
        /** The following fields are used in
644
 
        btr_cur_search_to_nth_level to pass information: */
645
 
        /* @{ */
646
 
        enum btr_cur_method     flag;   /*!< Search method used */
647
 
        ulint           tree_height;    /*!< Tree height if the search is done
648
 
                                        for a pessimistic insert or update
649
 
                                        operation */
650
 
        ulint           up_match;       /*!< If the search mode was PAGE_CUR_LE,
651
 
                                        the number of matched fields to the
652
 
                                        the first user record to the right of
653
 
                                        the cursor record after
654
 
                                        btr_cur_search_to_nth_level;
655
 
                                        for the mode PAGE_CUR_GE, the matched
656
 
                                        fields to the first user record AT THE
657
 
                                        CURSOR or to the right of it;
658
 
                                        NOTE that the up_match and low_match
659
 
                                        values may exceed the correct values
660
 
                                        for comparison to the adjacent user
661
 
                                        record if that record is on a
662
 
                                        different leaf page! (See the note in
663
 
                                        row_ins_duplicate_key.) */
664
 
        ulint           up_bytes;       /*!< number of matched bytes to the
665
 
                                        right at the time cursor positioned;
666
 
                                        only used internally in searches: not
667
 
                                        defined after the search */
668
 
        ulint           low_match;      /*!< if search mode was PAGE_CUR_LE,
669
 
                                        the number of matched fields to the
670
 
                                        first user record AT THE CURSOR or
671
 
                                        to the left of it after
672
 
                                        btr_cur_search_to_nth_level;
673
 
                                        NOT defined for PAGE_CUR_GE or any
674
 
                                        other search modes; see also the NOTE
675
 
                                        in up_match! */
676
 
        ulint           low_bytes;      /*!< number of matched bytes to the
677
 
                                        right at the time cursor positioned;
678
 
                                        only used internally in searches: not
679
 
                                        defined after the search */
680
 
        ulint           n_fields;       /*!< prefix length used in a hash
681
 
                                        search if hash_node != NULL */
682
 
        ulint           n_bytes;        /*!< hash prefix bytes if hash_node !=
683
 
                                        NULL */
684
 
        ulint           fold;           /*!< fold value used in the search if
685
 
                                        flag is BTR_CUR_HASH */
686
 
        /*------------------------------*/
687
 
        /* @} */
688
 
        btr_path_t*     path_arr;       /*!< in estimating the number of
689
 
                                        rows in range, we store in this array
690
 
                                        information of the path through
691
 
                                        the tree */
692
 
};
693
 
 
694
 
/** If pessimistic delete fails because of lack of file space, there
695
 
is still a good change of success a little later.  Try this many
696
 
times. */
697
 
#define BTR_CUR_RETRY_DELETE_N_TIMES    100
698
 
/** If pessimistic delete fails because of lack of file space, there
699
 
is still a good change of success a little later.  Sleep this many
700
 
microseconds between retries. */
701
 
#define BTR_CUR_RETRY_SLEEP_TIME        50000
702
 
 
703
 
/** The reference in a field for which data is stored on a different page.
704
 
The reference is at the end of the 'locally' stored part of the field.
705
 
'Locally' means storage in the index record.
706
 
We store locally a long enough prefix of each column so that we can determine
707
 
the ordering parts of each index record without looking into the externally
708
 
stored part. */
709
 
/*-------------------------------------- @{ */
710
 
#define BTR_EXTERN_SPACE_ID             0       /*!< space id where stored */
711
 
#define BTR_EXTERN_PAGE_NO              4       /*!< page no where stored */
712
 
#define BTR_EXTERN_OFFSET               8       /*!< offset of BLOB header
713
 
                                                on that page */
714
 
#define BTR_EXTERN_LEN                  12      /*!< 8 bytes containing the
715
 
                                                length of the externally
716
 
                                                stored part of the BLOB.
717
 
                                                The 2 highest bits are
718
 
                                                reserved to the flags below. */
719
 
/*-------------------------------------- @} */
720
 
/* #define BTR_EXTERN_FIELD_REF_SIZE    20 // moved to btr0types.h */
721
 
 
722
 
/** The most significant bit of BTR_EXTERN_LEN (i.e., the most
723
 
significant bit of the byte at smallest address) is set to 1 if this
724
 
field does not 'own' the externally stored field; only the owner field
725
 
is allowed to free the field in purge! */
726
 
#define BTR_EXTERN_OWNER_FLAG           128
727
 
/** If the second most significant bit of BTR_EXTERN_LEN (i.e., the
728
 
second most significant bit of the byte at smallest address) is 1 then
729
 
it means that the externally stored field was inherited from an
730
 
earlier version of the row.  In rollback we are not allowed to free an
731
 
inherited external field. */
732
 
#define BTR_EXTERN_INHERITED_FLAG       64
733
 
 
734
 
/** Number of searches down the B-tree in btr_cur_search_to_nth_level(). */
735
 
extern ulint    btr_cur_n_non_sea;
736
 
/** Number of successful adaptive hash index lookups in
737
 
btr_cur_search_to_nth_level(). */
738
 
extern ulint    btr_cur_n_sea;
739
 
/** Old value of btr_cur_n_non_sea.  Copied by
740
 
srv_refresh_innodb_monitor_stats().  Referenced by
741
 
srv_printf_innodb_monitor(). */
742
 
extern ulint    btr_cur_n_non_sea_old;
743
 
/** Old value of btr_cur_n_sea.  Copied by
744
 
srv_refresh_innodb_monitor_stats().  Referenced by
745
 
srv_printf_innodb_monitor(). */
746
 
extern ulint    btr_cur_n_sea_old;
747
 
#endif /* !UNIV_HOTBACKUP */
748
 
 
749
 
#ifndef UNIV_NONINL
750
 
#include "btr0cur.ic"
751
 
#endif
752
 
 
753
 
#endif