~drizzle-trunk/drizzle/development

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

Copyright (C) 2000, 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/row0mysql.c

Interface between Innobase row operations and MySQL.

Contains also create table and other data dictionary operations.

Created 9/17/2000 Heikki Tuuri

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

#include "row0mysql.h"

#ifdef UNIV_NONINL

#include "row0mysql.ic"

#endif

#include "row0ins.h"

#include "row0merge.h"

#include "row0sel.h"

#include "row0upd.h"

#include "row0row.h"

#include "que0que.h"

#include "pars0pars.h"

#include "dict0dict.h"

#include "dict0crea.h"

#include "dict0load.h"

#include "dict0boot.h"

#include "trx0roll.h"

#include "trx0purge.h"

#include "trx0rec.h"

#include "trx0undo.h"

#include "lock0lock.h"

#include "rem0cmp.h"

#include "log0log.h"

#include "btr0sea.h"

#include "fil0fil.h"

#include "ibuf0ibuf.h"

#include <errno.h>

/** Provide optional 4.x backwards compatibility for 5.0 and above */

UNIV_INTERN ibool	row_rollback_on_timeout	= FALSE;

/** Chain node of the list of tables to drop in the background. */

typedef struct row_mysql_drop_struct	row_mysql_drop_t;

/** Chain node of the list of tables to drop in the background. */

struct row_mysql_drop_struct{

	char*				table_name;	/*!< table name */

	UT_LIST_NODE_T(row_mysql_drop_t)row_mysql_drop_list;

							/*!< list chain node */

};

/** @brief List of tables we should drop in background.

ALTER TABLE in MySQL requires that the table handler can drop the

table in background when there are no queries to it any

more.  Protected by kernel_mutex. */

static UT_LIST_BASE_NODE_T(row_mysql_drop_t)	row_mysql_drop_list;

/** Flag: has row_mysql_drop_list been initialized? */

static ibool	row_mysql_drop_list_inited	= FALSE;

/** Magic table names for invoking various monitor threads */

/* @{ */

static const char S_innodb_monitor[] = "innodb_monitor";

static const char S_innodb_lock_monitor[] = "innodb_lock_monitor";

static const char S_innodb_tablespace_monitor[] = "innodb_tablespace_monitor";

static const char S_innodb_table_monitor[] = "innodb_table_monitor";

static const char S_innodb_mem_validate[] = "innodb_mem_validate";

/* @} */

/** Evaluates to true if str1 equals str2_onstack, used for comparing

the magic table names.

@param str1		in: string to compare

@param str1_len 	in: length of str1, in bytes, including terminating NUL

@param str2_onstack	in: char[] array containing a NUL terminated string

@return			TRUE if str1 equals str2_onstack */

#define STR_EQ(str1, str1_len, str2_onstack) \

	((str1_len) == sizeof(str2_onstack) \

	 && memcmp(str1, str2_onstack, sizeof(str2_onstack)) == 0)

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

If a table is not yet in the drop list, adds the table to the list of tables

which the master thread drops in background. We need this on Unix because in

ALTER TABLE MySQL may call drop table even if the table has running queries on

it. Also, if there are running foreign key checks on the table, we drop the

table lazily.

@return	TRUE if the table was not yet in the drop list, and was added there */

static

ibool

row_add_table_to_background_drop_list(

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

	const char*	name);	/*!< in: table name */

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

Delays an INSERT, DELETE or UPDATE operation if the purge is lagging. */

static

void

row_mysql_delay_if_needed(void)

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

{

	if (srv_dml_needed_delay) {

		os_thread_sleep(srv_dml_needed_delay);

	}

}

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

Frees the blob heap in prebuilt when no longer needed. */

UNIV_INTERN

void

row_mysql_prebuilt_free_blob_heap(

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

	row_prebuilt_t*	prebuilt)	/*!< in: prebuilt struct of a

					ha_innobase:: table handle */

{

	mem_heap_free(prebuilt->blob_heap);

	prebuilt->blob_heap = NULL;

}

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

Stores a >= 5.0.3 format true VARCHAR length to dest, in the MySQL row

format.

@return pointer to the data, we skip the 1 or 2 bytes at the start

that are used to store the len */

UNIV_INTERN

byte*

row_mysql_store_true_var_len(

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

	byte*	dest,	/*!< in: where to store */

	ulint	len,	/*!< in: length, must fit in two bytes */

	ulint	lenlen)	/*!< in: storage length of len: either 1 or 2 bytes */

{

	if (lenlen == 2) {

		ut_a(len < 256 * 256);

		mach_write_to_2_little_endian(dest, len);

		return(dest + 2);

	}

	ut_a(lenlen == 1);

	ut_a(len < 256);

	mach_write_to_1(dest, len);

	return(dest + 1);

}

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

Reads a >= 5.0.3 format true VARCHAR length, in the MySQL row format, and

returns a pointer to the data.

@return pointer to the data, we skip the 1 or 2 bytes at the start

that are used to store the len */

UNIV_INTERN

const byte*

row_mysql_read_true_varchar(

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

	ulint*		len,	/*!< out: variable-length field length */

	const byte*	field,	/*!< in: field in the MySQL format */

	ulint		lenlen)	/*!< in: storage length of len: either 1

				or 2 bytes */

{

	if (lenlen == 2) {

		*len = mach_read_from_2_little_endian(field);

		return(field + 2);

	}

	ut_a(lenlen == 1);

	*len = mach_read_from_1(field);

	return(field + 1);

}

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

Stores a reference to a BLOB in the MySQL format. */

UNIV_INTERN

void

row_mysql_store_blob_ref(

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

	byte*		dest,	/*!< in: where to store */

	ulint		col_len,/*!< in: dest buffer size: determines into

				how many bytes the BLOB length is stored,

				the space for the length may vary from 1

				to 4 bytes */

	const void*	data,	/*!< in: BLOB data; if the value to store

				is SQL NULL this should be NULL pointer */

	ulint		len)	/*!< in: BLOB length; if the value to store

				is SQL NULL this should be 0; remember

				also to set the NULL bit in the MySQL record

				header! */

{

	/* MySQL might assume the field is set to zero except the length and

	the pointer fields */

	memset(dest, '\0', col_len);

	/* In dest there are 1 - 4 bytes reserved for the BLOB length,

	and after that 8 bytes reserved for the pointer to the data.

	In 32-bit architectures we only use the first 4 bytes of the pointer

	slot. */

	ut_a(col_len - 8 > 1 || len < 256);

	ut_a(col_len - 8 > 2 || len < 256 * 256);

	ut_a(col_len - 8 > 3 || len < 256 * 256 * 256);

	mach_write_to_n_little_endian(dest, col_len - 8, len);

	memcpy(dest + col_len - 8, &data, sizeof data);

}

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

Reads a reference to a BLOB in the MySQL format.

@return	pointer to BLOB data */

UNIV_INTERN

const byte*

row_mysql_read_blob_ref(

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

	ulint*		len,		/*!< out: BLOB length */

	const byte*	ref,		/*!< in: BLOB reference in the

					MySQL format */

	ulint		col_len)	/*!< in: BLOB reference length

					(not BLOB length) */

{

	byte*	data;

	*len = mach_read_from_n_little_endian(ref, col_len - 8);

	memcpy(&data, ref + col_len - 8, sizeof data);

	return(data);

}

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

Pad a column with spaces. */

UNIV_INTERN

void

row_mysql_pad_col(

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

	ulint	mbminlen,	/*!< in: minimum size of a character,

				in bytes */

	byte*	pad,		/*!< out: padded buffer */

	ulint	len)		/*!< in: number of bytes to pad */

{

	const byte*	pad_end;

	switch (UNIV_EXPECT(mbminlen, 1)) {

	default:

		ut_error;

	case 1:

		/* space=0x20 */

		memset(pad, 0x20, len);

		break;

	case 2:

		/* space=0x0020 */

		pad_end = pad + len;

		ut_a(!(len % 2));

		do {

			*pad++ = 0x00;

			*pad++ = 0x20;

		} while (pad < pad_end);

		break;

	case 4:

		/* space=0x00000020 */

		pad_end = pad + len;

		ut_a(!(len % 4));

		do {

			*pad++ = 0x00;

			*pad++ = 0x00;

			*pad++ = 0x00;

			*pad++ = 0x20;

		} while (pad < pad_end);

		break;

	}

}

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

Stores a non-SQL-NULL field given in the MySQL format in the InnoDB format.

The counterpart of this function is row_sel_field_store_in_mysql_format() in

row0sel.c.

@return	up to which byte we used buf in the conversion */

UNIV_INTERN

byte*

row_mysql_store_col_in_innobase_format(

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

	dfield_t*	dfield,		/*!< in/out: dfield where dtype

					information must be already set when

					this function is called! */

	byte*		buf,		/*!< in/out: buffer for a converted

					integer value; this must be at least

					col_len long then! */

	ibool		row_format_col,	/*!< TRUE if the mysql_data is from

					a MySQL row, FALSE if from a MySQL

					key value;

					in MySQL, a true VARCHAR storage

					format differs in a row and in a

					key value: in a key value the length

					is always stored in 2 bytes! */

	const byte*	mysql_data,	/*!< in: MySQL column value, not

					SQL NULL; NOTE that dfield may also

					get a pointer to mysql_data,

					therefore do not discard this as long

					as dfield is used! */

	ulint		col_len,	/*!< in: MySQL column length; NOTE that

					this is the storage length of the

					column in the MySQL format row, not

					necessarily the length of the actual

					payload data; if the column is a true

					VARCHAR then this is irrelevant */

	ulint		comp)		/*!< in: nonzero=compact format */

{

	const byte*	ptr	= mysql_data;

	const dtype_t*	dtype;

	ulint		type;

	ulint		lenlen;

	dtype = dfield_get_type(dfield);

	type = dtype->mtype;

	if (type == DATA_INT) {

		/* Store integer data in Innobase in a big-endian format,

		sign bit negated if the data is a signed integer. In MySQL,

		integers are stored in a little-endian format. */

		byte*	p = buf + col_len;

		for (;;) {

			p--;

			*p = *mysql_data;

			if (p == buf) {

				break;

			}

			mysql_data++;

		}

		if (!(dtype->prtype & DATA_UNSIGNED)) {

			*buf ^= 128;

		}

		ptr = buf;

		buf += col_len;

	} else if ((type == DATA_VARCHAR

		    || type == DATA_VARMYSQL

		    || type == DATA_BINARY)) {

		if (dtype_get_mysql_type(dtype) == DATA_MYSQL_TRUE_VARCHAR) {

			/* The length of the actual data is stored to 1 or 2

			bytes at the start of the field */

			if (row_format_col) {

				if (dtype->prtype & DATA_LONG_TRUE_VARCHAR) {

					lenlen = 2;

				} else {

					lenlen = 1;

				}

			} else {

				/* In a MySQL key value, lenlen is always 2 */

				lenlen = 2;

			}

			ptr = row_mysql_read_true_varchar(&col_len, mysql_data,

							  lenlen);

		} else {

			/* Remove trailing spaces from old style VARCHAR

			columns. */

			/* Handle Unicode strings differently. */

			ulint	mbminlen	= dtype_get_mbminlen(dtype);

			ptr = mysql_data;

			switch (mbminlen) {

			default:

				ut_error;

			case 4:

				/* space=0x00000020 */

				/* Trim "half-chars", just in case. */

				col_len &= ~3;

				while (col_len >= 4

				       && ptr[col_len - 4] == 0x00

				       && ptr[col_len - 3] == 0x00

				       && ptr[col_len - 2] == 0x00

				       && ptr[col_len - 1] == 0x20) {

					col_len -= 4;

				}

				break;

			case 2:

				/* space=0x0020 */

				/* Trim "half-chars", just in case. */

				col_len &= ~1;

				while (col_len >= 2 && ptr[col_len - 2] == 0x00

				       && ptr[col_len - 1] == 0x20) {

					col_len -= 2;

				}

				break;

			case 1:

				/* space=0x20 */

				while (col_len > 0

				       && ptr[col_len - 1] == 0x20) {

					col_len--;

				}

			}

		}

	} else if (comp && type == DATA_MYSQL

		   && dtype_get_mbminlen(dtype) == 1

		   && dtype_get_mbmaxlen(dtype) > 1) {

		/* In some cases we strip trailing spaces from UTF-8 and other

		multibyte charsets, from FIXED-length CHAR columns, to save

		space. UTF-8 would otherwise normally use 3 * the string length

		bytes to store an ASCII string! */

		/* We assume that this CHAR field is encoded in a

		variable-length character set where spaces have

		1:1 correspondence to 0x20 bytes, such as UTF-8.

		Consider a CHAR(n) field, a field of n characters.

		It will contain between n * mbminlen and n * mbmaxlen bytes.

		We will try to truncate it to n bytes by stripping

		space padding.	If the field contains single-byte

		characters only, it will be truncated to n characters.

		Consider a CHAR(5) field containing the string ".a   "

		where "." denotes a 3-byte character represented by

		the bytes "$%&".  After our stripping, the string will

		be stored as "$%&a " (5 bytes).	 The string ".abc "

		will be stored as "$%&abc" (6 bytes).

		The space padding will be restored in row0sel.c, function

		row_sel_field_store_in_mysql_format(). */

		ulint		n_chars;

		ut_a(!(dtype_get_len(dtype) % dtype_get_mbmaxlen(dtype)));

		n_chars = dtype_get_len(dtype) / dtype_get_mbmaxlen(dtype);

		/* Strip space padding. */

		while (col_len > n_chars && ptr[col_len - 1] == 0x20) {

			col_len--;

		}

	} else if (type == DATA_BLOB && row_format_col) {

		ptr = row_mysql_read_blob_ref(&col_len, mysql_data, col_len);

	}

	dfield_set_data(dfield, ptr, col_len);

	return(buf);

}

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

Convert a row in the MySQL format to a row in the Innobase format. Note that

the function to convert a MySQL format key value to an InnoDB dtuple is

row_sel_convert_mysql_key_to_innobase() in row0sel.c. */

static

void

row_mysql_convert_row_to_innobase(

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

	dtuple_t*	row,		/*!< in/out: Innobase row where the

					field type information is already

					copied there! */

	row_prebuilt_t*	prebuilt,	/*!< in: prebuilt struct where template

					must be of type ROW_MYSQL_WHOLE_ROW */

	byte*		mysql_rec)	/*!< in: row in the MySQL format;

					NOTE: do not discard as long as

					row is used, as row may contain

					pointers to this record! */

{

	const mysql_row_templ_t*templ;

	dfield_t*		dfield;

	ulint			i;

	ut_ad(prebuilt->template_type == ROW_MYSQL_WHOLE_ROW);

	ut_ad(prebuilt->mysql_template);

	for (i = 0; i < prebuilt->n_template; i++) {

		templ = prebuilt->mysql_template + i;

		dfield = dtuple_get_nth_field(row, i);

		if (templ->mysql_null_bit_mask != 0) {

			/* Column may be SQL NULL */

			if (mysql_rec[templ->mysql_null_byte_offset]

			    & (byte) (templ->mysql_null_bit_mask)) {

				/* It is SQL NULL */

				dfield_set_null(dfield);

				goto next_column;

			}

		}

		row_mysql_store_col_in_innobase_format(

			dfield,

			prebuilt->ins_upd_rec_buff + templ->mysql_col_offset,

			TRUE, /* MySQL row format data */

			mysql_rec + templ->mysql_col_offset,

			templ->mysql_col_len,

			dict_table_is_comp(prebuilt->table));

next_column:

		;

	}

}

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

Handles user errors and lock waits detected by the database engine.

@return TRUE if it was a lock wait and we should continue running the

query thread and in that case the thr is ALREADY in the running state. */

UNIV_INTERN

ibool

row_mysql_handle_errors(

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

	ulint*		new_err,/*!< out: possible new error encountered in

				lock wait, or if no new error, the value

				of trx->error_state at the entry of this

				function */

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

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

	trx_savept_t*	savept)	/*!< in: savepoint or NULL */

{

	ulint	err;

handle_new_error:

	err = trx->error_state;

	ut_a(err != DB_SUCCESS);

	trx->error_state = DB_SUCCESS;

	switch (err) {

	case DB_LOCK_WAIT_TIMEOUT:

		if (row_rollback_on_timeout) {

			trx_general_rollback_for_mysql(trx, NULL);

			break;

		}

		/* fall through */

	case DB_DUPLICATE_KEY:

	case DB_FOREIGN_DUPLICATE_KEY:

	case DB_TOO_BIG_RECORD:

	case DB_ROW_IS_REFERENCED:

	case DB_NO_REFERENCED_ROW:

	case DB_CANNOT_ADD_CONSTRAINT:

	case DB_TOO_MANY_CONCURRENT_TRXS:

	case DB_OUT_OF_FILE_SPACE:

	case DB_INTERRUPTED:

		if (savept) {

			/* Roll back the latest, possibly incomplete

			insertion or update */

			trx_general_rollback_for_mysql(trx, savept);

		}

		/* MySQL will roll back the latest SQL statement */

		break;

	case DB_LOCK_WAIT:

		srv_suspend_mysql_thread(thr);

		if (trx->error_state != DB_SUCCESS) {

			que_thr_stop_for_mysql(thr);

			goto handle_new_error;

		}

		*new_err = err;

		return(TRUE);

	case DB_DEADLOCK:

	case DB_LOCK_TABLE_FULL:

		/* Roll back the whole transaction; this resolution was added

		to version 3.23.43 */

		trx_general_rollback_for_mysql(trx, NULL);

		break;

	case DB_MUST_GET_MORE_FILE_SPACE:

		fputs("InnoDB: The database cannot continue"

		      " operation because of\n"

		      "InnoDB: lack of space. You must add"

		      " a new data file to\n"

		      "InnoDB: my.cnf and restart the database.\n", stderr);

		exit(1);

	case DB_CORRUPTION:

		fputs("InnoDB: We detected index corruption"

		      " in an InnoDB type table.\n"

		      "InnoDB: You have to dump + drop + reimport"

		      " the table or, in\n"

		      "InnoDB: a case of widespread corruption,"

		      " dump all InnoDB\n"

		      "InnoDB: tables and recreate the"

		      " whole InnoDB tablespace.\n"

		      "InnoDB: If the mysqld server crashes"

		      " after the startup or when\n"

		      "InnoDB: you dump the tables, look at\n"

		      "InnoDB: " REFMAN "forcing-recovery.html"

		      " for help.\n", stderr);

		break;

	case DB_FOREIGN_EXCEED_MAX_CASCADE:

		fprintf(stderr, "InnoDB: Cannot delete/update rows with"

			" cascading foreign key constraints that exceed max"

			" depth of %lu\n"

			"Please drop excessive foreign constraints"

			" and try again\n", (ulong) DICT_FK_MAX_RECURSIVE_LOAD);

		break;

	default:

		fprintf(stderr, "InnoDB: unknown error code %lu\n",

			(ulong) err);

		ut_error;

	}

	if (trx->error_state != DB_SUCCESS) {

		*new_err = trx->error_state;

	} else {

		*new_err = err;

	}

	trx->error_state = DB_SUCCESS;

	return(FALSE);

}

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

Create a prebuilt struct for a MySQL table handle.

@return	own: a prebuilt struct */

UNIV_INTERN

row_prebuilt_t*

row_create_prebuilt(

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

	dict_table_t*	table)	/*!< in: Innobase table handle */

{

	row_prebuilt_t*	prebuilt;

	mem_heap_t*	heap;

	dict_index_t*	clust_index;

	dtuple_t*	ref;

	ulint		ref_len;

	heap = mem_heap_create(sizeof *prebuilt + 128);

	prebuilt = mem_heap_zalloc(heap, sizeof *prebuilt);

	prebuilt->magic_n = ROW_PREBUILT_ALLOCATED;

	prebuilt->magic_n2 = ROW_PREBUILT_ALLOCATED;

	prebuilt->table = table;

	prebuilt->sql_stat_start = TRUE;

	prebuilt->heap = heap;

	prebuilt->pcur = btr_pcur_create_for_mysql();

	prebuilt->clust_pcur = btr_pcur_create_for_mysql();

	prebuilt->select_lock_type = LOCK_NONE;

	prebuilt->stored_select_lock_type = 99999999;

	UNIV_MEM_INVALID(&prebuilt->stored_select_lock_type,

			 sizeof prebuilt->stored_select_lock_type);

	prebuilt->search_tuple = dtuple_create(

		heap, 2 * dict_table_get_n_cols(table));

	clust_index = dict_table_get_first_index(table);

	/* Make sure that search_tuple is long enough for clustered index */

	ut_a(2 * dict_table_get_n_cols(table) >= clust_index->n_fields);

	ref_len = dict_index_get_n_unique(clust_index);

	ref = dtuple_create(heap, ref_len);

	dict_index_copy_types(ref, clust_index, ref_len);

	prebuilt->clust_ref = ref;

	prebuilt->autoinc_error = 0;

	prebuilt->autoinc_offset = 0;

	/* Default to 1, we will set the actual value later in 

	ha_innobase::get_auto_increment(). */

	prebuilt->autoinc_increment = 1;

	prebuilt->autoinc_last_value = 0;

	return(prebuilt);

}

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

Free a prebuilt struct for a MySQL table handle. */

UNIV_INTERN

void

row_prebuilt_free(

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

	row_prebuilt_t*	prebuilt,	/*!< in, own: prebuilt struct */

	ibool		dict_locked)	/*!< in: TRUE=data dictionary locked */

{

	ulint	i;

	if (UNIV_UNLIKELY

	    (prebuilt->magic_n != ROW_PREBUILT_ALLOCATED

	     || prebuilt->magic_n2 != ROW_PREBUILT_ALLOCATED)) {

		fprintf(stderr,

			"InnoDB: Error: trying to free a corrupt\n"

			"InnoDB: table handle. Magic n %lu,"

			" magic n2 %lu, table name ",

			(ulong) prebuilt->magic_n,

			(ulong) prebuilt->magic_n2);

		ut_print_name(stderr, NULL, TRUE, prebuilt->table->name);

		putc('\n', stderr);

		mem_analyze_corruption(prebuilt);

		ut_error;

	}

	prebuilt->magic_n = ROW_PREBUILT_FREED;

	prebuilt->magic_n2 = ROW_PREBUILT_FREED;

	btr_pcur_free_for_mysql(prebuilt->pcur);

	btr_pcur_free_for_mysql(prebuilt->clust_pcur);

	if (prebuilt->mysql_template) {

		mem_free(prebuilt->mysql_template);

	}

	if (prebuilt->ins_graph) {

		que_graph_free_recursive(prebuilt->ins_graph);

	}

	if (prebuilt->sel_graph) {

		que_graph_free_recursive(prebuilt->sel_graph);

	}

	if (prebuilt->upd_graph) {

		que_graph_free_recursive(prebuilt->upd_graph);

	}

	if (prebuilt->blob_heap) {

		mem_heap_free(prebuilt->blob_heap);

	}

	if (prebuilt->old_vers_heap) {

		mem_heap_free(prebuilt->old_vers_heap);

	}

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

		if (prebuilt->fetch_cache[i] != NULL) {

			if ((ROW_PREBUILT_FETCH_MAGIC_N != mach_read_from_4(

				     (prebuilt->fetch_cache[i]) - 4))

			    || (ROW_PREBUILT_FETCH_MAGIC_N != mach_read_from_4(

					(prebuilt->fetch_cache[i])

					+ prebuilt->mysql_row_len))) {

				fputs("InnoDB: Error: trying to free"

				      " a corrupt fetch buffer.\n", stderr);

				mem_analyze_corruption(

					prebuilt->fetch_cache[i]);

				ut_error;

			}

			mem_free((prebuilt->fetch_cache[i]) - 4);

		}

	}

	dict_table_decrement_handle_count(prebuilt->table, dict_locked);

	mem_heap_free(prebuilt->heap);

}

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

Updates the transaction pointers in query graphs stored in the prebuilt

struct. */

UNIV_INTERN

void

row_update_prebuilt_trx(

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

	row_prebuilt_t*	prebuilt,	/*!< in/out: prebuilt struct

					in MySQL handle */

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

{

	if (trx->magic_n != TRX_MAGIC_N) {

		fprintf(stderr,

			"InnoDB: Error: trying to use a corrupt\n"

			"InnoDB: trx handle. Magic n %lu\n",

			(ulong) trx->magic_n);

		mem_analyze_corruption(trx);

		ut_error;

	}

	if (prebuilt->magic_n != ROW_PREBUILT_ALLOCATED) {

		fprintf(stderr,

			"InnoDB: Error: trying to use a corrupt\n"

			"InnoDB: table handle. Magic n %lu, table name ",

			(ulong) prebuilt->magic_n);

		ut_print_name(stderr, trx, TRUE, prebuilt->table->name);

		putc('\n', stderr);