~drizzle-trunk/drizzle/development

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

Copyright (C) 1996, 2010, 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., 51 Franklin

St, Fifth Floor, Boston, MA 02110-1301 USA

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

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

@file trx/trx0rec.c

Transaction undo log record

Created 3/26/1996 Heikki Tuuri

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

#include "trx0rec.h"

#ifdef UNIV_NONINL

#include "trx0rec.ic"

#endif

#include "fsp0fsp.h"

#include "mach0data.h"

#include "trx0undo.h"

#include "mtr0log.h"

#ifndef UNIV_HOTBACKUP

#include "dict0dict.h"

#include "ut0mem.h"

#include "row0ext.h"

#include "row0upd.h"

#include "que0que.h"

#include "trx0purge.h"

#include "trx0rseg.h"

#include "row0row.h"

/*=========== UNDO LOG RECORD CREATION AND DECODING ====================*/

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

Writes the mtr log entry of the inserted undo log record on the undo log

page. */

UNIV_INLINE

void

trx_undof_page_add_undo_rec_log(

/*============================*/

	page_t* undo_page,	/*!< in: undo log page */

	ulint	old_free,	/*!< in: start offset of the inserted entry */

	ulint	new_free,	/*!< in: end offset of the entry */

	mtr_t*	mtr)		/*!< in: mtr */

{

	byte*		log_ptr;

	const byte*	log_end;

	ulint		len;

	log_ptr = mlog_open(mtr, 11 + 13 + MLOG_BUF_MARGIN);

	if (log_ptr == NULL) {

		return;

	}

	log_end = &log_ptr[11 + 13 + MLOG_BUF_MARGIN];

	log_ptr = mlog_write_initial_log_record_fast(

		undo_page, MLOG_UNDO_INSERT, log_ptr, mtr);

	len = new_free - old_free - 4;

	mach_write_to_2(log_ptr, len);

	log_ptr += 2;

	if (log_ptr + len <= log_end) {

		memcpy(log_ptr, undo_page + old_free + 2, len);

		mlog_close(mtr, log_ptr + len);

	} else {

		mlog_close(mtr, log_ptr);

		mlog_catenate_string(mtr, undo_page + old_free + 2, len);

	}

}

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

{

	ulint	len;

	byte*	rec;

	ulint	first_free;

	if (end_ptr < ptr + 2) {

		return(NULL);

	}

	len = mach_read_from_2(ptr);

	ptr += 2;

	if (end_ptr < ptr + len) {

		return(NULL);

	}

	if (page == NULL) {

		return(ptr + len);

	}

	first_free = mach_read_from_2(page + TRX_UNDO_PAGE_HDR

				      + TRX_UNDO_PAGE_FREE);

	rec = page + first_free;

	mach_write_to_2(rec, first_free + 4 + len);

	mach_write_to_2(rec + 2 + len, first_free);

	mach_write_to_2(page + TRX_UNDO_PAGE_HDR + TRX_UNDO_PAGE_FREE,

			first_free + 4 + len);

	ut_memcpy(rec + 2, ptr, len);

	return(ptr + len);

}

#ifndef UNIV_HOTBACKUP

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

Calculates the free space left for extending an undo log record.

@return	bytes left */

UNIV_INLINE

ulint

trx_undo_left(

/*==========*/

	const page_t*	page,	/*!< in: undo log page */

	const byte*	ptr)	/*!< in: pointer to page */

{

	/* The '- 10' is a safety margin, in case we have some small

	calculation error below */

	return(UNIV_PAGE_SIZE - (ptr - page) - 10 - FIL_PAGE_DATA_END);

}

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

Set the next and previous pointers in the undo page for the undo record

that was written to ptr. Update the first free value by the number of bytes

written for this undo record.

@return	offset of the inserted entry on the page if succeeded, 0 if fail */

static

ulint

trx_undo_page_set_next_prev_and_add(

/*================================*/

	page_t*		undo_page,	/*!< in/out: undo log page */

	byte*		ptr,		/*!< in: ptr up to where data has been

					written on this undo page. */

	mtr_t*		mtr)		/*!< in: mtr */

{

	ulint		first_free;	/*!< offset within undo_page */

	ulint		end_of_rec;	/*!< offset within undo_page */

	byte*		ptr_to_first_free;

					/* pointer within undo_page

					that points to the next free

					offset value within undo_page.*/

	ut_ad(ptr > undo_page);

	ut_ad(ptr < undo_page + UNIV_PAGE_SIZE);

	if (UNIV_UNLIKELY(trx_undo_left(undo_page, ptr) < 2)) {

		return(0);

	}

	ptr_to_first_free = undo_page + TRX_UNDO_PAGE_HDR + TRX_UNDO_PAGE_FREE;

	first_free = mach_read_from_2(ptr_to_first_free);

	/* Write offset of the previous undo log record */

	mach_write_to_2(ptr, first_free);

	ptr += 2;

	end_of_rec = ptr - undo_page;

	/* Write offset of the next undo log record */

	mach_write_to_2(undo_page + first_free, end_of_rec);

	/* Update the offset to first free undo record */

	mach_write_to_2(ptr_to_first_free, end_of_rec);

	/* Write this log entry to the UNDO log */

	trx_undof_page_add_undo_rec_log(undo_page, first_free,

					end_of_rec, mtr);

	return(first_free);

}

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

Reports in the undo log of an insert of a clustered index record.

@return	offset of the inserted entry on the page if succeed, 0 if fail */

static

ulint

trx_undo_page_report_insert(

/*========================*/

	page_t*		undo_page,	/*!< in: undo log page */

	trx_t*		trx,		/*!< in: transaction */

	dict_index_t*	index,		/*!< in: clustered index */

	const dtuple_t*	clust_entry,	/*!< in: index entry which will be

					inserted to the clustered index */

	mtr_t*		mtr)		/*!< in: mtr */

{

	ulint		first_free;

	byte*		ptr;

	ulint		i;

	ut_ad(dict_index_is_clust(index));

	ut_ad(mach_read_from_2(undo_page + TRX_UNDO_PAGE_HDR

			       + TRX_UNDO_PAGE_TYPE) == TRX_UNDO_INSERT);

	first_free = mach_read_from_2(undo_page + TRX_UNDO_PAGE_HDR

				      + TRX_UNDO_PAGE_FREE);

	ptr = undo_page + first_free;

	ut_ad(first_free <= UNIV_PAGE_SIZE);

	if (trx_undo_left(undo_page, ptr) < 2 + 1 + 11 + 11) {

		/* Not enough space for writing the general parameters */

		return(0);

	}

	/* Reserve 2 bytes for the pointer to the next undo log record */

	ptr += 2;

	/* Store first some general parameters to the undo log */

	*ptr++ = TRX_UNDO_INSERT_REC;

	ptr += mach_ull_write_much_compressed(ptr, trx->undo_no);

	ptr += mach_ull_write_much_compressed(ptr, index->table->id);

	/*----------------------------------------*/

	/* Store then the fields required to uniquely determine the record

	to be inserted in the clustered index */

	for (i = 0; i < dict_index_get_n_unique(index); i++) {

		const dfield_t*	field	= dtuple_get_nth_field(clust_entry, i);

		ulint		flen	= dfield_get_len(field);

		if (trx_undo_left(undo_page, ptr) < 5) {

			return(0);

		}

		ptr += mach_write_compressed(ptr, flen);

		if (flen != UNIV_SQL_NULL) {

			if (trx_undo_left(undo_page, ptr) < flen) {

				return(0);

			}

			ut_memcpy(ptr, dfield_get_data(field), flen);

			ptr += flen;

		}

	}

	return(trx_undo_page_set_next_prev_and_add(undo_page, ptr, mtr));

}

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

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

	table_id_t*	table_id)	/*!< out: table id */

{

	byte*		ptr;

	ulint		type_cmpl;

	ptr = undo_rec + 2;

	type_cmpl = mach_read_from_1(ptr);

	ptr++;

	if (type_cmpl & TRX_UNDO_UPD_EXTERN) {

		*updated_extern = TRUE;

		type_cmpl -= TRX_UNDO_UPD_EXTERN;

	} else {

		*updated_extern = FALSE;

	}

	*type = type_cmpl & (TRX_UNDO_CMPL_INFO_MULT - 1);

	*cmpl_info = type_cmpl / TRX_UNDO_CMPL_INFO_MULT;

	*undo_no = mach_ull_read_much_compressed(ptr);

	ptr += mach_ull_get_much_compressed_size(*undo_no);

	*table_id = mach_ull_read_much_compressed(ptr);

	ptr += mach_ull_get_much_compressed_size(*table_id);

	return(ptr);

}

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

Reads from an undo log record a stored column value.

@return	remaining part of undo log record after reading these values */

static

byte*

trx_undo_rec_get_col_val(

/*=====================*/

	byte*	ptr,	/*!< in: pointer to remaining part of undo log record */

	byte**	field,	/*!< out: pointer to stored field */

	ulint*	len,	/*!< out: length of the field, or UNIV_SQL_NULL */

	ulint*	orig_len)/*!< out: original length of the locally

			stored part of an externally stored column, or 0 */

{

	*len = mach_read_compressed(ptr);

	ptr += mach_get_compressed_size(*len);

	*orig_len = 0;

	switch (*len) {

	case UNIV_SQL_NULL:

		*field = NULL;

		break;

	case UNIV_EXTERN_STORAGE_FIELD:

		*orig_len = mach_read_compressed(ptr);

		ptr += mach_get_compressed_size(*orig_len);

		*len = mach_read_compressed(ptr);

		ptr += mach_get_compressed_size(*len);

		*field = ptr;

		ptr += *len;

		ut_ad(*orig_len >= BTR_EXTERN_FIELD_REF_SIZE);

		ut_ad(*len > *orig_len);

		/* @see dtuple_convert_big_rec() */

		ut_ad(*len >= BTR_EXTERN_FIELD_REF_SIZE * 2);

		/* we do not have access to index->table here

		ut_ad(dict_table_get_format(index->table) >= DICT_TF_FORMAT_ZIP

		      || *len >= REC_MAX_INDEX_COL_LEN

		      + BTR_EXTERN_FIELD_REF_SIZE);

		*/

		*len += UNIV_EXTERN_STORAGE_FIELD;

		break;

	default:

		*field = ptr;

		if (*len >= UNIV_EXTERN_STORAGE_FIELD) {

			ptr += *len - UNIV_EXTERN_STORAGE_FIELD;

		} else {

			ptr += *len;

		}

	}

	return(ptr);

}

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

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

{

	ulint		ref_len;

	ulint		i;

	ut_ad(index && ptr && ref && heap);

	ut_a(dict_index_is_clust(index));

	ref_len = dict_index_get_n_unique(index);

	*ref = dtuple_create(heap, ref_len);

	dict_index_copy_types(*ref, index, ref_len);

	for (i = 0; i < ref_len; i++) {

		dfield_t*	dfield;

		byte*		field;

		ulint		len;

		ulint		orig_len;

		dfield = dtuple_get_nth_field(*ref, i);

		ptr = trx_undo_rec_get_col_val(ptr, &field, &len, &orig_len);

		dfield_set_data(dfield, field, len);

	}

	return(ptr);

}

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

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

{

	ulint	ref_len;

	ulint	i;

	ut_ad(index && ptr);

	ut_a(dict_index_is_clust(index));

	ref_len = dict_index_get_n_unique(index);

	for (i = 0; i < ref_len; i++) {

		byte*	field;

		ulint	len;

		ulint	orig_len;

		ptr = trx_undo_rec_get_col_val(ptr, &field, &len, &orig_len);

	}

	return(ptr);

}

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

Fetch a prefix of an externally stored column, for writing to the undo log

of an update or delete marking of a clustered index record.

@return	ext_buf */

static

byte*

trx_undo_page_fetch_ext(

/*====================*/

	byte*		ext_buf,	/*!< in: a buffer of

					REC_MAX_INDEX_COL_LEN

					+ BTR_EXTERN_FIELD_REF_SIZE */

	ulint		zip_size,	/*!< compressed page size in bytes,

					or 0 for uncompressed BLOB  */

	const byte*	field,		/*!< in: an externally stored column */

	ulint*		len)		/*!< in: length of field;

					out: used length of ext_buf */

{

	/* Fetch the BLOB. */

	ulint	ext_len = btr_copy_externally_stored_field_prefix(

		ext_buf, REC_MAX_INDEX_COL_LEN, zip_size, field, *len);

	/* BLOBs should always be nonempty. */

	ut_a(ext_len);

	/* Append the BLOB pointer to the prefix. */

	memcpy(ext_buf + ext_len,

	       field + *len - BTR_EXTERN_FIELD_REF_SIZE,

	       BTR_EXTERN_FIELD_REF_SIZE);

	*len = ext_len + BTR_EXTERN_FIELD_REF_SIZE;

	return(ext_buf);

}

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

Writes to the undo log a prefix of an externally stored column.

@return	undo log position */

static

byte*

trx_undo_page_report_modify_ext(

/*============================*/

	byte*		ptr,		/*!< in: undo log position,

					at least 15 bytes must be available */

	byte*		ext_buf,	/*!< in: a buffer of

					REC_MAX_INDEX_COL_LEN

					+ BTR_EXTERN_FIELD_REF_SIZE,

					or NULL when should not fetch

					a longer prefix */

	ulint		zip_size,	/*!< compressed page size in bytes,

					or 0 for uncompressed BLOB  */

	const byte**	field,		/*!< in/out: the locally stored part of

					the externally stored column */

	ulint*		len)		/*!< in/out: length of field, in bytes */

{

	if (ext_buf) {

		/* If an ordering column is externally stored, we will

		have to store a longer prefix of the field.  In this

		case, write to the log a marker followed by the

		original length and the real length of the field. */

		ptr += mach_write_compressed(ptr, UNIV_EXTERN_STORAGE_FIELD);

		ptr += mach_write_compressed(ptr, *len);

		*field = trx_undo_page_fetch_ext(ext_buf, zip_size,

						 *field, len);

		ptr += mach_write_compressed(ptr, *len);

	} else {

		ptr += mach_write_compressed(ptr, UNIV_EXTERN_STORAGE_FIELD

					     + *len);

	}

	return(ptr);

}

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

Reports in the undo log of an update or delete marking of a clustered index

record.

@return byte offset of the inserted undo log entry on the page if

succeed, 0 if fail */

static

ulint

trx_undo_page_report_modify(

/*========================*/

	page_t*		undo_page,	/*!< in: undo log page */

	trx_t*		trx,		/*!< in: transaction */

	dict_index_t*	index,		/*!< in: clustered index where update or

					delete marking is done */

	const rec_t*	rec,		/*!< in: clustered index record which

					has NOT yet been modified */

	const ulint*	offsets,	/*!< in: rec_get_offsets(rec, index) */

	const upd_t*	update,		/*!< in: update vector which tells the

					columns to be updated; in the case of

					a delete, this should be set to NULL */

	ulint		cmpl_info,	/*!< in: compiler info on secondary

					index updates */

	mtr_t*		mtr)		/*!< in: mtr */

{

	dict_table_t*	table;

	ulint		first_free;

	byte*		ptr;

	const byte*	field;

	ulint		flen;

	ulint		col_no;

	ulint		type_cmpl;

	byte*		type_cmpl_ptr;

	ulint		i;

	trx_id_t	trx_id;

	ibool		ignore_prefix = FALSE;

	byte		ext_buf[REC_MAX_INDEX_COL_LEN

				+ BTR_EXTERN_FIELD_REF_SIZE];

	ut_a(dict_index_is_clust(index));

	ut_ad(rec_offs_validate(rec, index, offsets));

	ut_ad(mach_read_from_2(undo_page + TRX_UNDO_PAGE_HDR

			       + TRX_UNDO_PAGE_TYPE) == TRX_UNDO_UPDATE);

	table = index->table;

	first_free = mach_read_from_2(undo_page + TRX_UNDO_PAGE_HDR

				      + TRX_UNDO_PAGE_FREE);

	ptr = undo_page + first_free;

	ut_ad(first_free <= UNIV_PAGE_SIZE);

	if (trx_undo_left(undo_page, ptr) < 50) {

		/* NOTE: the value 50 must be big enough so that the general

		fields written below fit on the undo log page */

		return(0);

	}

	/* Reserve 2 bytes for the pointer to the next undo log record */

	ptr += 2;

	/* Store first some general parameters to the undo log */

	if (!update) {

		type_cmpl = TRX_UNDO_DEL_MARK_REC;

	} else if (rec_get_deleted_flag(rec, dict_table_is_comp(table))) {

		type_cmpl = TRX_UNDO_UPD_DEL_REC;

		/* We are about to update a delete marked record.

		We don't typically need the prefix in this case unless

		the delete marking is done by the same transaction

		(which we check below). */

		ignore_prefix = TRUE;

	} else {

		type_cmpl = TRX_UNDO_UPD_EXIST_REC;

	}

	type_cmpl |= cmpl_info * TRX_UNDO_CMPL_INFO_MULT;

	type_cmpl_ptr = ptr;

	*ptr++ = (byte) type_cmpl;

	ptr += mach_ull_write_much_compressed(ptr, trx->undo_no);

	ptr += mach_ull_write_much_compressed(ptr, table->id);

	/*----------------------------------------*/

	/* Store the state of the info bits */

	*ptr++ = (byte) rec_get_info_bits(rec, dict_table_is_comp(table));

	/* Store the values of the system columns */

	field = rec_get_nth_field(rec, offsets,

				  dict_index_get_sys_col_pos(

					  index, DATA_TRX_ID), &flen);

	ut_ad(flen == DATA_TRX_ID_LEN);

	trx_id = trx_read_trx_id(field);

	/* If it is an update of a delete marked record, then we are

	allowed to ignore blob prefixes if the delete marking was done

	by some other trx as it must have committed by now for us to

	allow an over-write. */

	if (ignore_prefix) {

		ignore_prefix = (trx_id != trx->id);

	}

	ptr += mach_ull_write_compressed(ptr, trx_id);

	field = rec_get_nth_field(rec, offsets,

				  dict_index_get_sys_col_pos(

					  index, DATA_ROLL_PTR), &flen);

	ut_ad(flen == DATA_ROLL_PTR_LEN);

	ptr += mach_ull_write_compressed(ptr, trx_read_roll_ptr(field));

	/*----------------------------------------*/

	/* Store then the fields required to uniquely determine the

	record which will be modified in the clustered index */

	for (i = 0; i < dict_index_get_n_unique(index); i++) {

		field = rec_get_nth_field(rec, offsets, i, &flen);

		/* The ordering columns must not be stored externally. */

		ut_ad(!rec_offs_nth_extern(offsets, i));

		ut_ad(dict_index_get_nth_col(index, i)->ord_part);

		if (trx_undo_left(undo_page, ptr) < 5) {

			return(0);

		}

		ptr += mach_write_compressed(ptr, flen);

		if (flen != UNIV_SQL_NULL) {

			if (trx_undo_left(undo_page, ptr) < flen) {

				return(0);

			}

			ut_memcpy(ptr, field, flen);

			ptr += flen;

		}

	}

	/*----------------------------------------*/

	/* Save to the undo log the old values of the columns to be updated. */

	if (update) {

		if (trx_undo_left(undo_page, ptr) < 5) {

			return(0);

		}

		ptr += mach_write_compressed(ptr, upd_get_n_fields(update));

		for (i = 0; i < upd_get_n_fields(update); i++) {

			ulint	pos = upd_get_nth_field(update, i)->field_no;

			/* Write field number to undo log */

			if (trx_undo_left(undo_page, ptr) < 5) {

				return(0);

			}

			ptr += mach_write_compressed(ptr, pos);

			/* Save the old value of field */

			field = rec_get_nth_field(rec, offsets, pos, &flen);

			if (trx_undo_left(undo_page, ptr) < 15) {

				return(0);

			}

			if (rec_offs_nth_extern(offsets, pos)) {

				ptr = trx_undo_page_report_modify_ext(

					ptr,

					dict_index_get_nth_col(index, pos)

					->ord_part

					&& !ignore_prefix

					&& flen < REC_MAX_INDEX_COL_LEN

					? ext_buf : NULL,

					dict_table_zip_size(table),

					&field, &flen);

				/* Notify purge that it eventually has to

				free the old externally stored field */

				trx->update_undo->del_marks = TRUE;

				*type_cmpl_ptr |= TRX_UNDO_UPD_EXTERN;

			} else {

				ptr += mach_write_compressed(ptr, flen);

			}

			if (flen != UNIV_SQL_NULL) {

				if (trx_undo_left(undo_page, ptr) < flen) {

					return(0);

				}

				ut_memcpy(ptr, field, flen);

				ptr += flen;

			}

		}

	}

	/*----------------------------------------*/

	/* In the case of a delete marking, and also in the case of an update

	where any ordering field of any index changes, store the values of all

	columns which occur as ordering fields in any index. This info is used

	in the purge of old versions where we use it to build and search the

	delete marked index records, to look if we can remove them from the

	index tree. Note that starting from 4.0.14 also externally stored

	fields can be ordering in some index. Starting from 5.2, we no longer

	store REC_MAX_INDEX_COL_LEN first bytes to the undo log record,

	but we can construct the column prefix fields in the index by

	fetching the first page of the BLOB that is pointed to by the

	clustered index. This works also in crash recovery, because all pages

	(including BLOBs) are recovered before anything is rolled back. */

	if (!update || !(cmpl_info & UPD_NODE_NO_ORD_CHANGE)) {

		byte*	old_ptr = ptr;

		trx->update_undo->del_marks = TRUE;

		if (trx_undo_left(undo_page, ptr) < 5) {

			return(0);

		}

		/* Reserve 2 bytes to write the number of bytes the stored

		fields take in this undo record */

		ptr += 2;

		for (col_no = 0; col_no < dict_table_get_n_cols(table);

		     col_no++) {

			const dict_col_t*	col

				= dict_table_get_nth_col(table, col_no);

			if (col->ord_part) {

				ulint	pos;

				/* Write field number to undo log */

				if (trx_undo_left(undo_page, ptr) < 5 + 15) {

					return(0);

				}

				pos = dict_index_get_nth_col_pos(index,

								 col_no);

				ptr += mach_write_compressed(ptr, pos);

				/* Save the old value of field */

				field = rec_get_nth_field(rec, offsets, pos,

							  &flen);

				if (rec_offs_nth_extern(offsets, pos)) {

					ptr = trx_undo_page_report_modify_ext(

						ptr,

						flen < REC_MAX_INDEX_COL_LEN

						&& !ignore_prefix

						? ext_buf : NULL,

						dict_table_zip_size(table),

						&field, &flen);

				} else {

					ptr += mach_write_compressed(

						ptr, flen);

				}

				if (flen != UNIV_SQL_NULL) {

					if (trx_undo_left(undo_page, ptr)

					    < flen) {

						return(0);

					}