mtr0log.h

Go to the documentation of this file.

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

Copyright (c) 1995, 2009, 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 mtr0log_h
#define mtr0log_h

#include "univ.i"
#include "mtr0mtr.h"
#include "dict0types.h"

#ifndef UNIV_HOTBACKUP
/********************************************************/
UNIV_INTERN
void
mlog_write_ulint(
/*=============*/
        byte*   ptr,    
        ulint   val,    
        byte    type,   
        mtr_t*  mtr);   
/********************************************************/
UNIV_INTERN
void
mlog_write_ull(
/*===========*/
        byte*           ptr,    
        ib_uint64_t     val,    
        mtr_t*          mtr);   
/********************************************************/
UNIV_INTERN
void
mlog_write_string(
/*==============*/
        byte*           ptr,    
        const byte*     str,    
        ulint           len,    
        mtr_t*          mtr);   
/********************************************************/
UNIV_INTERN
void
mlog_log_string(
/*============*/
        byte*   ptr,    
        ulint   len,    
        mtr_t*  mtr);   
/********************************************************/
UNIV_INTERN
void
mlog_write_initial_log_record(
/*==========================*/
        const byte*     ptr,    
        byte            type,   
        mtr_t*          mtr);   
/********************************************************/
UNIV_INLINE
byte*
mlog_write_initial_log_record_for_file_op(
/*======================================*/
        ulint   type,   
        ulint   space_id,
        ulint   page_no,
        byte*   log_ptr,
        mtr_t*  mtr);   
/********************************************************/
UNIV_INLINE
void
mlog_catenate_ulint(
/*================*/
        mtr_t*  mtr,    
        ulint   val,    
        ulint   type);  
/********************************************************/
UNIV_INTERN
void
mlog_catenate_string(
/*=================*/
        mtr_t*          mtr,    
        const byte*     str,    
        ulint           len);   
/********************************************************/
UNIV_INLINE
void
mlog_catenate_ulint_compressed(
/*===========================*/
        mtr_t*  mtr,    
        ulint   val);   
/********************************************************/
UNIV_INLINE
void
mlog_catenate_ull_compressed(
/*=========================*/
        mtr_t*          mtr,    
        ib_uint64_t     val);   
/********************************************************/
UNIV_INLINE
byte*
mlog_open(
/*======*/
        mtr_t*  mtr,    
        ulint   size);  
/********************************************************/
UNIV_INLINE
void
mlog_close(
/*=======*/
        mtr_t*  mtr,    
        byte*   ptr);   
/********************************************************/
UNIV_INLINE
byte*
mlog_write_initial_log_record_fast(
/*===============================*/
        const byte*     ptr,    
        byte            type,   
        byte*           log_ptr,
        mtr_t*          mtr);   
#else /* !UNIV_HOTBACKUP */
# define mlog_write_initial_log_record(ptr,type,mtr) ((void) 0)
# define mlog_write_initial_log_record_fast(ptr,type,log_ptr,mtr) ((byte*) 0)
#endif /* !UNIV_HOTBACKUP */
/********************************************************/
UNIV_INTERN
byte*
mlog_parse_initial_log_record(
/*==========================*/
        byte*   ptr,    
        byte*   end_ptr,
        byte*   type,   
        ulint*  space,  
        ulint*  page_no);
/********************************************************/
UNIV_INTERN
byte*
mlog_parse_nbytes(
/*==============*/
        ulint   type,   
        byte*   ptr,    
        byte*   end_ptr,
        byte*   page,   
        void*   page_zip);
/********************************************************/
UNIV_INTERN
byte*
mlog_parse_string(
/*==============*/
        byte*   ptr,    
        byte*   end_ptr,
        byte*   page,   
        void*   page_zip);
#ifndef UNIV_HOTBACKUP
/********************************************************/
UNIV_INTERN
byte*
mlog_open_and_write_index(
/*======================*/
        mtr_t*                  mtr,    
        const byte*             rec,    
        const dict_index_t*     index,  
        byte                    type,   
        ulint                   size);  
#endif /* !UNIV_HOTBACKUP */

/********************************************************/
UNIV_INTERN
byte*
mlog_parse_index(
/*=============*/
        byte*           ptr,    
        const byte*     end_ptr,
        ibool           comp,   
        dict_index_t**  index); 
#ifndef UNIV_HOTBACKUP
/* Insert, update, and maybe other functions may use this value to define an
extra mlog buffer size for variable size data */
#define MLOG_BUF_MARGIN 256
#endif /* !UNIV_HOTBACKUP */

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

#endif