mirror of
https://github.com/MariaDB/server.git
synced 2025-01-17 12:32:27 +01:00
338 lines
13 KiB
C
338 lines
13 KiB
C
/*****************************************************************************
|
|
|
|
Copyright (c) 1996, 2009, Innobase Oy. 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., 59 Temple
|
|
Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
*****************************************************************************/
|
|
|
|
/**************************************************//**
|
|
@file include/trx0rec.h
|
|
Transaction undo log record
|
|
|
|
Created 3/26/1996 Heikki Tuuri
|
|
*******************************************************/
|
|
|
|
#ifndef trx0rec_h
|
|
#define trx0rec_h
|
|
|
|
#include "univ.i"
|
|
#include "trx0types.h"
|
|
#include "row0types.h"
|
|
#include "mtr0mtr.h"
|
|
#include "dict0types.h"
|
|
#include "data0data.h"
|
|
#include "rem0types.h"
|
|
|
|
#ifndef UNIV_HOTBACKUP
|
|
# include "que0types.h"
|
|
|
|
/***********************************************************************//**
|
|
Copies the undo record to the heap.
|
|
@return own: copy of undo log record */
|
|
UNIV_INLINE
|
|
trx_undo_rec_t*
|
|
trx_undo_rec_copy(
|
|
/*==============*/
|
|
trx_undo_rec_t* undo_rec, /*!< in: undo log record */
|
|
mem_heap_t* heap); /*!< in: heap where copied */
|
|
/**********************************************************************//**
|
|
Reads the undo log record type.
|
|
@return record type */
|
|
UNIV_INLINE
|
|
ulint
|
|
trx_undo_rec_get_type(
|
|
/*==================*/
|
|
const trx_undo_rec_t* undo_rec); /*!< in: undo log record */
|
|
/**********************************************************************//**
|
|
Reads from an undo log record the record compiler info.
|
|
@return compiler info */
|
|
UNIV_INLINE
|
|
ulint
|
|
trx_undo_rec_get_cmpl_info(
|
|
/*=======================*/
|
|
const trx_undo_rec_t* undo_rec); /*!< in: undo log record */
|
|
/**********************************************************************//**
|
|
Returns TRUE if an undo log record contains an extern storage field.
|
|
@return TRUE if extern */
|
|
UNIV_INLINE
|
|
ibool
|
|
trx_undo_rec_get_extern_storage(
|
|
/*============================*/
|
|
const trx_undo_rec_t* undo_rec); /*!< in: undo log record */
|
|
/**********************************************************************//**
|
|
Reads the undo log record number.
|
|
@return undo no */
|
|
UNIV_INLINE
|
|
undo_no_t
|
|
trx_undo_rec_get_undo_no(
|
|
/*=====================*/
|
|
const trx_undo_rec_t* undo_rec); /*!< in: undo log record */
|
|
/**********************************************************************//**
|
|
Returns the start of the undo record data area.
|
|
@return offset to the data area */
|
|
UNIV_INLINE
|
|
ulint
|
|
trx_undo_rec_get_offset(
|
|
/*====================*/
|
|
undo_no_t undo_no) /*!< in: undo no read from node */
|
|
__attribute__((const));
|
|
|
|
/**********************************************************************//**
|
|
Returns the start of the undo record data area. */
|
|
#define trx_undo_rec_get_ptr(undo_rec, undo_no) \
|
|
((undo_rec) + trx_undo_rec_get_offset(undo_no))
|
|
|
|
/**********************************************************************//**
|
|
Reads from an undo log record the general parameters.
|
|
@return remaining part of undo log record after reading these values */
|
|
UNIV_INTERN
|
|
byte*
|
|
trx_undo_rec_get_pars(
|
|
/*==================*/
|
|
trx_undo_rec_t* undo_rec, /*!< in: undo log record */
|
|
ulint* type, /*!< out: undo record type:
|
|
TRX_UNDO_INSERT_REC, ... */
|
|
ulint* cmpl_info, /*!< out: compiler info, relevant only
|
|
for update type records */
|
|
ibool* updated_extern, /*!< out: TRUE if we updated an
|
|
externally stored fild */
|
|
undo_no_t* undo_no, /*!< out: undo log record number */
|
|
dulint* table_id); /*!< out: table id */
|
|
/*******************************************************************//**
|
|
Builds a row reference from an undo log record.
|
|
@return pointer to remaining part of undo record */
|
|
UNIV_INTERN
|
|
byte*
|
|
trx_undo_rec_get_row_ref(
|
|
/*=====================*/
|
|
byte* ptr, /*!< in: remaining part of a copy of an undo log
|
|
record, at the start of the row reference;
|
|
NOTE that this copy of the undo log record must
|
|
be preserved as long as the row reference is
|
|
used, as we do NOT copy the data in the
|
|
record! */
|
|
dict_index_t* index, /*!< in: clustered index */
|
|
dtuple_t** ref, /*!< out, own: row reference */
|
|
mem_heap_t* heap); /*!< in: memory heap from which the memory
|
|
needed is allocated */
|
|
/*******************************************************************//**
|
|
Skips a row reference from an undo log record.
|
|
@return pointer to remaining part of undo record */
|
|
UNIV_INTERN
|
|
byte*
|
|
trx_undo_rec_skip_row_ref(
|
|
/*======================*/
|
|
byte* ptr, /*!< in: remaining part in update undo log
|
|
record, at the start of the row reference */
|
|
dict_index_t* index); /*!< in: clustered index */
|
|
/**********************************************************************//**
|
|
Reads from an undo log update record the system field values of the old
|
|
version.
|
|
@return remaining part of undo log record after reading these values */
|
|
UNIV_INTERN
|
|
byte*
|
|
trx_undo_update_rec_get_sys_cols(
|
|
/*=============================*/
|
|
byte* ptr, /*!< in: remaining part of undo
|
|
log record after reading
|
|
general parameters */
|
|
trx_id_t* trx_id, /*!< out: trx id */
|
|
roll_ptr_t* roll_ptr, /*!< out: roll ptr */
|
|
ulint* info_bits); /*!< out: info bits state */
|
|
/*******************************************************************//**
|
|
Builds an update vector based on a remaining part of an undo log record.
|
|
@return remaining part of the record, NULL if an error detected, which
|
|
means that the record is corrupted */
|
|
UNIV_INTERN
|
|
byte*
|
|
trx_undo_update_rec_get_update(
|
|
/*===========================*/
|
|
byte* ptr, /*!< in: remaining part in update undo log
|
|
record, after reading the row reference
|
|
NOTE that this copy of the undo log record must
|
|
be preserved as long as the update vector is
|
|
used, as we do NOT copy the data in the
|
|
record! */
|
|
dict_index_t* index, /*!< in: clustered index */
|
|
ulint type, /*!< in: TRX_UNDO_UPD_EXIST_REC,
|
|
TRX_UNDO_UPD_DEL_REC, or
|
|
TRX_UNDO_DEL_MARK_REC; in the last case,
|
|
only trx id and roll ptr fields are added to
|
|
the update vector */
|
|
trx_id_t trx_id, /*!< in: transaction id from this undorecord */
|
|
roll_ptr_t roll_ptr,/*!< in: roll pointer from this undo record */
|
|
ulint info_bits,/*!< in: info bits from this undo record */
|
|
trx_t* trx, /*!< in: transaction */
|
|
mem_heap_t* heap, /*!< in: memory heap from which the memory
|
|
needed is allocated */
|
|
upd_t** upd); /*!< out, own: update vector */
|
|
/*******************************************************************//**
|
|
Builds a partial row from an update undo log record. It contains the
|
|
columns which occur as ordering in any index of the table.
|
|
@return pointer to remaining part of undo record */
|
|
UNIV_INTERN
|
|
byte*
|
|
trx_undo_rec_get_partial_row(
|
|
/*=========================*/
|
|
byte* ptr, /*!< in: remaining part in update undo log
|
|
record of a suitable type, at the start of
|
|
the stored index columns;
|
|
NOTE that this copy of the undo log record must
|
|
be preserved as long as the partial row is
|
|
used, as we do NOT copy the data in the
|
|
record! */
|
|
dict_index_t* index, /*!< in: clustered index */
|
|
dtuple_t** row, /*!< out, own: partial row */
|
|
ibool ignore_prefix, /*!< in: flag to indicate if we
|
|
expect blob prefixes in undo. Used
|
|
only in the assertion. */
|
|
mem_heap_t* heap); /*!< in: memory heap from which the memory
|
|
needed is allocated */
|
|
/***********************************************************************//**
|
|
Writes information to an undo log about an insert, update, or a delete marking
|
|
of a clustered index record. This information is used in a rollback of the
|
|
transaction and in consistent reads that must look to the history of this
|
|
transaction.
|
|
@return DB_SUCCESS or error code */
|
|
UNIV_INTERN
|
|
ulint
|
|
trx_undo_report_row_operation(
|
|
/*==========================*/
|
|
ulint flags, /*!< in: if BTR_NO_UNDO_LOG_FLAG bit is
|
|
set, does nothing */
|
|
ulint op_type, /*!< in: TRX_UNDO_INSERT_OP or
|
|
TRX_UNDO_MODIFY_OP */
|
|
que_thr_t* thr, /*!< in: query thread */
|
|
dict_index_t* index, /*!< in: clustered index */
|
|
const dtuple_t* clust_entry, /*!< in: in the case of an insert,
|
|
index entry to insert into the
|
|
clustered index, otherwise NULL */
|
|
const upd_t* update, /*!< in: in the case of an update,
|
|
the update vector, otherwise NULL */
|
|
ulint cmpl_info, /*!< in: compiler info on secondary
|
|
index updates */
|
|
const rec_t* rec, /*!< in: case of an update or delete
|
|
marking, the record in the clustered
|
|
index, otherwise NULL */
|
|
roll_ptr_t* roll_ptr); /*!< out: rollback pointer to the
|
|
inserted undo log record,
|
|
ut_dulint_zero if BTR_NO_UNDO_LOG
|
|
flag was specified */
|
|
/******************************************************************//**
|
|
Copies an undo record to heap. This function can be called if we know that
|
|
the undo log record exists.
|
|
@return own: copy of the record */
|
|
UNIV_INTERN
|
|
trx_undo_rec_t*
|
|
trx_undo_get_undo_rec_low(
|
|
/*======================*/
|
|
roll_ptr_t roll_ptr, /*!< in: roll pointer to record */
|
|
mem_heap_t* heap); /*!< in: memory heap where copied */
|
|
/******************************************************************//**
|
|
Copies an undo record to heap.
|
|
|
|
NOTE: the caller must have latches on the clustered index page and
|
|
purge_view.
|
|
|
|
@return DB_SUCCESS, or DB_MISSING_HISTORY if the undo log has been
|
|
truncated and we cannot fetch the old version */
|
|
UNIV_INTERN
|
|
ulint
|
|
trx_undo_get_undo_rec(
|
|
/*==================*/
|
|
roll_ptr_t roll_ptr, /*!< in: roll pointer to record */
|
|
trx_id_t trx_id, /*!< in: id of the trx that generated
|
|
the roll pointer: it points to an
|
|
undo log of this transaction */
|
|
trx_undo_rec_t** undo_rec, /*!< out, own: copy of the record */
|
|
mem_heap_t* heap); /*!< in: memory heap where copied */
|
|
/*******************************************************************//**
|
|
Build a previous version of a clustered index record. This function checks
|
|
that the caller has a latch on the index page of the clustered index record
|
|
and an s-latch on the purge_view. This guarantees that the stack of versions
|
|
is locked.
|
|
@return DB_SUCCESS, or DB_MISSING_HISTORY if the previous version is
|
|
earlier than purge_view, which means that it may have been removed,
|
|
DB_ERROR if corrupted record */
|
|
UNIV_INTERN
|
|
ulint
|
|
trx_undo_prev_version_build(
|
|
/*========================*/
|
|
const rec_t* index_rec,/*!< in: clustered index record in the
|
|
index tree */
|
|
mtr_t* index_mtr,/*!< in: mtr which contains the latch to
|
|
index_rec page and purge_view */
|
|
const rec_t* rec, /*!< in: version of a clustered index record */
|
|
dict_index_t* index, /*!< in: clustered index */
|
|
ulint* offsets,/*!< in: rec_get_offsets(rec, index) */
|
|
mem_heap_t* heap, /*!< in: memory heap from which the memory
|
|
needed is allocated */
|
|
rec_t** old_vers);/*!< out, own: previous version, or NULL if
|
|
rec is the first inserted version, or if
|
|
history data has been deleted */
|
|
#endif /* !UNIV_HOTBACKUP */
|
|
/***********************************************************//**
|
|
Parses a redo log record of adding an undo log record.
|
|
@return end of log record or NULL */
|
|
UNIV_INTERN
|
|
byte*
|
|
trx_undo_parse_add_undo_rec(
|
|
/*========================*/
|
|
byte* ptr, /*!< in: buffer */
|
|
byte* end_ptr,/*!< in: buffer end */
|
|
page_t* page); /*!< in: page or NULL */
|
|
/***********************************************************//**
|
|
Parses a redo log record of erasing of an undo page end.
|
|
@return end of log record or NULL */
|
|
UNIV_INTERN
|
|
byte*
|
|
trx_undo_parse_erase_page_end(
|
|
/*==========================*/
|
|
byte* ptr, /*!< in: buffer */
|
|
byte* end_ptr,/*!< in: buffer end */
|
|
page_t* page, /*!< in: page or NULL */
|
|
mtr_t* mtr); /*!< in: mtr or NULL */
|
|
|
|
#ifndef UNIV_HOTBACKUP
|
|
|
|
/* Types of an undo log record: these have to be smaller than 16, as the
|
|
compilation info multiplied by 16 is ORed to this value in an undo log
|
|
record */
|
|
|
|
#define TRX_UNDO_INSERT_REC 11 /* fresh insert into clustered index */
|
|
#define TRX_UNDO_UPD_EXIST_REC 12 /* update of a non-delete-marked
|
|
record */
|
|
#define TRX_UNDO_UPD_DEL_REC 13 /* update of a delete marked record to
|
|
a not delete marked record; also the
|
|
fields of the record can change */
|
|
#define TRX_UNDO_DEL_MARK_REC 14 /* delete marking of a record; fields
|
|
do not change */
|
|
#define TRX_UNDO_CMPL_INFO_MULT 16 /* compilation info is multiplied by
|
|
this and ORed to the type above */
|
|
#define TRX_UNDO_UPD_EXTERN 128 /* This bit can be ORed to type_cmpl
|
|
to denote that we updated external
|
|
storage fields: used by purge to
|
|
free the external storage */
|
|
|
|
/* Operation type flags used in trx_undo_report_row_operation */
|
|
#define TRX_UNDO_INSERT_OP 1
|
|
#define TRX_UNDO_MODIFY_OP 2
|
|
|
|
#ifndef UNIV_NONINL
|
|
#include "trx0rec.ic"
|
|
#endif
|
|
|
|
#endif /* !UNIV_HOTBACKUP */
|
|
|
|
#endif /* trx0rec_h */
|