rem0cmp.h

Go to the documentation of this file.

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

Copyright (c) 1994, 2012, 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

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

/*******************************************************************/
#ifndef rem0cmp_h
#define rem0cmp_h

#include "univ.i"
#include "data0data.h"
#include "data0type.h"
#include "dict0dict.h"
#include "rem0rec.h"

/*************************************************************/
UNIV_INTERN
ibool
cmp_cols_are_equal(
/*===============*/
        const dict_col_t*       col1,   
        const dict_col_t*       col2,   
        ibool                   check_charsets);
/*************************************************************/
UNIV_INLINE
int
cmp_data_data(
/*==========*/
        ulint           mtype,  
        ulint           prtype, 
        const byte*     data1,  
        ulint           len1,   
        const byte*     data2,  
        ulint           len2);  
/*************************************************************/
UNIV_INTERN
int
cmp_data_data_slow(
/*===============*/
        ulint           mtype,  
        ulint           prtype, 
        const byte*     data1,  
        ulint           len1,   
        const byte*     data2,  
        ulint           len2);  
/*****************************************************************
This function is used to compare two data fields for which we know the
data type to be VARCHAR.
@return 1, 0, -1, if lhs is greater, equal, less than rhs, respectively */
UNIV_INTERN
int
cmp_data_data_slow_varchar(
/*=======================*/
        const byte*     lhs,    /* in: data field (== a pointer to a memory
                                buffer) */
        ulint           lhs_len,/* in: data field length or UNIV_SQL_NULL */
        const byte*     rhs,    /* in: data field (== a pointer to a memory
                                buffer) */
        ulint           rhs_len);/* in: data field length or UNIV_SQL_NULL */
/*****************************************************************
This function is used to compare two varchar/char fields. The comparison
is for the LIKE operator.
@return 1, 0, -1, if lhs is greater, equal, less than rhs, respectively */
UNIV_INTERN
int
cmp_data_data_slow_like_prefix(
/*===========================*/
        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 */
/*****************************************************************
This function is used to compare two varchar/char fields. The comparison
is for the LIKE operator.
@return 1, 0, -1, if data1 is greater, equal, less than data2, respectively */
UNIV_INTERN
int
cmp_data_data_slow_like_suffix(
/*===========================*/
        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 */
/*****************************************************************
This function is used to compare two varchar/char fields. The comparison
is for the LIKE operator.
@return 1, 0, -1, if data1 is greater, equal, less than data2, respectively */
UNIV_INTERN
int
cmp_data_data_slow_like_substr(
/*===========================*/
        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 */
/*************************************************************/
UNIV_INLINE
int
cmp_dfield_dfield(
/*==============*/
        const dfield_t* dfield1,
        const dfield_t* dfield2);
/*************************************************************/
UNIV_INTERN
int
cmp_dtuple_rec_with_match_low(
/*==========================*/
        const dtuple_t* dtuple, 
        const rec_t*    rec,    
        const ulint*    offsets,
        ulint           n_cmp,  
        ulint*          matched_fields,
        ulint*          matched_bytes)
        __attribute__((nonnull));
#define cmp_dtuple_rec_with_match(tuple,rec,offsets,fields,bytes)       \
        cmp_dtuple_rec_with_match_low(                                  \
                tuple,rec,offsets,dtuple_get_n_fields_cmp(tuple),fields,bytes)
/**************************************************************/
UNIV_INTERN
int
cmp_dtuple_rec(
/*===========*/
        const dtuple_t* dtuple, 
        const rec_t*    rec,    
        const ulint*    offsets);
/**************************************************************/
UNIV_INTERN
ibool
cmp_dtuple_is_prefix_of_rec(
/*========================*/
        const dtuple_t* dtuple, 
        const rec_t*    rec,    
        const ulint*    offsets);
/*************************************************************/
UNIV_INTERN
int
cmp_rec_rec_simple(
/*===============*/
        const rec_t*            rec1,   
        const rec_t*            rec2,   
        const ulint*            offsets1,
        const ulint*            offsets2,
        const dict_index_t*     index,  
        struct TABLE*           table)  
        __attribute__((nonnull(1,2,3,4), warn_unused_result));
/*************************************************************/
UNIV_INTERN
int
cmp_rec_rec_with_match(
/*===================*/
        const rec_t*    rec1,   
        const rec_t*    rec2,   
        const ulint*    offsets1,
        const ulint*    offsets2,
        dict_index_t*   index,  
        ibool           nulls_unequal,
                                /* in: TRUE if this is for index statistics
                                cardinality estimation, and innodb_stats_method
                                is "nulls_unequal" or "nulls_ignored" */
        ulint*          matched_fields, 
        ulint*          matched_bytes);
/*************************************************************/
UNIV_INLINE
int
cmp_rec_rec(
/*========*/
        const rec_t*    rec1,   
        const rec_t*    rec2,   
        const ulint*    offsets1,
        const ulint*    offsets2,
        dict_index_t*   index); 
/*****************************************************************
This function is used to compare two dfields where at least the first
has its data type field set. */
UNIV_INTERN
int
cmp_dfield_dfield_like_prefix(
/*==========================*/
                                /* 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 */
/*****************************************************************
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 */
/*****************************************************************
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 */

#ifndef UNIV_NONINL
#include "rem0cmp.ic"
#endif

#endif