~drizzle-trunk/drizzle/development

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

Record manager

(c) 1994-1996 Innobase Oy

Created 5/30/1994 Heikki Tuuri

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

#ifndef rem0rec_h

#define rem0rec_h

#include "univ.i"

#include "data0data.h"

#include "rem0types.h"

#include "mtr0types.h"

/* Info bit denoting the predefined minimum record: this bit is set

if and only if the record is the first user record on a non-leaf

B-tree page that is the leftmost page on its level

(PAGE_LEVEL is nonzero and FIL_PAGE_PREV is FIL_NULL). */

#define REC_INFO_MIN_REC_FLAG	0x10UL

/* Number of extra bytes in an old-style record,

in addition to the data and the offsets */

#define REC_N_OLD_EXTRA_BYTES	6

/* Number of extra bytes in a new-style record,

in addition to the data and the offsets */

#define REC_N_NEW_EXTRA_BYTES	5

/* Record status values */

#define REC_STATUS_ORDINARY	0

#define REC_STATUS_NODE_PTR	1

#define REC_STATUS_INFIMUM	2

#define REC_STATUS_SUPREMUM	3

/* Number of elements that should be initially allocated for the

offsets[] array, first passed to rec_get_offsets() */

#define REC_OFFS_NORMAL_SIZE	100

#define REC_OFFS_SMALL_SIZE	10

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

The following function is used to get the offset of the

next chained record on the same page. */

UNIV_INLINE

ulint

rec_get_next_offs(

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

			/* out: the page offset of the next

			chained record */

	rec_t*	rec,	/* in: physical record */

	ulint	comp);	/* in: nonzero=compact page format */

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

The following function is used to set the next record offset field

of the record. */

UNIV_INLINE

void

rec_set_next_offs(

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

	rec_t*	rec,	/* in: physical record */

	ulint	comp,	/* in: nonzero=compact page format */

	ulint	next);	/* in: offset of the next record */

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

The following function is used to get the number of fields

in an old-style record. */

UNIV_INLINE

ulint

rec_get_n_fields_old(

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

			/* out: number of data fields */

	rec_t*	rec);	/* in: physical record */

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

The following function is used to get the number of fields

in a record. */

UNIV_INLINE

ulint

rec_get_n_fields(

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

				/* out: number of data fields */

	rec_t*		rec,	/* in: physical record */

	dict_index_t*	index);	/* in: record descriptor */

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

The following function is used to get the number of records

owned by the previous directory record. */

UNIV_INLINE

ulint

rec_get_n_owned(

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

			/* out: number of owned records */

	rec_t*	rec,	/* in: physical record */

	ulint	comp);	/* in: nonzero=compact page format */

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

The following function is used to set the number of owned

records. */

UNIV_INLINE

void

rec_set_n_owned(

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

	rec_t*	rec,		/* in: physical record */

	ulint	comp,		/* in: nonzero=compact page format */

	ulint	n_owned);	/* in: the number of owned */

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

The following function is used to retrieve the info bits of

a record. */

UNIV_INLINE

ulint

rec_get_info_bits(

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

			/* out: info bits */

	rec_t*	rec,	/* in: physical record */

	ulint	comp);	/* in: nonzero=compact page format */

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

The following function is used to set the info bits of a record. */

UNIV_INLINE

void

rec_set_info_bits(

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

	rec_t*	rec,	/* in: physical record */

	ulint	comp,	/* in: nonzero=compact page format */

	ulint	bits);	/* in: info bits */

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

The following function retrieves the status bits of a new-style record. */

UNIV_INLINE

ulint

rec_get_status(

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

			/* out: status bits */

	rec_t*	rec);	/* in: physical record */

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

The following function is used to set the status bits of a new-style record. */

UNIV_INLINE

void

rec_set_status(

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

	rec_t*	rec,	/* in: physical record */

	ulint	bits);	/* in: info bits */

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

The following function is used to retrieve the info and status

bits of a record.  (Only compact records have status bits.) */

UNIV_INLINE

ulint

rec_get_info_and_status_bits(

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

			/* out: info bits */

	rec_t*	rec,	/* in: physical record */

	ulint	comp);	/* in: nonzero=compact page format */

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

The following function is used to set the info and status

bits of a record.  (Only compact records have status bits.) */

UNIV_INLINE

void

rec_set_info_and_status_bits(

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

	rec_t*	rec,	/* in: physical record */

	ulint	comp,	/* in: nonzero=compact page format */

	ulint	bits);	/* in: info bits */

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

The following function tells if record is delete marked. */

UNIV_INLINE

ulint

rec_get_deleted_flag(

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

			/* out: nonzero if delete marked */

	rec_t*	rec,	/* in: physical record */

	ulint	comp);	/* in: nonzero=compact page format */

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

The following function is used to set the deleted bit. */

UNIV_INLINE

void

rec_set_deleted_flag(

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

	rec_t*	rec,	/* in: physical record */

	ulint	comp,	/* in: nonzero=compact page format */

	ulint	flag);	/* in: nonzero if delete marked */

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

The following function tells if a new-style record is a node pointer. */

UNIV_INLINE

ibool

rec_get_node_ptr_flag(

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

			/* out: TRUE if node pointer */

	rec_t*	rec);	/* in: physical record */

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

The following function is used to get the order number

of the record in the heap of the index page. */

UNIV_INLINE

ulint

rec_get_heap_no(

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

			/* out: heap order number */

	rec_t*	rec,	/* in: physical record */

	ulint	comp);	/* in: nonzero=compact page format */

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

The following function is used to set the heap number

field in the record. */

UNIV_INLINE

void

rec_set_heap_no(

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

	rec_t*	rec,	/* in: physical record */

	ulint	comp,	/* in: nonzero=compact page format */

	ulint	heap_no);/* in: the heap number */

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

The following function is used to test whether the data offsets

in the record are stored in one-byte or two-byte format. */

UNIV_INLINE

ibool

rec_get_1byte_offs_flag(

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

			/* out: TRUE if 1-byte form */

	rec_t*	rec);	/* in: physical record */

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

The following function determines the offsets to each field

in the record.	It can reuse a previously allocated array. */

ulint*

rec_get_offsets_func(

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

				/* out: the new offsets */

	rec_t*		rec,	/* in: physical record */

	dict_index_t*	index,	/* in: record descriptor */

	ulint*		offsets,/* in: array consisting of offsets[0]

				allocated elements, or an array from

				rec_get_offsets(), or NULL */

	ulint		n_fields,/* in: maximum number of initialized fields

				(ULINT_UNDEFINED if all fields) */

	mem_heap_t**	heap,	/* in/out: memory heap */

	const char*	file,	/* in: file name where called */

	ulint		line);	/* in: line number where called */

#define rec_get_offsets(rec,index,offsets,n,heap)	\

	rec_get_offsets_func(rec,index,offsets,n,heap,__FILE__,__LINE__)

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

Validates offsets returned by rec_get_offsets(). */

UNIV_INLINE

ibool

rec_offs_validate(

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

				/* out: TRUE if valid */

	rec_t*		rec,	/* in: record or NULL */

	dict_index_t*	index,	/* in: record descriptor or NULL */

	const ulint*	offsets);/* in: array returned by rec_get_offsets() */

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

Updates debug data in offsets, in order to avoid bogus

rec_offs_validate() failures. */

UNIV_INLINE

void

rec_offs_make_valid(

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

	rec_t*		rec,	/* in: record */

	dict_index_t*	index,/* in: record descriptor */

	ulint*		offsets);/* in: array returned by rec_get_offsets() */

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

The following function is used to get a pointer to the nth

data field in an old-style record. */

byte*

rec_get_nth_field_old(

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

			/* out: pointer to the field */

	rec_t*	rec,	/* in: record */

	ulint	n,	/* in: index of the field */

	ulint*	len);	/* out: length of the field; UNIV_SQL_NULL

			if SQL null */

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

Gets the physical size of an old-style field.

Also an SQL null may have a field of size > 0,

if the data type is of a fixed size. */

UNIV_INLINE

ulint

rec_get_nth_field_size(

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

			/* out: field size in bytes */

	rec_t*	rec,	/* in: record */

	ulint	n);	/* in: index of the field */

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

The following function is used to get a pointer to the nth

data field in a record. */

UNIV_INLINE

byte*

rec_get_nth_field(

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

				/* out: pointer to the field */

	rec_t*		rec,	/* in: record */

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

	ulint		n,	/* in: index of the field */

	ulint*		len);	/* out: length of the field; UNIV_SQL_NULL

				if SQL null */

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

Determine if the offsets are for a record in the new

compact format. */

UNIV_INLINE

ulint

rec_offs_comp(

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

				/* out: nonzero if compact format */

	const ulint*	offsets);/* in: array returned by rec_get_offsets() */

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

Returns nonzero if the extern bit is set in nth field of rec. */

UNIV_INLINE

ulint

rec_offs_nth_extern(

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

				/* out: nonzero if externally stored */

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

	ulint		n);	/* in: nth field */

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

Returns nonzero if the SQL NULL bit is set in nth field of rec. */

UNIV_INLINE

ulint

rec_offs_nth_sql_null(

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

				/* out: nonzero if SQL NULL */

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

	ulint		n);	/* in: nth field */

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

Gets the physical size of a field. */

UNIV_INLINE

ulint

rec_offs_nth_size(

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

				/* out: length of field */

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

	ulint		n);	/* in: nth field */

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

Returns TRUE if the extern bit is set in any of the fields

of rec. */

UNIV_INLINE

ibool

rec_offs_any_extern(

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

				/* out: TRUE if a field is stored externally */

	const ulint*	offsets);/* in: array returned by rec_get_offsets() */

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

Sets the value of the ith field extern storage bit. */

UNIV_INLINE

void

rec_set_nth_field_extern_bit(

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

	rec_t*		rec,	/* in: record */

	dict_index_t*	index,	/* in: record descriptor */

	ulint		i,	/* in: ith field */

	ibool		val,	/* in: value to set */

	mtr_t*		mtr);	/* in: mtr holding an X-latch to the page

				where rec is, or NULL; in the NULL case

				we do not write to log about the change */

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

Sets TRUE the extern storage bits of fields mentioned in an array. */

void

rec_set_field_extern_bits(

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

	rec_t*		rec,	/* in: record */

	dict_index_t*	index,	/* in: record descriptor */

	const ulint*	vec,	/* in: array of field numbers */

	ulint		n_fields,/* in: number of fields numbers */

	mtr_t*		mtr);	/* in: mtr holding an X-latch to the page

				where rec is, or NULL; in the NULL case

				we do not write to log about the change */

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

This is used to modify the value of an already existing field in a record.

The previous value must have exactly the same size as the new value. If len

is UNIV_SQL_NULL then the field is treated as an SQL null for old-style

records. For new-style records, len must not be UNIV_SQL_NULL. */

UNIV_INLINE

void

rec_set_nth_field(

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

	rec_t*		rec,	/* in: record */

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

	ulint		n,	/* in: index number of the field */

	const void*	data,	/* in: pointer to the data if not SQL null */

	ulint		len);	/* in: length of the data or UNIV_SQL_NULL.

				If not SQL null, must have the same

				length as the previous value.

				If SQL null, previous value must be

				SQL null. */

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

The following function returns the data size of an old-style physical

record, that is the sum of field lengths. SQL null fields

are counted as length 0 fields. The value returned by the function

is the distance from record origin to record end in bytes. */

UNIV_INLINE

ulint

rec_get_data_size_old(

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

				/* out: size */

	rec_t*	rec);	/* in: physical record */

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

The following function returns the number of fields in a record. */

UNIV_INLINE

ulint

rec_offs_n_fields(

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

				/* out: number of fields */

	const ulint*	offsets);/* in: array returned by rec_get_offsets() */

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

The following function returns the data size of a physical

record, that is the sum of field lengths. SQL null fields

are counted as length 0 fields. The value returned by the function

is the distance from record origin to record end in bytes. */

UNIV_INLINE

ulint

rec_offs_data_size(

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

				/* out: size */

	const ulint*	offsets);/* in: array returned by rec_get_offsets() */

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

Returns the total size of record minus data size of record.

The value returned by the function is the distance from record

start to record origin in bytes. */

UNIV_INLINE

ulint

rec_offs_extra_size(

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

				/* out: size */

	const ulint*	offsets);/* in: array returned by rec_get_offsets() */

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

Returns the total size of a physical record.  */

UNIV_INLINE

ulint

rec_offs_size(

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

				/* out: size */

	const ulint*	offsets);/* in: array returned by rec_get_offsets() */

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

Returns a pointer to the start of the record. */

UNIV_INLINE

byte*

rec_get_start(

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

				/* out: pointer to start */

	rec_t*		rec,	/* in: pointer to record */

	const ulint*	offsets);/* in: array returned by rec_get_offsets() */

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

Returns a pointer to the end of the record. */

UNIV_INLINE

byte*

rec_get_end(

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

				/* out: pointer to end */

	rec_t*		rec,	/* in: pointer to record */

	const ulint*	offsets);/* in: array returned by rec_get_offsets() */

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

Copies a physical record to a buffer. */

UNIV_INLINE

rec_t*

rec_copy(

/*=====*/

				/* out: pointer to the origin of the copy */

	void*		buf,	/* in: buffer */

	const rec_t*	rec,	/* in: physical record */

	const ulint*	offsets);/* in: array returned by rec_get_offsets() */

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

Copies the first n fields of a physical record to a new physical record in

a buffer. */

rec_t*

rec_copy_prefix_to_buf(

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

					/* out, own: copied record */

	rec_t*		rec,		/* in: physical record */

	dict_index_t*	index,		/* in: record descriptor */

	ulint		n_fields,	/* in: number of fields to copy */

	byte**		buf,		/* in/out: memory buffer

					for the copied prefix, or NULL */

	ulint*		buf_size);	/* in/out: buffer size */

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

Folds a prefix of a physical record to a ulint. */

UNIV_INLINE

ulint

rec_fold(

/*=====*/

					/* out: the folded value */

	rec_t*		rec,		/* in: the physical record */

	const ulint*	offsets,	/* in: array returned by

					rec_get_offsets() */

	ulint		n_fields,	/* in: number of complete

					fields to fold */

	ulint		n_bytes,	/* in: number of bytes to fold

					in an incomplete last field */

	dulint		tree_id);	/* in: index tree id */

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

Builds a physical record out of a data tuple and stores it beginning from

address destination. */

rec_t*

rec_convert_dtuple_to_rec(

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

				/* out: pointer to the origin

				of physical record */

	byte*		buf,	/* in: start address of the

				physical record */

	dict_index_t*	index,	/* in: record descriptor */

	dtuple_t*	dtuple);/* in: data tuple */

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

Returns the extra size of an old-style physical record if we know its

data size and number of fields. */

UNIV_INLINE

ulint

rec_get_converted_extra_size(

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

				/* out: extra size */

	ulint	data_size,	/* in: data size */

	ulint	n_fields)	/* in: number of fields */

		__attribute__((const));

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

The following function returns the size of a data tuple when converted to

a physical record. */

UNIV_INLINE

ulint

rec_get_converted_size(

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

				/* out: size */

	dict_index_t*	index,	/* in: record descriptor */

	dtuple_t*	dtuple);/* in: data tuple */

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

Copies the first n fields of a physical record to a data tuple.

The fields are copied to the memory heap. */

void

rec_copy_prefix_to_dtuple(

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

	dtuple_t*	tuple,		/* in: data tuple */

	rec_t*		rec,		/* in: physical record */

	dict_index_t*	index,		/* in: record descriptor */

	ulint		n_fields,	/* in: number of fields to copy */

	mem_heap_t*	heap);		/* in: memory heap */

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

Validates the consistency of a physical record. */

ibool

rec_validate(

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

				/* out: TRUE if ok */

	rec_t*		rec,	/* in: physical record */

	const ulint*	offsets);/* in: array returned by rec_get_offsets() */

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

Prints an old-style physical record. */

void

rec_print_old(

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

	FILE*		file,	/* in: file where to print */

	rec_t*		rec);	/* in: physical record */

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

Prints a physical record. */

void

rec_print_new(

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

	FILE*		file,	/* in: file where to print */

	rec_t*		rec,	/* in: physical record */

	const ulint*	offsets);/* in: array returned by rec_get_offsets() */

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

Prints a physical record. */

void

rec_print(

/*======*/

	FILE*		file,	/* in: file where to print */

	rec_t*		rec,	/* in: physical record */

	dict_index_t*	index);	/* in: record descriptor */

#define REC_INFO_BITS		6	/* This is single byte bit-field */

/* Maximum lengths for the data in a physical record if the offsets

are given in one byte (resp. two byte) format. */

#define REC_1BYTE_OFFS_LIMIT	0x7FUL

#define REC_2BYTE_OFFS_LIMIT	0x7FFFUL

/* The data size of record must be smaller than this because we reserve

two upmost bits in a two byte offset for special purposes */

#define REC_MAX_DATA_SIZE	(16 * 1024)

#ifndef UNIV_NONINL

#include "rem0rec.ic"

#endif

#endif