diff options
Diffstat (limited to 'storage/innobase/btr/btr0cur.c')
| -rw-r--r-- | storage/innobase/btr/btr0cur.c | 4219 |
1 files changed, 2767 insertions, 1452 deletions
diff --git a/storage/innobase/btr/btr0cur.c b/storage/innobase/btr/btr0cur.c index 3c12e28feb6..625721133fd 100644 --- a/storage/innobase/btr/btr0cur.c +++ b/storage/innobase/btr/btr0cur.c @@ -1,4 +1,30 @@ -/****************************************************** +/***************************************************************************** + +Copyright (c) 1994, 2011, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 2008, Google Inc. + +Portions of this file contain modifications contributed and copyrighted by +Google, Inc. Those modifications are gratefully acknowledged and are described +briefly in the InnoDB documentation. The contributions by Google are +incorporated with their permission, and subject to the conditions contained in +the file COPYING.Google. + +This program is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free Software +Foundation; version 2 of the License. + +This program is distributed in the hope that it will be useful, but WITHOUT +ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with +this program; if not, write to the Free Software Foundation, Inc., 59 Temple +Place, Suite 330, Boston, MA 02111-1307 USA + +*****************************************************************************/ + +/**************************************************//** +@file btr/btr0cur.c The index tree cursor All changes that row operations make to a B-tree or the records @@ -12,8 +38,6 @@ many pages in the tablespace before we start the operation, because if leaf splitting has been started, it is difficult to undo, except by crashing the database and doing a roll-forward. -(c) 1994-2001 Innobase Oy - Created 10/16/1994 Heikki Tuuri *******************************************************/ @@ -23,65 +47,92 @@ Created 10/16/1994 Heikki Tuuri #include "btr0cur.ic" #endif +#include "row0upd.h" +#ifndef UNIV_HOTBACKUP #include "mtr0log.h" #include "page0page.h" +#include "page0zip.h" #include "rem0rec.h" #include "rem0cmp.h" +#include "buf0lru.h" #include "btr0btr.h" #include "btr0sea.h" +#include "row0purge.h" #include "row0upd.h" #include "trx0rec.h" -#include "trx0roll.h" /* trx_roll_crash_recv_trx */ +#include "trx0roll.h" /* trx_is_recv() */ #include "que0que.h" #include "row0row.h" #include "srv0srv.h" #include "ibuf0ibuf.h" #include "lock0lock.h" +#include "zlib.h" + +/** Buffered B-tree operation types, introduced as part of delete buffering. */ +typedef enum btr_op_enum { + BTR_NO_OP = 0, /*!< Not buffered */ + BTR_INSERT_OP, /*!< Insert, do not ignore UNIQUE */ + BTR_INSERT_IGNORE_UNIQUE_OP, /*!< Insert, ignoring UNIQUE */ + BTR_DELETE_OP, /*!< Purge a delete-marked record */ + BTR_DELMARK_OP /*!< Mark a record for deletion */ +} btr_op_t; #ifdef UNIV_DEBUG -/* If the following is set to TRUE, this module prints a lot of +/** If the following is set to TRUE, this module prints a lot of trace information of individual record operations */ -ibool btr_cur_print_record_ops = FALSE; +UNIV_INTERN ibool btr_cur_print_record_ops = FALSE; #endif /* UNIV_DEBUG */ -ulint btr_cur_n_non_sea = 0; -ulint btr_cur_n_sea = 0; -ulint btr_cur_n_non_sea_old = 0; -ulint btr_cur_n_sea_old = 0; - -/* In the optimistic insert, if the insert does not fit, but this much space +/** Number of searches down the B-tree in btr_cur_search_to_nth_level(). */ +UNIV_INTERN ulint btr_cur_n_non_sea = 0; +/** Number of successful adaptive hash index lookups in +btr_cur_search_to_nth_level(). */ +UNIV_INTERN ulint btr_cur_n_sea = 0; +/** Old value of btr_cur_n_non_sea. Copied by +srv_refresh_innodb_monitor_stats(). Referenced by +srv_printf_innodb_monitor(). */ +UNIV_INTERN ulint btr_cur_n_non_sea_old = 0; +/** Old value of btr_cur_n_sea. Copied by +srv_refresh_innodb_monitor_stats(). Referenced by +srv_printf_innodb_monitor(). */ +UNIV_INTERN ulint btr_cur_n_sea_old = 0; + +/** In the optimistic insert, if the insert does not fit, but this much space can be released by page reorganize, then it is reorganized */ - #define BTR_CUR_PAGE_REORGANIZE_LIMIT (UNIV_PAGE_SIZE / 32) -/* When estimating number of different key values in an index, sample -this many index pages */ -#define BTR_KEY_VAL_ESTIMATE_N_PAGES 8 - -/* The structure of a BLOB part header */ +/** The structure of a BLOB part header */ +/* @{ */ /*--------------------------------------*/ -#define BTR_BLOB_HDR_PART_LEN 0 /* BLOB part len on this +#define BTR_BLOB_HDR_PART_LEN 0 /*!< BLOB part len on this page */ -#define BTR_BLOB_HDR_NEXT_PAGE_NO 4 /* next BLOB part page no, +#define BTR_BLOB_HDR_NEXT_PAGE_NO 4 /*!< next BLOB part page no, FIL_NULL if none */ /*--------------------------------------*/ -#define BTR_BLOB_HDR_SIZE 8 - -/* Estimated table level stats from sampled value. */ -#define BTR_TABLE_STATS_FROM_SAMPLE(value, index, ext_size, not_empty) \ - ((value * (ib_longlong) index->stat_n_leaf_pages \ - + BTR_KEY_VAL_ESTIMATE_N_PAGES - 1 + ext_size \ - + not_empty) \ - / (BTR_KEY_VAL_ESTIMATE_N_PAGES + ext_size)) - -#if defined UNIV_DEBUG || defined UNIV_BLOB_LIGHT_DEBUG -/* A BLOB field reference full of zero, for use in assertions and tests. +#define BTR_BLOB_HDR_SIZE 8 /*!< Size of a BLOB + part header, in bytes */ + +/** Estimated table level stats from sampled value. +@param value sampled stats +@param index index being sampled +@param sample number of sampled rows +@param ext_size external stored data size +@param not_empty table not empty +@return estimated table wide stats from sampled value */ +#define BTR_TABLE_STATS_FROM_SAMPLE(value, index, sample, ext_size, not_empty)\ + (((value) * (ib_int64_t) index->stat_n_leaf_pages \ + + (sample) - 1 + (ext_size) + (not_empty)) / ((sample) + (ext_size))) + +/* @} */ +#endif /* !UNIV_HOTBACKUP */ + +/** A BLOB field reference full of zero, for use in assertions and tests. Initially, BLOB field references are set to zero, in dtuple_convert_big_rec(). */ -const byte field_ref_zero[BTR_EXTERN_FIELD_REF_SIZE]; -#endif /* UNIV_DEBUG || UNIV_BLOB_LIGHT_DEBUG */ +UNIV_INTERN const byte field_ref_zero[BTR_EXTERN_FIELD_REF_SIZE]; -/*********************************************************************** +#ifndef UNIV_HOTBACKUP +/*******************************************************************//** Marks all extern fields in a record as owned by the record. This function should be called if the delete mark of a record is removed: a not delete marked record always owns all its extern fields. */ @@ -89,165 +140,197 @@ static void btr_cur_unmark_extern_fields( /*=========================*/ - rec_t* rec, /* in: record in a clustered index */ - mtr_t* mtr, /* in: mtr */ - const ulint* offsets);/* in: array returned by rec_get_offsets() */ -/*********************************************************************** + page_zip_des_t* page_zip,/*!< in/out: compressed page whose uncompressed + part will be updated, or NULL */ + rec_t* rec, /*!< in/out: record in a clustered index */ + dict_index_t* index, /*!< in: index of the page */ + const ulint* offsets,/*!< in: array returned by rec_get_offsets() */ + mtr_t* mtr); /*!< in: mtr, or NULL if not logged */ +/*******************************************************************//** Adds path information to the cursor for the current page, for which the binary search has been performed. */ static void btr_cur_add_path_info( /*==================*/ - btr_cur_t* cursor, /* in: cursor positioned on a page */ - ulint height, /* in: height of the page in tree; + btr_cur_t* cursor, /*!< in: cursor positioned on a page */ + ulint height, /*!< in: height of the page in tree; 0 means leaf node */ - ulint root_height); /* in: root node height in tree */ -/*************************************************************** + ulint root_height); /*!< in: root node height in tree */ +/***********************************************************//** Frees the externally stored fields for a record, if the field is mentioned in the update vector. */ static void btr_rec_free_updated_extern_fields( /*===============================*/ - dict_index_t* index, /* in: index of rec; the index tree MUST be + 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) */ - upd_t* update, /* in: update vector */ - 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 + rec_t* rec, /*!< in: record */ + page_zip_des_t* page_zip,/*!< in: compressed page whose uncompressed + part will be updated, or NULL */ + const ulint* offsets,/*!< in: rec_get_offsets(rec, index) */ + const upd_t* update, /*!< in: update vector */ + enum trx_rb_ctx rb_ctx, /*!< in: rollback context */ + mtr_t* mtr); /*!< in: mini-transaction handle which contains an X-latch to record page and to the tree */ -/*************************************************************** -Gets the externally stored size of a record, in units of a database page. */ +/***********************************************************//** +Frees the externally stored fields for a record. */ +static +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) */ + page_zip_des_t* page_zip,/*!< in: compressed page whose uncompressed + part will be updated, or NULL */ + enum trx_rb_ctx rb_ctx, /*!< in: rollback context */ + mtr_t* mtr); /*!< in: mini-transaction handle which contains + an X-latch to record page and to the index + tree */ +/***********************************************************//** +Gets the externally stored size of a record, in units of a database page. +@return externally stored part, in units of a database page */ static ulint btr_rec_get_externally_stored_len( /*==============================*/ - /* out: externally stored part, - in units of a database page */ - rec_t* rec, /* in: record */ - const ulint* offsets);/* in: array returned by rec_get_offsets() */ + const rec_t* rec, /*!< in: record */ + const ulint* offsets);/*!< in: array returned by rec_get_offsets() */ +#endif /* !UNIV_HOTBACKUP */ + +/******************************************************//** +The following function is used to set the deleted bit of a record. */ +UNIV_INLINE +void +btr_rec_set_deleted_flag( +/*=====================*/ + rec_t* rec, /*!< in/out: physical record */ + page_zip_des_t* page_zip,/*!< in/out: compressed page (or NULL) */ + ulint flag) /*!< in: nonzero if delete marked */ +{ + if (page_rec_is_comp(rec)) { + rec_set_deleted_flag_new(rec, page_zip, flag); + } else { + ut_ad(!page_zip); + rec_set_deleted_flag_old(rec, flag); + } +} +#ifndef UNIV_HOTBACKUP /*==================== B-TREE SEARCH =========================*/ -/************************************************************************ +/********************************************************************//** Latches the leaf page or pages requested. */ static void btr_cur_latch_leaves( /*=================*/ - page_t* page, /* in: leaf page where the search + page_t* page, /*!< in: leaf page where the search converged */ - ulint space, /* in: space id */ - ulint page_no, /* in: page number of the leaf */ - ulint latch_mode, /* in: BTR_SEARCH_LEAF, ... */ - btr_cur_t* cursor, /* in: cursor */ - mtr_t* mtr) /* in: mtr */ + ulint space, /*!< in: space id */ + ulint zip_size, /*!< in: compressed page size in bytes + or 0 for uncompressed pages */ + ulint page_no, /*!< in: page number of the leaf */ + ulint latch_mode, /*!< in: BTR_SEARCH_LEAF, ... */ + btr_cur_t* cursor, /*!< in: cursor */ + mtr_t* mtr) /*!< in: mtr */ { - ulint left_page_no; - ulint right_page_no; - page_t* get_page; + ulint mode; + ulint left_page_no; + ulint right_page_no; + buf_block_t* get_block; ut_ad(page && mtr); - if (latch_mode == BTR_SEARCH_LEAF) { - - get_page = btr_page_get(space, page_no, RW_S_LATCH, mtr); - ut_a(page_is_comp(get_page) == page_is_comp(page)); - buf_block_align(get_page)->check_index_page_at_flush = TRUE; - - } else if (latch_mode == BTR_MODIFY_LEAF) { - - get_page = btr_page_get(space, page_no, RW_X_LATCH, mtr); - ut_a(page_is_comp(get_page) == page_is_comp(page)); - buf_block_align(get_page)->check_index_page_at_flush = TRUE; - - } else if (latch_mode == BTR_MODIFY_TREE) { - + switch (latch_mode) { + case BTR_SEARCH_LEAF: + case BTR_MODIFY_LEAF: + mode = latch_mode == BTR_SEARCH_LEAF ? RW_S_LATCH : RW_X_LATCH; + get_block = btr_block_get( + space, zip_size, page_no, mode, cursor->index, mtr); +#ifdef UNIV_BTR_DEBUG + ut_a(page_is_comp(get_block->frame) == page_is_comp(page)); +#endif /* UNIV_BTR_DEBUG */ + get_block->check_index_page_at_flush = TRUE; + return; + case BTR_MODIFY_TREE: /* x-latch also brothers from left to right */ left_page_no = btr_page_get_prev(page, mtr); if (left_page_no != FIL_NULL) { - get_page = btr_page_get(space, left_page_no, - RW_X_LATCH, mtr); + get_block = btr_block_get( + space, zip_size, left_page_no, + RW_X_LATCH, cursor->index, mtr); #ifdef UNIV_BTR_DEBUG - ut_a(btr_page_get_next(get_page, mtr) - == buf_frame_get_page_no(page)); + ut_a(page_is_comp(get_block->frame) + == page_is_comp(page)); + ut_a(btr_page_get_next(get_block->frame, mtr) + == page_get_page_no(page)); #endif /* UNIV_BTR_DEBUG */ - ut_a(page_is_comp(get_page) == page_is_comp(page)); - buf_block_align(get_page)->check_index_page_at_flush - = TRUE; + get_block->check_index_page_at_flush = TRUE; } - get_page = btr_page_get(space, page_no, RW_X_LATCH, mtr); - ut_a(page_is_comp(get_page) == page_is_comp(page)); - buf_block_align(get_page)->check_index_page_at_flush = TRUE; + get_block = btr_block_get( + space, zip_size, page_no, + RW_X_LATCH, cursor->index, mtr); +#ifdef UNIV_BTR_DEBUG + ut_a(page_is_comp(get_block->frame) == page_is_comp(page)); +#endif /* UNIV_BTR_DEBUG */ + get_block->check_index_page_at_flush = TRUE; right_page_no = btr_page_get_next(page, mtr); if (right_page_no != FIL_NULL) { - get_page = btr_page_get(space, right_page_no, - RW_X_LATCH, mtr); + get_block = btr_block_get( + space, zip_size, right_page_no, + RW_X_LATCH, cursor->index, mtr); #ifdef UNIV_BTR_DEBUG - ut_a(btr_page_get_prev(get_page, mtr) - == buf_frame_get_page_no(page)); + ut_a(page_is_comp(get_block->frame) + == page_is_comp(page)); + ut_a(btr_page_get_prev(get_block->frame, mtr) + == page_get_page_no(page)); #endif /* UNIV_BTR_DEBUG */ - buf_block_align(get_page)->check_index_page_at_flush - = TRUE; + get_block->check_index_page_at_flush = TRUE; } - } else if (latch_mode == BTR_SEARCH_PREV) { + return; - /* s-latch also left brother */ + case BTR_SEARCH_PREV: + case BTR_MODIFY_PREV: + mode = latch_mode == BTR_SEARCH_PREV ? RW_S_LATCH : RW_X_LATCH; + /* latch also left brother */ left_page_no = btr_page_get_prev(page, mtr); if (left_page_no != FIL_NULL) { - cursor->left_page = btr_page_get(space, left_page_no, - RW_S_LATCH, mtr); + get_block = btr_block_get( + space, zip_size, + left_page_no, mode, cursor->index, mtr); + cursor->left_block = get_block; #ifdef UNIV_BTR_DEBUG - ut_a(btr_page_get_next(cursor->left_page, mtr) - == buf_frame_get_page_no(page)); -#endif /* UNIV_BTR_DEBUG */ - ut_a(page_is_comp(cursor->left_page) + ut_a(page_is_comp(get_block->frame) == page_is_comp(page)); - buf_block_align(cursor->left_page) - ->check_index_page_at_flush = TRUE; + ut_a(btr_page_get_next(get_block->frame, mtr) + == page_get_page_no(page)); +#endif /* UNIV_BTR_DEBUG */ + get_block->check_index_page_at_flush = TRUE; } - get_page = btr_page_get(space, page_no, RW_S_LATCH, mtr); - ut_a(page_is_comp(get_page) == page_is_comp(page)); - buf_block_align(get_page)->check_index_page_at_flush = TRUE; - - } else if (latch_mode == BTR_MODIFY_PREV) { - - /* x-latch also left brother */ - left_page_no = btr_page_get_prev(page, mtr); - - if (left_page_no != FIL_NULL) { - cursor->left_page = btr_page_get(space, left_page_no, - RW_X_LATCH, mtr); + get_block = btr_block_get( + space, zip_size, page_no, mode, cursor->index, mtr); #ifdef UNIV_BTR_DEBUG - ut_a(btr_page_get_next(cursor->left_page, mtr) - == buf_frame_get_page_no(page)); + ut_a(page_is_comp(get_block->frame) == page_is_comp(page)); #endif /* UNIV_BTR_DEBUG */ - ut_a(page_is_comp(cursor->left_page) - == page_is_comp(page)); - buf_block_align(cursor->left_page) - ->check_index_page_at_flush = TRUE; - } - - get_page = btr_page_get(space, page_no, RW_X_LATCH, mtr); - ut_a(page_is_comp(get_page) == page_is_comp(page)); - buf_block_align(get_page)->check_index_page_at_flush = TRUE; - } else { - ut_error; + get_block->check_index_page_at_flush = TRUE; + return; } + + ut_error; } -/************************************************************************ +/********************************************************************//** 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! @@ -259,21 +342,22 @@ If mode is PAGE_CUR_LE , cursor is left at the place where an insert of the search tuple should be performed in the B-tree. InnoDB does an insert immediately after the cursor. Thus, the cursor may end up on a user record, or on a page infimum record. */ - +UNIV_INTERN 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 + dict_index_t* index, /*!< in: index */ + ulint level, /*!< in: the tree level of search */ + const 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, ...; + ulint mode, /*!< in: PAGE_CUR_L, ...; 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 + ulint latch_mode, /*!< in: BTR_SEARCH_LEAF, ..., ORed with + at most one of BTR_INSERT, BTR_DELETE_MARK, + BTR_DELETE, or BTR_ESTIMATE; + cursor->left_block 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 @@ -281,62 +365,101 @@ btr_cur_search_to_nth_level( 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 + 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: info on the latch mode the + ulint has_search_latch,/*!< in: info on the latch mode the caller currently has on btr_search_latch: RW_S_LATCH, or 0 */ - mtr_t* mtr) /* in: mtr */ + const char* file, /*!< in: file name */ + ulint line, /*!< in: line where called */ + mtr_t* mtr) /*!< in: mtr */ { - page_cur_t* page_cursor; page_t* page; - page_t* guess; - rec_t* node_ptr; - ulint page_no; + buf_block_t* block; ulint space; + buf_block_t* guess; + ulint height; + ulint page_no; ulint up_match; ulint up_bytes; ulint low_match; ulint low_bytes; - ulint height; ulint savepoint; ulint rw_latch; ulint page_mode; - ulint insert_planned; ulint buf_mode; ulint estimate; - ulint ignore_sec_unique; + ulint zip_size; + page_cur_t* page_cursor; + btr_op_t btr_op; ulint root_height = 0; /* remove warning */ + #ifdef BTR_CUR_ADAPT btr_search_t* info; #endif mem_heap_t* heap = NULL; ulint offsets_[REC_OFFS_NORMAL_SIZE]; ulint* offsets = offsets_; - *offsets_ = (sizeof offsets_) / sizeof *offsets_; + rec_offs_init(offsets_); /* Currently, PAGE_CUR_LE is the only search mode used for searches ending to upper levels */ ut_ad(level == 0 || mode == PAGE_CUR_LE); ut_ad(dict_index_check_search_tuple(index, tuple)); - ut_ad(!(index->type & DICT_IBUF) || ibuf_inside()); + ut_ad(!dict_index_is_ibuf(index) || ibuf_inside(mtr)); ut_ad(dtuple_check_typed(tuple)); #ifdef UNIV_DEBUG cursor->up_match = ULINT_UNDEFINED; cursor->low_match = ULINT_UNDEFINED; #endif - insert_planned = latch_mode & BTR_INSERT; + + /* These flags are mutually exclusive, they are lumped together + with the latch mode for historical reasons. It's possible for + none of the flags to be set. */ + switch (UNIV_EXPECT(latch_mode + & (BTR_INSERT | BTR_DELETE | BTR_DELETE_MARK), + 0)) { + case 0: + btr_op = BTR_NO_OP; + break; + case BTR_INSERT: + btr_op = (latch_mode & BTR_IGNORE_SEC_UNIQUE) + ? BTR_INSERT_IGNORE_UNIQUE_OP + : BTR_INSERT_OP; + break; + case BTR_DELETE: + btr_op = BTR_DELETE_OP; + ut_a(cursor->purge_node); + break; + case BTR_DELETE_MARK: + btr_op = BTR_DELMARK_OP; + break; + default: + /* only one of BTR_INSERT, BTR_DELETE, BTR_DELETE_MARK + should be specified at a time */ + ut_error; + } + + /* Operations on the insert buffer tree cannot be buffered. */ + ut_ad(btr_op == BTR_NO_OP || !dict_index_is_ibuf(index)); + /* Operations on the clustered index cannot be buffered. */ + ut_ad(btr_op == BTR_NO_OP || !dict_index_is_clust(index)); + estimate = latch_mode & BTR_ESTIMATE; - ignore_sec_unique = latch_mode & BTR_IGNORE_SEC_UNIQUE; - latch_mode = latch_mode & ~(BTR_INSERT | BTR_ESTIMATE - | BTR_IGNORE_SEC_UNIQUE); - ut_ad(!insert_planned || (mode == PAGE_CUR_LE)); + /* Turn the flags unrelated to the latch mode off. */ + latch_mode &= ~(BTR_INSERT + | BTR_DELETE_MARK + | BTR_DELETE + | BTR_ESTIMATE + | BTR_IGNORE_SEC_UNIQUE); cursor->flag = BTR_CUR_BINARY; cursor->index = index; + cursor->ibuf_cnt = ULINT_UNDEFINED; + #ifndef BTR_CUR_ADAPT guess = NULL; #else @@ -349,13 +472,17 @@ btr_cur_search_to_nth_level( #ifdef UNIV_SEARCH_PERF_STAT info->n_searches++; #endif - if (btr_search_latch.writer == RW_LOCK_NOT_LOCKED - && latch_mode <= BTR_MODIFY_LEAF && info->last_hash_succ + if (rw_lock_get_writer(&btr_search_latch) == RW_LOCK_NOT_LOCKED + && latch_mode <= BTR_MODIFY_LEAF + && info->last_hash_succ && !estimate #ifdef PAGE_CUR_LE_OR_EXTENDS && mode != PAGE_CUR_LE_OR_EXTENDS #endif /* PAGE_CUR_LE_OR_EXTENDS */ - && srv_use_adaptive_hash_indexes + /* If !has_search_latch, we do a dirty read of + btr_search_enabled below, and btr_search_guess_on_hash() + will have to check it again. */ + && UNIV_LIKELY(btr_search_enabled) && btr_search_guess_on_hash(index, info, tuple, mode, latch_mode, cursor, has_search_latch, mtr)) { @@ -372,8 +499,8 @@ btr_cur_search_to_nth_level( return; } -#endif -#endif +#endif /* BTR_CUR_HASH_ADAPT */ +#endif /* BTR_CUR_ADAPT */ btr_cur_n_non_sea++; /* If the hash search did not succeed, do binary search down the @@ -411,8 +538,6 @@ btr_cur_search_to_nth_level( low_bytes = 0; height = ULINT_UNDEFINED; - rw_latch = RW_NO_LATCH; - buf_mode = BUF_GET; /* We use these modified search modes on non-leaf levels of the B-tree. These let us end up in the right B-tree leaf. In that leaf @@ -438,146 +563,232 @@ btr_cur_search_to_nth_level( /* Loop and search until we arrive at the desired level */ - for (;;) { - if ((height == 0) && (latch_mode <= BTR_MODIFY_LEAF)) { +search_loop: + buf_mode = BUF_GET; + rw_latch = RW_NO_LATCH; - rw_latch = latch_mode; + if (height != 0) { + /* We are about to fetch the root or a non-leaf page. */ + } else if (latch_mode <= BTR_MODIFY_LEAF) { + rw_latch = latch_mode; - if (insert_planned - && ibuf_should_try(index, ignore_sec_unique)) { + if (btr_op != BTR_NO_OP + && ibuf_should_try(index, btr_op != BTR_INSERT_OP)) { - /* Try insert to the insert buffer if the - page is not in the buffer pool */ + /* Try to buffer the operation if the leaf + page is not in the buffer pool. */ - buf_mode = BUF_GET_IF_IN_POOL; - } + buf_mode = btr_op == BTR_DELETE_OP + ? BUF_GET_IF_IN_POOL_OR_WATCH + : BUF_GET_IF_IN_POOL; } + } + + zip_size = dict_table_zip_size(index->table); + retry_page_get: - page = buf_page_get_gen(space, page_no, rw_latch, guess, - buf_mode, - __FILE__, __LINE__, - mtr); - if (page == NULL) { - /* This must be a search to perform an insert; - try insert to the insert buffer */ + block = buf_page_get_gen( + space, zip_size, page_no, rw_latch, guess, buf_mode, + file, line, mtr); + + if (block == NULL) { + /* This must be a search to perform an insert/delete + mark/ delete; try using the insert/delete buffer */ + ut_ad(height == 0); + ut_ad(cursor->thr); + + switch (btr_op) { + case BTR_INSERT_OP: + case BTR_INSERT_IGNORE_UNIQUE_OP: ut_ad(buf_mode == BUF_GET_IF_IN_POOL); - ut_ad(insert_planned); - ut_ad(cursor->thr); - if (ibuf_should_try(index, ignore_sec_unique) - && ibuf_insert(tuple, index, space, page_no, - cursor->thr)) { - /* Insertion to the insert buffer succeeded */ + if (ibuf_insert(IBUF_OP_INSERT, tuple, index, + space, zip_size, page_no, + cursor->thr)) { + cursor->flag = BTR_CUR_INSERT_TO_IBUF; - if (UNIV_LIKELY_NULL(heap)) { - mem_heap_free(heap); - } + goto func_exit; } + break; - /* Insert to the insert buffer did not succeed: - retry page get */ + case BTR_DELMARK_OP: + ut_ad(buf_mode == BUF_GET_IF_IN_POOL); - buf_mode = BUF_GET; + if (ibuf_insert(IBUF_OP_DELETE_MARK, tuple, + index, space, zip_size, + page_no, cursor->thr)) { - goto retry_page_get; - } + cursor->flag = BTR_CUR_DEL_MARK_IBUF; - buf_block_align(page)->check_index_page_at_flush = TRUE; + goto func_exit; + } -#ifdef UNIV_SYNC_DEBUG - if (rw_latch != RW_NO_LATCH) { - buf_page_dbg_add_level(page, SYNC_TREE_NODE); - } -#endif - ut_ad(0 == ut_dulint_cmp(index->id, - btr_page_get_index_id(page))); + break; - if (height == ULINT_UNDEFINED) { - /* We are in the root node */ + case BTR_DELETE_OP: + ut_ad(buf_mode == BUF_GET_IF_IN_POOL_OR_WATCH); - height = btr_page_get_level(page, mtr); - root_height = height; - cursor->tree_height = root_height + 1; -#ifdef BTR_CUR_ADAPT - if (page != guess) { - info->root_guess = page; + if (!row_purge_poss_sec(cursor->purge_node, + index, tuple)) { + + /* The record cannot be purged yet. */ + cursor->flag = BTR_CUR_DELETE_REF; + } else if (ibuf_insert(IBUF_OP_DELETE, tuple, + index, space, zip_size, + page_no, + cursor->thr)) { + + /* The purge was buffered. */ + cursor->flag = BTR_CUR_DELETE_IBUF; + } else { + /* The purge could not be buffered. */ + buf_pool_watch_unset(space, page_no); + break; } -#endif + + buf_pool_watch_unset(space, page_no); + goto func_exit; + + default: + ut_error; } - if (height == 0) { - if (rw_latch == RW_NO_LATCH) { + /* Insert to the insert/delete buffer did not succeed, we + must read the page from disk. */ - btr_cur_latch_leaves(page, space, - page_no, latch_mode, - cursor, mtr); - } + buf_mode = BUF_GET; - if ((latch_mode != BTR_MODIFY_TREE) - && (latch_mode != BTR_CONT_MODIFY_TREE)) { + goto retry_page_get; + } - /* Release the tree s-latch */ + block->check_index_page_at_flush = TRUE; + page = buf_block_get_frame(block); - mtr_release_s_latch_at_savepoint( - mtr, savepoint, - dict_index_get_lock(index)); - } + if (rw_latch != RW_NO_LATCH) { +#ifdef UNIV_ZIP_DEBUG + const page_zip_des_t* page_zip + = buf_block_get_page_zip(block); + ut_a(!page_zip || page_zip_validate(page_zip, page)); +#endif /* UNIV_ZIP_DEBUG */ - page_mode = mode; - } + buf_block_dbg_add_level( + block, dict_index_is_ibuf(index) + ? SYNC_IBUF_TREE_NODE : SYNC_TREE_NODE); + } - page_cur_search_with_match(page, index, tuple, page_mode, - &up_match, &up_bytes, - &low_match, &low_bytes, - page_cursor); - if (estimate) { - btr_cur_add_path_info(cursor, height, root_height); + ut_ad(index->id == btr_page_get_index_id(page)); + + if (UNIV_UNLIKELY(height == ULINT_UNDEFINED)) { + /* We are in the root node */ + + height = btr_page_get_level(page, mtr); + root_height = height; + cursor->tree_height = root_height + 1; + +#ifdef BTR_CUR_ADAPT + if (block != guess) { + info->root_guess = block; } +#endif + } - /* If this is the desired level, leave the loop */ + if (height == 0) { + if (rw_latch == RW_NO_LATCH) { - ut_ad(height == btr_page_get_level( - page_cur_get_page(page_cursor), mtr)); + btr_cur_latch_leaves( + page, space, zip_size, page_no, latch_mode, + cursor, mtr); + } - if (level == height) { + if (latch_mode != BTR_MODIFY_TREE + && latch_mode != BTR_CONT_MODIFY_TREE) { - if (level > 0) { - /* x-latch the page */ - page = btr_page_get(space, - page_no, RW_X_LATCH, mtr); - ut_a((ibool)!!page_is_comp(page) - == dict_table_is_comp(index->table)); - } + /* Release the tree s-latch */ - break; + mtr_release_s_latch_at_savepoint( + mtr, savepoint, dict_index_get_lock(index)); } + page_mode = mode; + } + + page_cur_search_with_match( + block, index, tuple, page_mode, &up_match, &up_bytes, + &low_match, &low_bytes, page_cursor); + + if (estimate) { + btr_cur_add_path_info(cursor, height, root_height); + } + + /* If this is the desired level, leave the loop */ + + ut_ad(height == btr_page_get_level(page_cur_get_page(page_cursor), + mtr)); + + if (level != height) { + + const rec_t* node_ptr; ut_ad(height > 0); height--; guess = NULL; node_ptr = page_cur_get_rec(page_cursor); - offsets = rec_get_offsets(node_ptr, cursor->index, offsets, - ULINT_UNDEFINED, &heap); + + offsets = rec_get_offsets( + node_ptr, index, offsets, ULINT_UNDEFINED, &heap); + /* Go to the child node */ page_no = btr_node_ptr_get_child_page_no(node_ptr, offsets); - } - if (UNIV_LIKELY_NULL(heap)) { - mem_heap_free(heap); + if (UNIV_UNLIKELY(height == 0 && dict_index_is_ibuf(index))) { + /* We're doing a search on an ibuf tree and we're one + level above the leaf page. */ + + ulint is_min_rec; + + ut_ad(level == 0); + + is_min_rec = rec_get_info_bits(node_ptr, 0) + & REC_INFO_MIN_REC_FLAG; + + if (!is_min_rec) { + cursor->ibuf_cnt + = ibuf_rec_get_counter(node_ptr); + + ut_a(cursor->ibuf_cnt <= 0xFFFF + || cursor->ibuf_cnt == ULINT_UNDEFINED); + } + + buf_mode = BUF_GET; + rw_latch = RW_NO_LATCH; + goto retry_page_get; + } + + goto search_loop; } - if (level == 0) { + if (level != 0) { + /* x-latch the page */ + page = btr_page_get( + space, zip_size, page_no, RW_X_LATCH, index, mtr); + + ut_a((ibool)!!page_is_comp(page) + == dict_table_is_comp(index->table)); + } else { cursor->low_match = low_match; cursor->low_bytes = low_bytes; cursor->up_match = up_match; cursor->up_bytes = up_bytes; #ifdef BTR_CUR_ADAPT - if (srv_use_adaptive_hash_indexes) { + /* We do a dirty read of btr_search_enabled here. We + will properly check btr_search_enabled again in + btr_search_build_page_hash_index() before building a + page hash index, while holding btr_search_latch. */ + if (UNIV_LIKELY(btr_search_enabled)) { btr_search_info_update(index, cursor); } @@ -591,29 +802,36 @@ retry_page_get: } func_exit: + + if (UNIV_LIKELY_NULL(heap)) { + mem_heap_free(heap); + } + if (has_search_latch) { rw_lock_s_lock(&btr_search_latch); } } -/********************************************************************* +/*****************************************************************//** Opens a cursor at either end of an index. */ - +UNIV_INTERN void -btr_cur_open_at_index_side( -/*=======================*/ - ibool from_left, /* in: TRUE if open to the low end, +btr_cur_open_at_index_side_func( +/*============================*/ + 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 */ + dict_index_t* index, /*!< in: index */ + ulint latch_mode, /*!< in: latch mode */ + btr_cur_t* cursor, /*!< in: cursor */ + const char* file, /*!< in: file name */ + ulint line, /*!< in: line where called */ + mtr_t* mtr) /*!< in: mtr */ { page_cur_t* page_cursor; - page_t* page; ulint page_no; ulint space; + ulint zip_size; ulint height; ulint root_height = 0; /* remove warning */ rec_t* node_ptr; @@ -622,7 +840,7 @@ btr_cur_open_at_index_side( mem_heap_t* heap = NULL; ulint offsets_[REC_OFFS_NORMAL_SIZE]; ulint* offsets = offsets_; - *offsets_ = (sizeof offsets_) / sizeof *offsets_; + rec_offs_init(offsets_); estimate = latch_mode & BTR_ESTIMATE; latch_mode = latch_mode & ~BTR_ESTIMATE; @@ -642,19 +860,21 @@ btr_cur_open_at_index_side( cursor->index = index; space = dict_index_get_space(index); + zip_size = dict_table_zip_size(index->table); page_no = dict_index_get_page(index); height = ULINT_UNDEFINED; for (;;) { - page = buf_page_get_gen(space, page_no, RW_NO_LATCH, NULL, - BUF_GET, - __FILE__, __LINE__, - mtr); - ut_ad(0 == ut_dulint_cmp(index->id, - btr_page_get_index_id(page))); + buf_block_t* block; + page_t* page; + block = buf_page_get_gen(space, zip_size, page_no, + RW_NO_LATCH, NULL, BUF_GET, + file, line, mtr); + page = buf_block_get_frame(block); + ut_ad(index->id == btr_page_get_index_id(page)); - buf_block_align(page)->check_index_page_at_flush = TRUE; + block->check_index_page_at_flush = TRUE; if (height == ULINT_UNDEFINED) { /* We are in the root node */ @@ -664,7 +884,7 @@ btr_cur_open_at_index_side( } if (height == 0) { - btr_cur_latch_leaves(page, space, page_no, + btr_cur_latch_leaves(page, space, zip_size, page_no, latch_mode, cursor, mtr); /* In versions <= 3.23.52 we had forgotten to @@ -685,9 +905,9 @@ btr_cur_open_at_index_side( } if (from_left) { - page_cur_set_before_first(page, page_cursor); + page_cur_set_before_first(block, page_cursor); } else { - page_cur_set_after_last(page, page_cursor); + page_cur_set_after_last(block, page_cursor); } if (height == 0) { @@ -725,27 +945,29 @@ btr_cur_open_at_index_side( } } -/************************************************************************** +/**********************************************************************//** Positions a cursor at a randomly chosen position within a B-tree. */ - +UNIV_INTERN 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 */ +btr_cur_open_at_rnd_pos_func( +/*=========================*/ + dict_index_t* index, /*!< in: index */ + ulint latch_mode, /*!< in: BTR_SEARCH_LEAF, ... */ + btr_cur_t* cursor, /*!< in/out: B-tree cursor */ + const char* file, /*!< in: file name */ + ulint line, /*!< in: line where called */ + mtr_t* mtr) /*!< in: mtr */ { page_cur_t* page_cursor; - page_t* page; ulint page_no; ulint space; + ulint zip_size; ulint height; rec_t* node_ptr; mem_heap_t* heap = NULL; ulint offsets_[REC_OFFS_NORMAL_SIZE]; ulint* offsets = offsets_; - *offsets_ = (sizeof offsets_) / sizeof *offsets_; + rec_offs_init(offsets_); if (latch_mode == BTR_MODIFY_TREE) { mtr_x_lock(dict_index_get_lock(index), mtr); @@ -757,17 +979,20 @@ btr_cur_open_at_rnd_pos( cursor->index = index; space = dict_index_get_space(index); + zip_size = dict_table_zip_size(index->table); page_no = dict_index_get_page(index); height = ULINT_UNDEFINED; for (;;) { - page = buf_page_get_gen(space, page_no, RW_NO_LATCH, NULL, - BUF_GET, - __FILE__, __LINE__, - mtr); - ut_ad(0 == ut_dulint_cmp(index->id, - btr_page_get_index_id(page))); + buf_block_t* block; + page_t* page; + + block = buf_page_get_gen(space, zip_size, page_no, + RW_NO_LATCH, NULL, BUF_GET, + file, line, mtr); + page = buf_block_get_frame(block); + ut_ad(index->id == btr_page_get_index_id(page)); if (height == ULINT_UNDEFINED) { /* We are in the root node */ @@ -776,11 +1001,11 @@ btr_cur_open_at_rnd_pos( } if (height == 0) { - btr_cur_latch_leaves(page, space, page_no, + btr_cur_latch_leaves(page, space, zip_size, page_no, latch_mode, cursor, mtr); } - page_cur_open_on_rnd_user_rec(page, page_cursor); + page_cur_open_on_rnd_user_rec(block, page_cursor); if (height == 0) { @@ -805,80 +1030,76 @@ btr_cur_open_at_rnd_pos( /*==================== B-TREE INSERT =========================*/ -/***************************************************************** +/*************************************************************//** Inserts a record if there is enough space, or if enough space can -be freed by reorganizing. Differs from _optimistic_insert because +be freed by reorganizing. Differs from btr_cur_optimistic_insert because no heuristics is applied to whether it pays to use CPU time for -reorganizing the page or not. */ +reorganizing the page or not. +@return pointer to inserted record if succeed, else NULL */ static rec_t* btr_cur_insert_if_possible( /*=======================*/ - /* out: pointer to inserted record if succeed, - else NULL */ - btr_cur_t* cursor, /* in: cursor on page after which to insert; + btr_cur_t* cursor, /*!< in: cursor on page after which to insert; cursor stays valid */ - dtuple_t* tuple, /* in: tuple to insert; the size info need not + const dtuple_t* tuple, /*!< in: tuple to insert; the size info need not have been stored to tuple */ - ibool* reorg, /* out: TRUE if reorganization occurred */ - mtr_t* mtr) /* in: mtr */ + ulint n_ext, /*!< in: number of externally stored columns */ + mtr_t* mtr) /*!< in: mtr */ { page_cur_t* page_cursor; - page_t* page; + buf_block_t* block; rec_t* rec; ut_ad(dtuple_check_typed(tuple)); - *reorg = FALSE; - - page = btr_cur_get_page(cursor); + block = btr_cur_get_block(cursor); - ut_ad(mtr_memo_contains(mtr, buf_block_align(page), - MTR_MEMO_PAGE_X_FIX)); + ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX)); page_cursor = btr_cur_get_page_cur(cursor); /* Now, try the insert */ - rec = page_cur_tuple_insert(page_cursor, tuple, cursor->index, mtr); + rec = page_cur_tuple_insert(page_cursor, tuple, + cursor->index, n_ext, mtr); - if (!rec) { + if (UNIV_UNLIKELY(!rec)) { /* If record did not fit, reorganize */ - btr_page_reorganize(page, cursor->index, mtr); - - *reorg = TRUE; + if (btr_page_reorganize(block, cursor->index, mtr)) { - page_cur_search(page, cursor->index, tuple, - PAGE_CUR_LE, page_cursor); + page_cur_search(block, cursor->index, tuple, + PAGE_CUR_LE, page_cursor); - rec = page_cur_tuple_insert(page_cursor, tuple, - cursor->index, mtr); + rec = page_cur_tuple_insert(page_cursor, tuple, + cursor->index, n_ext, mtr); + } } return(rec); } -/***************************************************************** -For an insert, checks the locks and does the undo logging if desired. */ +/*************************************************************//** +For an insert, checks the locks and does the undo logging if desired. +@return DB_SUCCESS, DB_WAIT_LOCK, DB_FAIL, or error number */ UNIV_INLINE ulint btr_cur_ins_lock_and_undo( /*======================*/ - /* out: DB_SUCCESS, DB_WAIT_LOCK, - DB_FAIL, or error number */ - ulint flags, /* in: undo logging and locking flags: if + 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 */ - dtuple_t* entry, /* in: entry to insert */ - que_thr_t* thr, /* in: query thread or NULL */ - ibool* inherit)/* out: TRUE if the inserted new record maybe + btr_cur_t* cursor, /*!< in: cursor on page after which to insert */ + dtuple_t* entry, /*!< in/out: entry to insert */ + que_thr_t* thr, /*!< in: query thread or NULL */ + mtr_t* mtr, /*!< in/out: mini-transaction */ + ibool* inherit)/*!< out: TRUE if the inserted new record maybe should inherit LOCK_GAP type locks from the successor record */ { dict_index_t* index; ulint err; rec_t* rec; - dulint roll_ptr; + roll_ptr_t roll_ptr; /* Check if we have to wait for a lock: enqueue an explicit lock request if yes */ @@ -886,14 +1107,16 @@ btr_cur_ins_lock_and_undo( rec = btr_cur_get_rec(cursor); index = cursor->index; - err = lock_rec_insert_check_and_lock(flags, rec, index, thr, inherit); + err = lock_rec_insert_check_and_lock(flags, rec, + btr_cur_get_block(cursor), + index, thr, mtr, inherit); if (err != DB_SUCCESS) { return(err); } - if ((index->type & DICT_CLUSTERED) && !(index->type & DICT_IBUF)) { + if (dict_index_is_clust(index) && !dict_index_is_ibuf(index)) { err = trx_undo_report_row_operation(flags, TRX_UNDO_INSERT_OP, thr, index, entry, @@ -917,68 +1140,80 @@ btr_cur_ins_lock_and_undo( } #ifdef UNIV_DEBUG -/***************************************************************** +/*************************************************************//** Report information about a transaction. */ static void btr_cur_trx_report( /*===============*/ - trx_t* trx, /* in: transaction */ - const dict_index_t* index, /* in: index */ - const char* op) /* in: operation */ + trx_t* trx, /*!< in: transaction */ + const dict_index_t* index, /*!< in: index */ + const char* op) /*!< in: operation */ { - fprintf(stderr, "Trx with id %lu %lu going to ", - ut_dulint_get_high(trx->id), - ut_dulint_get_low(trx->id)); + fprintf(stderr, "Trx with id " TRX_ID_FMT " going to ", + (ullint) trx->id); fputs(op, stderr); dict_index_name_print(stderr, trx, index); putc('\n', stderr); } #endif /* UNIV_DEBUG */ -/***************************************************************** +/*************************************************************//** 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. */ - +prevent trying to split a page with just one record. +@return DB_SUCCESS, DB_WAIT_LOCK, DB_FAIL, or error number */ +UNIV_INTERN 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 + 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; + 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 + dtuple_t* entry, /*!< in/out: 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 + 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 */ + ulint n_ext, /*!< in: number of externally stored columns */ + que_thr_t* thr, /*!< in: query thread or NULL */ + mtr_t* mtr) /*!< in: mtr; if this function returns + DB_SUCCESS on a leaf page of a secondary + index in a compressed tablespace, the + mtr must be committed before latching + any further pages */ { big_rec_t* big_rec_vec = NULL; dict_index_t* index; page_cur_t* page_cursor; + buf_block_t* block; page_t* page; ulint max_size; rec_t* dummy_rec; - ulint level; + ibool leaf; ibool reorg; ibool inherit; + ulint zip_size; ulint rec_size; - ulint type; ulint err; *big_rec = NULL; - page = btr_cur_get_page(cursor); + block = btr_cur_get_block(cursor); + page = buf_block_get_frame(block); index = cursor->index; + zip_size = buf_block_get_zip_size(block); +#ifdef UNIV_DEBUG_VALGRIND + if (zip_size) { + UNIV_MEM_ASSERT_RW(page, UNIV_PAGE_SIZE); + UNIV_MEM_ASSERT_RW(block->page.zip.data, zip_size); + } +#endif /* UNIV_DEBUG_VALGRIND */ if (!dtuple_check_typed_no_assert(entry)) { fputs("InnoDB: Error in a tuple to insert into ", stderr); @@ -991,95 +1226,141 @@ btr_cur_optimistic_insert( } #endif /* UNIV_DEBUG */ - ut_ad(mtr_memo_contains(mtr, buf_block_align(page), - MTR_MEMO_PAGE_X_FIX)); + ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX)); max_size = page_get_max_insert_size_after_reorganize(page, 1); - level = btr_page_get_level(page, mtr); + leaf = page_is_leaf(page); -calculate_sizes_again: /* Calculate the record size when entry is converted to a record */ - rec_size = rec_get_converted_size(index, entry); + rec_size = rec_get_converted_size(index, entry, n_ext); - if (rec_size - >= ut_min(page_get_free_space_of_empty(page_is_comp(page)) / 2, - REC_MAX_DATA_SIZE)) { + if (page_zip_rec_needs_ext(rec_size, page_is_comp(page), + dtuple_get_n_fields(entry), zip_size)) { /* The record is so big that we have to store some fields externally on separate database pages */ + big_rec_vec = dtuple_convert_big_rec(index, entry, &n_ext); - big_rec_vec = dtuple_convert_big_rec(index, entry, NULL, 0); - - if (big_rec_vec == NULL) { + if (UNIV_UNLIKELY(big_rec_vec == NULL)) { return(DB_TOO_BIG_RECORD); } - goto calculate_sizes_again; + rec_size = rec_get_converted_size(index, entry, n_ext); + } + + if (UNIV_UNLIKELY(zip_size)) { + /* Estimate the free space of an empty compressed page. + Subtract one byte for the encoded heap_no in the + modification log. */ + ulint free_space_zip = page_zip_empty_size( + cursor->index->n_fields, zip_size) - 1; + ulint n_uniq = dict_index_get_n_unique_in_tree(index); + + ut_ad(dict_table_is_comp(index->table)); + + /* There should be enough room for two node pointer + records on an empty non-leaf page. This prevents + infinite page splits. */ + + if (UNIV_LIKELY(entry->n_fields >= n_uniq) + && UNIV_UNLIKELY(REC_NODE_PTR_SIZE + + rec_get_converted_size_comp_prefix( + index, entry->fields, n_uniq, + NULL) + /* On a compressed page, there is + a two-byte entry in the dense + page directory for every record. + But there is no record header. */ + - (REC_N_NEW_EXTRA_BYTES - 2) + > free_space_zip / 2)) { + + if (big_rec_vec) { + dtuple_convert_back_big_rec( + index, entry, big_rec_vec); + } + + return(DB_TOO_BIG_RECORD); + } } /* If there have been many consecutive inserts, and we are on the leaf level, check if we have to split the page to reserve enough free space for future updates of records. */ - type = index->type; - - if ((type & DICT_CLUSTERED) - && (dict_index_get_space_reserve() + rec_size > max_size) + if (dict_index_is_clust(index) && (page_get_n_recs(page) >= 2) - && (0 == level) + && UNIV_LIKELY(leaf) + && (dict_index_get_space_reserve() + rec_size > max_size) && (btr_page_get_split_rec_to_right(cursor, &dummy_rec) || btr_page_get_split_rec_to_left(cursor, &dummy_rec))) { +fail: + err = DB_FAIL; +fail_err: if (big_rec_vec) { dtuple_convert_back_big_rec(index, entry, big_rec_vec); } - return(DB_FAIL); + return(err); } - if (!(((max_size >= rec_size) - && (max_size >= BTR_CUR_PAGE_REORGANIZE_LIMIT)) - || (page_get_max_insert_size(page, 1) >= rec_size) - || (page_get_n_recs(page) <= 1))) { + if (UNIV_UNLIKELY(max_size < BTR_CUR_PAGE_REORGANIZE_LIMIT + || max_size < rec_size) + && UNIV_LIKELY(page_get_n_recs(page) > 1) + && page_get_max_insert_size(page, 1) < rec_size) { - if (big_rec_vec) { - dtuple_convert_back_big_rec(index, entry, big_rec_vec); - } - return(DB_FAIL); + goto fail; } /* Check locks and write to the undo log, if specified */ - err = btr_cur_ins_lock_and_undo(flags, cursor, entry, thr, &inherit); + err = btr_cur_ins_lock_and_undo(flags, cursor, entry, + thr, mtr, &inherit); - if (err != DB_SUCCESS) { + if (UNIV_UNLIKELY(err != DB_SUCCESS)) { - if (big_rec_vec) { - dtuple_convert_back_big_rec(index, entry, big_rec_vec); - } - return(err); + goto fail_err; } page_cursor = btr_cur_get_page_cur(cursor); - reorg = FALSE; - /* Now, try the insert */ - *rec = page_cur_insert_rec_low(page_cursor, entry, index, - NULL, NULL, mtr); - if (UNIV_UNLIKELY(!(*rec))) { + { + const rec_t* page_cursor_rec = page_cur_get_rec(page_cursor); + *rec = page_cur_tuple_insert(page_cursor, entry, index, + n_ext, mtr); + reorg = page_cursor_rec != page_cur_get_rec(page_cursor); + + if (UNIV_UNLIKELY(reorg)) { + ut_a(zip_size); + ut_a(*rec); + } + } + + if (UNIV_UNLIKELY(!*rec) && UNIV_LIKELY(!reorg)) { /* If the record did not fit, reorganize */ - btr_page_reorganize(page, index, mtr); + if (UNIV_UNLIKELY(!btr_page_reorganize(block, index, mtr))) { + ut_a(zip_size); - ut_ad(page_get_max_insert_size(page, 1) == max_size); + goto fail; + } + + ut_ad(zip_size + || page_get_max_insert_size(page, 1) == max_size); reorg = TRUE; - page_cur_search(page, index, entry, PAGE_CUR_LE, page_cursor); + page_cur_search(block, index, entry, PAGE_CUR_LE, page_cursor); - *rec = page_cur_tuple_insert(page_cursor, entry, index, mtr); + *rec = page_cur_tuple_insert(page_cursor, entry, index, + n_ext, mtr); if (UNIV_UNLIKELY(!*rec)) { + if (UNIV_LIKELY(zip_size != 0)) { + + goto fail; + } + fputs("InnoDB: Error: cannot insert tuple ", stderr); dtuple_print(stderr, entry); fputs(" into ", stderr); @@ -1091,7 +1372,7 @@ calculate_sizes_again: } #ifdef BTR_CUR_HASH_ADAPT - if (!reorg && (0 == level) && (cursor->flag == BTR_CUR_HASH)) { + if (!reorg && leaf && (cursor->flag == BTR_CUR_HASH)) { btr_search_update_hash_node_on_insert(cursor); } else { btr_search_update_hash_on_insert(cursor); @@ -1100,19 +1381,39 @@ calculate_sizes_again: if (!(flags & BTR_NO_LOCKING_FLAG) && inherit) { - lock_update_insert(*rec); + lock_update_insert(block, *rec); } #if 0 fprintf(stderr, "Insert into page %lu, max ins size %lu," " rec %lu ind type %lu\n", - buf_frame_get_page_no(page), max_size, - rec_size + PAGE_DIR_SLOT_SIZE, type); + buf_block_get_page_no(block), max_size, + rec_size + PAGE_DIR_SLOT_SIZE, index->type); #endif - if (!(type & DICT_CLUSTERED)) { - /* We have added a record to page: update its free bits */ - ibuf_update_free_bits_if_full(cursor->index, page, max_size, - rec_size + PAGE_DIR_SLOT_SIZE); + if (leaf && !dict_index_is_clust(index)) { + /* Update the free bits of the B-tree page in the + insert buffer bitmap. */ + + /* The free bits in the insert buffer bitmap must + never exceed the free space on a page. It is safe to + decrement or reset the bits in the bitmap in a + mini-transaction that is committed before the + mini-transaction that affects the free space. */ + + /* It is unsafe to increment the bits in a separately + committed mini-transaction, because in crash recovery, + the free bits could momentarily be set too high. */ + + if (zip_size) { + /* Update the bits in the same mini-transaction. */ + ibuf_update_free_bits_zip(block, mtr); + } else { + /* Decrement the bits in a separate + mini-transaction. */ + ibuf_update_free_bits_if_full( + block, max_size, + rec_size + PAGE_DIR_SLOT_SIZE); + } } *big_rec = big_rec_vec; @@ -1120,36 +1421,38 @@ calculate_sizes_again: return(DB_SUCCESS); } -/***************************************************************** +/*************************************************************//** 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. */ - +to brothers of page, if those brothers exist. +@return DB_SUCCESS or error number */ +UNIV_INTERN ulint btr_cur_pessimistic_insert( /*=======================*/ - /* out: DB_SUCCESS or error number */ - ulint flags, /* in: undo logging and locking flags: if not + 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; + 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 + dtuple_t* entry, /*!< in/out: 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 + 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 */ + ulint n_ext, /*!< in: number of externally stored columns */ + que_thr_t* thr, /*!< in: query thread or NULL */ + mtr_t* mtr) /*!< in: mtr */ { dict_index_t* index = cursor->index; + ulint zip_size = dict_table_zip_size(index->table); big_rec_t* big_rec_vec = NULL; - page_t* page; + mem_heap_t* heap = NULL; ulint err; ibool dummy_inh; ibool success; @@ -1160,12 +1463,10 @@ btr_cur_pessimistic_insert( *big_rec = NULL; - page = btr_cur_get_page(cursor); - ut_ad(mtr_memo_contains(mtr, dict_index_get_lock(btr_cur_get_index(cursor)), MTR_MEMO_X_LOCK)); - ut_ad(mtr_memo_contains(mtr, buf_block_align(page), + ut_ad(mtr_memo_contains(mtr, btr_cur_get_block(cursor), MTR_MEMO_PAGE_X_FIX)); /* Try first an optimistic insert; reset the cursor flag: we do not @@ -1173,8 +1474,8 @@ btr_cur_pessimistic_insert( cursor->flag = BTR_CUR_BINARY; - err = btr_cur_optimistic_insert(flags, cursor, entry, rec, big_rec, - thr, mtr); + err = btr_cur_optimistic_insert(flags, cursor, entry, rec, + big_rec, n_ext, thr, mtr); if (err != DB_FAIL) { return(err); @@ -1183,7 +1484,8 @@ btr_cur_pessimistic_insert( /* Retry with a pessimistic insert. Check locks and write to undo log, if specified */ - err = btr_cur_ins_lock_and_undo(flags, cursor, entry, thr, &dummy_inh); + err = btr_cur_ins_lock_and_undo(flags, cursor, entry, + thr, mtr, &dummy_inh); if (err != DB_SUCCESS) { @@ -1200,20 +1502,25 @@ btr_cur_pessimistic_insert( success = fsp_reserve_free_extents(&n_reserved, index->space, n_extents, FSP_NORMAL, mtr); if (!success) { - err = DB_OUT_OF_FILE_SPACE; - - return(err); + return(DB_OUT_OF_FILE_SPACE); } } - if (rec_get_converted_size(index, entry) - >= ut_min(page_get_free_space_of_empty(page_is_comp(page)) / 2, - REC_MAX_DATA_SIZE)) { - + if (page_zip_rec_needs_ext(rec_get_converted_size(index, entry, n_ext), + dict_table_is_comp(index->table), + dict_index_get_n_fields(index), + zip_size)) { /* The record is so big that we have to store some fields externally on separate database pages */ - big_rec_vec = dtuple_convert_big_rec(index, entry, NULL, 0); + if (UNIV_LIKELY_NULL(big_rec_vec)) { + /* This should never happen, but we handle + the situation in a robust manner. */ + ut_ad(0); + dtuple_convert_back_big_rec(index, entry, big_rec_vec); + } + + big_rec_vec = dtuple_convert_big_rec(index, entry, &n_ext); if (big_rec_vec == NULL) { @@ -1225,52 +1532,55 @@ btr_cur_pessimistic_insert( } } - if (dict_index_get_page(index) == buf_frame_get_page_no(page)) { + if (dict_index_get_page(index) + == buf_block_get_page_no(btr_cur_get_block(cursor))) { /* The page is the root page */ - *rec = btr_root_raise_and_insert(cursor, entry, mtr); + *rec = btr_root_raise_and_insert(cursor, entry, n_ext, mtr); } else { - *rec = btr_page_split_and_insert(cursor, entry, mtr); + *rec = btr_page_split_and_insert(cursor, entry, n_ext, mtr); } - btr_cur_position(index, page_rec_get_prev(*rec), cursor); + if (UNIV_LIKELY_NULL(heap)) { + mem_heap_free(heap); + } + + ut_ad(page_rec_get_next(btr_cur_get_rec(cursor)) == *rec); #ifdef BTR_CUR_ADAPT btr_search_update_hash_on_insert(cursor); #endif if (!(flags & BTR_NO_LOCKING_FLAG)) { - lock_update_insert(*rec); + lock_update_insert(btr_cur_get_block(cursor), *rec); } - err = DB_SUCCESS; - if (n_extents > 0) { fil_space_release_free_extents(index->space, n_reserved); } *big_rec = big_rec_vec; - return(err); + return(DB_SUCCESS); } /*==================== B-TREE UPDATE =========================*/ -/***************************************************************** -For an update, checks the locks and does the undo logging. */ +/*************************************************************//** +For an update, checks the locks and does the undo logging. +@return DB_SUCCESS, DB_WAIT_LOCK, or error number */ UNIV_INLINE ulint btr_cur_upd_lock_and_undo( /*======================*/ - /* out: DB_SUCCESS, DB_WAIT_LOCK, or error - number */ - ulint flags, /* in: undo logging and locking flags */ - btr_cur_t* cursor, /* in: cursor on record to update */ - upd_t* update, /* in: update vector */ - ulint cmpl_info,/* in: compiler info on secondary index + ulint flags, /*!< in: undo logging and locking flags */ + btr_cur_t* cursor, /*!< in: cursor on record to update */ + const upd_t* update, /*!< in: update vector */ + ulint cmpl_info,/*!< in: compiler info on secondary index updates */ - que_thr_t* thr, /* in: query thread */ - dulint* roll_ptr)/* out: roll pointer */ + que_thr_t* thr, /*!< in: query thread */ + mtr_t* mtr, /*!< in/out: mini-transaction */ + roll_ptr_t* roll_ptr)/*!< out: roll pointer */ { dict_index_t* index; rec_t* rec; @@ -1281,11 +1591,12 @@ btr_cur_upd_lock_and_undo( rec = btr_cur_get_rec(cursor); index = cursor->index; - if (!(index->type & DICT_CLUSTERED)) { + if (!dict_index_is_clust(index)) { /* We do undo logging only when we update a clustered index record */ - return(lock_sec_rec_modify_check_and_lock(flags, rec, index, - thr)); + return(lock_sec_rec_modify_check_and_lock( + flags, btr_cur_get_block(cursor), rec, + index, thr, mtr)); } /* Check if we have to wait for a lock: enqueue an explicit lock @@ -1296,10 +1607,10 @@ btr_cur_upd_lock_and_undo( if (!(flags & BTR_NO_LOCKING_FLAG)) { mem_heap_t* heap = NULL; ulint offsets_[REC_OFFS_NORMAL_SIZE]; - *offsets_ = (sizeof offsets_) / sizeof *offsets_; + rec_offs_init(offsets_); err = lock_clust_rec_modify_check_and_lock( - flags, rec, index, + flags, btr_cur_get_block(cursor), rec, index, rec_get_offsets(rec, index, offsets_, ULINT_UNDEFINED, &heap), thr); if (UNIV_LIKELY_NULL(heap)) { @@ -1319,19 +1630,19 @@ btr_cur_upd_lock_and_undo( return(err); } -/*************************************************************** +/***********************************************************//** Writes a redo log record of updating a record in-place. */ UNIV_INLINE void btr_cur_update_in_place_log( /*========================*/ - ulint flags, /* in: flags */ - rec_t* rec, /* in: record */ - dict_index_t* index, /* in: index where cursor positioned */ - upd_t* update, /* in: update vector */ - trx_t* trx, /* in: transaction */ - dulint roll_ptr, /* in: roll ptr */ - mtr_t* mtr) /* in: mtr */ + ulint flags, /*!< in: flags */ + rec_t* rec, /*!< in: record */ + dict_index_t* index, /*!< in: index where cursor positioned */ + const upd_t* update, /*!< in: update vector */ + trx_t* trx, /*!< in: transaction */ + roll_ptr_t roll_ptr, /*!< in: roll ptr */ + mtr_t* mtr) /*!< in: mtr */ { byte* log_ptr; page_t* page = page_align(rec); @@ -1366,28 +1677,30 @@ btr_cur_update_in_place_log( row_upd_index_write_log(update, log_ptr, mtr); } +#endif /* UNIV_HOTBACKUP */ -/*************************************************************** -Parses a redo log record of updating a record in-place. */ - +/***********************************************************//** +Parses a redo log record of updating a record in-place. +@return end of log record or NULL */ +UNIV_INTERN 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 */ + byte* ptr, /*!< in: buffer */ + byte* end_ptr,/*!< in: buffer end */ + page_t* page, /*!< in/out: page or NULL */ + page_zip_des_t* page_zip,/*!< in/out: compressed page, or NULL */ + dict_index_t* index) /*!< in: index corresponding to page */ { - ulint flags; - rec_t* rec; - upd_t* update; - ulint pos; - dulint trx_id; - dulint roll_ptr; - ulint rec_offset; - mem_heap_t* heap; - ulint* offsets; + ulint flags; + rec_t* rec; + upd_t* update; + ulint pos; + trx_id_t trx_id; + roll_ptr_t roll_ptr; + ulint rec_offset; + mem_heap_t* heap; + ulint* offsets; if (end_ptr < ptr + 1) { @@ -1432,11 +1745,11 @@ btr_cur_parse_update_in_place( offsets = rec_get_offsets(rec, index, NULL, ULINT_UNDEFINED, &heap); if (!(flags & BTR_KEEP_SYS_FLAG)) { - row_upd_rec_sys_fields_in_recovery(rec, offsets, + row_upd_rec_sys_fields_in_recovery(rec, page_zip, offsets, pos, trx_id, roll_ptr); } - row_upd_rec_in_place(rec, offsets, update); + row_upd_rec_in_place(rec, index, offsets, update, page_zip); func_exit: mem_heap_free(heap); @@ -1444,39 +1757,106 @@ func_exit: return(ptr); } -/***************************************************************** -Updates a record when the update causes no size changes in its fields. -We assume here that the ordering fields of the record do not change. */ +#ifndef UNIV_HOTBACKUP +/*************************************************************//** +See if there is enough place in the page modification log to log +an update-in-place. +@return TRUE if enough place */ +UNIV_INTERN +ibool +btr_cur_update_alloc_zip( +/*=====================*/ + page_zip_des_t* page_zip,/*!< in/out: compressed page */ + buf_block_t* block, /*!< in/out: buffer page */ + dict_index_t* index, /*!< in: the index corresponding to the block */ + ulint length, /*!< in: size needed */ + ibool create, /*!< in: TRUE=delete-and-insert, + FALSE=update-in-place */ + mtr_t* mtr) /*!< in: mini-transaction */ +{ + ut_a(page_zip == buf_block_get_page_zip(block)); + ut_ad(page_zip); + ut_ad(!dict_index_is_ibuf(index)); + + if (page_zip_available(page_zip, dict_index_is_clust(index), + length, create)) { + return(TRUE); + } + + if (!page_zip->m_nonempty) { + /* The page has been freshly compressed, so + recompressing it will not help. */ + return(FALSE); + } + + if (!page_zip_compress(page_zip, buf_block_get_frame(block), + index, mtr)) { + /* Unable to compress the page */ + return(FALSE); + } + /* After recompressing a page, we must make sure that the free + bits in the insert buffer bitmap will not exceed the free + space on the page. Because this function will not attempt + recompression unless page_zip_available() fails above, it is + safe to reset the free bits if page_zip_available() fails + again, below. The free bits can safely be reset in a separate + mini-transaction. If page_zip_available() succeeds below, we + can be sure that the page_zip_compress() above did not reduce + the free space available on the page. */ + + if (!page_zip_available(page_zip, dict_index_is_clust(index), + length, create)) { + /* Out of space: reset the free bits. */ + if (!dict_index_is_clust(index) + && page_is_leaf(buf_block_get_frame(block))) { + ibuf_reset_free_bits(block); + } + return(FALSE); + } + + return(TRUE); +} + +/*************************************************************//** +Updates a record when the update causes no size changes in its fields. +We assume here that the ordering fields of the record do not change. +@return DB_SUCCESS or error number */ +UNIV_INTERN 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; + 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 + const 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 */ + que_thr_t* thr, /*!< in: query thread */ + mtr_t* mtr) /*!< in: mtr; must be committed before + latching any further pages */ { dict_index_t* index; buf_block_t* block; + page_zip_des_t* page_zip; ulint err; rec_t* rec; - dulint roll_ptr = ut_dulint_zero; + roll_ptr_t roll_ptr = 0; trx_t* trx; ulint was_delete_marked; + ibool is_hashed; mem_heap_t* heap = NULL; ulint offsets_[REC_OFFS_NORMAL_SIZE]; ulint* offsets = offsets_; - *offsets_ = (sizeof offsets_) / sizeof *offsets_; + rec_offs_init(offsets_); rec = btr_cur_get_rec(cursor); index = cursor->index; ut_ad(!!page_rec_is_comp(rec) == dict_table_is_comp(index->table)); + /* The insert buffer tree should never be updated in place. */ + ut_ad(!dict_index_is_ibuf(index)); + trx = thr_get_trx(thr); offsets = rec_get_offsets(rec, index, offsets, ULINT_UNDEFINED, &heap); #ifdef UNIV_DEBUG @@ -1486,9 +1866,19 @@ btr_cur_update_in_place( } #endif /* UNIV_DEBUG */ + block = btr_cur_get_block(cursor); + page_zip = buf_block_get_page_zip(block); + + /* Check that enough space is available on the compressed page. */ + if (UNIV_LIKELY_NULL(page_zip) + && !btr_cur_update_alloc_zip(page_zip, block, index, + rec_offs_size(offsets), FALSE, mtr)) { + return(DB_ZIP_OVERFLOW); + } + /* Do lock checking and undo logging */ err = btr_cur_upd_lock_and_undo(flags, cursor, update, cmpl_info, - thr, &roll_ptr); + thr, mtr, &roll_ptr); if (UNIV_UNLIKELY(err != DB_SUCCESS)) { if (UNIV_LIKELY_NULL(heap)) { @@ -1497,17 +1887,28 @@ btr_cur_update_in_place( return(err); } - block = buf_block_align(rec); - ut_ad(!!page_is_comp(buf_block_get_frame(block)) - == dict_table_is_comp(index->table)); + if (!(flags & BTR_KEEP_SYS_FLAG)) { + row_upd_rec_sys_fields(rec, NULL, + index, offsets, trx, roll_ptr); + } + + was_delete_marked = rec_get_deleted_flag( + rec, page_is_comp(buf_block_get_frame(block))); + + is_hashed = (block->index != NULL); + + if (is_hashed) { + /* TO DO: Can we skip this if none of the fields + index->search_info->curr_n_fields + are being updated? */ - if (block->is_hashed) { /* The function row_upd_changes_ord_field_binary works only if the update vector was built for a clustered index, we must NOT call it if index is secondary */ - if (!(index->type & DICT_CLUSTERED) - || row_upd_changes_ord_field_binary(NULL, index, update)) { + if (!dict_index_is_clust(index) + || row_upd_changes_ord_field_binary(index, update, thr, + NULL, NULL)) { /* Remove possible hash index pointer to this record */ btr_search_update_hash_on_delete(cursor); @@ -1516,28 +1917,29 @@ btr_cur_update_in_place( rw_lock_x_lock(&btr_search_latch); } - if (!(flags & BTR_KEEP_SYS_FLAG)) { - row_upd_rec_sys_fields(rec, index, offsets, trx, roll_ptr); - } - - was_delete_marked = rec_get_deleted_flag( - rec, page_is_comp(buf_block_get_frame(block))); - - row_upd_rec_in_place(rec, offsets, update); + row_upd_rec_in_place(rec, index, offsets, update, page_zip); - if (block->is_hashed) { + if (is_hashed) { rw_lock_x_unlock(&btr_search_latch); } - btr_cur_update_in_place_log(flags, rec, index, update, trx, roll_ptr, - mtr); + if (page_zip && !dict_index_is_clust(index) + && page_is_leaf(buf_block_get_frame(block))) { + /* Update the free bits in the insert buffer. */ + ibuf_update_free_bits_zip(block, mtr); + } + + btr_cur_update_in_place_log(flags, rec, index, update, + trx, roll_ptr, mtr); + if (was_delete_marked && !rec_get_deleted_flag(rec, page_is_comp( buf_block_get_frame(block)))) { /* The new updated record owns its possible externally stored fields */ - btr_cur_unmark_extern_fields(rec, mtr, offsets); + btr_cur_unmark_extern_fields(page_zip, + rec, index, offsets, mtr); } if (UNIV_LIKELY_NULL(heap)) { @@ -1546,56 +1948,63 @@ btr_cur_update_in_place( return(DB_SUCCESS); } -/***************************************************************** +/*************************************************************//** 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. We assume here that the ordering -fields of the record do not change. */ - +fields of the record do not change. +@return DB_SUCCESS, or DB_OVERFLOW if the updated record does not fit, +DB_UNDERFLOW if the page would become too empty, or DB_ZIP_OVERFLOW if +there is not enough space left on the compressed page */ +UNIV_INTERN 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; + 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 + const 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 + ulint cmpl_info,/*!< in: compiler info on secondary index updates */ - que_thr_t* thr, /* in: query thread */ - mtr_t* mtr) /* in: mtr */ + que_thr_t* thr, /*!< in: query thread */ + mtr_t* mtr) /*!< in: mtr; must be committed before + latching any further pages */ { dict_index_t* index; page_cur_t* page_cursor; ulint err; + buf_block_t* block; page_t* page; + page_zip_des_t* page_zip; rec_t* rec; ulint max_size; ulint new_rec_size; ulint old_rec_size; dtuple_t* new_entry; - dulint roll_ptr; + roll_ptr_t roll_ptr; + trx_t* trx; mem_heap_t* heap; - ibool reorganized = FALSE; ulint i; + ulint n_ext; ulint* offsets; - page = btr_cur_get_page(cursor); + block = btr_cur_get_block(cursor); + page = buf_block_get_frame(block); rec = btr_cur_get_rec(cursor); index = cursor->index; ut_ad(!!page_rec_is_comp(rec) == dict_table_is_comp(index->table)); + ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX)); + /* The insert buffer tree should never be updated in place. */ + ut_ad(!dict_index_is_ibuf(index)); heap = mem_heap_create(1024); offsets = rec_get_offsets(rec, index, NULL, ULINT_UNDEFINED, &heap); -#if defined UNIV_DEBUG || defined UNIV_BLOB_LIGHT_DEBUG - ut_a(!rec_offs_any_null_extern(rec, offsets) - || thr_get_trx(thr) == trx_roll_crash_recv_trx); -#endif /* UNIV_DEBUG || UNIV_BLOB_LIGHT_DEBUG */ +#ifdef UNIV_BLOB_NULL_DEBUG + ut_a(!rec_offs_any_null_extern(rec, offsets)); +#endif /* UNIV_BLOB_NULL_DEBUG */ #ifdef UNIV_DEBUG if (btr_cur_print_record_ops && thr) { @@ -1604,30 +2013,20 @@ btr_cur_optimistic_update( } #endif /* UNIV_DEBUG */ - ut_ad(mtr_memo_contains(mtr, buf_block_align(page), - MTR_MEMO_PAGE_X_FIX)); if (!row_upd_changes_field_size_or_external(index, offsets, update)) { /* The simplest and the most common case: the update does not change the size of any field and none of the updated fields is - externally stored in rec or update */ + externally stored in rec or update, and there is enough space + on the compressed page to log the update. */ + mem_heap_free(heap); return(btr_cur_update_in_place(flags, cursor, update, cmpl_info, thr, mtr)); } - for (i = 0; i < upd_get_n_fields(update); i++) { - if (upd_get_nth_field(update, i)->extern_storage) { - - /* Externally stored fields are treated in pessimistic - update */ - - mem_heap_free(heap); - return(DB_OVERFLOW); - } - } - if (rec_offs_any_extern(offsets)) { +any_extern: /* Externally stored fields are treated in pessimistic update */ @@ -1635,38 +2034,61 @@ btr_cur_optimistic_update( return(DB_OVERFLOW); } + for (i = 0; i < upd_get_n_fields(update); i++) { + if (dfield_is_ext(&upd_get_nth_field(update, i)->new_val)) { + + goto any_extern; + } + } + page_cursor = btr_cur_get_page_cur(cursor); - new_entry = row_rec_to_index_entry(ROW_COPY_DATA, index, rec, heap); + new_entry = row_rec_to_index_entry(ROW_COPY_DATA, rec, index, offsets, + &n_ext, heap); + /* We checked above that there are no externally stored fields. */ + ut_a(!n_ext); + /* The page containing the clustered index record + corresponding to new_entry is latched in mtr. + Thus the following call is safe. */ row_upd_index_replace_new_col_vals_index_pos(new_entry, index, update, - FALSE, NULL); + FALSE, heap); old_rec_size = rec_offs_size(offsets); - new_rec_size = rec_get_converted_size(index, new_entry); + new_rec_size = rec_get_converted_size(index, new_entry, 0); + + page_zip = buf_block_get_page_zip(block); +#ifdef UNIV_ZIP_DEBUG + ut_a(!page_zip || page_zip_validate(page_zip, page)); +#endif /* UNIV_ZIP_DEBUG */ + + if (UNIV_LIKELY_NULL(page_zip) + && !btr_cur_update_alloc_zip(page_zip, block, index, + new_rec_size, TRUE, mtr)) { + err = DB_ZIP_OVERFLOW; + goto err_exit; + } if (UNIV_UNLIKELY(new_rec_size >= (page_get_free_space_of_empty(page_is_comp(page)) / 2))) { - mem_heap_free(heap); - - return(DB_OVERFLOW); + err = DB_OVERFLOW; + goto err_exit; } - max_size = old_rec_size - + page_get_max_insert_size_after_reorganize(page, 1); - if (UNIV_UNLIKELY(page_get_data_size(page) - old_rec_size + new_rec_size < BTR_CUR_PAGE_COMPRESS_LIMIT)) { /* The page would become too empty */ - mem_heap_free(heap); - - return(DB_UNDERFLOW); + err = DB_UNDERFLOW; + goto err_exit; } + max_size = old_rec_size + + page_get_max_insert_size_after_reorganize(page, 1); + if (!(((max_size >= BTR_CUR_PAGE_REORGANIZE_LIMIT) && (max_size >= new_rec_size)) || (page_get_n_recs(page) <= 1))) { @@ -1675,65 +2097,68 @@ btr_cur_optimistic_update( reorganize: for simplicity, we decide what to do assuming a reorganization is needed, though it might not be necessary */ - mem_heap_free(heap); - - return(DB_OVERFLOW); + err = DB_OVERFLOW; + goto err_exit; } /* Do lock checking and undo logging */ - err = btr_cur_upd_lock_and_undo(flags, cursor, update, cmpl_info, thr, - &roll_ptr); + err = btr_cur_upd_lock_and_undo(flags, cursor, update, cmpl_info, + thr, mtr, &roll_ptr); if (err != DB_SUCCESS) { - mem_heap_free(heap); - - return(err); + goto err_exit; } /* Ok, we may do the replacement. Store on the page infimum the explicit locks on rec, before deleting rec (see the comment in - .._pessimistic_update). */ + btr_cur_pessimistic_update). */ - lock_rec_store_on_page_infimum(page, rec); + lock_rec_store_on_page_infimum(block, rec); btr_search_update_hash_on_delete(cursor); + /* The call to row_rec_to_index_entry(ROW_COPY_DATA, ...) above + invokes rec_offs_make_valid() to point to the copied record that + the fields of new_entry point to. We have to undo it here. */ + ut_ad(rec_offs_validate(NULL, index, offsets)); + rec_offs_make_valid(page_cur_get_rec(page_cursor), index, offsets); + page_cur_delete_rec(page_cursor, index, offsets, mtr); page_cur_move_to_prev(page_cursor); + trx = thr_get_trx(thr); + if (!(flags & BTR_KEEP_SYS_FLAG)) { row_upd_index_entry_sys_field(new_entry, index, DATA_ROLL_PTR, roll_ptr); row_upd_index_entry_sys_field(new_entry, index, DATA_TRX_ID, - thr_get_trx(thr)->id); + trx->id); } - rec = btr_cur_insert_if_possible(cursor, new_entry, &reorganized, mtr); - + /* There are no externally stored columns in new_entry */ + rec = btr_cur_insert_if_possible(cursor, new_entry, 0/*n_ext*/, mtr); ut_a(rec); /* <- We calculated above the insert would fit */ - if (!rec_get_deleted_flag(rec, page_is_comp(page))) { - /* The new inserted record owns its possible externally - stored fields */ - - offsets = rec_get_offsets(rec, index, offsets, - ULINT_UNDEFINED, &heap); - btr_cur_unmark_extern_fields(rec, mtr, offsets); + if (page_zip && !dict_index_is_clust(index) + && page_is_leaf(page)) { + /* Update the free bits in the insert buffer. */ + ibuf_update_free_bits_zip(block, mtr); } /* Restore the old explicit lock state on the record */ - lock_rec_restore_from_page_infimum(rec, page); + lock_rec_restore_from_page_infimum(block, rec, block); page_cur_move_to_next(page_cursor); + err = DB_SUCCESS; +err_exit: mem_heap_free(heap); - - return(DB_SUCCESS); + return(err); } -/***************************************************************** +/*************************************************************//** If, in a split, a new supremum record was created as the predecessor of the updated record, the supremum record must inherit exactly the locks on the updated record. In the split it may have inherited locks from the successor @@ -1743,15 +2168,17 @@ static void btr_cur_pess_upd_restore_supremum( /*==============================*/ - rec_t* rec, /* in: updated record */ - mtr_t* mtr) /* in: mtr */ + buf_block_t* block, /*!< in: buffer block of rec */ + const rec_t* rec, /*!< in: updated record */ + mtr_t* mtr) /*!< in: mtr */ { - page_t* page; - page_t* prev_page; - ulint space; - ulint prev_page_no; + page_t* page; + buf_block_t* prev_block; + ulint space; + ulint zip_size; + ulint prev_page_no; - page = buf_frame_align(rec); + page = buf_block_get_frame(block); if (page_rec_get_next(page_get_infimum_rec(page)) != rec) { /* Updated record is not the first user record on its page */ @@ -1759,98 +2186,111 @@ btr_cur_pess_upd_restore_supremum( return; } - space = buf_frame_get_space_id(page); + space = buf_block_get_space(block); + zip_size = buf_block_get_zip_size(block); prev_page_no = btr_page_get_prev(page, mtr); ut_ad(prev_page_no != FIL_NULL); - prev_page = buf_page_get_with_no_latch(space, prev_page_no, mtr); + prev_block = buf_page_get_with_no_latch(space, zip_size, + prev_page_no, mtr); #ifdef UNIV_BTR_DEBUG - ut_a(btr_page_get_next(prev_page, mtr) - == buf_frame_get_page_no(page)); + ut_a(btr_page_get_next(prev_block->frame, mtr) + == page_get_page_no(page)); #endif /* UNIV_BTR_DEBUG */ - /* We must already have an x-latch to prev_page! */ - ut_ad(mtr_memo_contains(mtr, buf_block_align(prev_page), - MTR_MEMO_PAGE_X_FIX)); + /* We must already have an x-latch on prev_block! */ + ut_ad(mtr_memo_contains(mtr, prev_block, MTR_MEMO_PAGE_X_FIX)); - lock_rec_reset_and_inherit_gap_locks(page_get_supremum_rec(prev_page), - rec); + lock_rec_reset_and_inherit_gap_locks(prev_block, block, + PAGE_HEAP_NO_SUPREMUM, + page_rec_get_heap_no(rec)); } -/***************************************************************** +/*************************************************************//** 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. We assume -here that the ordering fields of the record do not change. */ - +here that the ordering fields of the record do not change. +@return DB_SUCCESS or error code */ +UNIV_INTERN ulint btr_cur_pessimistic_update( /*=======================*/ - /* out: DB_SUCCESS or error code */ - ulint flags, /* in: undo logging, locking, and rollback + 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 + btr_cur_t* cursor, /*!< in: cursor on the record to update */ + mem_heap_t** heap, /*!< in/out: pointer to memory heap, or NULL */ + 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 + const 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 + ulint cmpl_info,/*!< in: compiler info on secondary index updates */ - que_thr_t* thr, /* in: query thread */ - mtr_t* mtr) /* in: mtr */ + que_thr_t* thr, /*!< in: query thread */ + mtr_t* mtr) /*!< in: mtr; must be committed before + latching any further pages */ { big_rec_t* big_rec_vec = NULL; big_rec_t* dummy_big_rec; dict_index_t* index; + buf_block_t* block; page_t* page; + page_zip_des_t* page_zip; rec_t* rec; page_cur_t* page_cursor; dtuple_t* new_entry; - mem_heap_t* heap; ulint err; ulint optim_err; - ibool dummy_reorganized; - dulint roll_ptr; + roll_ptr_t roll_ptr; trx_t* trx; ibool was_first; - ibool success; ulint n_extents = 0; ulint n_reserved; - ulint* ext_vect; - ulint n_ext_vect; - ulint reserve_flag; + ulint n_ext; ulint* offsets = NULL; *big_rec = NULL; - page = btr_cur_get_page(cursor); + block = btr_cur_get_block(cursor); + page = buf_block_get_frame(block); + page_zip = buf_block_get_page_zip(block); rec = btr_cur_get_rec(cursor); index = cursor->index; ut_ad(mtr_memo_contains(mtr, dict_index_get_lock(index), MTR_MEMO_X_LOCK)); - ut_ad(mtr_memo_contains(mtr, buf_block_align(page), - MTR_MEMO_PAGE_X_FIX)); + ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX)); +#ifdef UNIV_ZIP_DEBUG + ut_a(!page_zip || page_zip_validate(page_zip, page)); +#endif /* UNIV_ZIP_DEBUG */ + /* The insert buffer tree should never be updated in place. */ + ut_ad(!dict_index_is_ibuf(index)); optim_err = btr_cur_optimistic_update(flags, cursor, update, cmpl_info, thr, mtr); - if (optim_err != DB_UNDERFLOW && optim_err != DB_OVERFLOW) { - + switch (optim_err) { + case DB_UNDERFLOW: + case DB_OVERFLOW: + case DB_ZIP_OVERFLOW: + break; + default: return(optim_err); } /* Do lock checking and undo logging */ err = btr_cur_upd_lock_and_undo(flags, cursor, update, cmpl_info, - thr, &roll_ptr); + thr, mtr, &roll_ptr); if (err != DB_SUCCESS) { return(err); } if (optim_err == DB_OVERFLOW) { + ulint reserve_flag; + /* First reserve enough free space for the file segments of the index tree, so that the update will not fail because of lack of space */ @@ -1863,25 +2303,35 @@ btr_cur_pessimistic_update( reserve_flag = FSP_NORMAL; } - success = fsp_reserve_free_extents(&n_reserved, index->space, - n_extents, - reserve_flag, mtr); - if (!success) { - err = DB_OUT_OF_FILE_SPACE; - - return(err); + if (!fsp_reserve_free_extents(&n_reserved, index->space, + n_extents, reserve_flag, mtr)) { + return(DB_OUT_OF_FILE_SPACE); } } - heap = mem_heap_create(1024); - offsets = rec_get_offsets(rec, index, NULL, ULINT_UNDEFINED, &heap); + if (!*heap) { + *heap = mem_heap_create(1024); + } + offsets = rec_get_offsets(rec, index, NULL, ULINT_UNDEFINED, heap); trx = thr_get_trx(thr); - new_entry = row_rec_to_index_entry(ROW_COPY_DATA, index, rec, heap); - + new_entry = row_rec_to_index_entry(ROW_COPY_DATA, rec, index, offsets, + &n_ext, *heap); + /* The call to row_rec_to_index_entry(ROW_COPY_DATA, ...) above + invokes rec_offs_make_valid() to point to the copied record that + the fields of new_entry point to. We have to undo it here. */ + ut_ad(rec_offs_validate(NULL, index, offsets)); + rec_offs_make_valid(rec, index, offsets); + + /* The page containing the clustered index record + corresponding to new_entry is latched in mtr. If the + clustered index record is delete-marked, then its externally + stored fields cannot have been purged yet, because then the + purge would also have removed the clustered index record + itself. Thus the following call is safe. */ row_upd_index_replace_new_col_vals_index_pos(new_entry, index, update, - FALSE, heap); + FALSE, *heap); if (!(flags & BTR_KEEP_SYS_FLAG)) { row_upd_index_entry_sys_field(new_entry, index, DATA_ROLL_PTR, roll_ptr); @@ -1889,7 +2339,7 @@ btr_cur_pessimistic_update( trx->id); } - if (flags & BTR_NO_UNDO_LOG_FLAG) { + if ((flags & BTR_NO_UNDO_LOG_FLAG) && rec_offs_any_extern(offsets)) { /* We are in a transaction rollback undoing a row update: we must free possible externally stored fields which got new values in the update, if they are not @@ -1897,38 +2347,42 @@ btr_cur_pessimistic_update( updated the primary key to another value, and then update it back again. */ - ut_a(big_rec_vec == NULL); + ut_ad(big_rec_vec == NULL); - btr_rec_free_updated_extern_fields(index, rec, offsets, - update, TRUE, mtr); + btr_rec_free_updated_extern_fields( + index, rec, page_zip, offsets, update, + trx_is_recv(trx) ? RB_RECOVERY : RB_NORMAL, mtr); } /* We have to set appropriate extern storage bits in the new record to be inserted: we have to remember which fields were such */ - ext_vect = mem_heap_alloc(heap, sizeof(ulint) - * dict_index_get_n_fields(index)); ut_ad(!page_is_comp(page) || !rec_get_node_ptr_flag(rec)); - offsets = rec_get_offsets(rec, index, offsets, - ULINT_UNDEFINED, &heap); - n_ext_vect = btr_push_update_extern_fields(ext_vect, offsets, update); - - if (UNIV_UNLIKELY(rec_get_converted_size(index, new_entry) - >= ut_min(page_get_free_space_of_empty( - page_is_comp(page)) / 2, - REC_MAX_DATA_SIZE))) { - - big_rec_vec = dtuple_convert_big_rec(index, new_entry, - ext_vect, n_ext_vect); - if (big_rec_vec == NULL) { + offsets = rec_get_offsets(rec, index, offsets, ULINT_UNDEFINED, heap); + n_ext += btr_push_update_extern_fields(new_entry, update, *heap); + + if (UNIV_LIKELY_NULL(page_zip)) { + ut_ad(page_is_comp(page)); + if (page_zip_rec_needs_ext( + rec_get_converted_size(index, new_entry, n_ext), + TRUE, + dict_index_get_n_fields(index), + page_zip_get_size(page_zip))) { + + goto make_external; + } + } else if (page_zip_rec_needs_ext( + rec_get_converted_size(index, new_entry, n_ext), + page_is_comp(page), 0, 0)) { +make_external: + big_rec_vec = dtuple_convert_big_rec(index, new_entry, &n_ext); + if (UNIV_UNLIKELY(big_rec_vec == NULL)) { err = DB_TOO_BIG_RECORD; goto return_after_reservations; } } - page_cursor = btr_cur_get_page_cur(cursor); - /* Store state of explicit locks on rec on the page infimum record, before deleting rec. The page infimum acts as a dummy carrier of the locks, taking care also of lock releases, before we can move the locks @@ -1938,70 +2392,103 @@ btr_cur_pessimistic_update( delete the lock structs set on the root page even if the root page carries just node pointers. */ - lock_rec_store_on_page_infimum(buf_frame_align(rec), rec); + lock_rec_store_on_page_infimum(block, rec); btr_search_update_hash_on_delete(cursor); +#ifdef UNIV_ZIP_DEBUG + ut_a(!page_zip || page_zip_validate(page_zip, page)); +#endif /* UNIV_ZIP_DEBUG */ + page_cursor = btr_cur_get_page_cur(cursor); + page_cur_delete_rec(page_cursor, index, offsets, mtr); page_cur_move_to_prev(page_cursor); - rec = btr_cur_insert_if_possible(cursor, new_entry, - &dummy_reorganized, mtr); - ut_a(rec || optim_err != DB_UNDERFLOW); + rec = btr_cur_insert_if_possible(cursor, new_entry, n_ext, mtr); if (rec) { - lock_rec_restore_from_page_infimum(rec, page); - rec_set_field_extern_bits(rec, index, - ext_vect, n_ext_vect, mtr); + lock_rec_restore_from_page_infimum(btr_cur_get_block(cursor), + rec, block); offsets = rec_get_offsets(rec, index, offsets, - ULINT_UNDEFINED, &heap); + ULINT_UNDEFINED, heap); if (!rec_get_deleted_flag(rec, rec_offs_comp(offsets))) { /* The new inserted record owns its possible externally stored fields */ - btr_cur_unmark_extern_fields(rec, mtr, offsets); + btr_cur_unmark_extern_fields(page_zip, + rec, index, offsets, mtr); } btr_cur_compress_if_useful(cursor, mtr); + if (page_zip && !dict_index_is_clust(index) + && page_is_leaf(page)) { + /* Update the free bits in the insert buffer. */ + ibuf_update_free_bits_zip(block, mtr); + } + err = DB_SUCCESS; goto return_after_reservations; - } - - if (page_cur_is_before_first(page_cursor)) { - /* The record to be updated was positioned as the first user - record on its page */ - - was_first = TRUE; } else { - was_first = FALSE; + ut_a(optim_err != DB_UNDERFLOW); + + /* Out of space: reset the free bits. */ + if (!dict_index_is_clust(index) + && page_is_leaf(page)) { + ibuf_reset_free_bits(block); + } } - /* The first parameter means that no lock checking and undo logging - is made in the insert */ + /* Was the record to be updated positioned as the first user + record on its page? */ + was_first = page_cur_is_before_first(page_cursor); + + /* Lock checks and undo logging were already performed by + btr_cur_upd_lock_and_undo(). */ err = btr_cur_pessimistic_insert(BTR_NO_UNDO_LOG_FLAG | BTR_NO_LOCKING_FLAG | BTR_KEEP_SYS_FLAG, cursor, new_entry, &rec, - &dummy_big_rec, NULL, mtr); + &dummy_big_rec, n_ext, NULL, mtr); ut_a(rec); ut_a(err == DB_SUCCESS); ut_a(dummy_big_rec == NULL); - rec_set_field_extern_bits(rec, index, ext_vect, n_ext_vect, mtr); - offsets = rec_get_offsets(rec, index, offsets, ULINT_UNDEFINED, &heap); + if (dict_index_is_sec_or_ibuf(index)) { + /* Update PAGE_MAX_TRX_ID in the index page header. + It was not updated by btr_cur_pessimistic_insert() + because of BTR_NO_LOCKING_FLAG. */ + buf_block_t* rec_block; + + rec_block = btr_cur_get_block(cursor); + + page_update_max_trx_id(rec_block, + buf_block_get_page_zip(rec_block), + trx->id, mtr); + } if (!rec_get_deleted_flag(rec, rec_offs_comp(offsets))) { /* The new inserted record owns its possible externally stored fields */ + buf_block_t* rec_block = btr_cur_get_block(cursor); + +#ifdef UNIV_ZIP_DEBUG + ut_a(!page_zip || page_zip_validate(page_zip, page)); + page = buf_block_get_frame(rec_block); +#endif /* UNIV_ZIP_DEBUG */ + page_zip = buf_block_get_page_zip(rec_block); - btr_cur_unmark_extern_fields(rec, mtr, offsets); + offsets = rec_get_offsets(rec, index, offsets, + ULINT_UNDEFINED, heap); + btr_cur_unmark_extern_fields(page_zip, + rec, index, offsets, mtr); } - lock_rec_restore_from_page_infimum(rec, page); + lock_rec_restore_from_page_infimum(btr_cur_get_block(cursor), + rec, block); /* If necessary, restore also the correct lock state for a new, preceding supremum record created in a page split. While the old @@ -2009,11 +2496,14 @@ btr_cur_pessimistic_update( from a wrong record. */ if (!was_first) { - btr_cur_pess_upd_restore_supremum(rec, mtr); + btr_cur_pess_upd_restore_supremum(btr_cur_get_block(cursor), + rec, mtr); } return_after_reservations: - mem_heap_free(heap); +#ifdef UNIV_ZIP_DEBUG + ut_a(!page_zip || page_zip_validate(page_zip, page)); +#endif /* UNIV_ZIP_DEBUG */ if (n_extents > 0) { fil_space_release_free_extents(index->space, n_reserved); @@ -2026,20 +2516,20 @@ return_after_reservations: /*==================== B-TREE DELETE MARK AND UNMARK ===============*/ -/******************************************************************** +/****************************************************************//** Writes the redo log record for delete marking or unmarking of an index record. */ UNIV_INLINE void btr_cur_del_mark_set_clust_rec_log( /*===============================*/ - ulint flags, /* in: flags */ - rec_t* rec, /* in: record */ - dict_index_t* index, /* in: index of the record */ - ibool val, /* in: value to set */ - trx_t* trx, /* in: deleting transaction */ - dulint roll_ptr,/* in: roll ptr to the undo log record */ - mtr_t* mtr) /* in: mtr */ + ulint flags, /*!< in: flags */ + rec_t* rec, /*!< in: record */ + dict_index_t* index, /*!< in: index of the record */ + ibool val, /*!< in: value to set */ + trx_t* trx, /*!< in: deleting transaction */ + roll_ptr_t roll_ptr,/*!< in: roll ptr to the undo log record */ + mtr_t* mtr) /*!< in: mtr */ { byte* log_ptr; ut_ad(flags < 256); @@ -2071,27 +2561,29 @@ btr_cur_del_mark_set_clust_rec_log( mlog_close(mtr, log_ptr); } +#endif /* !UNIV_HOTBACKUP */ -/******************************************************************** +/****************************************************************//** Parses the redo log record for delete marking or unmarking of a clustered -index record. */ - +index record. +@return end of log record or NULL */ +UNIV_INTERN 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 */ + byte* ptr, /*!< in: buffer */ + byte* end_ptr,/*!< in: buffer end */ + page_t* page, /*!< in/out: page or NULL */ + page_zip_des_t* page_zip,/*!< in/out: compressed page, or NULL */ + dict_index_t* index) /*!< in: index corresponding to page */ { - ulint flags; - ulint val; - ulint pos; - dulint trx_id; - dulint roll_ptr; - ulint offset; - rec_t* rec; + ulint flags; + ulint val; + ulint pos; + trx_id_t trx_id; + roll_ptr_t roll_ptr; + ulint offset; + rec_t* rec; ut_ad(!page || !!page_is_comp(page) == dict_table_is_comp(index->table)); @@ -2126,62 +2618,62 @@ btr_cur_parse_del_mark_set_clust_rec( if (page) { rec = page + offset; + /* We do not need to reserve btr_search_latch, as the page + is only being recovered, and there cannot be a hash index to + it. Besides, these fields are being updated in place + and the adaptive hash index does not depend on them. */ + + btr_rec_set_deleted_flag(rec, page_zip, val); + if (!(flags & BTR_KEEP_SYS_FLAG)) { mem_heap_t* heap = NULL; ulint offsets_[REC_OFFS_NORMAL_SIZE]; - *offsets_ = (sizeof offsets_) / sizeof *offsets_; + rec_offs_init(offsets_); row_upd_rec_sys_fields_in_recovery( - rec, rec_get_offsets(rec, index, offsets_, - ULINT_UNDEFINED, &heap), + rec, page_zip, + rec_get_offsets(rec, index, offsets_, + ULINT_UNDEFINED, &heap), pos, trx_id, roll_ptr); if (UNIV_LIKELY_NULL(heap)) { mem_heap_free(heap); } } - - /* We do not need to reserve btr_search_latch, as the page - is only being recovered, and there cannot be a hash index to - it. */ - - rec_set_deleted_flag(rec, page_is_comp(page), val); } return(ptr); } -/*************************************************************** +#ifndef UNIV_HOTBACKUP +/***********************************************************//** 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. */ - +undo log record created. +@return DB_SUCCESS, DB_LOCK_WAIT, or error number */ +UNIV_INTERN 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 */ + ulint flags, /*!< in: undo logging and locking flags */ + buf_block_t* block, /*!< in/out: buffer block of the record */ + rec_t* rec, /*!< in/out: record */ + dict_index_t* index, /*!< in: clustered index of the record */ + const ulint* offsets,/*!< in: rec_get_offsets(rec) */ + ibool val, /*!< in: value to set */ + que_thr_t* thr, /*!< in: query thread */ + mtr_t* mtr) /*!< in: mtr */ { - dict_index_t* index; - buf_block_t* block; - dulint roll_ptr; + roll_ptr_t roll_ptr; ulint err; - rec_t* rec; + page_zip_des_t* page_zip; trx_t* trx; - mem_heap_t* heap = NULL; - ulint offsets_[REC_OFFS_NORMAL_SIZE]; - ulint* offsets = offsets_; - *offsets_ = (sizeof offsets_) / sizeof *offsets_; - rec = btr_cur_get_rec(cursor); - index = cursor->index; + ut_ad(dict_index_is_clust(index)); + ut_ad(rec_offs_validate(rec, index, offsets)); ut_ad(!!page_rec_is_comp(rec) == dict_table_is_comp(index->table)); - offsets = rec_get_offsets(rec, index, offsets, ULINT_UNDEFINED, &heap); + ut_ad(buf_block_get_frame(block) == page_align(rec)); + ut_ad(page_is_leaf(page_align(rec))); #ifdef UNIV_DEBUG if (btr_cur_print_record_ops && thr) { @@ -2190,17 +2682,14 @@ btr_cur_del_mark_set_clust_rec( } #endif /* UNIV_DEBUG */ - ut_ad(index->type & DICT_CLUSTERED); + ut_ad(dict_index_is_clust(index)); ut_ad(!rec_get_deleted_flag(rec, rec_offs_comp(offsets))); - err = lock_clust_rec_modify_check_and_lock(flags, + err = lock_clust_rec_modify_check_and_lock(flags, block, rec, index, offsets, thr); if (err != DB_SUCCESS) { - if (UNIV_LIKELY_NULL(heap)) { - mem_heap_free(heap); - } return(err); } @@ -2209,48 +2698,41 @@ btr_cur_del_mark_set_clust_rec( &roll_ptr); if (err != DB_SUCCESS) { - if (UNIV_LIKELY_NULL(heap)) { - mem_heap_free(heap); - } return(err); } - block = buf_block_align(rec); + /* The btr_search_latch is not needed here, because + the adaptive hash index does not depend on the delete-mark + and the delete-mark is being updated in place. */ - if (block->is_hashed) { - rw_lock_x_lock(&btr_search_latch); - } + page_zip = buf_block_get_page_zip(block); - rec_set_deleted_flag(rec, rec_offs_comp(offsets), val); + btr_blob_dbg_set_deleted_flag(rec, index, offsets, val); + btr_rec_set_deleted_flag(rec, page_zip, val); trx = thr_get_trx(thr); if (!(flags & BTR_KEEP_SYS_FLAG)) { - row_upd_rec_sys_fields(rec, index, offsets, trx, roll_ptr); - } - - if (block->is_hashed) { - rw_lock_x_unlock(&btr_search_latch); + row_upd_rec_sys_fields(rec, page_zip, + index, offsets, trx, roll_ptr); } btr_cur_del_mark_set_clust_rec_log(flags, rec, index, val, trx, roll_ptr, mtr); - if (UNIV_LIKELY_NULL(heap)) { - mem_heap_free(heap); - } - return(DB_SUCCESS); + + return(err); } -/******************************************************************** +/****************************************************************//** Writes the redo log record for a delete mark setting of a secondary index record. */ UNIV_INLINE void btr_cur_del_mark_set_sec_rec_log( /*=============================*/ - rec_t* rec, /* in: record */ - ibool val, /* in: value to set */ - mtr_t* mtr) /* in: mtr */ + rec_t* rec, /*!< in: record */ + ibool val, /*!< in: value to set */ + mtr_t* mtr) /*!< in: mtr */ { byte* log_ptr; ut_ad(val <= 1); @@ -2273,18 +2755,20 @@ btr_cur_del_mark_set_sec_rec_log( mlog_close(mtr, log_ptr); } +#endif /* !UNIV_HOTBACKUP */ -/******************************************************************** +/****************************************************************//** Parses the redo log record for delete marking or unmarking of a secondary -index record. */ - +index record. +@return end of log record or NULL */ +UNIV_INTERN 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 */ + byte* ptr, /*!< in: buffer */ + byte* end_ptr,/*!< in: buffer end */ + page_t* page, /*!< in/out: page or NULL */ + page_zip_des_t* page_zip)/*!< in/out: compressed page, or NULL */ { ulint val; ulint offset; @@ -2308,32 +2792,34 @@ btr_cur_parse_del_mark_set_sec_rec( /* We do not need to reserve btr_search_latch, as the page is only being recovered, and there cannot be a hash index to - it. */ + it. Besides, the delete-mark flag is being updated in place + and the adaptive hash index does not depend on it. */ - rec_set_deleted_flag(rec, page_is_comp(page), val); + btr_rec_set_deleted_flag(rec, page_zip, val); } return(ptr); } -/*************************************************************** -Sets a secondary index record delete mark to TRUE or FALSE. */ - +#ifndef UNIV_HOTBACKUP +/***********************************************************//** +Sets a secondary index record delete mark to TRUE or FALSE. +@return DB_SUCCESS, DB_LOCK_WAIT, or error number */ +UNIV_INTERN 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 */ + 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 */ { buf_block_t* block; rec_t* rec; ulint err; + block = btr_cur_get_block(cursor); rec = btr_cur_get_rec(cursor); #ifdef UNIV_DEBUG @@ -2344,141 +2830,114 @@ btr_cur_del_mark_set_sec_rec( } #endif /* UNIV_DEBUG */ - err = lock_sec_rec_modify_check_and_lock(flags, rec, cursor->index, - thr); + err = lock_sec_rec_modify_check_and_lock(flags, + btr_cur_get_block(cursor), + rec, cursor->index, thr, mtr); if (err != DB_SUCCESS) { return(err); } - block = buf_block_align(rec); - ut_ad(!!page_is_comp(buf_block_get_frame(block)) + ut_ad(!!page_rec_is_comp(rec) == dict_table_is_comp(cursor->index->table)); - if (block->is_hashed) { - rw_lock_x_lock(&btr_search_latch); - } - - rec_set_deleted_flag(rec, page_is_comp(buf_block_get_frame(block)), - val); - - if (block->is_hashed) { - rw_lock_x_unlock(&btr_search_latch); - } + /* We do not need to reserve btr_search_latch, as the + delete-mark flag is being updated in place and the adaptive + hash index does not depend on it. */ + btr_rec_set_deleted_flag(rec, buf_block_get_page_zip(block), val); btr_cur_del_mark_set_sec_rec_log(rec, val, mtr); return(DB_SUCCESS); } -/*************************************************************** -Sets a secondary index record delete mark to FALSE. This function is only -used by the insert buffer insert merge mechanism. */ - +/***********************************************************//** +Sets a secondary index record's delete mark to the given value. This +function is only used by the insert buffer merge mechanism. */ +UNIV_INTERN void -btr_cur_del_unmark_for_ibuf( -/*========================*/ - rec_t* rec, /* in: record to delete unmark */ - mtr_t* mtr) /* in: mtr */ +btr_cur_set_deleted_flag_for_ibuf( +/*==============================*/ + rec_t* rec, /*!< in/out: record */ + page_zip_des_t* page_zip, /*!< in/out: compressed page + corresponding to rec, or NULL + when the tablespace is + uncompressed */ + ibool val, /*!< in: value to set */ + mtr_t* mtr) /*!< in: mtr */ { - /* We do not need to reserve btr_search_latch, as the page has just - been read to the buffer pool and there cannot be a hash index to it. */ + /* We do not need to reserve btr_search_latch, as the page + has just been read to the buffer pool and there cannot be + a hash index to it. Besides, the delete-mark flag is being + updated in place and the adaptive hash index does not depend + on it. */ - rec_set_deleted_flag(rec, page_is_comp(buf_frame_align(rec)), FALSE); + btr_rec_set_deleted_flag(rec, page_zip, val); - btr_cur_del_mark_set_sec_rec_log(rec, FALSE, mtr); + btr_cur_del_mark_set_sec_rec_log(rec, val, mtr); } /*==================== B-TREE RECORD REMOVE =========================*/ -/***************************************************************** -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 */ -{ - ut_ad(mtr_memo_contains(mtr, - dict_index_get_lock(btr_cur_get_index(cursor)), - MTR_MEMO_X_LOCK)); - ut_ad(mtr_memo_contains(mtr, buf_block_align(btr_cur_get_rec(cursor)), - MTR_MEMO_PAGE_X_FIX)); - ut_ad(btr_page_get_level(btr_cur_get_page(cursor), mtr) == 0); - - btr_compress(cursor, 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! */ - +free extents so that the compression will always succeed if done! +@return TRUE if compression occurred */ +UNIV_INTERN ibool btr_cur_compress_if_useful( /*=======================*/ - /* out: TRUE if compression occurred */ - btr_cur_t* cursor, /* in: cursor on the page to compress; + btr_cur_t* cursor, /*!< in: cursor on the page to compress; cursor does not stay valid if compression occurs */ - mtr_t* mtr) /* in: mtr */ + mtr_t* mtr) /*!< in: mtr */ { ut_ad(mtr_memo_contains(mtr, dict_index_get_lock(btr_cur_get_index(cursor)), MTR_MEMO_X_LOCK)); - ut_ad(mtr_memo_contains(mtr, buf_block_align(btr_cur_get_rec(cursor)), + ut_ad(mtr_memo_contains(mtr, btr_cur_get_block(cursor), MTR_MEMO_PAGE_X_FIX)); - if (btr_cur_compress_recommendation(cursor, mtr)) { - - btr_compress(cursor, mtr); - - return(TRUE); - } - - return(FALSE); + return(btr_cur_compress_recommendation(cursor, mtr) + && btr_compress(cursor, mtr)); } -/*********************************************************** +/*******************************************************//** Removes the record on which the tree cursor is positioned on a leaf page. 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. */ - +positioned, but no latch on the whole tree. +@return TRUE if success, i.e., the page did not become too empty */ +UNIV_INTERN 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 leaf page, on the record to + btr_cur_t* cursor, /*!< in: cursor on leaf page, 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 */ + mtr_t* mtr) /*!< in: mtr; if this function returns + TRUE on a leaf page of a secondary + index, the mtr must be committed + before latching any further pages */ { - page_t* page; - ulint max_ins_size; + buf_block_t* block; rec_t* rec; mem_heap_t* heap = NULL; ulint offsets_[REC_OFFS_NORMAL_SIZE]; ulint* offsets = offsets_; ibool no_compress_needed; - *offsets_ = (sizeof offsets_) / sizeof *offsets_; + rec_offs_init(offsets_); - ut_ad(mtr_memo_contains(mtr, buf_block_align(btr_cur_get_rec(cursor)), + ut_ad(mtr_memo_contains(mtr, btr_cur_get_block(cursor), MTR_MEMO_PAGE_X_FIX)); /* This is intended only for leaf page deletions */ - page = btr_cur_get_page(cursor); + block = btr_cur_get_block(cursor); - ut_ad(btr_page_get_level(page, mtr) == 0); + ut_ad(page_is_leaf(buf_block_get_frame(block))); rec = btr_cur_get_rec(cursor); offsets = rec_get_offsets(rec, cursor->index, offsets, @@ -2490,17 +2949,39 @@ btr_cur_optimistic_delete( if (no_compress_needed) { - lock_update_delete(rec); + page_t* page = buf_block_get_frame(block); + page_zip_des_t* page_zip= buf_block_get_page_zip(block); + ulint max_ins = 0; + + lock_update_delete(block, rec); btr_search_update_hash_on_delete(cursor); - max_ins_size = page_get_max_insert_size_after_reorganize( - page, 1); + if (!page_zip) { + max_ins = page_get_max_insert_size_after_reorganize( + page, 1); + } +#ifdef UNIV_ZIP_DEBUG + ut_a(!page_zip || page_zip_validate(page_zip, page)); +#endif /* UNIV_ZIP_DEBUG */ page_cur_delete_rec(btr_cur_get_page_cur(cursor), cursor->index, offsets, mtr); - - ibuf_update_free_bits_low(cursor->index, page, max_ins_size, - mtr); +#ifdef UNIV_ZIP_DEBUG + ut_a(!page_zip || page_zip_validate(page_zip, page)); +#endif /* UNIV_ZIP_DEBUG */ + + if (dict_index_is_clust(cursor->index) + || dict_index_is_ibuf(cursor->index) + || !page_is_leaf(page)) { + /* The insert buffer does not handle + inserts to clustered indexes, to + non-leaf pages of secondary index B-trees, + or to the insert buffer. */ + } else if (page_zip) { + ibuf_update_free_bits_zip(block, mtr); + } else { + ibuf_update_free_bits_low(block, max_ins, mtr); + } } if (UNIV_LIKELY_NULL(heap)) { @@ -2510,35 +2991,37 @@ btr_cur_optimistic_delete( return(no_compress_needed); } -/***************************************************************** +/*************************************************************//** 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. */ - +exist. +@return TRUE if compression occurred */ +UNIV_INTERN ibool btr_cur_pessimistic_delete( /*=======================*/ - /* out: TRUE if compression occurred */ - ulint* err, /* out: DB_SUCCESS or DB_OUT_OF_FILE_SPACE; + 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 + 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; + 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 */ + enum trx_rb_ctx rb_ctx, /*!< in: rollback context */ + mtr_t* mtr) /*!< in: mtr */ { + buf_block_t* block; page_t* page; + page_zip_des_t* page_zip; dict_index_t* index; rec_t* rec; dtuple_t* node_ptr; @@ -2550,13 +3033,13 @@ btr_cur_pessimistic_delete( mem_heap_t* heap; ulint* offsets; - page = btr_cur_get_page(cursor); + block = btr_cur_get_block(cursor); + page = buf_block_get_frame(block); index = btr_cur_get_index(cursor); ut_ad(mtr_memo_contains(mtr, dict_index_get_lock(index), MTR_MEMO_X_LOCK)); - ut_ad(mtr_memo_contains(mtr, buf_block_align(page), - MTR_MEMO_PAGE_X_FIX)); + ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX)); if (!has_reserved_extents) { /* First reserve enough free space for the file segments of the index tree, so that the node pointer updates will @@ -2577,23 +3060,25 @@ btr_cur_pessimistic_delete( heap = mem_heap_create(1024); rec = btr_cur_get_rec(cursor); + page_zip = buf_block_get_page_zip(block); +#ifdef UNIV_ZIP_DEBUG + ut_a(!page_zip || page_zip_validate(page_zip, page)); +#endif /* UNIV_ZIP_DEBUG */ offsets = rec_get_offsets(rec, index, NULL, ULINT_UNDEFINED, &heap); - /* Free externally stored fields if the record is neither - a node pointer nor in two-byte format. - This avoids an unnecessary loop. */ - if (page_is_comp(page) - ? !rec_get_node_ptr_flag(rec) - : !rec_get_1byte_offs_flag(rec)) { + if (rec_offs_any_extern(offsets)) { btr_rec_free_externally_stored_fields(index, - rec, offsets, - in_rollback, mtr); + rec, offsets, page_zip, + rb_ctx, mtr); +#ifdef UNIV_ZIP_DEBUG + ut_a(!page_zip || page_zip_validate(page_zip, page)); +#endif /* UNIV_ZIP_DEBUG */ } if (UNIV_UNLIKELY(page_get_n_recs(page) < 2) - && UNIV_UNLIKELY(dict_index_get_page(btr_cur_get_index(cursor)) - != buf_frame_get_page_no(page))) { + && UNIV_UNLIKELY(dict_index_get_page(index) + != buf_block_get_page_no(block))) { /* If there is only one record, drop the whole page in btr_discard_page, if this is not the root page */ @@ -2606,7 +3091,7 @@ btr_cur_pessimistic_delete( goto return_after_reservations; } - lock_update_delete(rec); + lock_update_delete(block, rec); level = btr_page_get_level(page, mtr); if (level > 0 @@ -2621,18 +3106,22 @@ btr_cur_pessimistic_delete( non-leaf level, we must mark the new leftmost node pointer as the predefined minimum record */ - btr_set_min_rec_mark(next_rec, page_is_comp(page), - mtr); + /* This will make page_zip_validate() fail until + page_cur_delete_rec() completes. This is harmless, + because everything will take place within a single + mini-transaction and because writing to the redo log + is an atomic operation (performed by mtr_commit()). */ + btr_set_min_rec_mark(next_rec, mtr); } else { /* Otherwise, if we delete the leftmost node pointer on a page, we have to change the father node pointer so that it is equal to the new leftmost node pointer on the page */ - btr_node_ptr_delete(index, page, mtr); + btr_node_ptr_delete(index, block, mtr); node_ptr = dict_index_build_node_ptr( - index, next_rec, buf_frame_get_page_no(page), + index, next_rec, buf_block_get_page_no(block), heap, level); btr_insert_on_non_leaf_level(index, @@ -2643,8 +3132,11 @@ btr_cur_pessimistic_delete( btr_search_update_hash_on_delete(cursor); page_cur_delete_rec(btr_cur_get_page_cur(cursor), index, offsets, mtr); +#ifdef UNIV_ZIP_DEBUG + ut_a(!page_zip || page_zip_validate(page_zip, page)); +#endif /* UNIV_ZIP_DEBUG */ - ut_ad(btr_check_node_ptr(index, page, mtr)); + ut_ad(btr_check_node_ptr(index, block, mtr)); *err = DB_SUCCESS; @@ -2662,20 +3154,21 @@ return_after_reservations: return(ret); } -/*********************************************************************** +/*******************************************************************//** Adds path information to the cursor for the current page, for which the binary search has been performed. */ static void btr_cur_add_path_info( /*==================*/ - btr_cur_t* cursor, /* in: cursor positioned on a page */ - ulint height, /* in: height of the page in tree; + btr_cur_t* cursor, /*!< in: cursor positioned on a page */ + ulint height, /*!< in: height of the page in tree; 0 means leaf node */ - ulint root_height) /* in: root node height in tree */ + ulint root_height) /*!< in: root node height in tree */ { btr_path_t* slot; rec_t* rec; + page_t* page; ut_a(cursor->path_arr); @@ -2698,22 +3191,182 @@ btr_cur_add_path_info( slot = cursor->path_arr + (root_height - height); + page = page_align(rec); + slot->nth_rec = page_rec_get_n_recs_before(rec); - slot->n_recs = page_get_n_recs(buf_frame_align(rec)); + slot->n_recs = page_get_n_recs(page); + slot->page_no = page_get_page_no(page); + slot->page_level = btr_page_get_level_low(page); } -/*********************************************************************** -Estimates the number of rows in a given index range. */ +/*******************************************************************//** +Estimate the number of rows between slot1 and slot2 for any level on a +B-tree. This function starts from slot1->page and reads a few pages to +the right, counting their records. If we reach slot2->page quickly then +we know exactly how many records there are between slot1 and slot2 and +we set is_n_rows_exact to TRUE. If we cannot reach slot2->page quickly +then we calculate the average number of records in the pages scanned +so far and assume that all pages that we did not scan up to slot2->page +contain the same number of records, then we multiply that average to +the number of pages between slot1->page and slot2->page (which is +n_rows_on_prev_level). In this case we set is_n_rows_exact to FALSE. +@return number of rows (exact or estimated) */ +static +ib_int64_t +btr_estimate_n_rows_in_range_on_level( +/*==================================*/ + dict_index_t* index, /*!< in: index */ + btr_path_t* slot1, /*!< in: left border */ + btr_path_t* slot2, /*!< in: right border */ + ib_int64_t n_rows_on_prev_level, /*!< in: number of rows + on the previous level for the + same descend paths; used to + determine the numbe of pages + on this level */ + ibool* is_n_rows_exact) /*!< out: TRUE if the returned + value is exact i.e. not an + estimation */ +{ + ulint space; + ib_int64_t n_rows; + ulint n_pages_read; + ulint page_no; + ulint zip_size; + ulint level; + + space = dict_index_get_space(index); + + n_rows = 0; + n_pages_read = 0; + + /* Assume by default that we will scan all pages between + slot1->page_no and slot2->page_no */ + *is_n_rows_exact = TRUE; + + /* add records from slot1->page_no which are to the right of + the record which serves as a left border of the range, if any */ + if (slot1->nth_rec < slot1->n_recs) { + n_rows += slot1->n_recs - slot1->nth_rec; + } + + /* add records from slot2->page_no which are to the left of + the record which servers as a right border of the range, if any */ + if (slot2->nth_rec > 1) { + n_rows += slot2->nth_rec - 1; + } + + /* count the records in the pages between slot1->page_no and + slot2->page_no (non inclusive), if any */ + + zip_size = fil_space_get_zip_size(space); + + /* Do not read more than this number of pages in order not to hurt + performance with this code which is just an estimation. If we read + this many pages before reaching slot2->page_no then we estimate the + average from the pages scanned so far */ +# define N_PAGES_READ_LIMIT 10 + + page_no = slot1->page_no; + level = slot1->page_level; + + do { + mtr_t mtr; + page_t* page; + buf_block_t* block; + + mtr_start(&mtr); + + /* Fetch the page. Because we are not holding the + index->lock, the tree may have changed and we may be + attempting to read a page that is no longer part of + the B-tree. We pass BUF_GET_POSSIBLY_FREED in order to + silence a debug assertion about this. */ + block = buf_page_get_gen(space, zip_size, page_no, RW_S_LATCH, + NULL, BUF_GET_POSSIBLY_FREED, + __FILE__, __LINE__, &mtr); + + page = buf_block_get_frame(block); + + /* It is possible that the tree has been reorganized in the + meantime and this is a different page. If this happens the + calculated estimate will be bogus, which is not fatal as + this is only an estimate. We are sure that a page with + page_no exists because InnoDB never frees pages, only + reuses them. */ + if (fil_page_get_type(page) != FIL_PAGE_INDEX + || btr_page_get_index_id(page) != index->id + || btr_page_get_level_low(page) != level) { + + /* The page got reused for something else */ + mtr_commit(&mtr); + goto inexact; + } + + /* It is possible but highly unlikely that the page was + originally written by an old version of InnoDB that did + not initialize FIL_PAGE_TYPE on other than B-tree pages. + For example, this could be an almost-empty BLOB page + that happens to contain the magic values in the fields + that we checked above. */ + + n_pages_read++; + + if (page_no != slot1->page_no) { + /* Do not count the records on slot1->page_no, + we already counted them before this loop. */ + n_rows += page_get_n_recs(page); + } + + page_no = btr_page_get_next(page, &mtr); + + mtr_commit(&mtr); + + if (n_pages_read == N_PAGES_READ_LIMIT + || page_no == FIL_NULL) { + /* Either we read too many pages or + we reached the end of the level without passing + through slot2->page_no, the tree must have changed + in the meantime */ + goto inexact; + } + + } while (page_no != slot2->page_no); + + return(n_rows); + +inexact: + + *is_n_rows_exact = FALSE; + + /* We did interrupt before reaching slot2->page */ -ib_longlong + if (n_pages_read > 0) { + /* The number of pages on this level is + n_rows_on_prev_level, multiply it by the + average number of recs per page so far */ + n_rows = n_rows_on_prev_level + * n_rows / n_pages_read; + } else { + /* The tree changed before we could even + start with slot1->page_no */ + n_rows = 10; + } + + return(n_rows); +} + +/*******************************************************************//** +Estimates the number of rows in a given index range. +@return estimated number of rows */ +UNIV_INTERN +ib_int64_t 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 */ + dict_index_t* index, /*!< in: index */ + const dtuple_t* tuple1, /*!< in: range start, may also be empty tuple */ + ulint mode1, /*!< in: search mode for range start */ + const dtuple_t* tuple2, /*!< in: range end, may also be empty tuple */ + ulint mode2) /*!< in: search mode for range end */ { btr_path_t path1[BTR_PATH_ARRAY_N_SLOTS]; btr_path_t path2[BTR_PATH_ARRAY_N_SLOTS]; @@ -2723,7 +3376,8 @@ btr_estimate_n_rows_in_range( ibool diverged; ibool diverged_lot; ulint divergence_level; - ib_longlong n_rows; + ib_int64_t n_rows; + ibool is_n_rows_exact; ulint i; mtr_t mtr; @@ -2735,7 +3389,8 @@ btr_estimate_n_rows_in_range( btr_cur_search_to_nth_level(index, 0, tuple1, mode1, BTR_SEARCH_LEAF | BTR_ESTIMATE, - &cursor, 0, &mtr); + &cursor, 0, + __FILE__, __LINE__, &mtr); } else { btr_cur_open_at_index_side(TRUE, index, BTR_SEARCH_LEAF | BTR_ESTIMATE, @@ -2752,7 +3407,8 @@ btr_estimate_n_rows_in_range( btr_cur_search_to_nth_level(index, 0, tuple2, mode2, BTR_SEARCH_LEAF | BTR_ESTIMATE, - &cursor, 0, &mtr); + &cursor, 0, + __FILE__, __LINE__, &mtr); } else { btr_cur_open_at_index_side(FALSE, index, BTR_SEARCH_LEAF | BTR_ESTIMATE, @@ -2764,6 +3420,7 @@ btr_estimate_n_rows_in_range( /* We have the path information for the range in path1 and path2 */ n_rows = 1; + is_n_rows_exact = TRUE; diverged = FALSE; /* This becomes true when the path is not the same any more */ diverged_lot = FALSE; /* This becomes true when the paths are @@ -2779,7 +3436,7 @@ btr_estimate_n_rows_in_range( if (slot1->nth_rec == ULINT_UNDEFINED || slot2->nth_rec == ULINT_UNDEFINED) { - if (i > divergence_level + 1) { + if (i > divergence_level + 1 && !is_n_rows_exact) { /* In trees whose height is > 1 our algorithm tends to underestimate: multiply the estimate by 2: */ @@ -2791,7 +3448,9 @@ btr_estimate_n_rows_in_range( to over 1 / 2 of the estimated rows in the whole table */ - if (n_rows > index->table->stat_n_rows / 2) { + if (n_rows > index->table->stat_n_rows / 2 + && !is_n_rows_exact) { + n_rows = index->table->stat_n_rows / 2; /* If there are just 0 or 1 rows in the table, @@ -2817,10 +3476,15 @@ btr_estimate_n_rows_in_range( divergence_level = i; } } else { - /* Maybe the tree has changed between - searches */ - - return(10); + /* It is possible that + slot1->nth_rec >= slot2->nth_rec + if, for example, we have a single page + tree which contains (inf, 5, 6, supr) + and we select where x > 20 and x < 30; + in this case slot1->nth_rec will point + to the supr record and slot2->nth_rec + will point to 6 */ + n_rows = 0; } } else if (diverged && !diverged_lot) { @@ -2844,13 +3508,14 @@ btr_estimate_n_rows_in_range( } } else if (diverged_lot) { - n_rows = (n_rows * (slot1->n_recs + slot2->n_recs)) - / 2; + n_rows = btr_estimate_n_rows_in_range_on_level( + index, slot1, slot2, n_rows, + &is_n_rows_exact); } } } -/*********************************************************************** +/*******************************************************************//** Record the number of non_null 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 eventually stored in the array: @@ -2859,13 +3524,13 @@ static void btr_record_not_null_field_in_rec( /*=============================*/ - ulint n_unique, /* in: dict_index_get_n_unique(index), + ulint n_unique, /*!< in: dict_index_get_n_unique(index), number of columns uniquely determine an index entry */ - const ulint* offsets, /* in: rec_get_offsets(rec, index), + const ulint* offsets, /*!< in: rec_get_offsets(rec, index), its size could be for all fields or that of "n_unique" */ - ib_longlong* n_not_null) /* in/out: array to record number of + ib_int64_t* n_not_null) /*!< in/out: array to record number of not null rows for n-column prefix */ { ulint i; @@ -2885,18 +3550,18 @@ btr_record_not_null_field_in_rec( } } -/*********************************************************************** +/*******************************************************************//** 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. If innodb_stats_method is "nulls_ignored", we also record the number of non-null values for each prefix and store the estimates in array index->stat_n_non_null_key_vals. */ - +UNIV_INTERN void btr_estimate_number_of_different_key_vals( /*======================================*/ - dict_index_t* index) /* in: index */ + dict_index_t* index) /*!< in: index */ { btr_cur_t cursor; page_t* page; @@ -2904,14 +3569,15 @@ btr_estimate_number_of_different_key_vals( ulint n_cols; ulint matched_fields; ulint matched_bytes; - ib_longlong* n_diff; - ib_longlong* n_not_null; + ib_int64_t* n_diff; + ib_int64_t* n_not_null; ibool stats_null_not_equal; + ullint n_sample_pages; /* number of pages to sample */ ulint not_empty_flag = 0; ulint total_external_size = 0; ulint i; ulint j; - ulint add_on; + ullint add_on; mtr_t mtr; mem_heap_t* heap = NULL; ulint* offsets_rec = NULL; @@ -2925,7 +3591,7 @@ btr_estimate_number_of_different_key_vals( * (sizeof *offsets_rec + sizeof *offsets_next_rec)); - n_diff = mem_heap_zalloc(heap, (n_cols + 1) * sizeof(ib_longlong)); + n_diff = mem_heap_zalloc(heap, (n_cols + 1) * sizeof(ib_int64_t)); n_not_null = NULL; @@ -2950,18 +3616,30 @@ btr_estimate_number_of_different_key_vals( default: ut_error; + } + + /* It makes no sense to test more pages than are contained + in the index, thus we lower the number if it is too high */ + if (srv_stats_sample_pages > index->stat_index_size) { + if (index->stat_index_size > 0) { + n_sample_pages = index->stat_index_size; + } else { + n_sample_pages = 1; + } + } else { + n_sample_pages = srv_stats_sample_pages; } /* We sample some pages in the index to get an estimate */ - for (i = 0; i < BTR_KEY_VAL_ESTIMATE_N_PAGES; i++) { + for (i = 0; i < n_sample_pages; i++) { mtr_start(&mtr); btr_cur_open_at_rnd_pos(index, BTR_SEARCH_LEAF, &cursor, &mtr); /* Count the number of different key values for each prefix of the key on this index page. If the prefix does not determine - the index record uniquely in te B-tree, then we subtract one + the index record uniquely in the B-tree, then we subtract one because otherwise our algorithm would give a wrong estimate for an index where there is just one key value. */ @@ -3052,7 +3730,7 @@ btr_estimate_number_of_different_key_vals( } /* If we saw k borders between different key values on - BTR_KEY_VAL_ESTIMATE_N_PAGES leaf pages, we can estimate how many + n_sample_pages leaf pages, we can estimate how many there will be in index->stat_n_leaf_pages */ /* We must take into account that our sample actually represents @@ -3060,23 +3738,25 @@ btr_estimate_number_of_different_key_vals( included in index->stat_n_leaf_pages) */ for (j = 0; j <= n_cols; j++) { - index->stat_n_diff_key_vals[j] = BTR_TABLE_STATS_FROM_SAMPLE( - n_diff[j], index, total_external_size, not_empty_flag); + index->stat_n_diff_key_vals[j] + = BTR_TABLE_STATS_FROM_SAMPLE( + n_diff[j], index, n_sample_pages, + total_external_size, not_empty_flag); /* If the tree is small, smaller than - 10 * BTR_KEY_VAL_ESTIMATE_N_PAGES + total_external_size, then + 10 * n_sample_pages + total_external_size, then the above estimate is ok. For bigger trees it is common that we do not see any borders between key values in the few pages - we pick. But still there may be BTR_KEY_VAL_ESTIMATE_N_PAGES + we pick. But still there may be n_sample_pages different key values, or even more. Let us try to approximate that: */ add_on = index->stat_n_leaf_pages - / (10 * (BTR_KEY_VAL_ESTIMATE_N_PAGES + / (10 * (n_sample_pages + total_external_size)); - if (add_on > BTR_KEY_VAL_ESTIMATE_N_PAGES) { - add_on = BTR_KEY_VAL_ESTIMATE_N_PAGES; + if (add_on > n_sample_pages) { + add_on = n_sample_pages; } index->stat_n_diff_key_vals[j] += add_on; @@ -3088,7 +3768,7 @@ btr_estimate_number_of_different_key_vals( if (n_not_null != NULL && (j < n_cols)) { index->stat_n_non_null_key_vals[j] = BTR_TABLE_STATS_FROM_SAMPLE( - n_not_null[j], index, + n_not_null[j], index, n_sample_pages, total_external_size, not_empty_flag); } } @@ -3098,36 +3778,63 @@ btr_estimate_number_of_different_key_vals( /*================== EXTERNAL STORAGE OF BIG FIELDS ===================*/ -/*************************************************************** -Gets the externally stored size of a record, in units of a database page. */ +/***********************************************************//** +Gets the offset of the pointer to the externally stored part of a field. +@return offset of the pointer to the externally stored part */ +static +ulint +btr_rec_get_field_ref_offs( +/*=======================*/ + const ulint* offsets,/*!< in: array returned by rec_get_offsets() */ + ulint n) /*!< in: index of the external field */ +{ + ulint field_ref_offs; + ulint local_len; + + ut_a(rec_offs_nth_extern(offsets, n)); + field_ref_offs = rec_get_nth_field_offs(offsets, n, &local_len); + ut_a(local_len != UNIV_SQL_NULL); + ut_a(local_len >= BTR_EXTERN_FIELD_REF_SIZE); + + return(field_ref_offs + local_len - BTR_EXTERN_FIELD_REF_SIZE); +} + +/** Gets a pointer to the externally stored part of a field. +@param rec record +@param offsets rec_get_offsets(rec) +@param n index of the externally stored field +@return pointer to the externally stored part */ +#define btr_rec_get_field_ref(rec, offsets, n) \ + ((rec) + btr_rec_get_field_ref_offs(offsets, n)) + +/***********************************************************//** +Gets the externally stored size of a record, in units of a database page. +@return externally stored part, in units of a database page */ static ulint btr_rec_get_externally_stored_len( /*==============================*/ - /* out: externally stored part, - in units of a database page */ - rec_t* rec, /* in: record */ - const ulint* offsets)/* in: array returned by rec_get_offsets() */ + const rec_t* rec, /*!< in: record */ + const ulint* offsets)/*!< in: array returned by rec_get_offsets() */ { ulint n_fields; - byte* data; - ulint local_len; - ulint extern_len; ulint total_extern_len = 0; ulint i; ut_ad(!rec_offs_comp(offsets) || !rec_get_node_ptr_flag(rec)); + + if (!rec_offs_any_extern(offsets)) { + return(0); + } + n_fields = rec_offs_n_fields(offsets); for (i = 0; i < n_fields; i++) { if (rec_offs_nth_extern(offsets, i)) { - data = rec_get_nth_field(rec, offsets, i, &local_len); - - local_len -= BTR_EXTERN_FIELD_REF_SIZE; - - extern_len = mach_read_from_4(data + local_len - + BTR_EXTERN_LEN + 4); + ulint extern_len = mach_read_from_4( + btr_rec_get_field_ref(rec, offsets, i) + + BTR_EXTERN_LEN + 4); total_extern_len += ut_calc_align(extern_len, UNIV_PAGE_SIZE); @@ -3137,24 +3844,27 @@ btr_rec_get_externally_stored_len( return(total_extern_len / UNIV_PAGE_SIZE); } -/*********************************************************************** +/*******************************************************************//** Sets the ownership bit of an externally stored field in a record. */ static void btr_cur_set_ownership_of_extern_field( /*==================================*/ - rec_t* rec, /* in: clustered index record */ - const ulint* offsets,/* in: array returned by rec_get_offsets() */ - ulint i, /* in: field number */ - ibool val, /* in: value to set */ - mtr_t* mtr) /* in: mtr */ + page_zip_des_t* page_zip,/*!< in/out: compressed page whose uncompressed + part will be updated, or NULL */ + rec_t* rec, /*!< in/out: clustered index record */ + dict_index_t* index, /*!< in: index of the page */ + const ulint* offsets,/*!< in: array returned by rec_get_offsets() */ + ulint i, /*!< in: field number */ + ibool val, /*!< in: value to set */ + mtr_t* mtr) /*!< in: mtr, or NULL if not logged */ { byte* data; ulint local_len; ulint byte_val; data = rec_get_nth_field(rec, offsets, i, &local_len); - + ut_ad(rec_offs_nth_extern(offsets, i)); ut_a(local_len >= BTR_EXTERN_FIELD_REF_SIZE); local_len -= BTR_EXTERN_FIELD_REF_SIZE; @@ -3164,119 +3874,60 @@ btr_cur_set_ownership_of_extern_field( if (val) { byte_val = byte_val & (~BTR_EXTERN_OWNER_FLAG); } else { +#if defined UNIV_DEBUG || defined UNIV_BLOB_LIGHT_DEBUG + ut_a(!(byte_val & BTR_EXTERN_OWNER_FLAG)); +#endif /* UNIV_DEBUG || UNIV_BLOB_LIGHT_DEBUG */ byte_val = byte_val | BTR_EXTERN_OWNER_FLAG; } - mlog_write_ulint(data + local_len + BTR_EXTERN_LEN, byte_val, - MLOG_1BYTE, mtr); + if (UNIV_LIKELY_NULL(page_zip)) { + mach_write_to_1(data + local_len + BTR_EXTERN_LEN, byte_val); + page_zip_write_blob_ptr(page_zip, rec, index, offsets, i, mtr); + } else if (UNIV_LIKELY(mtr != NULL)) { + + mlog_write_ulint(data + local_len + BTR_EXTERN_LEN, byte_val, + MLOG_1BYTE, mtr); + } else { + mach_write_to_1(data + local_len + BTR_EXTERN_LEN, byte_val); + } + + btr_blob_dbg_owner(rec, index, offsets, i, val); } -/*********************************************************************** -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 +/*******************************************************************//** +Marks non-updated off-page fields as disowned by this record. The ownership +must be 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. */ - +UNIV_INTERN 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 */ +btr_cur_disown_inherited_fields( +/*============================*/ + page_zip_des_t* page_zip,/*!< in/out: compressed page whose uncompressed + part will be updated, or NULL */ + rec_t* rec, /*!< in/out: record in a clustered index */ + dict_index_t* index, /*!< in: index of the page */ + const ulint* offsets,/*!< in: array returned by rec_get_offsets() */ + const upd_t* update, /*!< in: update vector */ + mtr_t* mtr) /*!< in/out: mini-transaction */ { - ibool is_updated; - ulint n; - ulint j; ulint i; - ut_ad(rec_offs_validate(rec, NULL, offsets)); + ut_ad(rec_offs_validate(rec, index, offsets)); ut_ad(!rec_offs_comp(offsets) || !rec_get_node_ptr_flag(rec)); - n = rec_offs_n_fields(offsets); - - for (i = 0; i < n; i++) { - if (rec_offs_nth_extern(offsets, i)) { - - /* Check it is not in updated fields */ - is_updated = FALSE; - - if (update) { - for (j = 0; j < upd_get_n_fields(update); - j++) { - if (upd_get_nth_field(update, j) - ->field_no == i) { - is_updated = TRUE; - } - } - } - - if (!is_updated) { - btr_cur_set_ownership_of_extern_field( - rec, offsets, i, FALSE, 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 */ -{ - dfield_t* dfield; - ulint byte_val; - byte* data; - ulint len; - ibool is_updated; - ulint j; - ulint i; - - if (ext_vec == NULL) { - - return; - } - - for (i = 0; i < n_ext_vec; i++) { - - /* Check ext_vec[i] is in updated fields */ - is_updated = FALSE; - - for (j = 0; j < upd_get_n_fields(update); j++) { - if (upd_get_nth_field(update, j)->field_no - == ext_vec[i]) { - is_updated = TRUE; - } - } - - if (!is_updated) { - dfield = dtuple_get_nth_field(entry, ext_vec[i]); - - data = (byte*) dfield_get_data(dfield); - len = dfield_get_len(dfield); - - len -= BTR_EXTERN_FIELD_REF_SIZE; - - byte_val = mach_read_from_1(data + len - + BTR_EXTERN_LEN); - - byte_val = byte_val | BTR_EXTERN_INHERITED_FLAG; - - mach_write_to_1(data + len + BTR_EXTERN_LEN, byte_val); + ut_ad(rec_offs_any_extern(offsets)); + ut_ad(mtr); + + for (i = 0; i < rec_offs_n_fields(offsets); i++) { + if (rec_offs_nth_extern(offsets, i) + && !upd_get_field_by_field_no(update, i)) { + btr_cur_set_ownership_of_extern_field( + page_zip, rec, index, offsets, i, FALSE, mtr); } } } -/*********************************************************************** +/*******************************************************************//** Marks all extern fields in a record as owned by the record. This function should be called if the delete mark of a record is removed: a not delete marked record always owns all its extern fields. */ @@ -3284,9 +3935,12 @@ static void btr_cur_unmark_extern_fields( /*=========================*/ - rec_t* rec, /* in: record in a clustered index */ - mtr_t* mtr, /* in: mtr */ - const ulint* offsets)/* in: array returned by rec_get_offsets() */ + page_zip_des_t* page_zip,/*!< in/out: compressed page whose uncompressed + part will be updated, or NULL */ + rec_t* rec, /*!< in/out: record in a clustered index */ + dict_index_t* index, /*!< in: index of the page */ + const ulint* offsets,/*!< in: array returned by rec_get_offsets() */ + mtr_t* mtr) /*!< in: mtr, or NULL if not logged */ { ulint n; ulint i; @@ -3294,106 +3948,93 @@ btr_cur_unmark_extern_fields( ut_ad(!rec_offs_comp(offsets) || !rec_get_node_ptr_flag(rec)); n = rec_offs_n_fields(offsets); - for (i = 0; i < n; i++) { - if (rec_offs_nth_extern(offsets, i)) { + if (!rec_offs_any_extern(offsets)) { - btr_cur_set_ownership_of_extern_field(rec, offsets, i, - TRUE, mtr); - } + return; } -} - -/*********************************************************************** -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 */ -{ - dfield_t* dfield; - ulint byte_val; - byte* data; - ulint len; - ulint i; - - for (i = 0; i < n_ext_vec; i++) { - dfield = dtuple_get_nth_field(entry, ext_vec[i]); - - data = (byte*) dfield_get_data(dfield); - len = dfield_get_len(dfield); - len -= BTR_EXTERN_FIELD_REF_SIZE; - - byte_val = mach_read_from_1(data + len + BTR_EXTERN_LEN); - - byte_val = byte_val & (~BTR_EXTERN_OWNER_FLAG); + for (i = 0; i < n; i++) { + if (rec_offs_nth_extern(offsets, i)) { - mach_write_to_1(data + len + BTR_EXTERN_LEN, byte_val); + btr_cur_set_ownership_of_extern_field( + page_zip, rec, index, offsets, i, TRUE, mtr); + } } } -/*********************************************************************** -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. */ - +/*******************************************************************//** +Flags the data tuple fields that are marked as extern storage in the +update vector. We use this function to remember which fields we must +mark as extern storage in a record inserted for an update. +@return number of flagged external columns */ +UNIV_INTERN 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 */ + dtuple_t* tuple, /*!< in/out: data tuple */ + const upd_t* update, /*!< in: update vector */ + mem_heap_t* heap) /*!< in: memory heap */ { - ulint n_pushed = 0; - ibool is_updated; - ulint n; - ulint j; - ulint i; - - if (update) { - n = upd_get_n_fields(update); + ulint n_pushed = 0; + ulint n; + const upd_field_t* uf; - for (i = 0; i < n; i++) { + ut_ad(tuple); + ut_ad(update); - if (upd_get_nth_field(update, i)->extern_storage) { + uf = update->fields; + n = upd_get_n_fields(update); - ext_vect[n_pushed] = upd_get_nth_field( - update, i)->field_no; + for (; n--; uf++) { + if (dfield_is_ext(&uf->new_val)) { + dfield_t* field + = dtuple_get_nth_field(tuple, uf->field_no); + if (!dfield_is_ext(field)) { + dfield_set_ext(field); n_pushed++; } - } - } - - n = rec_offs_n_fields(offsets); - - for (i = 0; i < n; i++) { - if (rec_offs_nth_extern(offsets, i)) { - - /* Check it is not in updated fields */ - is_updated = FALSE; - - if (update) { - for (j = 0; j < upd_get_n_fields(update); - j++) { - if (upd_get_nth_field(update, j) - ->field_no == i) { - is_updated = TRUE; - } - } - } - if (!is_updated) { - ext_vect[n_pushed] = i; - n_pushed++; + switch (uf->orig_len) { + byte* data; + ulint len; + byte* buf; + case 0: + break; + case BTR_EXTERN_FIELD_REF_SIZE: + /* Restore the original locally stored + part of the column. In the undo log, + InnoDB writes a longer prefix of externally + stored columns, so that column prefixes + in secondary indexes can be reconstructed. */ + dfield_set_data(field, (byte*) dfield_get_data(field) + + dfield_get_len(field) + - BTR_EXTERN_FIELD_REF_SIZE, + BTR_EXTERN_FIELD_REF_SIZE); + dfield_set_ext(field); + break; + default: + /* Reconstruct the original locally + stored part of the column. The data + will have to be copied. */ + ut_a(uf->orig_len > BTR_EXTERN_FIELD_REF_SIZE); + + data = dfield_get_data(field); + len = dfield_get_len(field); + + buf = mem_heap_alloc(heap, uf->orig_len); + /* Copy the locally stored prefix. */ + memcpy(buf, data, + uf->orig_len + - BTR_EXTERN_FIELD_REF_SIZE); + /* Copy the BLOB pointer. */ + memcpy(buf + uf->orig_len + - BTR_EXTERN_FIELD_REF_SIZE, + data + len - BTR_EXTERN_FIELD_REF_SIZE, + BTR_EXTERN_FIELD_REF_SIZE); + + dfield_set_data(field, buf, uf->orig_len); + dfield_set_ext(field); } } } @@ -3401,218 +4042,543 @@ btr_push_update_extern_fields( return(n_pushed); } -/*********************************************************************** -Returns the length of a BLOB part stored on the header page. */ +/*******************************************************************//** +Returns the length of a BLOB part stored on the header page. +@return part length */ static ulint btr_blob_get_part_len( /*==================*/ - /* out: part length */ - byte* blob_header) /* in: blob header */ + const byte* blob_header) /*!< in: blob header */ { return(mach_read_from_4(blob_header + BTR_BLOB_HDR_PART_LEN)); } -/*********************************************************************** -Returns the page number where the next BLOB part is stored. */ +/*******************************************************************//** +Returns the page number where the next BLOB part is stored. +@return page number or FIL_NULL if no more pages */ static ulint btr_blob_get_next_page_no( /*======================*/ - /* out: page number or FIL_NULL if - no more pages */ - byte* blob_header) /* in: blob header */ + const byte* blob_header) /*!< in: blob header */ { return(mach_read_from_4(blob_header + BTR_BLOB_HDR_NEXT_PAGE_NO)); } -/*********************************************************************** -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. */ +/*******************************************************************//** +Deallocate a buffer block that was reserved for a BLOB part. */ +static +void +btr_blob_free( +/*==========*/ + buf_block_t* block, /*!< in: buffer block */ + ibool all, /*!< in: TRUE=remove also the compressed page + if there is one */ + mtr_t* mtr) /*!< in: mini-transaction to commit */ +{ + buf_pool_t* buf_pool = buf_pool_from_block(block); + ulint space = buf_block_get_space(block); + ulint page_no = buf_block_get_page_no(block); + + ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX)); + + mtr_commit(mtr); + + buf_pool_mutex_enter(buf_pool); + mutex_enter(&block->mutex); + + /* Only free the block if it is still allocated to + the same file page. */ + + if (buf_block_get_state(block) + == BUF_BLOCK_FILE_PAGE + && buf_block_get_space(block) == space + && buf_block_get_page_no(block) == page_no) { + + if (!buf_LRU_free_block(&block->page, all) + && all && block->page.zip.data) { + /* Attempt to deallocate the uncompressed page + if the whole block cannot be deallocted. */ + buf_LRU_free_block(&block->page, FALSE); + } + } + + buf_pool_mutex_exit(buf_pool); + mutex_exit(&block->mutex); +} + +/*******************************************************************//** +Stores the fields in big_rec_vec to the tablespace and puts pointers to +them in rec. The extern flags in rec will have to be set beforehand. +The fields are stored on pages allocated from leaf node +file segment of the index tree. +@return DB_SUCCESS or DB_OUT_OF_FILE_SPACE */ +UNIV_INTERN ulint -btr_store_big_rec_extern_fields( -/*============================*/ - /* out: DB_SUCCESS or error */ - dict_index_t* index, /* in: index of rec; the index tree +btr_store_big_rec_extern_fields_func( +/*=================================*/ + 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); + buf_block_t* rec_block, /*!< in/out: block containing rec */ + rec_t* rec, /*!< in/out: 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 +#ifdef UNIV_DEBUG + mtr_t* local_mtr, /*!< in: mtr containing the + latch to rec and to the tree */ +#endif /* UNIV_DEBUG */ +#if defined UNIV_DEBUG || defined UNIV_BLOB_LIGHT_DEBUG + ibool update_in_place,/*! in: TRUE if the record is updated + in place (not delete+insert) */ +#endif /* UNIV_DEBUG || UNIV_BLOB_LIGHT_DEBUG */ + const big_rec_t*big_rec_vec) /*!< in: vector containing fields to be stored externally */ - mtr_t* local_mtr __attribute__((unused))) /* in: mtr - containing the latch to rec and to the - tree */ + { - byte* data; - ulint local_len; + ulint rec_page_no; + byte* field_ref; ulint extern_len; ulint store_len; ulint page_no; - page_t* page; ulint space_id; - page_t* prev_page; -#ifdef UNIV_SYNC_DEBUG - page_t* rec_page; -#endif /* UNIV_SYNC_DEBUG */ + ulint zip_size; ulint prev_page_no; ulint hint_page_no; ulint i; mtr_t mtr; + mem_heap_t* heap = NULL; + page_zip_des_t* page_zip; + z_stream c_stream; ut_ad(rec_offs_validate(rec, index, offsets)); + ut_ad(rec_offs_any_extern(offsets)); ut_ad(mtr_memo_contains(local_mtr, dict_index_get_lock(index), MTR_MEMO_X_LOCK)); - ut_ad(mtr_memo_contains(local_mtr, buf_block_align(rec), - MTR_MEMO_PAGE_X_FIX)); - ut_a(index->type & DICT_CLUSTERED); - - space_id = buf_frame_get_space_id(rec); + ut_ad(mtr_memo_contains(local_mtr, rec_block, MTR_MEMO_PAGE_X_FIX)); + ut_ad(buf_block_get_frame(rec_block) == page_align(rec)); + ut_a(dict_index_is_clust(index)); + + page_zip = buf_block_get_page_zip(rec_block); + ut_a(dict_table_zip_size(index->table) + == buf_block_get_zip_size(rec_block)); + + space_id = buf_block_get_space(rec_block); + zip_size = buf_block_get_zip_size(rec_block); + rec_page_no = buf_block_get_page_no(rec_block); + ut_a(fil_page_get_type(page_align(rec)) == FIL_PAGE_INDEX); + + if (UNIV_LIKELY_NULL(page_zip)) { + int err; + + /* Zlib deflate needs 128 kilobytes for the default + window size, plus 512 << memLevel, plus a few + kilobytes for small objects. We use reduced memLevel + to limit the memory consumption, and preallocate the + heap, hoping to avoid memory fragmentation. */ + heap = mem_heap_create(250000); + page_zip_set_alloc(&c_stream, heap); + + err = deflateInit2(&c_stream, Z_DEFAULT_COMPRESSION, + Z_DEFLATED, 15, 7, Z_DEFAULT_STRATEGY); + ut_a(err == Z_OK); + } +#if defined UNIV_DEBUG || defined UNIV_BLOB_LIGHT_DEBUG + /* All pointers to externally stored columns in the record + must either be zero or they must be pointers to inherited + columns, owned by this record or an earlier record version. */ + for (i = 0; i < rec_offs_n_fields(offsets); i++) { + if (!rec_offs_nth_extern(offsets, i)) { + continue; + } + field_ref = btr_rec_get_field_ref(rec, offsets, i); + + ut_a(!(field_ref[BTR_EXTERN_LEN] & BTR_EXTERN_OWNER_FLAG)); + /* Either this must be an update in place, + or the BLOB must be inherited, or the BLOB pointer + must be zero (will be written in this function). */ + ut_a(update_in_place + || (field_ref[BTR_EXTERN_LEN] & BTR_EXTERN_INHERITED_FLAG) + || !memcmp(field_ref, field_ref_zero, + BTR_EXTERN_FIELD_REF_SIZE)); + } +#endif /* UNIV_DEBUG || UNIV_BLOB_LIGHT_DEBUG */ /* We have to create a file segment to the tablespace for each field and put the pointer to the field in rec */ for (i = 0; i < big_rec_vec->n_fields; i++) { - - data = rec_get_nth_field(rec, offsets, - big_rec_vec->fields[i].field_no, - &local_len); - ut_a(local_len >= BTR_EXTERN_FIELD_REF_SIZE); - local_len -= BTR_EXTERN_FIELD_REF_SIZE; + field_ref = btr_rec_get_field_ref( + rec, offsets, big_rec_vec->fields[i].field_no); +#if defined UNIV_DEBUG || defined UNIV_BLOB_LIGHT_DEBUG + /* A zero BLOB pointer should have been initially inserted. */ + ut_a(!memcmp(field_ref, field_ref_zero, + BTR_EXTERN_FIELD_REF_SIZE)); +#endif /* UNIV_DEBUG || UNIV_BLOB_LIGHT_DEBUG */ extern_len = big_rec_vec->fields[i].len; + UNIV_MEM_ASSERT_RW(big_rec_vec->fields[i].data, + extern_len); ut_a(extern_len > 0); prev_page_no = FIL_NULL; - while (extern_len > 0) { + if (UNIV_LIKELY_NULL(page_zip)) { + int err = deflateReset(&c_stream); + ut_a(err == Z_OK); + + c_stream.next_in = (void*) big_rec_vec->fields[i].data; + c_stream.avail_in = extern_len; + } + + for (;;) { + buf_block_t* block; + page_t* page; + mtr_start(&mtr); if (prev_page_no == FIL_NULL) { - hint_page_no = buf_frame_get_page_no(rec) + 1; + hint_page_no = 1 + rec_page_no; } else { hint_page_no = prev_page_no + 1; } - page = btr_page_alloc(index, hint_page_no, - FSP_NO_DIR, 0, &mtr); - if (page == NULL) { + block = btr_page_alloc(index, hint_page_no, + FSP_NO_DIR, 0, &mtr); + if (UNIV_UNLIKELY(block == NULL)) { mtr_commit(&mtr); + if (UNIV_LIKELY_NULL(page_zip)) { + deflateEnd(&c_stream); + mem_heap_free(heap); + } + return(DB_OUT_OF_FILE_SPACE); } - mlog_write_ulint(page + FIL_PAGE_TYPE, - FIL_PAGE_TYPE_BLOB, - MLOG_2BYTES, &mtr); - - page_no = buf_frame_get_page_no(page); + page_no = buf_block_get_page_no(block); + page = buf_block_get_frame(block); if (prev_page_no != FIL_NULL) { - prev_page = buf_page_get(space_id, - prev_page_no, + buf_block_t* prev_block; + page_t* prev_page; + + prev_block = buf_page_get(space_id, zip_size, + prev_page_no, + RW_X_LATCH, &mtr); + buf_block_dbg_add_level(prev_block, + SYNC_EXTERN_STORAGE); + prev_page = buf_block_get_frame(prev_block); + + if (UNIV_LIKELY_NULL(page_zip)) { + mlog_write_ulint( + prev_page + FIL_PAGE_NEXT, + page_no, MLOG_4BYTES, &mtr); + memcpy(buf_block_get_page_zip( + prev_block) + ->data + FIL_PAGE_NEXT, + prev_page + FIL_PAGE_NEXT, 4); + } else { + mlog_write_ulint( + prev_page + FIL_PAGE_DATA + + BTR_BLOB_HDR_NEXT_PAGE_NO, + page_no, MLOG_4BYTES, &mtr); + } + + } + + if (UNIV_LIKELY_NULL(page_zip)) { + int err; + page_zip_des_t* blob_page_zip; + + /* Write FIL_PAGE_TYPE to the redo log + separately, before logging any other + changes to the page, so that the debug + assertions in + recv_parse_or_apply_log_rec_body() can + be made simpler. Before InnoDB Plugin + 1.0.4, the initialization of + FIL_PAGE_TYPE was logged as part of + the mlog_log_string() below. */ + + mlog_write_ulint(page + FIL_PAGE_TYPE, + prev_page_no == FIL_NULL + ? FIL_PAGE_TYPE_ZBLOB + : FIL_PAGE_TYPE_ZBLOB2, + MLOG_2BYTES, &mtr); + + c_stream.next_out = page + + FIL_PAGE_DATA; + c_stream.avail_out + = page_zip_get_size(page_zip) + - FIL_PAGE_DATA; + + err = deflate(&c_stream, Z_FINISH); + ut_a(err == Z_OK || err == Z_STREAM_END); + ut_a(err == Z_STREAM_END + || c_stream.avail_out == 0); + + /* Write the "next BLOB page" pointer */ + mlog_write_ulint(page + FIL_PAGE_NEXT, + FIL_NULL, MLOG_4BYTES, &mtr); + /* Initialize the unused "prev page" pointer */ + mlog_write_ulint(page + FIL_PAGE_PREV, + FIL_NULL, MLOG_4BYTES, &mtr); + /* Write a back pointer to the record + into the otherwise unused area. This + information could be useful in + debugging. Later, we might want to + implement the possibility to relocate + BLOB pages. Then, we would need to be + able to adjust the BLOB pointer in the + record. We do not store the heap + number of the record, because it can + change in page_zip_reorganize() or + btr_page_reorganize(). However, also + the page number of the record may + change when B-tree nodes are split or + merged. */ + mlog_write_ulint(page + + FIL_PAGE_FILE_FLUSH_LSN, + space_id, + MLOG_4BYTES, &mtr); + mlog_write_ulint(page + + FIL_PAGE_FILE_FLUSH_LSN + 4, + rec_page_no, + MLOG_4BYTES, &mtr); + + /* Zero out the unused part of the page. */ + memset(page + page_zip_get_size(page_zip) + - c_stream.avail_out, + 0, c_stream.avail_out); + mlog_log_string(page + FIL_PAGE_FILE_FLUSH_LSN, + page_zip_get_size(page_zip) + - FIL_PAGE_FILE_FLUSH_LSN, + &mtr); + /* Copy the page to compressed storage, + because it will be flushed to disk + from there. */ + blob_page_zip = buf_block_get_page_zip(block); + ut_ad(blob_page_zip); + ut_ad(page_zip_get_size(blob_page_zip) + == page_zip_get_size(page_zip)); + memcpy(blob_page_zip->data, page, + page_zip_get_size(page_zip)); + + if (err == Z_OK && prev_page_no != FIL_NULL) { + + goto next_zip_page; + } + + rec_block = buf_page_get(space_id, zip_size, + rec_page_no, RW_X_LATCH, &mtr); + buf_block_dbg_add_level(rec_block, + SYNC_NO_ORDER_CHECK); + + if (err == Z_STREAM_END) { + mach_write_to_4(field_ref + + BTR_EXTERN_LEN, 0); + mach_write_to_4(field_ref + + BTR_EXTERN_LEN + 4, + c_stream.total_in); + } else { + memset(field_ref + BTR_EXTERN_LEN, + 0, 8); + } -#ifdef UNIV_SYNC_DEBUG - buf_page_dbg_add_level(prev_page, - SYNC_EXTERN_STORAGE); -#endif /* UNIV_SYNC_DEBUG */ + if (prev_page_no == FIL_NULL) { + btr_blob_dbg_add_blob( + rec, big_rec_vec->fields[i] + .field_no, page_no, index, + "store"); - mlog_write_ulint(prev_page + FIL_PAGE_DATA - + BTR_BLOB_HDR_NEXT_PAGE_NO, - page_no, MLOG_4BYTES, &mtr); - } + mach_write_to_4(field_ref + + BTR_EXTERN_SPACE_ID, + space_id); + + mach_write_to_4(field_ref + + BTR_EXTERN_PAGE_NO, + page_no); - if (extern_len > (UNIV_PAGE_SIZE - FIL_PAGE_DATA - - BTR_BLOB_HDR_SIZE - - FIL_PAGE_DATA_END)) { - store_len = UNIV_PAGE_SIZE - FIL_PAGE_DATA - - BTR_BLOB_HDR_SIZE - - FIL_PAGE_DATA_END; + mach_write_to_4(field_ref + + BTR_EXTERN_OFFSET, + FIL_PAGE_NEXT); + } + + page_zip_write_blob_ptr( + page_zip, rec, index, offsets, + big_rec_vec->fields[i].field_no, &mtr); + +next_zip_page: + prev_page_no = page_no; + + /* Commit mtr and release the + uncompressed page frame to save memory. */ + btr_blob_free(block, FALSE, &mtr); + + if (err == Z_STREAM_END) { + break; + } } else { - store_len = extern_len; - } + mlog_write_ulint(page + FIL_PAGE_TYPE, + FIL_PAGE_TYPE_BLOB, + MLOG_2BYTES, &mtr); + + if (extern_len > (UNIV_PAGE_SIZE + - FIL_PAGE_DATA + - BTR_BLOB_HDR_SIZE + - FIL_PAGE_DATA_END)) { + store_len = UNIV_PAGE_SIZE + - FIL_PAGE_DATA + - BTR_BLOB_HDR_SIZE + - FIL_PAGE_DATA_END; + } else { + store_len = extern_len; + } - mlog_write_string(page + FIL_PAGE_DATA - + BTR_BLOB_HDR_SIZE, - big_rec_vec->fields[i].data - + big_rec_vec->fields[i].len - - extern_len, - store_len, &mtr); - mlog_write_ulint(page + FIL_PAGE_DATA - + BTR_BLOB_HDR_PART_LEN, - store_len, MLOG_4BYTES, &mtr); - mlog_write_ulint(page + FIL_PAGE_DATA - + BTR_BLOB_HDR_NEXT_PAGE_NO, - FIL_NULL, MLOG_4BYTES, &mtr); - - extern_len -= store_len; + mlog_write_string(page + FIL_PAGE_DATA + + BTR_BLOB_HDR_SIZE, + (const byte*) + big_rec_vec->fields[i].data + + big_rec_vec->fields[i].len + - extern_len, + store_len, &mtr); + mlog_write_ulint(page + FIL_PAGE_DATA + + BTR_BLOB_HDR_PART_LEN, + store_len, MLOG_4BYTES, &mtr); + mlog_write_ulint(page + FIL_PAGE_DATA + + BTR_BLOB_HDR_NEXT_PAGE_NO, + FIL_NULL, MLOG_4BYTES, &mtr); -#ifdef UNIV_SYNC_DEBUG - rec_page = -#endif /* UNIV_SYNC_DEBUG */ - buf_page_get(space_id, - buf_frame_get_page_no(data), - RW_X_LATCH, &mtr); -#ifdef UNIV_SYNC_DEBUG - buf_page_dbg_add_level(rec_page, SYNC_NO_ORDER_CHECK); -#endif /* UNIV_SYNC_DEBUG */ - mlog_write_ulint(data + local_len + BTR_EXTERN_LEN, 0, - MLOG_4BYTES, &mtr); - mlog_write_ulint(data + local_len + BTR_EXTERN_LEN + 4, - big_rec_vec->fields[i].len - - extern_len, - MLOG_4BYTES, &mtr); + extern_len -= store_len; - if (prev_page_no == FIL_NULL) { - mlog_write_ulint(data + local_len - + BTR_EXTERN_SPACE_ID, - space_id, - MLOG_4BYTES, &mtr); + rec_block = buf_page_get(space_id, zip_size, + rec_page_no, + RW_X_LATCH, &mtr); + buf_block_dbg_add_level(rec_block, + SYNC_NO_ORDER_CHECK); - mlog_write_ulint(data + local_len - + BTR_EXTERN_PAGE_NO, - page_no, + mlog_write_ulint(field_ref + BTR_EXTERN_LEN, 0, MLOG_4BYTES, &mtr); - - mlog_write_ulint(data + local_len - + BTR_EXTERN_OFFSET, - FIL_PAGE_DATA, + mlog_write_ulint(field_ref + + BTR_EXTERN_LEN + 4, + big_rec_vec->fields[i].len + - extern_len, MLOG_4BYTES, &mtr); - /* Set the bit denoting that this field - in rec is stored externally */ + if (prev_page_no == FIL_NULL) { + btr_blob_dbg_add_blob( + rec, big_rec_vec->fields[i] + .field_no, page_no, index, + "store"); + + mlog_write_ulint(field_ref + + BTR_EXTERN_SPACE_ID, + space_id, + MLOG_4BYTES, &mtr); + + mlog_write_ulint(field_ref + + BTR_EXTERN_PAGE_NO, + page_no, + MLOG_4BYTES, &mtr); + + mlog_write_ulint(field_ref + + BTR_EXTERN_OFFSET, + FIL_PAGE_DATA, + MLOG_4BYTES, &mtr); + } - rec_set_nth_field_extern_bit( - rec, index, - big_rec_vec->fields[i].field_no, - TRUE, &mtr); - } + prev_page_no = page_no; - prev_page_no = page_no; + mtr_commit(&mtr); - mtr_commit(&mtr); + if (extern_len == 0) { + break; + } + } } } + if (UNIV_LIKELY_NULL(page_zip)) { + deflateEnd(&c_stream); + mem_heap_free(heap); + } + +#if defined UNIV_DEBUG || defined UNIV_BLOB_LIGHT_DEBUG + /* All pointers to externally stored columns in the record + must be valid. */ + for (i = 0; i < rec_offs_n_fields(offsets); i++) { + if (!rec_offs_nth_extern(offsets, i)) { + continue; + } + + field_ref = btr_rec_get_field_ref(rec, offsets, i); + + /* The pointer must not be zero. */ + ut_a(0 != memcmp(field_ref, field_ref_zero, + BTR_EXTERN_FIELD_REF_SIZE)); + /* The column must not be disowned by this record. */ + ut_a(!(field_ref[BTR_EXTERN_LEN] & BTR_EXTERN_OWNER_FLAG)); + } +#endif /* UNIV_DEBUG || UNIV_BLOB_LIGHT_DEBUG */ return(DB_SUCCESS); } -/*********************************************************************** +/*******************************************************************//** +Check the FIL_PAGE_TYPE on an uncompressed BLOB page. */ +static +void +btr_check_blob_fil_page_type( +/*=========================*/ + ulint space_id, /*!< in: space id */ + ulint page_no, /*!< in: page number */ + const page_t* page, /*!< in: page */ + ibool read) /*!< in: TRUE=read, FALSE=purge */ +{ + ulint type = fil_page_get_type(page); + + ut_a(space_id == page_get_space_id(page)); + ut_a(page_no == page_get_page_no(page)); + + if (UNIV_UNLIKELY(type != FIL_PAGE_TYPE_BLOB)) { + ulint flags = fil_space_get_flags(space_id); + +#ifndef UNIV_DEBUG /* Improve debug test coverage */ + if (UNIV_LIKELY + ((flags & DICT_TF_FORMAT_MASK) == DICT_TF_FORMAT_51)) { + /* Old versions of InnoDB did not initialize + FIL_PAGE_TYPE on BLOB pages. Do not print + anything about the type mismatch when reading + a BLOB page that is in Antelope format.*/ + return; + } +#endif /* !UNIV_DEBUG */ + + ut_print_timestamp(stderr); + fprintf(stderr, + " InnoDB: FIL_PAGE_TYPE=%lu" + " on BLOB %s space %lu page %lu flags %lx\n", + (ulong) type, read ? "read" : "purge", + (ulong) space_id, (ulong) page_no, (ulong) flags); + ut_error; + } +} + +/*******************************************************************//** Frees the space in an externally stored field to the file space -management if the field in data is owned the externally stored field, +management if the field in data is owned by the externally stored field, in a rollback we may have the additional condition that the field must not be inherited. */ - +UNIV_INTERN void btr_free_externally_stored_field( /*=============================*/ - dict_index_t* index, /* in: index of the data, the index + 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 @@ -3620,147 +4586,220 @@ btr_free_externally_stored_field( 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 __attribute__((unused))) /* in: mtr + byte* field_ref, /*!< in/out: field reference */ + const rec_t* rec, /*!< in: record containing field_ref, for + page_zip_write_blob_ptr(), or NULL */ + const ulint* offsets, /*!< in: rec_get_offsets(rec, index), + or NULL */ + page_zip_des_t* page_zip, /*!< in: compressed page corresponding + to rec, or NULL if rec == NULL */ + ulint i, /*!< in: field number of field_ref; + ignored if rec == NULL */ + enum trx_rb_ctx rb_ctx, /*!< in: rollback context */ + mtr_t* local_mtr __attribute__((unused))) /*!< in: mtr containing the latch to data an an X-latch to the index tree */ { - page_t* page; -#ifdef UNIV_SYNC_DEBUG - page_t* rec_page; -#endif /* UNIV_SYNC_DEBUG */ - ulint space_id; - ulint page_no; - ulint extern_len; - ulint next_page_no; - ulint part_len; - mtr_t mtr; + page_t* page; + ulint space_id; + ulint rec_zip_size = dict_table_zip_size(index->table); + ulint ext_zip_size; + ulint page_no; + ulint next_page_no; + mtr_t mtr; - ut_a(local_len >= BTR_EXTERN_FIELD_REF_SIZE); ut_ad(mtr_memo_contains(local_mtr, dict_index_get_lock(index), MTR_MEMO_X_LOCK)); - ut_ad(mtr_memo_contains(local_mtr, buf_block_align(data), - MTR_MEMO_PAGE_X_FIX)); - ut_a(local_len >= BTR_EXTERN_FIELD_REF_SIZE); - local_len -= BTR_EXTERN_FIELD_REF_SIZE; - - for (;;) { - mtr_start(&mtr); - -#ifdef UNIV_SYNC_DEBUG - rec_page = -#endif /* UNIV_SYNC_DEBUG */ - buf_page_get(buf_frame_get_space_id(data), - buf_frame_get_page_no(data), - RW_X_LATCH, &mtr); -#ifdef UNIV_SYNC_DEBUG - buf_page_dbg_add_level(rec_page, SYNC_NO_ORDER_CHECK); -#endif /* UNIV_SYNC_DEBUG */ - space_id = mach_read_from_4(data + local_len - + BTR_EXTERN_SPACE_ID); - - page_no = mach_read_from_4(data + local_len - + BTR_EXTERN_PAGE_NO); - - extern_len = mach_read_from_4(data + local_len - + BTR_EXTERN_LEN + 4); - - /* If extern len is 0, then there is no external storage data - at all */ + ut_ad(mtr_memo_contains_page(local_mtr, field_ref, + MTR_MEMO_PAGE_X_FIX)); + ut_ad(!rec || rec_offs_validate(rec, index, offsets)); + ut_ad(!rec || field_ref == btr_rec_get_field_ref(rec, offsets, i)); + + if (UNIV_UNLIKELY(!memcmp(field_ref, field_ref_zero, + BTR_EXTERN_FIELD_REF_SIZE))) { + /* In the rollback of uncommitted transactions, we may + encounter a clustered index record whose BLOBs have + not been written. There is nothing to free then. */ + ut_a(rb_ctx == RB_RECOVERY || rb_ctx == RB_RECOVERY_PURGE_REC); + return; + } - if (extern_len == 0) { + space_id = mach_read_from_4(field_ref + BTR_EXTERN_SPACE_ID); + + if (UNIV_UNLIKELY(space_id != dict_index_get_space(index))) { + ext_zip_size = fil_space_get_zip_size(space_id); + /* This must be an undo log record in the system tablespace, + that is, in row_purge_upd_exist_or_extern(). + Currently, externally stored records are stored in the + same tablespace as the referring records. */ + ut_ad(!page_get_space_id(page_align(field_ref))); + ut_ad(!rec); + ut_ad(!page_zip); + } else { + ext_zip_size = rec_zip_size; + } - mtr_commit(&mtr); + if (!rec) { + /* This is a call from row_purge_upd_exist_or_extern(). */ + ut_ad(!page_zip); + rec_zip_size = 0; + } - return; +#ifdef UNIV_BLOB_DEBUG + if (!(field_ref[BTR_EXTERN_LEN] & BTR_EXTERN_OWNER_FLAG) + && !((field_ref[BTR_EXTERN_LEN] & BTR_EXTERN_INHERITED_FLAG) + && (rb_ctx == RB_NORMAL || rb_ctx == RB_RECOVERY))) { + /* This off-page column will be freed. + Check that no references remain. */ + + btr_blob_dbg_t b; + + b.blob_page_no = mach_read_from_4( + field_ref + BTR_EXTERN_PAGE_NO); + + if (rec) { + /* Remove the reference from the record to the + BLOB. If the BLOB were not freed, the + reference would be removed when the record is + removed. Freeing the BLOB will overwrite the + BTR_EXTERN_PAGE_NO in the field_ref of the + record with FIL_NULL, which would make the + btr_blob_dbg information inconsistent with the + record. */ + b.ref_page_no = page_get_page_no(page_align(rec)); + b.ref_heap_no = page_rec_get_heap_no(rec); + b.ref_field_no = i; + btr_blob_dbg_rbt_delete(index, &b, "free"); } - if (mach_read_from_1(data + local_len + BTR_EXTERN_LEN) - & BTR_EXTERN_OWNER_FLAG) { - /* This field does not own the externally - stored field: do not free! */ - - mtr_commit(&mtr); + btr_blob_dbg_assert_empty(index, b.blob_page_no); + } +#endif /* UNIV_BLOB_DEBUG */ - return; - } + for (;;) { +#ifdef UNIV_SYNC_DEBUG + buf_block_t* rec_block; +#endif /* UNIV_SYNC_DEBUG */ + buf_block_t* ext_block; - if (do_not_free_inherited - && mach_read_from_1(data + local_len + BTR_EXTERN_LEN) - & BTR_EXTERN_INHERITED_FLAG) { - /* Rollback and inherited field: do not free! */ + mtr_start(&mtr); +#ifdef UNIV_SYNC_DEBUG + rec_block = +#endif /* UNIV_SYNC_DEBUG */ + buf_page_get(page_get_space_id(page_align(field_ref)), + rec_zip_size, + page_get_page_no(page_align(field_ref)), + RW_X_LATCH, &mtr); + buf_block_dbg_add_level(rec_block, SYNC_NO_ORDER_CHECK); + page_no = mach_read_from_4(field_ref + BTR_EXTERN_PAGE_NO); + + if (/* There is no external storage data */ + page_no == FIL_NULL + /* This field does not own the externally stored field */ + || (mach_read_from_1(field_ref + BTR_EXTERN_LEN) + & BTR_EXTERN_OWNER_FLAG) + /* Rollback and inherited field */ + || ((rb_ctx == RB_NORMAL || rb_ctx == RB_RECOVERY) + && (mach_read_from_1(field_ref + BTR_EXTERN_LEN) + & BTR_EXTERN_INHERITED_FLAG))) { + + /* Do not free */ mtr_commit(&mtr); return; } - page = buf_page_get(space_id, page_no, RW_X_LATCH, &mtr); -#ifdef UNIV_SYNC_DEBUG - buf_page_dbg_add_level(page, SYNC_EXTERN_STORAGE); -#endif /* UNIV_SYNC_DEBUG */ - next_page_no = mach_read_from_4(page + FIL_PAGE_DATA - + BTR_BLOB_HDR_NEXT_PAGE_NO); + ext_block = buf_page_get(space_id, ext_zip_size, page_no, + RW_X_LATCH, &mtr); + buf_block_dbg_add_level(ext_block, SYNC_EXTERN_STORAGE); + page = buf_block_get_frame(ext_block); + + if (ext_zip_size) { + /* Note that page_zip will be NULL + in row_purge_upd_exist_or_extern(). */ + switch (fil_page_get_type(page)) { + case FIL_PAGE_TYPE_ZBLOB: + case FIL_PAGE_TYPE_ZBLOB2: + break; + default: + ut_error; + } + next_page_no = mach_read_from_4(page + FIL_PAGE_NEXT); - part_len = btr_blob_get_part_len(page + FIL_PAGE_DATA); + btr_page_free_low(index, ext_block, 0, &mtr); - ut_a(extern_len >= part_len); + if (UNIV_LIKELY(page_zip != NULL)) { + mach_write_to_4(field_ref + BTR_EXTERN_PAGE_NO, + next_page_no); + mach_write_to_4(field_ref + BTR_EXTERN_LEN + 4, + 0); + page_zip_write_blob_ptr(page_zip, rec, index, + offsets, i, &mtr); + } else { + mlog_write_ulint(field_ref + + BTR_EXTERN_PAGE_NO, + next_page_no, + MLOG_4BYTES, &mtr); + mlog_write_ulint(field_ref + + BTR_EXTERN_LEN + 4, 0, + MLOG_4BYTES, &mtr); + } + } else { + ut_a(!page_zip); + btr_check_blob_fil_page_type(space_id, page_no, page, + FALSE); - /* We must supply the page level (= 0) as an argument - because we did not store it on the page (we save the space - overhead from an index page header. */ + next_page_no = mach_read_from_4( + page + FIL_PAGE_DATA + + BTR_BLOB_HDR_NEXT_PAGE_NO); - btr_page_free_low(index, page, 0, &mtr); + /* We must supply the page level (= 0) as an argument + because we did not store it on the page (we save the + space overhead from an index page header. */ - mlog_write_ulint(data + local_len + BTR_EXTERN_PAGE_NO, - next_page_no, - MLOG_4BYTES, &mtr); - mlog_write_ulint(data + local_len + BTR_EXTERN_LEN + 4, - extern_len - part_len, - MLOG_4BYTES, &mtr); - if (next_page_no == FIL_NULL) { - ut_a(extern_len - part_len == 0); - } + btr_page_free_low(index, ext_block, 0, &mtr); - if (extern_len - part_len == 0) { - ut_a(next_page_no == FIL_NULL); + mlog_write_ulint(field_ref + BTR_EXTERN_PAGE_NO, + next_page_no, + MLOG_4BYTES, &mtr); + /* Zero out the BLOB length. If the server + crashes during the execution of this function, + trx_rollback_or_clean_all_recovered() could + dereference the half-deleted BLOB, fetching a + wrong prefix for the BLOB. */ + mlog_write_ulint(field_ref + BTR_EXTERN_LEN + 4, + 0, + MLOG_4BYTES, &mtr); } - mtr_commit(&mtr); + /* Commit mtr and release the BLOB block to save memory. */ + btr_blob_free(ext_block, TRUE, &mtr); } } -/*************************************************************** +/***********************************************************//** Frees the externally stored fields for a record. */ - +static void btr_rec_free_externally_stored_fields( /*==================================*/ - dict_index_t* index, /* in: index of the data, the index + 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 + rec_t* rec, /*!< in/out: record */ + const ulint* offsets,/*!< in: rec_get_offsets(rec, index) */ + page_zip_des_t* page_zip,/*!< in: compressed page whose uncompressed + part will be updated, or NULL */ + enum trx_rb_ctx rb_ctx, /*!< in: rollback context */ + mtr_t* mtr) /*!< in: mini-transaction handle which contains an X-latch to record page and to the index tree */ { ulint n_fields; - byte* data; - ulint len; ulint i; ut_ad(rec_offs_validate(rec, index, offsets)); - ut_ad(mtr_memo_contains(mtr, buf_block_align(rec), - MTR_MEMO_PAGE_X_FIX)); + ut_ad(mtr_memo_contains_page(mtr, rec, MTR_MEMO_PAGE_X_FIX)); /* Free possible externally stored fields in the record */ ut_ad(dict_table_is_comp(index->table) == !!rec_offs_comp(offsets)); @@ -3768,168 +4807,430 @@ btr_rec_free_externally_stored_fields( for (i = 0; i < n_fields; i++) { if (rec_offs_nth_extern(offsets, i)) { - - data = rec_get_nth_field(rec, offsets, i, &len); - btr_free_externally_stored_field(index, data, len, - do_not_free_inherited, - mtr); + btr_free_externally_stored_field( + index, btr_rec_get_field_ref(rec, offsets, i), + rec, offsets, page_zip, i, rb_ctx, mtr); } } } -/*************************************************************** +/***********************************************************//** Frees the externally stored fields for a record, if the field is mentioned in the update vector. */ static void btr_rec_free_updated_extern_fields( /*===============================*/ - dict_index_t* index, /* in: index of rec; the index tree MUST be + 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) */ - upd_t* update, /* in: update vector */ - 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 + rec_t* rec, /*!< in/out: record */ + page_zip_des_t* page_zip,/*!< in: compressed page whose uncompressed + part will be updated, or NULL */ + const ulint* offsets,/*!< in: rec_get_offsets(rec, index) */ + const upd_t* update, /*!< in: update vector */ + enum trx_rb_ctx rb_ctx, /*!< in: rollback context */ + mtr_t* mtr) /*!< in: mini-transaction handle which contains an X-latch to record page and to the tree */ { - upd_field_t* ufield; - ulint n_fields; - byte* data; - ulint len; - ulint i; + ulint n_fields; + ulint i; ut_ad(rec_offs_validate(rec, index, offsets)); - ut_ad(mtr_memo_contains(mtr, buf_block_align(rec), - MTR_MEMO_PAGE_X_FIX)); + ut_ad(mtr_memo_contains_page(mtr, rec, MTR_MEMO_PAGE_X_FIX)); /* Free possible externally stored fields in the record */ n_fields = upd_get_n_fields(update); for (i = 0; i < n_fields; i++) { - ufield = upd_get_nth_field(update, i); + const upd_field_t* ufield = upd_get_nth_field(update, i); if (rec_offs_nth_extern(offsets, ufield->field_no)) { + ulint len; + byte* data = rec_get_nth_field( + rec, offsets, ufield->field_no, &len); + ut_a(len >= BTR_EXTERN_FIELD_REF_SIZE); + + btr_free_externally_stored_field( + index, data + len - BTR_EXTERN_FIELD_REF_SIZE, + rec, offsets, page_zip, + ufield->field_no, rb_ctx, mtr); + } + } +} + +/*******************************************************************//** +Copies the prefix of an uncompressed BLOB. The clustered index record +that points to this BLOB must be protected by a lock or a page latch. +@return number of bytes written to buf */ +static +ulint +btr_copy_blob_prefix( +/*=================*/ + byte* buf, /*!< out: the externally stored part of + the field, or a prefix of it */ + ulint len, /*!< in: length of buf, in bytes */ + ulint space_id,/*!< in: space id of the BLOB pages */ + ulint page_no,/*!< in: page number of the first BLOB page */ + ulint offset) /*!< in: offset on the first BLOB page */ +{ + ulint copied_len = 0; + + for (;;) { + mtr_t mtr; + buf_block_t* block; + const page_t* page; + const byte* blob_header; + ulint part_len; + ulint copy_len; + + mtr_start(&mtr); + + block = buf_page_get(space_id, 0, page_no, RW_S_LATCH, &mtr); + buf_block_dbg_add_level(block, SYNC_EXTERN_STORAGE); + page = buf_block_get_frame(block); + + btr_check_blob_fil_page_type(space_id, page_no, page, TRUE); + + blob_header = page + offset; + part_len = btr_blob_get_part_len(blob_header); + copy_len = ut_min(part_len, len - copied_len); + + memcpy(buf + copied_len, + blob_header + BTR_BLOB_HDR_SIZE, copy_len); + copied_len += copy_len; + + page_no = btr_blob_get_next_page_no(blob_header); + + mtr_commit(&mtr); - data = rec_get_nth_field(rec, offsets, - ufield->field_no, &len); - btr_free_externally_stored_field(index, data, len, - do_not_free_inherited, - mtr); + if (page_no == FIL_NULL || copy_len != part_len) { + UNIV_MEM_ASSERT_RW(buf, copied_len); + return(copied_len); } + + /* On other BLOB pages except the first the BLOB header + always is at the page data start: */ + + offset = FIL_PAGE_DATA; + + ut_ad(copied_len <= len); } } -/*********************************************************************** -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. */ +/*******************************************************************//** +Copies the prefix of a compressed BLOB. The clustered index record +that points to this BLOB must be protected by a lock or a page latch. +@return number of bytes written to buf */ +static +ulint +btr_copy_zblob_prefix( +/*==================*/ + byte* buf, /*!< out: the externally stored part of + the field, or a prefix of it */ + ulint len, /*!< in: length of buf, in bytes */ + ulint zip_size,/*!< in: compressed BLOB page size */ + ulint space_id,/*!< in: space id of the BLOB pages */ + ulint page_no,/*!< in: page number of the first BLOB page */ + ulint offset) /*!< in: offset on the first BLOB page */ +{ + ulint page_type = FIL_PAGE_TYPE_ZBLOB; + mem_heap_t* heap; + int err; + z_stream d_stream; + + d_stream.next_out = buf; + d_stream.avail_out = len; + d_stream.next_in = Z_NULL; + d_stream.avail_in = 0; -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 + /* Zlib inflate needs 32 kilobytes for the default + window size, plus a few kilobytes for small objects. */ + heap = mem_heap_create(40000); + page_zip_set_alloc(&d_stream, heap); + + ut_ad(ut_is_2pow(zip_size)); + ut_ad(zip_size >= PAGE_ZIP_MIN_SIZE); + ut_ad(zip_size <= UNIV_PAGE_SIZE); + ut_ad(space_id); + + err = inflateInit(&d_stream); + ut_a(err == Z_OK); + + for (;;) { + buf_page_t* bpage; + ulint next_page_no; + + /* There is no latch on bpage directly. Instead, + bpage is protected by the B-tree page latch that + is being held on the clustered index record, or, + in row_merge_copy_blobs(), by an exclusive table lock. */ + bpage = buf_page_get_zip(space_id, zip_size, page_no); + + if (UNIV_UNLIKELY(!bpage)) { + ut_print_timestamp(stderr); + fprintf(stderr, + " InnoDB: Cannot load" + " compressed BLOB" + " page %lu space %lu\n", + (ulong) page_no, (ulong) space_id); + goto func_exit; + } + + if (UNIV_UNLIKELY + (fil_page_get_type(bpage->zip.data) != page_type)) { + ut_print_timestamp(stderr); + fprintf(stderr, + " InnoDB: Unexpected type %lu of" + " compressed BLOB" + " page %lu space %lu\n", + (ulong) fil_page_get_type(bpage->zip.data), + (ulong) page_no, (ulong) space_id); + goto end_of_blob; + } + + next_page_no = mach_read_from_4(bpage->zip.data + offset); + + if (UNIV_LIKELY(offset == FIL_PAGE_NEXT)) { + /* When the BLOB begins at page header, + the compressed data payload does not + immediately follow the next page pointer. */ + offset = FIL_PAGE_DATA; + } else { + offset += 4; + } + + d_stream.next_in = bpage->zip.data + offset; + d_stream.avail_in = zip_size - offset; + + err = inflate(&d_stream, Z_NO_FLUSH); + switch (err) { + case Z_OK: + if (!d_stream.avail_out) { + goto end_of_blob; + } + break; + case Z_STREAM_END: + if (next_page_no == FIL_NULL) { + goto end_of_blob; + } + /* fall through */ + default: +inflate_error: + ut_print_timestamp(stderr); + fprintf(stderr, + " InnoDB: inflate() of" + " compressed BLOB" + " page %lu space %lu returned %d (%s)\n", + (ulong) page_no, (ulong) space_id, + err, d_stream.msg); + case Z_BUF_ERROR: + goto end_of_blob; + } + + if (next_page_no == FIL_NULL) { + if (!d_stream.avail_in) { + ut_print_timestamp(stderr); + fprintf(stderr, + " InnoDB: unexpected end of" + " compressed BLOB" + " page %lu space %lu\n", + (ulong) page_no, + (ulong) space_id); + } else { + err = inflate(&d_stream, Z_FINISH); + switch (err) { + case Z_STREAM_END: + case Z_BUF_ERROR: + break; + default: + goto inflate_error; + } + } + +end_of_blob: + buf_page_release_zip(bpage); + goto func_exit; + } + + buf_page_release_zip(bpage); + + /* On other BLOB pages except the first + the BLOB header always is at the page header: */ + + page_no = next_page_no; + offset = FIL_PAGE_NEXT; + page_type = FIL_PAGE_TYPE_ZBLOB2; + } + +func_exit: + inflateEnd(&d_stream); + mem_heap_free(heap); + UNIV_MEM_ASSERT_RW(buf, d_stream.total_out); + return(d_stream.total_out); +} + +/*******************************************************************//** +Copies the prefix of an externally stored field of a record. The +clustered index record that points to this BLOB must be protected by a +lock or a page latch. +@return number of bytes written to buf */ +static +ulint +btr_copy_externally_stored_field_prefix_low( +/*========================================*/ + byte* buf, /*!< out: the externally stored part of + the field, or a prefix of it */ + ulint len, /*!< in: length of buf, in bytes */ + ulint zip_size,/*!< in: nonzero=compressed BLOB page size, + zero for uncompressed BLOBs */ + ulint space_id,/*!< in: space id of the first BLOB page */ + ulint page_no,/*!< in: page number of the first BLOB page */ + ulint offset) /*!< in: offset on the first BLOB page */ +{ + if (UNIV_UNLIKELY(len == 0)) { + return(0); + } + + if (UNIV_UNLIKELY(zip_size)) { + return(btr_copy_zblob_prefix(buf, len, zip_size, + space_id, page_no, offset)); + } else { + return(btr_copy_blob_prefix(buf, len, space_id, + page_no, offset)); + } +} + +/*******************************************************************//** +Copies the prefix of an externally stored field of a record. The +clustered index record must be protected by a lock or a page latch. +@return the length of the copied field, or 0 if the column was being +or has been deleted */ +UNIV_INTERN +ulint +btr_copy_externally_stored_field_prefix( +/*====================================*/ + byte* buf, /*!< out: the field, or a prefix of it */ + ulint len, /*!< in: length of buf, in bytes */ + ulint zip_size,/*!< in: nonzero=compressed BLOB page size, + zero for uncompressed BLOBs */ + const 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 */ + the external part; must be protected by + a lock or a page latch */ + ulint local_len)/*!< in: length of data, in bytes */ { - page_t* page; ulint space_id; ulint page_no; ulint offset; - ulint extern_len; - byte* blob_header; - ulint part_len; - byte* buf; - ulint copied_len; - mtr_t mtr; ut_a(local_len >= BTR_EXTERN_FIELD_REF_SIZE); local_len -= BTR_EXTERN_FIELD_REF_SIZE; - space_id = mach_read_from_4(data + local_len + BTR_EXTERN_SPACE_ID); + if (UNIV_UNLIKELY(local_len >= len)) { + memcpy(buf, data, len); + return(len); + } - page_no = mach_read_from_4(data + local_len + BTR_EXTERN_PAGE_NO); + memcpy(buf, data, local_len); + data += local_len; - offset = mach_read_from_4(data + local_len + BTR_EXTERN_OFFSET); + ut_a(memcmp(data, field_ref_zero, BTR_EXTERN_FIELD_REF_SIZE)); - /* Currently a BLOB cannot be bigger that 4 GB; we - leave the 4 upper bytes in the length field unused */ - - extern_len = mach_read_from_4(data + local_len + BTR_EXTERN_LEN + 4); + if (!mach_read_from_4(data + BTR_EXTERN_LEN + 4)) { + /* The externally stored part of the column has been + (partially) deleted. Signal the half-deleted BLOB + to the caller. */ - buf = mem_heap_alloc(heap, local_len + extern_len); + return(0); + } - ut_memcpy(buf, data, local_len); - copied_len = local_len; + space_id = mach_read_from_4(data + BTR_EXTERN_SPACE_ID); - if (extern_len == 0) { - *len = copied_len; + page_no = mach_read_from_4(data + BTR_EXTERN_PAGE_NO); - return(buf); - } + offset = mach_read_from_4(data + BTR_EXTERN_OFFSET); - for (;;) { - mtr_start(&mtr); + return(local_len + + btr_copy_externally_stored_field_prefix_low(buf + local_len, + len - local_len, + zip_size, + space_id, page_no, + offset)); +} - page = buf_page_get(space_id, page_no, RW_S_LATCH, &mtr); -#ifdef UNIV_SYNC_DEBUG - buf_page_dbg_add_level(page, SYNC_EXTERN_STORAGE); -#endif /* UNIV_SYNC_DEBUG */ - blob_header = page + offset; +/*******************************************************************//** +Copies an externally stored field of a record to mem heap. The +clustered index record must be protected by a lock or a page latch. +@return the whole field copied to heap */ +static +byte* +btr_copy_externally_stored_field( +/*=============================*/ + ulint* len, /*!< out: length of the whole field */ + const byte* data, /*!< in: 'internally' stored part of the + field containing also the reference to + the external part; must be protected by + a lock or a page latch */ + ulint zip_size,/*!< in: nonzero=compressed BLOB page size, + zero for uncompressed BLOBs */ + ulint local_len,/*!< in: length of data */ + mem_heap_t* heap) /*!< in: mem heap */ +{ + ulint space_id; + ulint page_no; + ulint offset; + ulint extern_len; + byte* buf; - part_len = btr_blob_get_part_len(blob_header); + ut_a(local_len >= BTR_EXTERN_FIELD_REF_SIZE); - ut_memcpy(buf + copied_len, blob_header + BTR_BLOB_HDR_SIZE, - part_len); - copied_len += part_len; + local_len -= BTR_EXTERN_FIELD_REF_SIZE; - page_no = btr_blob_get_next_page_no(blob_header); + space_id = mach_read_from_4(data + local_len + BTR_EXTERN_SPACE_ID); - mtr_commit(&mtr); + page_no = mach_read_from_4(data + local_len + BTR_EXTERN_PAGE_NO); - if (page_no == FIL_NULL) { - ut_a(copied_len == local_len + extern_len); + offset = mach_read_from_4(data + local_len + BTR_EXTERN_OFFSET); - *len = copied_len; + /* Currently a BLOB cannot be bigger than 4 GB; we + leave the 4 upper bytes in the length field unused */ - return(buf); - } + extern_len = mach_read_from_4(data + local_len + BTR_EXTERN_LEN + 4); - /* On other BLOB pages except the first the BLOB header - always is at the page data start: */ + buf = mem_heap_alloc(heap, local_len + extern_len); - offset = FIL_PAGE_DATA; + memcpy(buf, data, local_len); + *len = local_len + + btr_copy_externally_stored_field_prefix_low(buf + local_len, + extern_len, + zip_size, + space_id, + page_no, offset); - ut_a(copied_len < local_len + extern_len); - } + return(buf); } -/*********************************************************************** -Copies an externally stored field of a record to mem heap. */ - +/*******************************************************************//** +Copies an externally stored field of a record to mem heap. +@return the field copied to heap, or NULL if the field is incomplete */ +UNIV_INTERN 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 */ + const rec_t* rec, /*!< in: record in a clustered index; + must be protected by a lock or a page latch */ + const ulint* offsets,/*!< in: array returned by rec_get_offsets() */ + ulint zip_size,/*!< in: nonzero=compressed BLOB page size, + zero for uncompressed BLOBs */ + ulint no, /*!< in: field number */ + ulint* len, /*!< out: length of the field */ + mem_heap_t* heap) /*!< in: mem heap */ { - ulint local_len; - byte* data; + ulint local_len; + const byte* data; - ut_ad(rec_offs_validate(rec, NULL, offsets)); ut_a(rec_offs_nth_extern(offsets, no)); /* An externally stored field can contain some initial @@ -3943,5 +5244,19 @@ btr_rec_copy_externally_stored_field( data = rec_get_nth_field(rec, offsets, no, &local_len); - return(btr_copy_externally_stored_field(len, data, local_len, heap)); + ut_a(local_len >= BTR_EXTERN_FIELD_REF_SIZE); + + if (UNIV_UNLIKELY + (!memcmp(data + local_len - BTR_EXTERN_FIELD_REF_SIZE, + field_ref_zero, BTR_EXTERN_FIELD_REF_SIZE))) { + /* The externally stored field was not written yet. + This record should only be seen by + recv_recovery_rollback_active() or any + TRX_ISO_READ_UNCOMMITTED transactions. */ + return(NULL); + } + + return(btr_copy_externally_stored_field(len, data, + zip_size, local_len, heap)); } +#endif /* !UNIV_HOTBACKUP */ |