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

Copyright (c) 1994, 2011, Oracle and/or its affiliates. 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 Street, Suite 500, Boston, MA 02110-1335 USA

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

/*******************************************************************//**
@file include/rem0cmp.ic
Comparison services for records

Created 7/1/1994 Heikki Tuuri
************************************************************************/

/*************************************************************//**
This function is used to compare two data fields for which we know the
data type.
@return	1, 0, -1, if data1 is greater, equal, less than data2, respectively */
UNIV_INLINE
int
cmp_data_data(
/*==========*/
	ulint		mtype,	/*!< in: main type */
	ulint		prtype,	/*!< in: precise type */
	const byte*	data1,	/*!< in: data field (== a pointer to a memory
				buffer) */
	ulint		len1,	/*!< in: data field length or UNIV_SQL_NULL */
	const byte*	data2,	/*!< in: data field (== a pointer to a memory
				buffer) */
	ulint		len2)	/*!< in: data field length or UNIV_SQL_NULL */
{
	return(cmp_data_data_slow(mtype, prtype, data1, len1, data2, len2));
}

/*****************************************************************
This function is used to compare two (CHAR) data fields for the LIKE
operator. */
UNIV_INLINE
int
cmp_data_data_like_prefix(
/*======================*/
				/* out: 1, 0, -1, if data1 is greater, equal,
				less than data2, respectively */
	byte*           data1,  /* in: data field (== a pointer to a memory
				buffer) */
	ulint           len1,   /* in: data field length or UNIV_SQL_NULL */
	byte*           data2,  /* in: data field (== a pointer to a memory
				buffer) */
	ulint           len2)   /* in: data field length or UNIV_SQL_NULL */
{
	return(cmp_data_data_slow_like_prefix(data1, len1, data2, len2));
}
/*****************************************************************
This function is used to compare two (CHAR) data fields for the LIKE
operator. */
UNIV_INLINE
int
cmp_data_data_like_suffix(
/*======================*/
				/* out: 1, 0, -1, if data1 is greater, equal,
				less than data2, respectively */
	byte*           data1,  /* in: data field (== a pointer to a memory
				buffer) */
	ulint           len1,   /* in: data field length or UNIV_SQL_NULL */
	byte*           data2,  /* in: data field (== a pointer to a memory
				buffer) */
	ulint           len2)   /* in: data field length or UNIV_SQL_NULL */
{
	return(cmp_data_data_slow_like_suffix(data1, len1, data2, len2));
}
/*****************************************************************
This function is used to compare two (CHAR) data fields for the LIKE
operator. */
UNIV_INLINE
int
cmp_data_data_like_substr(
/*======================*/
				/* out: 1, 0, -1, if data1 is greater, equal,
				less than data2, respectively */
	byte*           data1,  /* in: data field (== a pointer to a memory
				buffer) */
	ulint           len1,   /* in: data field length or UNIV_SQL_NULL */
	byte*           data2,  /* in: data field (== a pointer to a memory
				buffer) */
	ulint           len2)   /* in: data field length or UNIV_SQL_NULL */
{
	return(cmp_data_data_slow_like_substr(data1, len1, data2, len2));
}
/*************************************************************//**
This function is used to compare two dfields where at least the first
has its data type field set.
@return 1, 0, -1, if dfield1 is greater, equal, less than dfield2,
respectively */
UNIV_INLINE
int
cmp_dfield_dfield(
/*==============*/
	const dfield_t*	dfield1,/*!< in: data field; must have type field set */
	const dfield_t*	dfield2)/*!< in: data field */
{
	const dtype_t*	type;

	ut_ad(dfield_check_typed(dfield1));

	type = dfield_get_type(dfield1);

	return(cmp_data_data(type->mtype, type->prtype,
			     (const byte*) dfield_get_data(dfield1),
			     dfield_get_len(dfield1),
			     (const byte*) dfield_get_data(dfield2),
			     dfield_get_len(dfield2)));
}

/*****************************************************************
This function is used to compare two dfields where at least the first
has its data type field set. */
UNIV_INLINE
int
cmp_dfield_dfield_like_suffix(
/*==========================*/
				/* out: 1, 0, -1, if dfield1 is greater, equal,
				less than dfield2, respectively */
	dfield_t*       dfield1,/* in: data field; must have type field set */
	dfield_t*       dfield2)/* in: data field */
{
	ut_ad(dfield_check_typed(dfield1));

	return(cmp_data_data_like_suffix(
		(byte*) dfield_get_data(dfield1),
		dfield_get_len(dfield1),
		(byte*) dfield_get_data(dfield2),
		dfield_get_len(dfield2)));
}

/*****************************************************************
This function is used to compare two dfields where at least the first
has its data type field set. */
UNIV_INLINE
int
cmp_dfield_dfield_like_substr(
/*==========================*/
				/* out: 1, 0, -1, if dfield1 is greater, equal,
				less than dfield2, respectively */
	dfield_t*       dfield1,/* in: data field; must have type field set */
	dfield_t*       dfield2)/* in: data field */
{
	ut_ad(dfield_check_typed(dfield1));

	return(cmp_data_data_like_substr(
		(byte*) dfield_get_data(dfield1),
		dfield_get_len(dfield1),
		(byte*) dfield_get_data(dfield2),
		dfield_get_len(dfield2)));
}
/*************************************************************//**
This function is used to compare two physical records. Only the common
first fields are compared.
@return 1, 0 , -1 if rec1 is greater, equal, less, respectively, than
rec2; only the common first fields are compared */
UNIV_INLINE
int
cmp_rec_rec(
/*========*/
	const rec_t*	rec1,	/*!< in: physical record */
	const rec_t*	rec2,	/*!< in: physical record */
	const ulint*	offsets1,/*!< in: rec_get_offsets(rec1, index) */
	const ulint*	offsets2,/*!< in: rec_get_offsets(rec2, index) */
	dict_index_t*	index)	/*!< in: data dictionary index */
{
	ulint	match_f		= 0;
	ulint	match_b		= 0;

	return(cmp_rec_rec_with_match(rec1, rec2, offsets1, offsets2, index,
				      FALSE, &match_f, &match_b));
}