ibuf0ibuf.h

Go to the documentation of this file.

/*****************************************************************************

Copyright (c) 1997, 2013, Oracle and/or its affiliates. All Rights Reserved.

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

*****************************************************************************/

/**************************************************/
#ifndef ibuf0ibuf_h
#define ibuf0ibuf_h

#include "univ.i"

#include "mtr0mtr.h"
#include "dict0mem.h"
#include "fsp0fsp.h"

#ifndef UNIV_HOTBACKUP
# include "ibuf0types.h"

#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;

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;

extern ibuf_use_t       ibuf_use;

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. */

/******************************************************************/
UNIV_INTERN
void
ibuf_init_at_db_start(void);
/*=======================*/
/*********************************************************************/
UNIV_INTERN
void
ibuf_max_size_update(
/*=================*/
        ulint   new_val);       
/*********************************************************************/
UNIV_INTERN
void
ibuf_update_max_tablespace_id(void);
/*===============================*/
/***************************************************************/
UNIV_INLINE
void
ibuf_mtr_start(
/*===========*/
        mtr_t*  mtr)    
        __attribute__((nonnull));
/***************************************************************/
UNIV_INLINE
void
ibuf_mtr_commit(
/*============*/
        mtr_t*  mtr)    
        __attribute__((nonnull));
/*********************************************************************/
UNIV_INTERN
void
ibuf_bitmap_page_init(
/*==================*/
        buf_block_t*    block,  
        mtr_t*          mtr);   
/************************************************************************/
UNIV_INTERN
void
ibuf_reset_free_bits(
/*=================*/
        buf_block_t*    block); 
/************************************************************************/
UNIV_INLINE
void
ibuf_update_free_bits_if_full(
/*==========================*/
        buf_block_t*    block,  
        ulint           max_ins_size,
        ulint           increase);
/**********************************************************************/
UNIV_INTERN
void
ibuf_update_free_bits_low(
/*======================*/
        const buf_block_t*      block,          
        ulint                   max_ins_size,   
        mtr_t*                  mtr);           
/**********************************************************************/
UNIV_INTERN
void
ibuf_update_free_bits_zip(
/*======================*/
        buf_block_t*    block,  
        mtr_t*          mtr);   
/**********************************************************************/
UNIV_INTERN
void
ibuf_update_free_bits_for_two_pages_low(
/*====================================*/
        ulint           zip_size,
        buf_block_t*    block1, 
        buf_block_t*    block2, 
        mtr_t*          mtr);   
/**********************************************************************/
UNIV_INLINE
ibool
ibuf_should_try(
/*============*/
        dict_index_t*   index,                  
        ulint           ignore_sec_unique);     
/******************************************************************/
UNIV_INLINE
ibool
ibuf_inside(
/*========*/
        const mtr_t*    mtr)    
        __attribute__((nonnull, pure));
/***********************************************************************/
UNIV_INLINE
ibool
ibuf_bitmap_page(
/*=============*/
        ulint   zip_size,
        ulint   page_no);
/***********************************************************************/
UNIV_INTERN
ibool
ibuf_page_low(
/*==========*/
        ulint           space,  
        ulint           zip_size,
        ulint           page_no,
#ifdef UNIV_DEBUG
        ibool           x_latch,
#endif /* UNIV_DEBUG */
        const char*     file,   
        ulint           line,   
        mtr_t*          mtr)    
        __attribute__((warn_unused_result));
#ifdef UNIV_DEBUG

# define ibuf_page(space, zip_size, page_no, mtr)                       \
        ibuf_page_low(space, zip_size, page_no, TRUE, __FILE__, __LINE__, mtr)
#else /* UVIV_DEBUG */

# define ibuf_page(space, zip_size, page_no, mtr)                       \
        ibuf_page_low(space, zip_size, page_no, __FILE__, __LINE__, mtr)
#endif /* UVIV_DEBUG */
/***********************************************************************/
UNIV_INTERN
void
ibuf_free_excess_pages(void);
/*========================*/
/*********************************************************************/
UNIV_INTERN
ibool
ibuf_insert(
/*========*/
        ibuf_op_t       op,     
        const dtuple_t* entry,  
        dict_index_t*   index,  
        ulint           space,  
        ulint           zip_size,
        ulint           page_no,
        que_thr_t*      thr);   
/*********************************************************************/
UNIV_INTERN
void
ibuf_merge_or_delete_for_page(
/*==========================*/
        buf_block_t*    block,  
        ulint           space,  
        ulint           page_no,
        ulint           zip_size,
        ibool           update_ibuf_bitmap);
/*********************************************************************/
UNIV_INTERN
void
ibuf_delete_for_discarded_space(
/*============================*/
        ulint   space); 
/*********************************************************************/
UNIV_INTERN
ulint
ibuf_contract_in_background(
/*========================*/
        table_id_t      table_id,       
        ibool           full);          
#endif /* !UNIV_HOTBACKUP */
/*********************************************************************/
UNIV_INTERN
byte*
ibuf_parse_bitmap_init(
/*===================*/
        byte*           ptr,    
        byte*           end_ptr,
        buf_block_t*    block,  
        mtr_t*          mtr);   
#ifndef UNIV_HOTBACKUP
#ifdef UNIV_IBUF_COUNT_DEBUG
/******************************************************************/
UNIV_INTERN
ulint
ibuf_count_get(
/*===========*/
        ulint   space,  
        ulint   page_no);
#endif
/******************************************************************/
UNIV_INTERN
bool
ibuf_is_empty(void);
/*===============*/
/******************************************************************/
UNIV_INTERN
void
ibuf_print(
/*=======*/
        FILE*   file);  
/********************************************************************
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 */
UNIV_INTERN
ulint
ibuf_rec_get_counter(
/*=================*/
        const rec_t*    rec);   
/******************************************************************/
UNIV_INTERN
void
ibuf_close(void);
/*============*/

/******************************************************************/
UNIV_INTERN
dberr_t
ibuf_check_bitmap_on_import(
/*========================*/
        const trx_t*    trx,            
        ulint           space_id)       
        __attribute__((nonnull, warn_unused_result));

#define IBUF_HEADER_PAGE_NO     FSP_IBUF_HEADER_PAGE_NO
#define IBUF_TREE_ROOT_PAGE_NO  FSP_IBUF_TREE_ROOT_PAGE_NO

#endif /* !UNIV_HOTBACKUP */

/* 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           0

#ifndef UNIV_NONINL
#include "ibuf0ibuf.ic"
#endif

#endif