mirror of
https://github.com/MariaDB/server.git
synced 2025-01-17 12:32:27 +01:00
8d2bb926fb
innobase/btr/btr0cur.c: Make btr_cur_unmark_extern_fields() a static function innobase/include/btr0cur.h: Remove btr_cur_unmark_extern_fields()
695 lines
26 KiB
C
695 lines
26 KiB
C
/******************************************************
|
|
The index tree cursor
|
|
|
|
(c) 1994-1996 Innobase Oy
|
|
|
|
Created 10/16/1994 Heikki Tuuri
|
|
*******************************************************/
|
|
|
|
#ifndef btr0cur_h
|
|
#define btr0cur_h
|
|
|
|
#include "univ.i"
|
|
#include "dict0dict.h"
|
|
#include "data0data.h"
|
|
#include "page0cur.h"
|
|
#include "btr0types.h"
|
|
#include "que0types.h"
|
|
#include "row0types.h"
|
|
#include "ha0ha.h"
|
|
|
|
/* Mode flags for btr_cur operations; these can be ORed */
|
|
#define BTR_NO_UNDO_LOG_FLAG 1 /* do no undo logging */
|
|
#define BTR_NO_LOCKING_FLAG 2 /* do no record lock checking */
|
|
#define BTR_KEEP_SYS_FLAG 4 /* sys fields will be found from the
|
|
update vector or inserted entry */
|
|
|
|
#define BTR_CUR_ADAPT
|
|
#define BTR_CUR_HASH_ADAPT
|
|
|
|
/*************************************************************
|
|
Returns the page cursor component of a tree cursor. */
|
|
UNIV_INLINE
|
|
page_cur_t*
|
|
btr_cur_get_page_cur(
|
|
/*=================*/
|
|
/* out: pointer to page cursor component */
|
|
btr_cur_t* cursor); /* in: tree cursor */
|
|
/*************************************************************
|
|
Returns the record pointer of a tree cursor. */
|
|
UNIV_INLINE
|
|
rec_t*
|
|
btr_cur_get_rec(
|
|
/*============*/
|
|
/* out: pointer to record */
|
|
btr_cur_t* cursor); /* in: tree cursor */
|
|
/*************************************************************
|
|
Invalidates a tree cursor by setting record pointer to NULL. */
|
|
UNIV_INLINE
|
|
void
|
|
btr_cur_invalidate(
|
|
/*===============*/
|
|
btr_cur_t* cursor); /* in: tree cursor */
|
|
/*************************************************************
|
|
Returns the page of a tree cursor. */
|
|
UNIV_INLINE
|
|
page_t*
|
|
btr_cur_get_page(
|
|
/*=============*/
|
|
/* out: pointer to page */
|
|
btr_cur_t* cursor); /* in: tree cursor */
|
|
/*************************************************************
|
|
Returns the tree of a cursor. */
|
|
UNIV_INLINE
|
|
dict_tree_t*
|
|
btr_cur_get_tree(
|
|
/*=============*/
|
|
/* out: tree */
|
|
btr_cur_t* cursor); /* in: tree cursor */
|
|
/*************************************************************
|
|
Positions a tree cursor at a given record. */
|
|
UNIV_INLINE
|
|
void
|
|
btr_cur_position(
|
|
/*=============*/
|
|
dict_index_t* index, /* in: index */
|
|
rec_t* rec, /* in: record in tree */
|
|
btr_cur_t* cursor);/* in: cursor */
|
|
/************************************************************************
|
|
Searches an index tree and positions a tree cursor on a given level.
|
|
NOTE: n_fields_cmp in tuple must be set so that it cannot be compared
|
|
to node pointer page number fields on the upper levels of the tree!
|
|
Note that if mode is PAGE_CUR_LE, which is used in inserts, then
|
|
cursor->up_match and cursor->low_match both will have sensible values.
|
|
If mode is PAGE_CUR_GE, then up_match will a have a sensible value. */
|
|
|
|
void
|
|
btr_cur_search_to_nth_level(
|
|
/*========================*/
|
|
dict_index_t* index, /* in: index */
|
|
ulint level, /* in: the tree level of search */
|
|
dtuple_t* tuple, /* in: data tuple; NOTE: n_fields_cmp in
|
|
tuple must be set so that it cannot get
|
|
compared to the node ptr page number field! */
|
|
ulint mode, /* in: PAGE_CUR_L, ...;
|
|
NOTE that if the search is made using a unique
|
|
prefix of a record, mode should be PAGE_CUR_LE,
|
|
not PAGE_CUR_GE, as the latter may end up on
|
|
the previous page of the record! Inserts
|
|
should always be made using PAGE_CUR_LE to
|
|
search the position! */
|
|
ulint latch_mode, /* in: BTR_SEARCH_LEAF, ..., ORed with
|
|
BTR_INSERT and BTR_ESTIMATE;
|
|
cursor->left_page is used to store a pointer
|
|
to the left neighbor page, in the cases
|
|
BTR_SEARCH_PREV and BTR_MODIFY_PREV;
|
|
NOTE that if has_search_latch
|
|
is != 0, we maybe do not have a latch set
|
|
on the cursor page, we assume
|
|
the caller uses his search latch
|
|
to protect the record! */
|
|
btr_cur_t* cursor, /* in/out: tree cursor; the cursor page is
|
|
s- or x-latched, but see also above! */
|
|
ulint has_search_latch,/* in: latch mode the caller
|
|
currently has on btr_search_latch:
|
|
RW_S_LATCH, or 0 */
|
|
mtr_t* mtr); /* in: mtr */
|
|
/*********************************************************************
|
|
Opens a cursor at either end of an index. */
|
|
|
|
void
|
|
btr_cur_open_at_index_side(
|
|
/*=======================*/
|
|
ibool from_left, /* in: TRUE if open to the low end,
|
|
FALSE if to the high end */
|
|
dict_index_t* index, /* in: index */
|
|
ulint latch_mode, /* in: latch mode */
|
|
btr_cur_t* cursor, /* in: cursor */
|
|
mtr_t* mtr); /* in: mtr */
|
|
/**************************************************************************
|
|
Positions a cursor at a randomly chosen position within a B-tree. */
|
|
|
|
void
|
|
btr_cur_open_at_rnd_pos(
|
|
/*====================*/
|
|
dict_index_t* index, /* in: index */
|
|
ulint latch_mode, /* in: BTR_SEARCH_LEAF, ... */
|
|
btr_cur_t* cursor, /* in/out: B-tree cursor */
|
|
mtr_t* mtr); /* in: mtr */
|
|
/*****************************************************************
|
|
Tries to perform an insert to a page in an index tree, next to cursor.
|
|
It is assumed that mtr holds an x-latch on the page. The operation does
|
|
not succeed if there is too little space on the page. If there is just
|
|
one record on the page, the insert will always succeed; this is to
|
|
prevent trying to split a page with just one record. */
|
|
|
|
ulint
|
|
btr_cur_optimistic_insert(
|
|
/*======================*/
|
|
/* out: DB_SUCCESS, DB_WAIT_LOCK,
|
|
DB_FAIL, or error number */
|
|
ulint flags, /* in: undo logging and locking flags: if not
|
|
zero, the parameters index and thr should be
|
|
specified */
|
|
btr_cur_t* cursor, /* in: cursor on page after which to insert;
|
|
cursor stays valid */
|
|
dtuple_t* entry, /* in: entry to insert */
|
|
rec_t** rec, /* out: pointer to inserted record if
|
|
succeed */
|
|
big_rec_t** big_rec,/* out: big rec vector whose fields have to
|
|
be stored externally by the caller, or
|
|
NULL */
|
|
que_thr_t* thr, /* in: query thread or NULL */
|
|
mtr_t* mtr); /* in: mtr */
|
|
/*****************************************************************
|
|
Performs an insert on a page of an index tree. It is assumed that mtr
|
|
holds an x-latch on the tree and on the cursor page. If the insert is
|
|
made on the leaf level, to avoid deadlocks, mtr must also own x-latches
|
|
to brothers of page, if those brothers exist. */
|
|
|
|
ulint
|
|
btr_cur_pessimistic_insert(
|
|
/*=======================*/
|
|
/* out: DB_SUCCESS or error number */
|
|
ulint flags, /* in: undo logging and locking flags: if not
|
|
zero, the parameter thr should be
|
|
specified; if no undo logging is specified,
|
|
then the caller must have reserved enough
|
|
free extents in the file space so that the
|
|
insertion will certainly succeed */
|
|
btr_cur_t* cursor, /* in: cursor after which to insert;
|
|
cursor stays valid */
|
|
dtuple_t* entry, /* in: entry to insert */
|
|
rec_t** rec, /* out: pointer to inserted record if
|
|
succeed */
|
|
big_rec_t** big_rec,/* out: big rec vector whose fields have to
|
|
be stored externally by the caller, or
|
|
NULL */
|
|
que_thr_t* thr, /* in: query thread or NULL */
|
|
mtr_t* mtr); /* in: mtr */
|
|
/*****************************************************************
|
|
Updates a record when the update causes no size changes in its fields. */
|
|
|
|
ulint
|
|
btr_cur_update_in_place(
|
|
/*====================*/
|
|
/* out: DB_SUCCESS or error number */
|
|
ulint flags, /* in: undo logging and locking flags */
|
|
btr_cur_t* cursor, /* in: cursor on the record to update;
|
|
cursor stays valid and positioned on the
|
|
same record */
|
|
upd_t* update, /* in: update vector */
|
|
ulint cmpl_info,/* in: compiler info on secondary index
|
|
updates */
|
|
que_thr_t* thr, /* in: query thread */
|
|
mtr_t* mtr); /* in: mtr */
|
|
/*****************************************************************
|
|
Tries to update a record on a page in an index tree. It is assumed that mtr
|
|
holds an x-latch on the page. The operation does not succeed if there is too
|
|
little space on the page or if the update would result in too empty a page,
|
|
so that tree compression is recommended. */
|
|
|
|
ulint
|
|
btr_cur_optimistic_update(
|
|
/*======================*/
|
|
/* out: DB_SUCCESS, or DB_OVERFLOW if the
|
|
updated record does not fit, DB_UNDERFLOW
|
|
if the page would become too empty */
|
|
ulint flags, /* in: undo logging and locking flags */
|
|
btr_cur_t* cursor, /* in: cursor on the record to update;
|
|
cursor stays valid and positioned on the
|
|
same record */
|
|
upd_t* update, /* in: update vector; this must also
|
|
contain trx id and roll ptr fields */
|
|
ulint cmpl_info,/* in: compiler info on secondary index
|
|
updates */
|
|
que_thr_t* thr, /* in: query thread */
|
|
mtr_t* mtr); /* in: mtr */
|
|
/*****************************************************************
|
|
Performs an update of a record on a page of a tree. It is assumed
|
|
that mtr holds an x-latch on the tree and on the cursor page. If the
|
|
update is made on the leaf level, to avoid deadlocks, mtr must also
|
|
own x-latches to brothers of page, if those brothers exist. */
|
|
|
|
ulint
|
|
btr_cur_pessimistic_update(
|
|
/*=======================*/
|
|
/* out: DB_SUCCESS or error code */
|
|
ulint flags, /* in: undo logging, locking, and rollback
|
|
flags */
|
|
btr_cur_t* cursor, /* in: cursor on the record to update */
|
|
big_rec_t** big_rec,/* out: big rec vector whose fields have to
|
|
be stored externally by the caller, or NULL */
|
|
upd_t* update, /* in: update vector; this is allowed also
|
|
contain trx id and roll ptr fields, but
|
|
the values in update vector have no effect */
|
|
ulint cmpl_info,/* in: compiler info on secondary index
|
|
updates */
|
|
que_thr_t* thr, /* in: query thread */
|
|
mtr_t* mtr); /* in: mtr */
|
|
/***************************************************************
|
|
Marks a clustered index record deleted. Writes an undo log record to
|
|
undo log on this delete marking. Writes in the trx id field the id
|
|
of the deleting transaction, and in the roll ptr field pointer to the
|
|
undo log record created. */
|
|
|
|
ulint
|
|
btr_cur_del_mark_set_clust_rec(
|
|
/*===========================*/
|
|
/* out: DB_SUCCESS, DB_LOCK_WAIT, or error
|
|
number */
|
|
ulint flags, /* in: undo logging and locking flags */
|
|
btr_cur_t* cursor, /* in: cursor */
|
|
ibool val, /* in: value to set */
|
|
que_thr_t* thr, /* in: query thread */
|
|
mtr_t* mtr); /* in: mtr */
|
|
/***************************************************************
|
|
Sets a secondary index record delete mark to TRUE or FALSE. */
|
|
|
|
ulint
|
|
btr_cur_del_mark_set_sec_rec(
|
|
/*=========================*/
|
|
/* out: DB_SUCCESS, DB_LOCK_WAIT, or error
|
|
number */
|
|
ulint flags, /* in: locking flag */
|
|
btr_cur_t* cursor, /* in: cursor */
|
|
ibool val, /* in: value to set */
|
|
que_thr_t* thr, /* in: query thread */
|
|
mtr_t* mtr); /* in: mtr */
|
|
/***************************************************************
|
|
Sets a secondary index record delete mark to FALSE. This function is
|
|
only used by the insert buffer insert merge mechanism. */
|
|
|
|
void
|
|
btr_cur_del_unmark_for_ibuf(
|
|
/*========================*/
|
|
rec_t* rec, /* in: record to delete unmark */
|
|
mtr_t* mtr); /* in: mtr */
|
|
/*****************************************************************
|
|
Tries to compress a page of the tree on the leaf level. It is assumed
|
|
that mtr holds an x-latch on the tree and on the cursor page. To avoid
|
|
deadlocks, mtr must also own x-latches to brothers of page, if those
|
|
brothers exist. NOTE: it is assumed that the caller has reserved enough
|
|
free extents so that the compression will always succeed if done! */
|
|
|
|
void
|
|
btr_cur_compress(
|
|
/*=============*/
|
|
btr_cur_t* cursor, /* in: cursor on the page to compress;
|
|
cursor does not stay valid */
|
|
mtr_t* mtr); /* in: mtr */
|
|
/*****************************************************************
|
|
Tries to compress a page of the tree if it seems useful. It is assumed
|
|
that mtr holds an x-latch on the tree and on the cursor page. To avoid
|
|
deadlocks, mtr must also own x-latches to brothers of page, if those
|
|
brothers exist. NOTE: it is assumed that the caller has reserved enough
|
|
free extents so that the compression will always succeed if done! */
|
|
|
|
ibool
|
|
btr_cur_compress_if_useful(
|
|
/*=======================*/
|
|
/* out: TRUE if compression occurred */
|
|
btr_cur_t* cursor, /* in: cursor on the page to compress;
|
|
cursor does not stay valid if compression
|
|
occurs */
|
|
mtr_t* mtr); /* in: mtr */
|
|
/***********************************************************
|
|
Removes the record on which the tree cursor is positioned. It is assumed
|
|
that the mtr has an x-latch on the page where the cursor is positioned,
|
|
but no latch on the whole tree. */
|
|
|
|
ibool
|
|
btr_cur_optimistic_delete(
|
|
/*======================*/
|
|
/* out: TRUE if success, i.e., the page
|
|
did not become too empty */
|
|
btr_cur_t* cursor, /* in: cursor on the record to delete;
|
|
cursor stays valid: if deletion succeeds,
|
|
on function exit it points to the successor
|
|
of the deleted record */
|
|
mtr_t* mtr); /* in: mtr */
|
|
/*****************************************************************
|
|
Removes the record on which the tree cursor is positioned. Tries
|
|
to compress the page if its fillfactor drops below a threshold
|
|
or if it is the only page on the level. It is assumed that mtr holds
|
|
an x-latch on the tree and on the cursor page. To avoid deadlocks,
|
|
mtr must also own x-latches to brothers of page, if those brothers
|
|
exist. */
|
|
|
|
ibool
|
|
btr_cur_pessimistic_delete(
|
|
/*=======================*/
|
|
/* out: TRUE if compression occurred */
|
|
ulint* err, /* out: DB_SUCCESS or DB_OUT_OF_FILE_SPACE;
|
|
the latter may occur because we may have
|
|
to update node pointers on upper levels,
|
|
and in the case of variable length keys
|
|
these may actually grow in size */
|
|
ibool has_reserved_extents, /* in: TRUE if the
|
|
caller has already reserved enough free
|
|
extents so that he knows that the operation
|
|
will succeed */
|
|
btr_cur_t* cursor, /* in: cursor on the record to delete;
|
|
if compression does not occur, the cursor
|
|
stays valid: it points to successor of
|
|
deleted record on function exit */
|
|
ibool in_rollback,/* in: TRUE if called in rollback */
|
|
mtr_t* mtr); /* in: mtr */
|
|
/***************************************************************
|
|
Parses a redo log record of updating a record in-place. */
|
|
|
|
byte*
|
|
btr_cur_parse_update_in_place(
|
|
/*==========================*/
|
|
/* out: end of log record or NULL */
|
|
byte* ptr, /* in: buffer */
|
|
byte* end_ptr,/* in: buffer end */
|
|
page_t* page); /* in: page or NULL */
|
|
/********************************************************************
|
|
Parses the redo log record for delete marking or unmarking of a clustered
|
|
index record. */
|
|
|
|
byte*
|
|
btr_cur_parse_del_mark_set_clust_rec(
|
|
/*=================================*/
|
|
/* out: end of log record or NULL */
|
|
byte* ptr, /* in: buffer */
|
|
byte* end_ptr,/* in: buffer end */
|
|
page_t* page); /* in: page or NULL */
|
|
/********************************************************************
|
|
Parses the redo log record for delete marking or unmarking of a secondary
|
|
index record. */
|
|
|
|
byte*
|
|
btr_cur_parse_del_mark_set_sec_rec(
|
|
/*===============================*/
|
|
/* out: end of log record or NULL */
|
|
byte* ptr, /* in: buffer */
|
|
byte* end_ptr,/* in: buffer end */
|
|
page_t* page); /* in: page or NULL */
|
|
/***********************************************************************
|
|
Estimates the number of rows in a given index range. */
|
|
|
|
ib_longlong
|
|
btr_estimate_n_rows_in_range(
|
|
/*=========================*/
|
|
/* out: estimated number of rows */
|
|
dict_index_t* index, /* in: index */
|
|
dtuple_t* tuple1, /* in: range start, may also be empty tuple */
|
|
ulint mode1, /* in: search mode for range start */
|
|
dtuple_t* tuple2, /* in: range end, may also be empty tuple */
|
|
ulint mode2); /* in: search mode for range end */
|
|
/***********************************************************************
|
|
Estimates the number of different key values in a given index, for
|
|
each n-column prefix of the index where n <= dict_index_get_n_unique(index).
|
|
The estimates are stored in the array index->stat_n_diff_key_vals. */
|
|
|
|
void
|
|
btr_estimate_number_of_different_key_vals(
|
|
/*======================================*/
|
|
dict_index_t* index); /* in: index */
|
|
/***********************************************************************
|
|
Marks not updated extern fields as not-owned by this record. The ownership
|
|
is transferred to the updated record which is inserted elsewhere in the
|
|
index tree. In purge only the owner of externally stored field is allowed
|
|
to free the field. */
|
|
|
|
void
|
|
btr_cur_mark_extern_inherited_fields(
|
|
/*=================================*/
|
|
rec_t* rec, /* in: record in a clustered index */
|
|
upd_t* update, /* in: update vector */
|
|
mtr_t* mtr); /* in: mtr */
|
|
/***********************************************************************
|
|
The complement of the previous function: in an update entry may inherit
|
|
some externally stored fields from a record. We must mark them as inherited
|
|
in entry, so that they are not freed in a rollback. */
|
|
|
|
void
|
|
btr_cur_mark_dtuple_inherited_extern(
|
|
/*=================================*/
|
|
dtuple_t* entry, /* in: updated entry to be inserted to
|
|
clustered index */
|
|
ulint* ext_vec, /* in: array of extern fields in the
|
|
original record */
|
|
ulint n_ext_vec, /* in: number of elements in ext_vec */
|
|
upd_t* update); /* in: update vector */
|
|
/***********************************************************************
|
|
Marks all extern fields in a dtuple as owned by the record. */
|
|
|
|
void
|
|
btr_cur_unmark_dtuple_extern_fields(
|
|
/*================================*/
|
|
dtuple_t* entry, /* in: clustered index entry */
|
|
ulint* ext_vec, /* in: array of numbers of fields
|
|
which have been stored externally */
|
|
ulint n_ext_vec); /* in: number of elements in ext_vec */
|
|
/***********************************************************************
|
|
Stores the fields in big_rec_vec to the tablespace and puts pointers to
|
|
them in rec. The fields are stored on pages allocated from leaf node
|
|
file segment of the index tree. */
|
|
|
|
ulint
|
|
btr_store_big_rec_extern_fields(
|
|
/*============================*/
|
|
/* out: DB_SUCCESS or error */
|
|
dict_index_t* index, /* in: index of rec; the index tree
|
|
MUST be X-latched */
|
|
rec_t* rec, /* in: record */
|
|
big_rec_t* big_rec_vec, /* in: vector containing fields
|
|
to be stored externally */
|
|
mtr_t* local_mtr); /* in: mtr containing the latch to
|
|
rec and to the tree */
|
|
/***********************************************************************
|
|
Frees the space in an externally stored field to the file space
|
|
management if the field in data is owned the externally stored field,
|
|
in a rollback we may have the additional condition that the field must
|
|
not be inherited. */
|
|
|
|
void
|
|
btr_free_externally_stored_field(
|
|
/*=============================*/
|
|
dict_index_t* index, /* in: index of the data, the index
|
|
tree MUST be X-latched; if the tree
|
|
height is 1, then also the root page
|
|
must be X-latched! (this is relevant
|
|
in the case this function is called
|
|
from purge where 'data' is located on
|
|
an undo log page, not an index
|
|
page) */
|
|
byte* data, /* in: internally stored data
|
|
+ reference to the externally
|
|
stored part */
|
|
ulint local_len, /* in: length of data */
|
|
ibool do_not_free_inherited,/* in: TRUE if called in a
|
|
rollback and we do not want to free
|
|
inherited fields */
|
|
mtr_t* local_mtr); /* in: mtr containing the latch to
|
|
data an an X-latch to the index
|
|
tree */
|
|
/***************************************************************
|
|
Frees the externally stored fields for a record. */
|
|
|
|
void
|
|
btr_rec_free_externally_stored_fields(
|
|
/*==================================*/
|
|
dict_index_t* index, /* in: index of the data, the index
|
|
tree MUST be X-latched */
|
|
rec_t* rec, /* in: record */
|
|
ibool do_not_free_inherited,/* in: TRUE if called in a
|
|
rollback and we do not want to free
|
|
inherited fields */
|
|
mtr_t* mtr); /* in: mini-transaction handle which contains
|
|
an X-latch to record page and to the index
|
|
tree */
|
|
/***********************************************************************
|
|
Copies an externally stored field of a record to mem heap. */
|
|
|
|
byte*
|
|
btr_rec_copy_externally_stored_field(
|
|
/*=================================*/
|
|
/* out: the field copied to heap */
|
|
rec_t* rec, /* in: record */
|
|
ulint no, /* in: field number */
|
|
ulint* len, /* out: length of the field */
|
|
mem_heap_t* heap); /* in: mem heap */
|
|
/***********************************************************************
|
|
Copies an externally stored field of a record to mem heap. Parameter
|
|
data contains a pointer to 'internally' stored part of the field:
|
|
possibly some data, and the reference to the externally stored part in
|
|
the last 20 bytes of data. */
|
|
|
|
byte*
|
|
btr_copy_externally_stored_field(
|
|
/*=============================*/
|
|
/* out: the whole field copied to heap */
|
|
ulint* len, /* out: length of the whole field */
|
|
byte* data, /* in: 'internally' stored part of the
|
|
field containing also the reference to
|
|
the external part */
|
|
ulint local_len,/* in: length of data */
|
|
mem_heap_t* heap); /* in: mem heap */
|
|
/***********************************************************************
|
|
Stores the positions of the fields marked as extern storage in the update
|
|
vector, and also those fields who are marked as extern storage in rec
|
|
and not mentioned in updated fields. We use this function to remember
|
|
which fields we must mark as extern storage in a record inserted for an
|
|
update. */
|
|
|
|
ulint
|
|
btr_push_update_extern_fields(
|
|
/*==========================*/
|
|
/* out: number of values stored in ext_vect */
|
|
ulint* ext_vect, /* in: array of ulints, must be preallocated
|
|
to have place for all fields in rec */
|
|
rec_t* rec, /* in: record */
|
|
upd_t* update); /* in: update vector */
|
|
|
|
|
|
/*######################################################################*/
|
|
|
|
/* In the pessimistic delete, if the page data size drops below this
|
|
limit, merging it to a neighbor is tried */
|
|
|
|
#define BTR_CUR_PAGE_COMPRESS_LIMIT (UNIV_PAGE_SIZE / 2)
|
|
|
|
/* A slot in the path array. We store here info on a search path down the
|
|
tree. Each slot contains data on a single level of the tree. */
|
|
|
|
typedef struct btr_path_struct btr_path_t;
|
|
struct btr_path_struct{
|
|
ulint nth_rec; /* index of the record
|
|
where the page cursor stopped on
|
|
this level (index in alphabetical
|
|
order); value ULINT_UNDEFINED
|
|
denotes array end */
|
|
ulint n_recs; /* number of records on the page */
|
|
};
|
|
|
|
#define BTR_PATH_ARRAY_N_SLOTS 250 /* size of path array (in slots) */
|
|
|
|
/* The tree cursor: the definition appears here only for the compiler
|
|
to know struct size! */
|
|
|
|
struct btr_cur_struct {
|
|
dict_index_t* index; /* index where positioned */
|
|
page_cur_t page_cur; /* page cursor */
|
|
page_t* left_page; /* this field is used to store a pointer
|
|
to the left neighbor page, in the cases
|
|
BTR_SEARCH_PREV and BTR_MODIFY_PREV */
|
|
/*------------------------------*/
|
|
que_thr_t* thr; /* this field is only used when
|
|
btr_cur_search_... is called for an
|
|
index entry insertion: the calling
|
|
query thread is passed here to be
|
|
used in the insert buffer */
|
|
/*------------------------------*/
|
|
/* The following fields are used in btr_cur_search... to pass
|
|
information: */
|
|
ulint flag; /* BTR_CUR_HASH, BTR_CUR_HASH_FAIL,
|
|
BTR_CUR_BINARY, or
|
|
BTR_CUR_INSERT_TO_IBUF */
|
|
ulint tree_height; /* Tree height if the search is done
|
|
for a pessimistic insert or update
|
|
operation */
|
|
ulint up_match; /* If the search mode was PAGE_CUR_LE,
|
|
the number of matched fields to the
|
|
the first user record to the right of
|
|
the cursor record after
|
|
btr_cur_search_...;
|
|
for the mode PAGE_CUR_GE, the matched
|
|
fields to the first user record AT THE
|
|
CURSOR or to the right of it;
|
|
NOTE that the up_match and low_match
|
|
values may exceed the correct values
|
|
for comparison to the adjacent user
|
|
record if that record is on a
|
|
different leaf page! (See the note in
|
|
row_ins_duplicate_key.) */
|
|
ulint up_bytes; /* number of matched bytes to the
|
|
right at the time cursor positioned;
|
|
only used internally in searches: not
|
|
defined after the search */
|
|
ulint low_match; /* if search mode was PAGE_CUR_LE,
|
|
the number of matched fields to the
|
|
first user record AT THE CURSOR or
|
|
to the left of it after
|
|
btr_cur_search_...;
|
|
NOT defined for PAGE_CUR_GE or any
|
|
other search modes; see also the NOTE
|
|
in up_match! */
|
|
ulint low_bytes; /* number of matched bytes to the
|
|
right at the time cursor positioned;
|
|
only used internally in searches: not
|
|
defined after the search */
|
|
ulint n_fields; /* prefix length used in a hash
|
|
search if hash_node != NULL */
|
|
ulint n_bytes; /* hash prefix bytes if hash_node !=
|
|
NULL */
|
|
ulint fold; /* fold value used in the search if
|
|
flag is BTR_CUR_HASH */
|
|
/*------------------------------*/
|
|
btr_path_t* path_arr; /* in estimating the number of
|
|
rows in range, we store in this array
|
|
information of the path through
|
|
the tree */
|
|
};
|
|
|
|
/* Values for the flag documenting the used search method */
|
|
#define BTR_CUR_HASH 1 /* successful shortcut using the hash
|
|
index */
|
|
#define BTR_CUR_HASH_FAIL 2 /* failure using hash, success using
|
|
binary search: the misleading hash
|
|
reference is stored in the field
|
|
hash_node, and might be necessary to
|
|
update */
|
|
#define BTR_CUR_BINARY 3 /* success using the binary search */
|
|
#define BTR_CUR_INSERT_TO_IBUF 4 /* performed the intended insert to
|
|
the insert buffer */
|
|
|
|
/* If pessimistic delete fails because of lack of file space,
|
|
there is still a good change of success a little later: try this many times,
|
|
and sleep this many microseconds in between */
|
|
#define BTR_CUR_RETRY_DELETE_N_TIMES 100
|
|
#define BTR_CUR_RETRY_SLEEP_TIME 50000
|
|
|
|
/* The reference in a field for which data is stored on a different page.
|
|
The reference is at the end of the 'locally' stored part of the field.
|
|
'Locally' means storage in the index record.
|
|
We store locally a long enough prefix of each column so that we can determine
|
|
the ordering parts of each index record without looking into the externally
|
|
stored part. */
|
|
|
|
/*--------------------------------------*/
|
|
#define BTR_EXTERN_SPACE_ID 0 /* space id where stored */
|
|
#define BTR_EXTERN_PAGE_NO 4 /* page no where stored */
|
|
#define BTR_EXTERN_OFFSET 8 /* offset of BLOB header
|
|
on that page */
|
|
#define BTR_EXTERN_LEN 12 /* 8 bytes containing the
|
|
length of the externally
|
|
stored part of the BLOB.
|
|
The 2 highest bits are
|
|
reserved to the flags below. */
|
|
/*--------------------------------------*/
|
|
#define BTR_EXTERN_FIELD_REF_SIZE 20
|
|
|
|
/* The highest bit of BTR_EXTERN_LEN (i.e., the highest bit of the byte
|
|
at lowest address) is set to 1 if this field does not 'own' the externally
|
|
stored field; only the owner field is allowed to free the field in purge!
|
|
If the 2nd highest bit is 1 then it means that the externally stored field
|
|
was inherited from an earlier version of the row. In rollback we are not
|
|
allowed to free an inherited external field. */
|
|
|
|
#define BTR_EXTERN_OWNER_FLAG 128
|
|
#define BTR_EXTERN_INHERITED_FLAG 64
|
|
|
|
extern ulint btr_cur_n_non_sea;
|
|
extern ulint btr_cur_n_sea;
|
|
extern ulint btr_cur_n_non_sea_old;
|
|
extern ulint btr_cur_n_sea_old;
|
|
|
|
#ifndef UNIV_NONINL
|
|
#include "btr0cur.ic"
|
|
#endif
|
|
|
|
#endif
|