mirror of
https://github.com/MariaDB/server.git
synced 2025-01-22 06:44:16 +01:00
89d80c1b0b
Define my_thread_id as an unsigned type, to avoid mismatch with ulonglong. Change some parameters to this type. Use size_t in a few more places. Declare many flag constants as unsigned to avoid sign mismatch when shifting bits or applying the unary ~ operator. When applying the unary ~ operator to enum constants, explictly cast the result to an unsigned type, because enum constants can be treated as signed. In InnoDB, change the source code line number parameters from ulint to unsigned type. Also, make some InnoDB functions return a narrower type (unsigned or uint32_t instead of ulint; bool instead of ibool).
457 lines
17 KiB
C
457 lines
17 KiB
C
/*****************************************************************************
|
|
|
|
Copyright (c) 1997, 2016, Oracle and/or its affiliates. All Rights Reserved.
|
|
Copyright (c) 2016, 2017, MariaDB Corporation.
|
|
|
|
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.,
|
|
51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA
|
|
|
|
*****************************************************************************/
|
|
|
|
/**************************************************//**
|
|
@file include/ibuf0ibuf.h
|
|
Insert buffer
|
|
|
|
Created 7/19/1997 Heikki Tuuri
|
|
*******************************************************/
|
|
|
|
#ifndef ibuf0ibuf_h
|
|
#define ibuf0ibuf_h
|
|
|
|
#include "univ.i"
|
|
|
|
#include "mtr0mtr.h"
|
|
#include "dict0mem.h"
|
|
#include "fsp0fsp.h"
|
|
#include "ibuf0types.h"
|
|
|
|
/** Default value for maximum on-disk size of change buffer in terms
|
|
of percentage of the buffer pool. */
|
|
#define CHANGE_BUFFER_DEFAULT_SIZE (25)
|
|
|
|
/* Possible operations buffered in the insert/whatever buffer. See
|
|
ibuf_insert(). DO NOT CHANGE THE VALUES OF THESE, THEY ARE STORED ON DISK. */
|
|
typedef enum {
|
|
IBUF_OP_INSERT = 0,
|
|
IBUF_OP_DELETE_MARK = 1,
|
|
IBUF_OP_DELETE = 2,
|
|
|
|
/* Number of different operation types. */
|
|
IBUF_OP_COUNT = 3
|
|
} ibuf_op_t;
|
|
|
|
/** Combinations of operations that can be buffered. Because the enum
|
|
values are used for indexing innobase_change_buffering_values[], they
|
|
should start at 0 and there should not be any gaps. */
|
|
typedef enum {
|
|
IBUF_USE_NONE = 0,
|
|
IBUF_USE_INSERT, /* insert */
|
|
IBUF_USE_DELETE_MARK, /* delete */
|
|
IBUF_USE_INSERT_DELETE_MARK, /* insert+delete */
|
|
IBUF_USE_DELETE, /* delete+purge */
|
|
IBUF_USE_ALL, /* insert+delete+purge */
|
|
|
|
IBUF_USE_COUNT /* number of entries in ibuf_use_t */
|
|
} ibuf_use_t;
|
|
|
|
/** Operations that can currently be buffered. */
|
|
extern ibuf_use_t ibuf_use;
|
|
|
|
/** The insert buffer control structure */
|
|
extern ibuf_t* ibuf;
|
|
|
|
/* The purpose of the insert buffer is to reduce random disk access.
|
|
When we wish to insert a record into a non-unique secondary index and
|
|
the B-tree leaf page where the record belongs to is not in the buffer
|
|
pool, we insert the record into the insert buffer B-tree, indexed by
|
|
(space_id, page_no). When the page is eventually read into the buffer
|
|
pool, we look up the insert buffer B-tree for any modifications to the
|
|
page, and apply these upon the completion of the read operation. This
|
|
is called the insert buffer merge. */
|
|
|
|
/* The insert buffer merge must always succeed. To guarantee this,
|
|
the insert buffer subsystem keeps track of the free space in pages for
|
|
which it can buffer operations. Two bits per page in the insert
|
|
buffer bitmap indicate the available space in coarse increments. 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. */
|
|
|
|
/******************************************************************//**
|
|
Creates the insert buffer data structure at a database startup.
|
|
@return DB_SUCCESS or failure */
|
|
dberr_t
|
|
ibuf_init_at_db_start(void);
|
|
/*=======================*/
|
|
/*********************************************************************//**
|
|
Updates the max_size value for ibuf. */
|
|
void
|
|
ibuf_max_size_update(
|
|
/*=================*/
|
|
ulint new_val); /*!< in: new value in terms of
|
|
percentage of the buffer pool size */
|
|
/*********************************************************************//**
|
|
Reads the biggest tablespace id from the high end of the insert buffer
|
|
tree and updates the counter in fil_system. */
|
|
void
|
|
ibuf_update_max_tablespace_id(void);
|
|
/*===============================*/
|
|
/***************************************************************//**
|
|
Starts an insert buffer mini-transaction. */
|
|
UNIV_INLINE
|
|
void
|
|
ibuf_mtr_start(
|
|
/*===========*/
|
|
mtr_t* mtr) /*!< out: mini-transaction */
|
|
MY_ATTRIBUTE((nonnull));
|
|
/***************************************************************//**
|
|
Commits an insert buffer mini-transaction. */
|
|
UNIV_INLINE
|
|
void
|
|
ibuf_mtr_commit(
|
|
/*============*/
|
|
mtr_t* mtr) /*!< in/out: mini-transaction */
|
|
MY_ATTRIBUTE((nonnull));
|
|
/*********************************************************************//**
|
|
Initializes an ibuf bitmap page. */
|
|
void
|
|
ibuf_bitmap_page_init(
|
|
/*==================*/
|
|
buf_block_t* block, /*!< in: bitmap page */
|
|
mtr_t* mtr); /*!< in: mtr */
|
|
/************************************************************************//**
|
|
Resets the free bits of the page in the ibuf bitmap. This is done in a
|
|
separate mini-transaction, hence this operation does not restrict
|
|
further work to only ibuf bitmap operations, which would result if the
|
|
latch to the bitmap page were kept. NOTE: 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. */
|
|
void
|
|
ibuf_reset_free_bits(
|
|
/*=================*/
|
|
buf_block_t* block); /*!< in: index page; free bits are set to 0
|
|
if the index is a non-clustered
|
|
non-unique, and page level is 0 */
|
|
/************************************************************************//**
|
|
Updates the free bits of an uncompressed page in the ibuf bitmap if
|
|
there is not enough free on the page any more. This is done in a
|
|
separate mini-transaction, hence this operation does not restrict
|
|
further work to only ibuf bitmap operations, which would result if the
|
|
latch to the bitmap page were kept. NOTE: The free bits in the insert
|
|
buffer bitmap must never exceed the free space on a page. 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. It is only safe to use this function for
|
|
decrementing the free bits. Should more free space become available,
|
|
we must not update the free bits here, because that would break crash
|
|
recovery. */
|
|
UNIV_INLINE
|
|
void
|
|
ibuf_update_free_bits_if_full(
|
|
/*==========================*/
|
|
buf_block_t* block, /*!< in: index page to which we have added new
|
|
records; the free bits are updated if the
|
|
index is non-clustered and non-unique and
|
|
the page level is 0, and the page becomes
|
|
fuller */
|
|
ulint max_ins_size,/*!< in: value of maximum insert size with
|
|
reorganize before the latest operation
|
|
performed to the page */
|
|
ulint increase);/*!< in: upper limit for the additional space
|
|
used in the latest operation, if known, or
|
|
ULINT_UNDEFINED */
|
|
/**********************************************************************//**
|
|
Updates the free bits for an uncompressed page to reflect the present
|
|
state. Does this in the mtr given, which means that the latching
|
|
order rules virtually prevent any further operations for this OS
|
|
thread until mtr is committed. NOTE: The free bits in the insert
|
|
buffer bitmap must never exceed the free space on a page. It is safe
|
|
to set the free bits in the same mini-transaction that updated the
|
|
page. */
|
|
void
|
|
ibuf_update_free_bits_low(
|
|
/*======================*/
|
|
const buf_block_t* block, /*!< in: index page */
|
|
ulint max_ins_size, /*!< in: value of
|
|
maximum insert size
|
|
with reorganize before
|
|
the latest operation
|
|
performed to the page */
|
|
mtr_t* mtr); /*!< in/out: mtr */
|
|
/**********************************************************************//**
|
|
Updates the free bits for a compressed page to reflect the present
|
|
state. Does this in the mtr given, which means that the latching
|
|
order rules virtually prevent any further operations for this OS
|
|
thread until mtr is committed. NOTE: The free bits in the insert
|
|
buffer bitmap must never exceed the free space on a page. It is safe
|
|
to set the free bits in the same mini-transaction that updated the
|
|
page. */
|
|
void
|
|
ibuf_update_free_bits_zip(
|
|
/*======================*/
|
|
buf_block_t* block, /*!< in/out: index page */
|
|
mtr_t* mtr); /*!< in/out: mtr */
|
|
/**********************************************************************//**
|
|
Updates the free bits for the two pages to reflect the present state.
|
|
Does this in the mtr given, which means that the latching order rules
|
|
virtually prevent any further operations until mtr is committed.
|
|
NOTE: The free bits in the insert buffer bitmap must never exceed the
|
|
free space on a page. It is safe to set the free bits in the same
|
|
mini-transaction that updated the pages. */
|
|
void
|
|
ibuf_update_free_bits_for_two_pages_low(
|
|
/*====================================*/
|
|
buf_block_t* block1, /*!< in: index page */
|
|
buf_block_t* block2, /*!< in: index page */
|
|
mtr_t* mtr); /*!< in: mtr */
|
|
/**********************************************************************//**
|
|
A basic partial test if an insert to the insert buffer could be possible and
|
|
recommended. */
|
|
UNIV_INLINE
|
|
ibool
|
|
ibuf_should_try(
|
|
/*============*/
|
|
dict_index_t* index, /*!< in: index where to insert */
|
|
ulint ignore_sec_unique); /*!< in: if != 0, we should
|
|
ignore UNIQUE constraint on
|
|
a secondary index when we
|
|
decide */
|
|
/******************************************************************//**
|
|
Returns TRUE if the current OS thread is performing an insert buffer
|
|
routine.
|
|
|
|
For instance, a read-ahead of non-ibuf pages is forbidden by threads
|
|
that are executing an insert buffer routine.
|
|
@return TRUE if inside an insert buffer routine */
|
|
UNIV_INLINE
|
|
ibool
|
|
ibuf_inside(
|
|
/*========*/
|
|
const mtr_t* mtr) /*!< in: mini-transaction */
|
|
MY_ATTRIBUTE((warn_unused_result));
|
|
|
|
/** Checks if a page address is an ibuf bitmap page (level 3 page) address.
|
|
@param[in] page_id page id
|
|
@param[in] page_size page size
|
|
@return TRUE if a bitmap page */
|
|
UNIV_INLINE
|
|
ibool
|
|
ibuf_bitmap_page(
|
|
const page_id_t& page_id,
|
|
const page_size_t& page_size);
|
|
|
|
/** Checks if a page is a level 2 or 3 page in the ibuf hierarchy of pages.
|
|
Must not be called when recv_no_ibuf_operations==true.
|
|
@param[in] page_id page id
|
|
@param[in] page_size page size
|
|
@param[in] x_latch FALSE if relaxed check (avoid latching the
|
|
bitmap page)
|
|
@param[in] file file name
|
|
@param[in] line line where called
|
|
@param[in,out] mtr mtr which will contain an x-latch to the
|
|
bitmap page if the page is not one of the fixed address ibuf pages, or NULL,
|
|
in which case a new transaction is created.
|
|
@return TRUE if level 2 or level 3 page */
|
|
ibool
|
|
ibuf_page_low(
|
|
const page_id_t& page_id,
|
|
const page_size_t& page_size,
|
|
#ifdef UNIV_DEBUG
|
|
ibool x_latch,
|
|
#endif /* UNIV_DEBUG */
|
|
const char* file,
|
|
unsigned line,
|
|
mtr_t* mtr)
|
|
MY_ATTRIBUTE((warn_unused_result));
|
|
|
|
#ifdef UNIV_DEBUG
|
|
|
|
/** Checks if a page is a level 2 or 3 page in the ibuf hierarchy of pages.
|
|
Must not be called when recv_no_ibuf_operations==true.
|
|
@param[in] page_id tablespace/page identifier
|
|
@param[in] page_size page size
|
|
@param[in,out] mtr mini-transaction or NULL
|
|
@return TRUE if level 2 or level 3 page */
|
|
# define ibuf_page(page_id, page_size, mtr) \
|
|
ibuf_page_low(page_id, page_size, TRUE, __FILE__, __LINE__, mtr)
|
|
|
|
#else /* UVIV_DEBUG */
|
|
|
|
/** Checks if a page is a level 2 or 3 page in the ibuf hierarchy of pages.
|
|
Must not be called when recv_no_ibuf_operations==true.
|
|
@param[in] page_id tablespace/page identifier
|
|
@param[in] page_size page size
|
|
@param[in,out] mtr mini-transaction or NULL
|
|
@return TRUE if level 2 or level 3 page */
|
|
# define ibuf_page(page_id, page_size, mtr) \
|
|
ibuf_page_low(page_id, page_size, __FILE__, __LINE__, mtr)
|
|
|
|
#endif /* UVIV_DEBUG */
|
|
/***********************************************************************//**
|
|
Frees excess pages from the ibuf free list. This function is called when an OS
|
|
thread calls fsp services to allocate a new file segment, or a new page to a
|
|
file segment, and the thread did not own the fsp latch before this call. */
|
|
void
|
|
ibuf_free_excess_pages(void);
|
|
/*========================*/
|
|
|
|
/** Buffer an operation in the insert/delete buffer, instead of doing it
|
|
directly to the disk page, if this is possible. Does not do it if the index
|
|
is clustered or unique.
|
|
@param[in] op operation type
|
|
@param[in] entry index entry to insert
|
|
@param[in,out] index index where to insert
|
|
@param[in] page_id page id where to insert
|
|
@param[in] page_size page size
|
|
@param[in,out] thr query thread
|
|
@return TRUE if success */
|
|
ibool
|
|
ibuf_insert(
|
|
ibuf_op_t op,
|
|
const dtuple_t* entry,
|
|
dict_index_t* index,
|
|
const page_id_t& page_id,
|
|
const page_size_t& page_size,
|
|
que_thr_t* thr);
|
|
|
|
/** When an index page is read from a disk to the buffer pool, this function
|
|
applies any buffered operations to the page and deletes the entries from the
|
|
insert buffer. If the page is not read, but created in the buffer pool, this
|
|
function deletes its buffered entries from the insert buffer; there can
|
|
exist entries for such a page if the page belonged to an index which
|
|
subsequently was dropped.
|
|
@param[in,out] block if page has been read from disk,
|
|
pointer to the page x-latched, else NULL
|
|
@param[in] page_id page id of the index page
|
|
@param[in] update_ibuf_bitmap normally this is set to TRUE, but
|
|
if we have deleted or are deleting the tablespace, then we naturally do not
|
|
want to update a non-existent bitmap page */
|
|
void
|
|
ibuf_merge_or_delete_for_page(
|
|
buf_block_t* block,
|
|
const page_id_t& page_id,
|
|
const page_size_t* page_size,
|
|
ibool update_ibuf_bitmap);
|
|
|
|
/*********************************************************************//**
|
|
Deletes all entries in the insert buffer for a given space id. This is used
|
|
in DISCARD TABLESPACE and IMPORT TABLESPACE.
|
|
NOTE: this does not update the page free bitmaps in the space. The space will
|
|
become CORRUPT when you call this function! */
|
|
void
|
|
ibuf_delete_for_discarded_space(
|
|
/*============================*/
|
|
ulint space); /*!< in: space id */
|
|
/** Contract the change buffer by reading pages to the buffer pool.
|
|
@param[in] full If true, do a full contraction based
|
|
on PCT_IO(100). If false, the size of contract batch is determined
|
|
based on the current size of the change buffer.
|
|
@return a lower limit for the combined size in bytes of entries which
|
|
will be merged from ibuf trees to the pages read, 0 if ibuf is
|
|
empty */
|
|
ulint
|
|
ibuf_merge_in_background(
|
|
bool full);
|
|
|
|
/** Contracts insert buffer trees by reading pages referring to space_id
|
|
to the buffer pool.
|
|
@returns number of pages merged.*/
|
|
ulint
|
|
ibuf_merge_space(
|
|
/*=============*/
|
|
ulint space); /*!< in: space id */
|
|
|
|
/*********************************************************************//**
|
|
Parses a redo log record of an ibuf bitmap page init.
|
|
@return end of log record or NULL */
|
|
byte*
|
|
ibuf_parse_bitmap_init(
|
|
/*===================*/
|
|
byte* ptr, /*!< in: buffer */
|
|
byte* end_ptr,/*!< in: buffer end */
|
|
buf_block_t* block, /*!< in: block or NULL */
|
|
mtr_t* mtr); /*!< in: mtr or NULL */
|
|
|
|
#ifdef UNIV_IBUF_COUNT_DEBUG
|
|
/** Gets the ibuf count for a given page.
|
|
@param[in] page_id page id
|
|
@return number of entries in the insert buffer currently buffered for
|
|
this page */
|
|
ulint
|
|
ibuf_count_get(
|
|
const page_id_t& page_id);
|
|
#endif
|
|
/******************************************************************//**
|
|
Looks if the insert buffer is empty.
|
|
@return true if empty */
|
|
bool
|
|
ibuf_is_empty(void);
|
|
/*===============*/
|
|
/******************************************************************//**
|
|
Prints info of ibuf. */
|
|
void
|
|
ibuf_print(
|
|
/*=======*/
|
|
FILE* file); /*!< in: file where to print */
|
|
/********************************************************************
|
|
Read the first two bytes from a record's fourth field (counter field in new
|
|
records; something else in older records).
|
|
@return "counter" field, or ULINT_UNDEFINED if for some reason it can't be read */
|
|
ulint
|
|
ibuf_rec_get_counter(
|
|
/*=================*/
|
|
const rec_t* rec); /*!< in: ibuf record */
|
|
/******************************************************************//**
|
|
Closes insert buffer and frees the data structures. */
|
|
void
|
|
ibuf_close(void);
|
|
/*============*/
|
|
|
|
/******************************************************************//**
|
|
Checks the insert buffer bitmaps on IMPORT TABLESPACE.
|
|
@return DB_SUCCESS or error code */
|
|
dberr_t
|
|
ibuf_check_bitmap_on_import(
|
|
/*========================*/
|
|
const trx_t* trx, /*!< in: transaction */
|
|
ulint space_id) /*!< in: tablespace identifier */
|
|
MY_ATTRIBUTE((nonnull, warn_unused_result));
|
|
|
|
/** Updates free bits and buffered bits for bulk loaded page.
|
|
@param[in] block index page
|
|
@param]in] reset flag if reset free val */
|
|
void
|
|
ibuf_set_bitmap_for_bulk_load(
|
|
buf_block_t* block,
|
|
bool reset);
|
|
|
|
#define IBUF_HEADER_PAGE_NO FSP_IBUF_HEADER_PAGE_NO
|
|
#define IBUF_TREE_ROOT_PAGE_NO FSP_IBUF_TREE_ROOT_PAGE_NO
|
|
|
|
/* The ibuf header page currently contains only the file segment header
|
|
for the file segment from which the pages for the ibuf tree are allocated */
|
|
#define IBUF_HEADER PAGE_DATA
|
|
#define IBUF_TREE_SEG_HEADER 0 /* fseg header for ibuf tree */
|
|
|
|
/* The insert buffer tree itself is always located in space 0. */
|
|
#define IBUF_SPACE_ID static_cast<ulint>(0)
|
|
|
|
#ifndef UNIV_NONINL
|
|
#include "ibuf0ibuf.ic"
|
|
#endif
|
|
|
|
#endif
|