Creation of mysql-trunk = {summit + "Innodb plugin replacing the builtin"}:

bzr branch mysql-5.1-performance-version mysql-trunk # Summit
cd mysql-trunk
bzr merge mysql-5.1-innodb_plugin # which is 5.1 + Innodb plugin 
bzr rm innobase # remove the builtin
Next step: build, test fixes.

1 files changed, 0 insertions, 734 deletions

diff --git a/storage/innobase/include/mach0data.ic b/storage/innobase/include/mach0data.ic
deleted file mode 100644
index ec15c10c661..00000000000
--- a/storage/innobase/include/mach0data.ic
+++ /dev/null
@@ -1,734 +0,0 @@
-/**********************************************************************
-Utilities for converting data from the database file
-to the machine format.
-
-(c) 1995 Innobase Oy
-
-Created 11/28/1995 Heikki Tuuri
-***********************************************************************/
-
-#include "ut0mem.h"
-
-/***********************************************************
-The following function is used to store data in one byte. */
-UNIV_INLINE
-void
-mach_write_to_1(
-/*============*/
-	byte*	b,	/* in: pointer to byte where to store */
-	ulint	n)	/* in: ulint integer to be stored, >= 0, < 256 */
-{
-	ut_ad(b);
-	ut_ad(n <= 0xFFUL);
-
-	b[0] = (byte)n;
-}
-
-/************************************************************
-The following function is used to fetch data from one byte. */
-UNIV_INLINE
-ulint
-mach_read_from_1(
-/*=============*/
-			/* out: ulint integer, >= 0, < 256 */
-	byte*	b)	/* in: pointer to byte */
-{
-	ut_ad(b);
-	return((ulint)(b[0]));
-}
-
-/***********************************************************
-The following function is used to store data in two consecutive
-bytes. We store the most significant byte to the lowest address. */
-UNIV_INLINE
-void
-mach_write_to_2(
-/*============*/
-	byte*	b,	/* in: pointer to two bytes where to store */
-	ulint	n)	/* in: ulint integer to be stored */
-{
-	ut_ad(b);
-	ut_ad(n <= 0xFFFFUL);
-
-	b[0] = (byte)(n >> 8);
-	b[1] = (byte)(n);
-}
-
-/************************************************************
-The following function is used to fetch data from 2 consecutive
-bytes. The most significant byte is at the lowest address. */
-UNIV_INLINE
-ulint
-mach_read_from_2(
-/*=============*/
-			/* out: ulint integer */
-	byte*	b)	/* in: pointer to 2 bytes */
-{
-	ut_ad(b);
-	return( ((ulint)(b[0]) << 8)
-		+ (ulint)(b[1])
-		);
-}
-
-/************************************************************
-The following function is used to convert a 16-bit data item
-to the canonical format, for fast bytewise equality test
-against memory. */
-UNIV_INLINE
-uint16
-mach_encode_2(
-/*==========*/
-			/* out: 16-bit integer in canonical format */
-	ulint	n)	/* in: integer in machine-dependent format */
-{
-	uint16	ret;
-	ut_ad(2 == sizeof ret);
-	mach_write_to_2((byte*) &ret, n);
-	return(ret);
-}
-/************************************************************
-The following function is used to convert a 16-bit data item
-from the canonical format, for fast bytewise equality test
-against memory. */
-UNIV_INLINE
-ulint
-mach_decode_2(
-/*==========*/
-			/* out: integer in machine-dependent format */
-	uint16	n)	/* in: 16-bit integer in canonical format */
-{
-	ut_ad(2 == sizeof n);
-	return(mach_read_from_2((byte*) &n));
-}
-
-/***********************************************************
-The following function is used to store data in 3 consecutive
-bytes. We store the most significant byte to the lowest address. */
-UNIV_INLINE
-void
-mach_write_to_3(
-/*============*/
-	byte*	b,	/* in: pointer to 3 bytes where to store */
-	ulint	n)	/* in: ulint integer to be stored */
-{
-	ut_ad(b);
-	ut_ad(n <= 0xFFFFFFUL);
-
-	b[0] = (byte)(n >> 16);
-	b[1] = (byte)(n >> 8);
-	b[2] = (byte)(n);
-}
-
-/************************************************************
-The following function is used to fetch data from 3 consecutive
-bytes. The most significant byte is at the lowest address. */
-UNIV_INLINE
-ulint
-mach_read_from_3(
-/*=============*/
-			/* out: ulint integer */
-	byte*	b)	/* in: pointer to 3 bytes */
-{
-	ut_ad(b);
-	return( ((ulint)(b[0]) << 16)
-		+ ((ulint)(b[1]) << 8)
-		+ (ulint)(b[2])
-		);
-}
-
-/***********************************************************
-The following function is used to store data in four consecutive
-bytes. We store the most significant byte to the lowest address. */
-UNIV_INLINE
-void
-mach_write_to_4(
-/*============*/
-	byte*	b,	/* in: pointer to four bytes where to store */
-	ulint	n)	/* in: ulint integer to be stored */
-{
-	ut_ad(b);
-
-	b[0] = (byte)(n >> 24);
-	b[1] = (byte)(n >> 16);
-	b[2] = (byte)(n >> 8);
-	b[3] = (byte)n;
-}
-
-/************************************************************
-The following function is used to fetch data from 4 consecutive
-bytes. The most significant byte is at the lowest address. */
-UNIV_INLINE
-ulint
-mach_read_from_4(
-/*=============*/
-			/* out: ulint integer */
-	byte*	b)	/* in: pointer to four bytes */
-{
-	ut_ad(b);
-	return( ((ulint)(b[0]) << 24)
-		+ ((ulint)(b[1]) << 16)
-		+ ((ulint)(b[2]) << 8)
-		+ (ulint)(b[3])
-		);
-}
-
-/*************************************************************
-Writes a ulint in a compressed form where the first byte codes the
-length of the stored ulint. We look at the most significant bits of
-the byte. If the most significant bit is zero, it means 1-byte storage,
-else if the 2nd bit is 0, it means 2-byte storage, else if 3rd is 0,
-it means 3-byte storage, else if 4th is 0, it means 4-byte storage,
-else the storage is 5-byte. */
-UNIV_INLINE
-ulint
-mach_write_compressed(
-/*==================*/
-			/* out: compressed size in bytes */
-	byte*	b,	/* in: pointer to memory where to store */
-	ulint	n)	/* in: ulint integer (< 2^32) to be stored */
-{
-	ut_ad(b);
-
-	if (n < 0x80UL) {
-		mach_write_to_1(b, n);
-		return(1);
-	} else if (n < 0x4000UL) {
-		mach_write_to_2(b, n | 0x8000UL);
-		return(2);
-	} else if (n < 0x200000UL) {
-		mach_write_to_3(b, n | 0xC00000UL);
-		return(3);
-	} else if (n < 0x10000000UL) {
-		mach_write_to_4(b, n | 0xE0000000UL);
-		return(4);
-	} else {
-		mach_write_to_1(b, 0xF0UL);
-		mach_write_to_4(b + 1, n);
-		return(5);
-	}
-}
-
-/*************************************************************
-Returns the size of a ulint when written in the compressed form. */
-UNIV_INLINE
-ulint
-mach_get_compressed_size(
-/*=====================*/
-			/* out: compressed size in bytes */
-	ulint	n)	/* in: ulint integer (< 2^32) to be stored */
-{
-	if (n < 0x80UL) {
-		return(1);
-	} else if (n < 0x4000UL) {
-		return(2);
-	} else if (n < 0x200000UL) {
-		return(3);
-	} else if (n < 0x10000000UL) {
-		return(4);
-	} else {
-		return(5);
-	}
-}
-
-/*************************************************************
-Reads a ulint in a compressed form. */
-UNIV_INLINE
-ulint
-mach_read_compressed(
-/*=================*/
-			/* out: read integer (< 2^32) */
-	byte*	b)	/* in: pointer to memory from where to read */
-{
-	ulint	flag;
-
-	ut_ad(b);
-
-	flag = mach_read_from_1(b);
-
-	if (flag < 0x80UL) {
-		return(flag);
-	} else if (flag < 0xC0UL) {
-		return(mach_read_from_2(b) & 0x7FFFUL);
-	} else if (flag < 0xE0UL) {
-		return(mach_read_from_3(b) & 0x3FFFFFUL);
-	} else if (flag < 0xF0UL) {
-		return(mach_read_from_4(b) & 0x1FFFFFFFUL);
-	} else {
-		ut_ad(flag == 0xF0UL);
-		return(mach_read_from_4(b + 1));
-	}
-}
-
-/***********************************************************
-The following function is used to store data in 8 consecutive
-bytes. We store the most significant byte to the lowest address. */
-UNIV_INLINE
-void
-mach_write_to_8(
-/*============*/
-	byte*	b,	/* in: pointer to 8 bytes where to store */
-	dulint	n)	/* in: dulint integer to be stored */
-{
-	ut_ad(b);
-
-	mach_write_to_4(b, ut_dulint_get_high(n));
-	mach_write_to_4(b + 4, ut_dulint_get_low(n));
-}
-
-/************************************************************
-The following function is used to fetch data from 8 consecutive
-bytes. The most significant byte is at the lowest address. */
-UNIV_INLINE
-dulint
-mach_read_from_8(
-/*=============*/
-			/* out: dulint integer */
-	byte*	b)	/* in: pointer to 8 bytes */
-{
-	ulint	high;
-	ulint	low;
-
-	ut_ad(b);
-
-	high = mach_read_from_4(b);
-	low = mach_read_from_4(b + 4);
-
-	return(ut_dulint_create(high, low));
-}
-
-/***********************************************************
-The following function is used to store data in 7 consecutive
-bytes. We store the most significant byte to the lowest address. */
-UNIV_INLINE
-void
-mach_write_to_7(
-/*============*/
-	byte*	b,	/* in: pointer to 7 bytes where to store */
-	dulint	n)	/* in: dulint integer to be stored */
-{
-	ut_ad(b);
-
-	mach_write_to_3(b, ut_dulint_get_high(n));
-	mach_write_to_4(b + 3, ut_dulint_get_low(n));
-}
-
-/************************************************************
-The following function is used to fetch data from 7 consecutive
-bytes. The most significant byte is at the lowest address. */
-UNIV_INLINE
-dulint
-mach_read_from_7(
-/*=============*/
-			/* out: dulint integer */
-	byte*	b)	/* in: pointer to 7 bytes */
-{
-	ulint	high;
-	ulint	low;
-
-	ut_ad(b);
-
-	high = mach_read_from_3(b);
-	low = mach_read_from_4(b + 3);
-
-	return(ut_dulint_create(high, low));
-}
-
-/***********************************************************
-The following function is used to store data in 6 consecutive
-bytes. We store the most significant byte to the lowest address. */
-UNIV_INLINE
-void
-mach_write_to_6(
-/*============*/
-	byte*	b,	/* in: pointer to 6 bytes where to store */
-	dulint	n)	/* in: dulint integer to be stored */
-{
-	ut_ad(b);
-
-	mach_write_to_2(b, ut_dulint_get_high(n));
-	mach_write_to_4(b + 2, ut_dulint_get_low(n));
-}
-
-/************************************************************
-The following function is used to fetch data from 6 consecutive
-bytes. The most significant byte is at the lowest address. */
-UNIV_INLINE
-dulint
-mach_read_from_6(
-/*=============*/
-			/* out: dulint integer */
-	byte*	b)	/* in: pointer to 7 bytes */
-{
-	ulint	high;
-	ulint	low;
-
-	ut_ad(b);
-
-	high = mach_read_from_2(b);
-	low = mach_read_from_4(b + 2);
-
-	return(ut_dulint_create(high, low));
-}
-
-/*************************************************************
-Writes a dulint in a compressed form (5..9 bytes). */
-UNIV_INLINE
-ulint
-mach_dulint_write_compressed(
-/*=========================*/
-			/* out: size in bytes */
-	byte*	b,	/* in: pointer to memory where to store */
-	dulint	n)	/* in: dulint integer to be stored */
-{
-	ulint	size;
-
-	ut_ad(b);
-
-	size = mach_write_compressed(b, ut_dulint_get_high(n));
-	mach_write_to_4(b + size, ut_dulint_get_low(n));
-
-	return(size + 4);
-}
-
-/*************************************************************
-Returns the size of a dulint when written in the compressed form. */
-UNIV_INLINE
-ulint
-mach_dulint_get_compressed_size(
-/*============================*/
-			/* out: compressed size in bytes */
-	dulint	 n)	/* in: dulint integer to be stored */
-{
-	return(4 + mach_get_compressed_size(ut_dulint_get_high(n)));
-}
-
-/*************************************************************
-Reads a dulint in a compressed form. */
-UNIV_INLINE
-dulint
-mach_dulint_read_compressed(
-/*========================*/
-			/* out: read dulint */
-	byte*	b)	/* in: pointer to memory from where to read */
-{
-	ulint	high;
-	ulint	low;
-	ulint	size;
-
-	ut_ad(b);
-
-	high = mach_read_compressed(b);
-
-	size = mach_get_compressed_size(high);
-
-	low = mach_read_from_4(b + size);
-
-	return(ut_dulint_create(high, low));
-}
-
-/*************************************************************
-Writes a dulint in a compressed form (1..11 bytes). */
-UNIV_INLINE
-ulint
-mach_dulint_write_much_compressed(
-/*==============================*/
-			/* out: size in bytes */
-	byte*	b,	/* in: pointer to memory where to store */
-	dulint	n)	/* in: dulint integer to be stored */
-{
-	ulint	size;
-
-	ut_ad(b);
-
-	if (ut_dulint_get_high(n) == 0) {
-		return(mach_write_compressed(b, ut_dulint_get_low(n)));
-	}
-
-	*b = (byte)0xFF;
-	size = 1 + mach_write_compressed(b + 1, ut_dulint_get_high(n));
-
-	size += mach_write_compressed(b + size, ut_dulint_get_low(n));
-
-	return(size);
-}
-
-/*************************************************************
-Returns the size of a dulint when written in the compressed form. */
-UNIV_INLINE
-ulint
-mach_dulint_get_much_compressed_size(
-/*=================================*/
-			/* out: compressed size in bytes */
-	dulint	 n)	/* in: dulint integer to be stored */
-{
-	if (0 == ut_dulint_get_high(n)) {
-		return(mach_get_compressed_size(ut_dulint_get_low(n)));
-	}
-
-	return(1 + mach_get_compressed_size(ut_dulint_get_high(n))
-	       + mach_get_compressed_size(ut_dulint_get_low(n)));
-}
-
-/*************************************************************
-Reads a dulint in a compressed form. */
-UNIV_INLINE
-dulint
-mach_dulint_read_much_compressed(
-/*=============================*/
-			/* out: read dulint */
-	byte*	b)	/* in: pointer to memory from where to read */
-{
-	ulint	high;
-	ulint	low;
-	ulint	size;
-
-	ut_ad(b);
-
-	if (*b != (byte)0xFF) {
-		high = 0;
-		size = 0;
-	} else {
-		high = mach_read_compressed(b + 1);
-
-		size = 1 + mach_get_compressed_size(high);
-	}
-
-	low = mach_read_compressed(b + size);
-
-	return(ut_dulint_create(high, low));
-}
-
-/*************************************************************
-Reads a double. It is stored in a little-endian format. */
-UNIV_INLINE
-double
-mach_double_read(
-/*=============*/
-			/* out: double read */
-	byte*	b)	/* in: pointer to memory from where to read */
-{
-	double	d;
-	ulint	i;
-	byte*	ptr;
-
-	ptr = (byte*)&d;
-
-	for (i = 0; i < sizeof(double); i++) {
-#ifdef WORDS_BIGENDIAN
-		ptr[sizeof(double) - i - 1] = b[i];
-#else
-		ptr[i] = b[i];
-#endif
-	}
-
-	return(d);
-}
-
-/*************************************************************
-Writes a double. It is stored in a little-endian format. */
-UNIV_INLINE
-void
-mach_double_write(
-/*==============*/
-	byte*	b,	/* in: pointer to memory where to write */
-	double	d)	/* in: double */
-{
-	ulint	i;
-	byte*	ptr;
-
-	ptr = (byte*)&d;
-
-	for (i = 0; i < sizeof(double); i++) {
-#ifdef WORDS_BIGENDIAN
-		b[i] = ptr[sizeof(double) - i - 1];
-#else
-		b[i] = ptr[i];
-#endif
-	}
-}
-
-/*************************************************************
-Reads a float. It is stored in a little-endian format. */
-UNIV_INLINE
-float
-mach_float_read(
-/*============*/
-			/* out: float read */
-	byte*	b)	/* in: pointer to memory from where to read */
-{
-	float	d;
-	ulint	i;
-	byte*	ptr;
-
-	ptr = (byte*)&d;
-
-	for (i = 0; i < sizeof(float); i++) {
-#ifdef WORDS_BIGENDIAN
-		ptr[sizeof(float) - i - 1] = b[i];
-#else
-		ptr[i] = b[i];
-#endif
-	}
-
-	return(d);
-}
-
-/*************************************************************
-Writes a float. It is stored in a little-endian format. */
-UNIV_INLINE
-void
-mach_float_write(
-/*=============*/
-	byte*	b,	/* in: pointer to memory where to write */
-	float	d)	/* in: float */
-{
-	ulint	i;
-	byte*	ptr;
-
-	ptr = (byte*)&d;
-
-	for (i = 0; i < sizeof(float); i++) {
-#ifdef WORDS_BIGENDIAN
-		b[i] = ptr[sizeof(float) - i - 1];
-#else
-		b[i] = ptr[i];
-#endif
-	}
-}
-
-/*************************************************************
-Reads a ulint stored in the little-endian format. */
-UNIV_INLINE
-ulint
-mach_read_from_n_little_endian(
-/*===========================*/
-				/* out: unsigned long int */
-	byte*	buf,		/* in: from where to read */
-	ulint	buf_size)	/* in: from how many bytes to read */
-{
-	ulint	n	= 0;
-	byte*	ptr;
-
-	ut_ad(buf_size <= sizeof(ulint));
-	ut_ad(buf_size > 0);
-
-	ptr = buf + buf_size;
-
-	for (;;) {
-		ptr--;
-
-		n = n << 8;
-
-		n += (ulint)(*ptr);
-
-		if (ptr == buf) {
-			break;
-		}
-	}
-
-	return(n);
-}
-
-/*************************************************************
-Writes a ulint in the little-endian format. */
-UNIV_INLINE
-void
-mach_write_to_n_little_endian(
-/*==========================*/
-	byte*	dest,		/* in: where to write */
-	ulint	dest_size,	/* in: into how many bytes to write */
-	ulint	n)		/* in: unsigned long int to write */
-{
-	byte*	end;
-
-	ut_ad(dest_size <= sizeof(ulint));
-	ut_ad(dest_size > 0);
-
-	end = dest + dest_size;
-
-	for (;;) {
-		*dest = (byte)(n & 0xFF);
-
-		n = n >> 8;
-
-		dest++;
-
-		if (dest == end) {
-			break;
-		}
-	}
-
-	ut_ad(n == 0);
-}
-
-/*************************************************************
-Reads a ulint stored in the little-endian format. */
-UNIV_INLINE
-ulint
-mach_read_from_2_little_endian(
-/*===========================*/
-				/* out: unsigned long int */
-	byte*	buf)		/* in: from where to read */
-{
-	return((ulint)(*buf) + ((ulint)(*(buf + 1))) * 256);
-}
-
-/*************************************************************
-Writes a ulint in the little-endian format. */
-UNIV_INLINE
-void
-mach_write_to_2_little_endian(
-/*==========================*/
-	byte*	dest,		/* in: where to write */
-	ulint	n)		/* in: unsigned long int to write */
-{
-	ut_ad(n < 256 * 256);
-
-	*dest = (byte)(n & 0xFFUL);
-
-	n = n >> 8;
-	dest++;
-
-	*dest = (byte)(n & 0xFFUL);
-}
-
-/*************************************************************
-Convert integral type from storage byte order (big endian) to
-host byte order. */
-UNIV_INLINE
-ullint
-mach_read_int_type(
-/*===============*/
-					/* out: integer value */
-	const byte*	src,		/* in: where to read from */
-	ulint		len,		/* in: length of src */
-	ibool		unsigned_type)	/* in: signed or unsigned flag */
-{
-	/* XXX this can be optimized on big-endian machines */
-
-	ullint	ret;
-	uint	i;
-
-	if (unsigned_type || (src[0] & 0x80)) {
-
-		ret = 0x0000000000000000ULL;
-	} else {
-
-		ret = 0xFFFFFFFFFFFFFF00ULL;
-	}
-
-	if (unsigned_type) {
-
-		ret |= src[0];
-	} else {
-
-		ret |= src[0] ^ 0x80;
-	}
-
-	for (i = 1; i < len; i++) {
-		ret <<= 8;
-		ret |= src[i];
-	}
-
-	return(ret);
-}