diff options
Diffstat (limited to 'storage/innobase/include/btr0cur.h')
| -rw-r--r-- | storage/innobase/include/btr0cur.h | 706 |
1 files changed, 0 insertions, 706 deletions
diff --git a/storage/innobase/include/btr0cur.h b/storage/innobase/include/btr0cur.h deleted file mode 100644 index 213dcb7f568..00000000000 --- a/storage/innobase/include/btr0cur.h +++ /dev/null @@ -1,706 +0,0 @@ -/****************************************************** -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 index of a cursor. */ -UNIV_INLINE -dict_index_t* -btr_cur_get_index( -/*==============*/ - /* out: index */ - btr_cur_t* cursor);/* in: B-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 */ - dict_index_t* index); /* in: index corresponding to page */ -/******************************************************************** -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 */ - dict_index_t* index, /* in: index corresponding to page */ - 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 */ - const ulint* offsets,/* in: array returned by rec_get_offsets() */ - 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 */ - const ulint* offsets, /* in: rec_get_offsets(rec, index); - the "external storage" flags in offsets - will not correspond to rec when - this function returns */ - 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 */ - const ulint* offsets,/* in: rec_get_offsets(rec, index) */ - 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 */ - const ulint* offsets,/* in: array returned by rec_get_offsets() */ - 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 space for all fields in rec */ - const ulint* offsets,/* in: array returned by rec_get_offsets() */ - upd_t* update);/* in: update vector or NULL */ - - -/*######################################################################*/ - -/* 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 |