mirror of
https://github.com/MariaDB/server.git
synced 2025-01-17 12:32:27 +01:00
f802c989ec
trx_undof_page_add_undo_rec_log(): Remove. trx_undo_page_set_next_prev_and_add(), trx_undo_page_report_modify(), trx_undo_page_report_rename(): Write lower-level redo log records.
338 lines
13 KiB
C
338 lines
13 KiB
C
/*****************************************************************************
|
|
|
|
Copyright (c) 1996, 2016, Oracle and/or its affiliates. All Rights Reserved.
|
|
Copyright (c) 2017, 2019, 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, Fifth Floor, Boston, MA 02110-1335 USA
|
|
|
|
*****************************************************************************/
|
|
|
|
/**************************************************//**
|
|
@file include/trx0rec.h
|
|
Transaction undo log record
|
|
|
|
Created 3/26/1996 Heikki Tuuri
|
|
*******************************************************/
|
|
|
|
#ifndef trx0rec_h
|
|
#define trx0rec_h
|
|
|
|
#include "trx0types.h"
|
|
#include "row0types.h"
|
|
#include "mtr0mtr.h"
|
|
#include "rem0types.h"
|
|
#include "page0types.h"
|
|
#include "row0log.h"
|
|
#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(
|
|
/*==============*/
|
|
const 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 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. */
|
|
#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 */
|
|
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 */
|
|
bool* updated_extern, /*!< out: true if we updated an
|
|
externally stored fild */
|
|
undo_no_t* undo_no, /*!< out: undo log record number */
|
|
table_id_t* table_id) /*!< out: table id */
|
|
MY_ATTRIBUTE((nonnull));
|
|
/*******************************************************************//**
|
|
Builds a row reference from an undo log record.
|
|
@return pointer to remaining part of undo record */
|
|
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 */
|
|
const dtuple_t**ref, /*!< out, own: row reference */
|
|
mem_heap_t* heap); /*!< in: memory heap from which the memory
|
|
needed is allocated */
|
|
/**********************************************************************//**
|
|
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 */
|
|
byte*
|
|
trx_undo_update_rec_get_sys_cols(
|
|
/*=============================*/
|
|
const 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 */
|
|
byte*
|
|
trx_undo_update_rec_get_update(
|
|
/*===========================*/
|
|
const 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 */
|
|
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, for purge.
|
|
It contains the columns which occur as ordering in any index of the table.
|
|
Any missing columns are indicated by col->mtype == DATA_MISSING.
|
|
@return pointer to remaining part of undo record */
|
|
byte*
|
|
trx_undo_rec_get_partial_row(
|
|
/*=========================*/
|
|
const 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 */
|
|
const upd_t* update, /*!< in: updated columns */
|
|
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 */
|
|
MY_ATTRIBUTE((nonnull, warn_unused_result));
|
|
/** Report a RENAME TABLE operation.
|
|
@param[in,out] trx transaction
|
|
@param[in] table table that is being renamed
|
|
@return DB_SUCCESS or error code */
|
|
dberr_t trx_undo_report_rename(trx_t* trx, const dict_table_t* table)
|
|
MY_ATTRIBUTE((nonnull, warn_unused_result));
|
|
/***********************************************************************//**
|
|
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 */
|
|
dberr_t
|
|
trx_undo_report_row_operation(
|
|
/*==========================*/
|
|
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; in updates,
|
|
may contain a clustered index
|
|
record tuple that also contains
|
|
virtual columns of the table;
|
|
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; NULL if insert */
|
|
const offset_t* offsets, /*!< in: rec_get_offsets(rec) */
|
|
roll_ptr_t* roll_ptr) /*!< out: DB_ROLL_PTR to the
|
|
undo log record */
|
|
MY_ATTRIBUTE((nonnull(1,2,8), warn_unused_result));
|
|
|
|
/** status bit used for trx_undo_prev_version_build() */
|
|
|
|
/** TRX_UNDO_PREV_IN_PURGE tells trx_undo_prev_version_build() that it
|
|
is being called purge view and we would like to get the purge record
|
|
even it is in the purge view (in normal case, it will return without
|
|
fetching the purge record */
|
|
#define TRX_UNDO_PREV_IN_PURGE 0x1
|
|
|
|
/** This tells trx_undo_prev_version_build() to fetch the old value in
|
|
the undo log (which is the after image for an update) */
|
|
#define TRX_UNDO_GET_OLD_V_VALUE 0x2
|
|
|
|
/*******************************************************************//**
|
|
Build a previous version of a clustered index record. The caller must
|
|
hold a latch on the index page of the clustered index record.
|
|
@retval true if previous version was built, or if it was an insert
|
|
or the table has been rebuilt
|
|
@retval false if the previous version is earlier than purge_view,
|
|
which means that it may have been removed */
|
|
bool
|
|
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 */
|
|
offset_t* offsets,/*!< in/out: 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 */
|
|
mem_heap_t* v_heap, /* !< in: memory heap used to create vrow
|
|
dtuple if it is not yet created. This heap
|
|
diffs from "heap" above in that it could be
|
|
prebuilt->old_vers_heap for selection */
|
|
dtuple_t** vrow, /*!< out: virtual column info, if any */
|
|
ulint v_status);
|
|
/*!< in: status determine if it is going
|
|
into this function by purge thread or not.
|
|
And if we read "after image" of undo log */
|
|
|
|
/** Parse MLOG_UNDO_INSERT.
|
|
@param[in] ptr log record
|
|
@param[in] end_ptr end of log record buffer
|
|
@param[in,out] page page or NULL
|
|
@return end of log record
|
|
@retval NULL if the log record is incomplete */
|
|
ATTRIBUTE_COLD /* only used when crash-upgrading */
|
|
byte*
|
|
trx_undo_parse_add_undo_rec(
|
|
const byte* ptr,
|
|
const byte* end_ptr,
|
|
page_t* page);
|
|
|
|
/** Read from an undo log record a non-virtual column value.
|
|
@param[in,out] ptr pointer to remaining part of the undo record
|
|
@param[in,out] field stored field
|
|
@param[in,out] len length of the field, or UNIV_SQL_NULL
|
|
@param[in,out] orig_len original length of the locally stored part
|
|
of an externally stored column, or 0
|
|
@return remaining part of undo log record after reading these values */
|
|
byte*
|
|
trx_undo_rec_get_col_val(
|
|
const byte* ptr,
|
|
const byte** field,
|
|
ulint* len,
|
|
ulint* orig_len);
|
|
|
|
/** Read virtual column value from undo log
|
|
@param[in] table the table
|
|
@param[in] ptr undo log pointer
|
|
@param[in,out] row the dtuple to fill
|
|
@param[in] in_purge whether this is called by purge */
|
|
void
|
|
trx_undo_read_v_cols(
|
|
const dict_table_t* table,
|
|
const byte* ptr,
|
|
dtuple_t* row,
|
|
bool in_purge);
|
|
|
|
/** Read virtual column index from undo log if the undo log contains such
|
|
info, and verify the column is still indexed, and output its position
|
|
@param[in] table the table
|
|
@param[in] ptr undo log pointer
|
|
@param[in] first_v_col if this is the first virtual column, which
|
|
has the version marker
|
|
@param[in,out] is_undo_log his function is used to parse both undo log,
|
|
and online log for virtual columns. So
|
|
check to see if this is undo log
|
|
@param[out] field_no the column number
|
|
@return remaining part of undo log record after reading these values */
|
|
const byte*
|
|
trx_undo_read_v_idx(
|
|
const dict_table_t* table,
|
|
const byte* ptr,
|
|
bool first_v_col,
|
|
bool* is_undo_log,
|
|
ulint* field_no);
|
|
|
|
/* 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_RENAME_TABLE 9 /*!< RENAME TABLE */
|
|
#define TRX_UNDO_INSERT_METADATA 10 /*!< insert a metadata
|
|
pseudo-record for instant ALTER */
|
|
#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 16U /* compilation info is multiplied by
|
|
this and ORed to the type above */
|
|
#define TRX_UNDO_UPD_EXTERN 128U /* This bit can be ORed to type_cmpl
|
|
to denote that we updated external
|
|
storage fields: used by purge to
|
|
free the external storage */
|
|
|
|
/** The search tuple corresponding to TRX_UNDO_INSERT_METADATA */
|
|
extern const dtuple_t trx_undo_metadata;
|
|
|
|
/** Read the table id from an undo log record.
|
|
@param[in] rec Undo log record
|
|
@return table id stored as a part of undo log record */
|
|
inline table_id_t trx_undo_rec_get_table_id(const trx_undo_rec_t *rec)
|
|
{
|
|
rec+= 3;
|
|
mach_read_next_much_compressed(&rec);
|
|
return mach_read_next_much_compressed(&rec);
|
|
}
|
|
|
|
#include "trx0rec.ic"
|
|
|
|
#endif /* trx0rec_h */
|