~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 row/row0upd.c

Update of a row

Created 12/27/1996 Heikki Tuuri

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

#include "row0upd.h"

#ifdef UNIV_NONINL

#include "row0upd.ic"

#endif

#include "dict0dict.h"

#include "trx0undo.h"

#include "rem0rec.h"

#ifndef UNIV_HOTBACKUP

#include "dict0boot.h"

#include "dict0crea.h"

#include "mach0data.h"

#include "btr0btr.h"

#include "btr0cur.h"

#include "que0que.h"

#include "row0ext.h"

#include "row0ins.h"

#include "row0sel.h"

#include "row0row.h"

#include "rem0cmp.h"

#include "lock0lock.h"

#include "log0log.h"

#include "pars0sym.h"

#include "eval0eval.h"

#include "buf0lru.h"

/* What kind of latch and lock can we assume when the control comes to

   -------------------------------------------------------------------

an update node?

--------------

Efficiency of massive updates would require keeping an x-latch on a

clustered index page through many updates, and not setting an explicit

x-lock on clustered index records, as they anyway will get an implicit

x-lock when they are updated. A problem is that the read nodes in the

graph should know that they must keep the latch when passing the control

up to the update node, and not set any record lock on the record which

will be updated. Another problem occurs if the execution is stopped,

as the kernel switches to another query thread, or the transaction must

wait for a lock. Then we should be able to release the latch and, maybe,

acquire an explicit x-lock on the record.

	Because this seems too complicated, we conclude that the less

efficient solution of releasing all the latches when the control is

transferred to another node, and acquiring explicit x-locks, is better. */

/* How is a delete performed? If there is a delete without an

explicit cursor, i.e., a searched delete, there are at least

two different situations:

the implicit select cursor may run on (1) the clustered index or

on (2) a secondary index. The delete is performed by setting

the delete bit in the record and substituting the id of the

deleting transaction for the original trx id, and substituting a

new roll ptr for previous roll ptr. The old trx id and roll ptr

are saved in the undo log record. Thus, no physical changes occur

in the index tree structure at the time of the delete. Only

when the undo log is purged, the index records will be physically

deleted from the index trees.

The query graph executing a searched delete would consist of

a delete node which has as a subtree a select subgraph.

The select subgraph should return a (persistent) cursor

in the clustered index, placed on page which is x-latched.

The delete node should look for all secondary index records for

this clustered index entry and mark them as deleted. When is

the x-latch freed? The most efficient way for performing a

searched delete is obviously to keep the x-latch for several

steps of query graph execution. */

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

IMPORTANT NOTE: Any operation that generates redo MUST check that there

is enough space in the redo log before for that operation. This is

done by calling log_free_check(). The reason for checking the

availability of the redo log space before the start of the operation is

that we MUST not hold any synchonization objects when performing the

check.

If you make a change in this module make sure that no codepath is

introduced where a call to log_free_check() is bypassed. */

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

IMPORTANT NOTE: Any operation that generates redo MUST check that there

is enough space in the redo log before for that operation. This is

done by calling log_free_check(). The reason for checking the

availability of the redo log space before the start of the operation is

that we MUST not hold any synchonization objects when performing the

check.

If you make a change in this module make sure that no codepath is

introduced where a call to log_free_check() is bypassed. */

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

Checks if an update vector changes some of the first ordering fields of an

index record. This is only used in foreign key checks and we can assume

that index does not contain column prefixes.

@return	TRUE if changes */

static

ibool

row_upd_changes_first_fields_binary(

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

	dtuple_t*	entry,	/*!< in: old value of index entry */

	dict_index_t*	index,	/*!< in: index of entry */

	const upd_t*	update,	/*!< in: update vector for the row */

	ulint		n);	/*!< in: how many first fields to check */

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

Checks if index currently is mentioned as a referenced index in a foreign

key constraint.

NOTE that since we do not hold dict_operation_lock when leaving the

function, it may be that the referencing table has been dropped when

we leave this function: this function is only for heuristic use!

@return TRUE if referenced */

static

ibool

row_upd_index_is_referenced(

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

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

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

{

	dict_table_t*	table		= index->table;

	dict_foreign_t*	foreign;

	ibool		froze_data_dict	= FALSE;

	ibool		is_referenced	= FALSE;

	if (!UT_LIST_GET_FIRST(table->referenced_list)) {

		return(FALSE);

	}

	if (trx->dict_operation_lock_mode == 0) {

		row_mysql_freeze_data_dictionary(trx);

		froze_data_dict = TRUE;

	}

	foreign = UT_LIST_GET_FIRST(table->referenced_list);

	while (foreign) {

		if (foreign->referenced_index == index) {

			is_referenced = TRUE;

			goto func_exit;

		}

		foreign = UT_LIST_GET_NEXT(referenced_list, foreign);

	}

func_exit:

	if (froze_data_dict) {

		row_mysql_unfreeze_data_dictionary(trx);

	}

	return(is_referenced);

}

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

Checks if possible foreign key constraints hold after a delete of the record

under pcur.

NOTE that this function will temporarily commit mtr and lose the

pcur position!

@return	DB_SUCCESS or an error code */

static

ulint

row_upd_check_references_constraints(

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

	upd_node_t*	node,	/*!< in: row update node */

	btr_pcur_t*	pcur,	/*!< in: cursor positioned on a record; NOTE: the

				cursor position is lost in this function! */

	dict_table_t*	table,	/*!< in: table in question */

	dict_index_t*	index,	/*!< in: index of the cursor */

	ulint*		offsets,/*!< in/out: rec_get_offsets(pcur.rec, index) */

	que_thr_t*	thr,	/*!< in: query thread */

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

{

	dict_foreign_t*	foreign;

	mem_heap_t*	heap;

	dtuple_t*	entry;

	trx_t*		trx;

	const rec_t*	rec;

	ulint		n_ext;

	ulint		err;

	ibool		got_s_lock	= FALSE;

	if (UT_LIST_GET_FIRST(table->referenced_list) == NULL) {

		return(DB_SUCCESS);

	}

	trx = thr_get_trx(thr);

	rec = btr_pcur_get_rec(pcur);

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

	heap = mem_heap_create(500);

	entry = row_rec_to_index_entry(ROW_COPY_DATA, rec, index, offsets,

				       &n_ext, heap);

	mtr_commit(mtr);

	mtr_start(mtr);

	if (trx->dict_operation_lock_mode == 0) {

		got_s_lock = TRUE;

		row_mysql_freeze_data_dictionary(trx);

	}

	foreign = UT_LIST_GET_FIRST(table->referenced_list);

	while (foreign) {

		/* Note that we may have an update which updates the index

		record, but does NOT update the first fields which are

		referenced in a foreign key constraint. Then the update does

		NOT break the constraint. */

		if (foreign->referenced_index == index

		    && (node->is_delete

			|| row_upd_changes_first_fields_binary(

				entry, index, node->update,

				foreign->n_fields))) {

			if (foreign->foreign_table == NULL) {

				dict_table_get(foreign->foreign_table_name,

					       FALSE);

			}

			if (foreign->foreign_table) {

				mutex_enter(&(dict_sys->mutex));

				(foreign->foreign_table

				 ->n_foreign_key_checks_running)++;

				mutex_exit(&(dict_sys->mutex));

			}

			/* NOTE that if the thread ends up waiting for a lock

			we will release dict_operation_lock temporarily!

			But the counter on the table protects 'foreign' from

			being dropped while the check is running. */

			err = row_ins_check_foreign_constraint(

				FALSE, foreign, table, entry, thr);

			if (foreign->foreign_table) {

				mutex_enter(&(dict_sys->mutex));

				ut_a(foreign->foreign_table

				     ->n_foreign_key_checks_running > 0);

				(foreign->foreign_table

				 ->n_foreign_key_checks_running)--;

				mutex_exit(&(dict_sys->mutex));

			}

			if (err != DB_SUCCESS) {

				goto func_exit;

			}

		}

		foreign = UT_LIST_GET_NEXT(referenced_list, foreign);

	}

	err = DB_SUCCESS;

func_exit:

	if (got_s_lock) {

		row_mysql_unfreeze_data_dictionary(trx);

	}

	mem_heap_free(heap);

	return(err);

}

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

Creates an update node for a query graph.

@return	own: update node */

UNIV_INTERN

upd_node_t*

upd_node_create(

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

	mem_heap_t*	heap)	/*!< in: mem heap where created */

{

	upd_node_t*	node;

        node = static_cast<upd_node_t *>(mem_heap_alloc(heap, sizeof(upd_node_t)));

	node->common.type = QUE_NODE_UPDATE;

	node->state = UPD_NODE_UPDATE_CLUSTERED;

	node->in_mysql_interface = FALSE;

	node->row = NULL;

	node->ext = NULL;

	node->upd_row = NULL;

	node->upd_ext = NULL;

	node->index = NULL;

	node->update = NULL;

	node->foreign = NULL;

	node->cascade_heap = NULL;

	node->cascade_node = NULL;

	node->select = NULL;

	node->heap = mem_heap_create(128);

	node->magic_n = UPD_NODE_MAGIC_N;

	node->cmpl_info = 0;

	return(node);

}

#endif /* !UNIV_HOTBACKUP */

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

Updates the trx id and roll ptr field in a clustered index record in database

recovery. */

UNIV_INTERN

void

row_upd_rec_sys_fields_in_recovery(

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

	rec_t*		rec,	/*!< in/out: record */

	page_zip_des_t*	page_zip,/*!< in/out: compressed page, or NULL */

	const ulint*	offsets,/*!< in: array returned by rec_get_offsets() */

	ulint		pos,	/*!< in: TRX_ID position in rec */

	trx_id_t	trx_id,	/*!< in: transaction id */

	roll_ptr_t	roll_ptr)/*!< in: roll ptr of the undo log record */

{

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

	if (UNIV_LIKELY_NULL(page_zip)) {

		page_zip_write_trx_id_and_roll_ptr(

			page_zip, rec, offsets, pos, trx_id, roll_ptr);

	} else {

		byte*	field;

		ulint	len;

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

		ut_ad(len == DATA_TRX_ID_LEN);

#if DATA_TRX_ID + 1 != DATA_ROLL_PTR

# error "DATA_TRX_ID + 1 != DATA_ROLL_PTR"

#endif

		trx_write_trx_id(field, trx_id);

		trx_write_roll_ptr(field + DATA_TRX_ID_LEN, roll_ptr);

	}

}

#ifndef UNIV_HOTBACKUP

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

Sets the trx id or roll ptr field of a clustered index entry. */

UNIV_INTERN

void

row_upd_index_entry_sys_field(

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

	dtuple_t*	entry,	/*!< in/out: index entry, where the memory

				buffers for sys fields are already allocated:

				the function just copies the new values to

				them */

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

	ulint		type,	/*!< in: DATA_TRX_ID or DATA_ROLL_PTR */

	ib_uint64_t	val)	/*!< in: value to write */

{

	dfield_t*	dfield;

	byte*		field;

	ulint		pos;

	ut_ad(dict_index_is_clust(index));

	pos = dict_index_get_sys_col_pos(index, type);

	dfield = dtuple_get_nth_field(entry, pos);

        field = static_cast<byte *>(dfield_get_data(dfield));

	if (type == DATA_TRX_ID) {

		trx_write_trx_id(field, val);

	} else {

		ut_ad(type == DATA_ROLL_PTR);

		trx_write_roll_ptr(field, val);

	}

}

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

Returns TRUE if row update changes size of some field in index or if some

field to be updated is stored externally in rec or update.

@return TRUE if the update changes the size of some field in index or

the field is external in rec or update */

UNIV_INTERN

ibool

row_upd_changes_field_size_or_external(

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

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

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

	const upd_t*	update)	/*!< in: update vector */

{

	const upd_field_t*	upd_field;

	const dfield_t*		new_val;

	ulint			old_len;

	ulint			new_len;

	ulint			n_fields;

	ulint			i;

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

	n_fields = upd_get_n_fields(update);

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

		upd_field = upd_get_nth_field(update, i);

		new_val = &(upd_field->new_val);

		new_len = dfield_get_len(new_val);

		if (dfield_is_null(new_val) && !rec_offs_comp(offsets)) {

			/* A bug fixed on Dec 31st, 2004: we looked at the

			SQL NULL size from the wrong field! We may backport

			this fix also to 4.0. The merge to 5.0 will be made

			manually immediately after we commit this to 4.1. */

			new_len = dict_col_get_sql_null_size(

				dict_index_get_nth_col(index,

						       upd_field->field_no),

				0);

		}

		old_len = rec_offs_nth_size(offsets, upd_field->field_no);

		if (rec_offs_comp(offsets)

		    && rec_offs_nth_sql_null(offsets,

					     upd_field->field_no)) {

			/* Note that in the compact table format, for a

			variable length field, an SQL NULL will use zero

			bytes in the offset array at the start of the physical

			record, but a zero-length value (empty string) will

			use one byte! Thus, we cannot use update-in-place

			if we update an SQL NULL varchar to an empty string! */

			old_len = UNIV_SQL_NULL;

		}

		if (dfield_is_ext(new_val) || old_len != new_len

		    || rec_offs_nth_extern(offsets, upd_field->field_no)) {

			return(TRUE);

		}

	}

	return(FALSE);

}

#endif /* !UNIV_HOTBACKUP */

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

Replaces the new column values stored in the update vector to the

record given. No field size changes are allowed. This function is

usually invoked on a clustered index. The only use case for a

secondary index is row_ins_sec_index_entry_by_modify() or its

counterpart in ibuf_insert_to_index_page(). */

UNIV_INTERN

void

row_upd_rec_in_place(

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

	rec_t*		rec,	/*!< in/out: record where replaced */

	dict_index_t*	index,	/*!< in: the index the record belongs to */

	const ulint*	offsets,/*!< in: array returned by rec_get_offsets() */

	const upd_t*	update,	/*!< in: update vector */

	page_zip_des_t*	page_zip)/*!< in: compressed page with enough space

				available, or NULL */

{

	const upd_field_t*	upd_field;

	const dfield_t*		new_val;

	ulint			n_fields;

	ulint			i;

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

	if (rec_offs_comp(offsets)) {

		rec_set_info_bits_new(rec, update->info_bits);

	} else {

		rec_set_info_bits_old(rec, update->info_bits);

	}

	n_fields = upd_get_n_fields(update);

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

		upd_field = upd_get_nth_field(update, i);

		new_val = &(upd_field->new_val);

		ut_ad(!dfield_is_ext(new_val) ==

		      !rec_offs_nth_extern(offsets, upd_field->field_no));

		rec_set_nth_field(rec, offsets, upd_field->field_no,

				  dfield_get_data(new_val),

				  dfield_get_len(new_val));

	}

	if (UNIV_LIKELY_NULL(page_zip)) {

		page_zip_write_rec(page_zip, rec, index, offsets, 0);

	}

}

#ifndef UNIV_HOTBACKUP

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

Writes into the redo log the values of trx id and roll ptr and enough info

to determine their positions within a clustered index record.

@return	new pointer to mlog */

UNIV_INTERN

byte*

row_upd_write_sys_vals_to_log(

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

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

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

	roll_ptr_t	roll_ptr,/*!< in: roll ptr of the undo log record */

	byte*		log_ptr,/*!< pointer to a buffer of size > 20 opened

				in mlog */

	mtr_t*		/*mtr __attribute__((unused))*/) /*!< in: mtr */

{

	ut_ad(dict_index_is_clust(index));

	ut_ad(mtr);

	log_ptr += mach_write_compressed(log_ptr,

					 dict_index_get_sys_col_pos(

						 index, DATA_TRX_ID));

	trx_write_roll_ptr(log_ptr, roll_ptr);

	log_ptr += DATA_ROLL_PTR_LEN;

	log_ptr += mach_ull_write_compressed(log_ptr, trx->id);

	return(log_ptr);

}

#endif /* !UNIV_HOTBACKUP */

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

Parses the log data of system field values.

@return	log data end or NULL */

UNIV_INTERN

byte*

row_upd_parse_sys_vals(

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

	byte*		ptr,	/*!< in: buffer */

	byte*		end_ptr,/*!< in: buffer end */

	ulint*		pos,	/*!< out: TRX_ID position in record */

	trx_id_t*	trx_id,	/*!< out: trx id */

	roll_ptr_t*	roll_ptr)/*!< out: roll ptr */

{

	ptr = mach_parse_compressed(ptr, end_ptr, pos);

	if (ptr == NULL) {

		return(NULL);

	}

	if (end_ptr < ptr + DATA_ROLL_PTR_LEN) {

		return(NULL);

	}

	*roll_ptr = trx_read_roll_ptr(ptr);

	ptr += DATA_ROLL_PTR_LEN;

	ptr = mach_ull_parse_compressed(ptr, end_ptr, trx_id);

	return(ptr);

}

#ifndef UNIV_HOTBACKUP

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

Writes to the redo log the new values of the fields occurring in the index. */

UNIV_INTERN

void

row_upd_index_write_log(

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

	const upd_t*	update,	/*!< in: update vector */

	byte*		log_ptr,/*!< in: pointer to mlog buffer: must

				contain at least MLOG_BUF_MARGIN bytes

				of free space; the buffer is closed

				within this function */

	mtr_t*		mtr)	/*!< in: mtr into whose log to write */

{

	const upd_field_t*	upd_field;

	const dfield_t*		new_val;

	ulint			len;

	ulint			n_fields;

	byte*			buf_end;

	ulint			i;

	n_fields = upd_get_n_fields(update);

	buf_end = log_ptr + MLOG_BUF_MARGIN;

	mach_write_to_1(log_ptr, update->info_bits);

	log_ptr++;

	log_ptr += mach_write_compressed(log_ptr, n_fields);

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

#if MLOG_BUF_MARGIN <= 30

# error "MLOG_BUF_MARGIN <= 30"

#endif

		if (log_ptr + 30 > buf_end) {

			mlog_close(mtr, log_ptr);

			log_ptr = mlog_open(mtr, MLOG_BUF_MARGIN);

			buf_end = log_ptr + MLOG_BUF_MARGIN;

		}

		upd_field = upd_get_nth_field(update, i);

		new_val = &(upd_field->new_val);

		len = dfield_get_len(new_val);

		log_ptr += mach_write_compressed(log_ptr, upd_field->field_no);

		log_ptr += mach_write_compressed(log_ptr, len);

		if (len != UNIV_SQL_NULL) {

			if (log_ptr + len < buf_end) {

				memcpy(log_ptr, dfield_get_data(new_val), len);

				log_ptr += len;

			} else {

				mlog_close(mtr, log_ptr);

				mlog_catenate_string(mtr,

                                                     static_cast<byte *>(dfield_get_data(new_val)),

						     len);

				log_ptr = mlog_open(mtr, MLOG_BUF_MARGIN);

				buf_end = log_ptr + MLOG_BUF_MARGIN;

			}

		}

	}

	mlog_close(mtr, log_ptr);

}

#endif /* !UNIV_HOTBACKUP */

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

Parses the log data written by row_upd_index_write_log.

@return	log data end or NULL */

UNIV_INTERN

byte*

row_upd_index_parse(

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

	byte*		ptr,	/*!< in: buffer */

	byte*		end_ptr,/*!< in: buffer end */

	mem_heap_t*	heap,	/*!< in: memory heap where update vector is

				built */

	upd_t**		update_out)/*!< out: update vector */

{

	upd_t*		update;

	upd_field_t*	upd_field;

	dfield_t*	new_val;

	ulint		len;

	ulint		n_fields;

	ulint		info_bits;

	ulint		i;

	if (end_ptr < ptr + 1) {

		return(NULL);

	}

	info_bits = mach_read_from_1(ptr);

	ptr++;

	ptr = mach_parse_compressed(ptr, end_ptr, &n_fields);

	if (ptr == NULL) {

		return(NULL);

	}

	update = upd_create(n_fields, heap);

	update->info_bits = info_bits;

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

		ulint	field_no;

		upd_field = upd_get_nth_field(update, i);

		new_val = &(upd_field->new_val);

		ptr = mach_parse_compressed(ptr, end_ptr, &field_no);

		if (ptr == NULL) {

			return(NULL);

		}

		upd_field->field_no = field_no;

		ptr = mach_parse_compressed(ptr, end_ptr, &len);

		if (ptr == NULL) {

			return(NULL);

		}

		if (len != UNIV_SQL_NULL) {

			if (end_ptr < ptr + len) {

				return(NULL);

			}

			dfield_set_data(new_val,

					mem_heap_dup(heap, ptr, len), len);

			ptr += len;

		} else {

			dfield_set_null(new_val);

		}

	}

	*update_out = update;

	return(ptr);

}

#ifndef UNIV_HOTBACKUP

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

Builds an update vector from those fields which in a secondary index entry

differ from a record that has the equal ordering fields. NOTE: we compare

the fields as binary strings!

@return	own: update vector of differing fields */

UNIV_INTERN

upd_t*

row_upd_build_sec_rec_difference_binary(

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

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

	const dtuple_t*	entry,	/*!< in: entry to insert */

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

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

	mem_heap_t*	heap)	/*!< in: memory heap from which allocated */

{

	upd_field_t*	upd_field;

	const dfield_t*	dfield;

	const byte*	data;

	ulint		len;

	upd_t*		update;

	ulint		n_diff;

	ulint		i;

	ulint		offsets_[REC_OFFS_SMALL_SIZE];

	const ulint*	offsets;

	rec_offs_init(offsets_);

	/* This function is used only for a secondary index */

	ut_a(!dict_index_is_clust(index));

	update = upd_create(dtuple_get_n_fields(entry), heap);

	n_diff = 0;

	offsets = rec_get_offsets(rec, index, offsets_,

				  ULINT_UNDEFINED, &heap);

	for (i = 0; i < dtuple_get_n_fields(entry); i++) {

		data = rec_get_nth_field(rec, offsets, i, &len);

		dfield = dtuple_get_nth_field(entry, i);

		/* NOTE that it may be that len != dfield_get_len(dfield) if we

		are updating in a character set and collation where strings of

		different length can be equal in an alphabetical comparison,

		and also in the case where we have a column prefix index

		and the last characters in the index field are spaces; the

		latter case probably caused the assertion failures reported at

		row0upd.c line 713 in versions 4.0.14 - 4.0.16. */

		/* NOTE: we compare the fields as binary strings!

		(No collation) */

		if (!dfield_data_is_binary_equal(dfield, len, data)) {

			upd_field = upd_get_nth_field(update, n_diff);

			dfield_copy(&(upd_field->new_val), dfield);

			upd_field_set_field_no(upd_field, i, index, trx);

			n_diff++;

		}

	}

	update->n_fields = n_diff;

	return(update);

}

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

Builds an update vector from those fields, excluding the roll ptr and

trx id fields, which in an index entry differ from a record that has

the equal ordering fields. NOTE: we compare the fields as binary strings!

@return own: update vector of differing fields, excluding roll ptr and

trx id */

UNIV_INTERN

upd_t*

row_upd_build_difference_binary(

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

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

	const dtuple_t*	entry,	/*!< in: entry to insert */

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

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

	mem_heap_t*	heap)	/*!< in: memory heap from which allocated */

{

	upd_field_t*	upd_field;

	const dfield_t*	dfield;

	const byte*	data;

	ulint		len;

	upd_t*		update;

	ulint		n_diff;