271 lines
8.7 KiB
C++
271 lines
8.7 KiB
C++
/*
|
|
Copyright (c) 2003, 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 St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
#ifndef NDB_SQL_UTIL_HPP
|
|
#define NDB_SQL_UTIL_HPP
|
|
|
|
#include <ndb_global.h>
|
|
#include <kernel/ndb_limits.h>
|
|
|
|
struct charset_info_st;
|
|
typedef struct charset_info_st CHARSET_INFO;
|
|
|
|
/**
|
|
* Helper class with comparison functions on NDB (column) data types.
|
|
*
|
|
* Notes: this Helper class
|
|
* - is used by kernel code
|
|
* - provides non-elementary functions
|
|
* - is not generic, template-based code
|
|
* - has link/library dependencies upon MySQL code
|
|
* (in contrast to other type utility classes, like ./NdbTypesUtil).
|
|
*/
|
|
class NdbSqlUtil {
|
|
public:
|
|
/**
|
|
* Compare attribute values. Returns negative, zero, positive for
|
|
* less, equal, greater. We trust DBTUP to validate all data and
|
|
* mysql upgrade to not invalidate them. Bad values (such as NaN)
|
|
* causing undefined results crash here always (require, not assert)
|
|
* since they are likely to cause a more obscure crash in DBTUX.
|
|
* wl4163_todo: API probably should not crash.
|
|
*
|
|
* Parameters are pointers to values (no alignment requirements) and
|
|
* their lengths in bytes. First parameter is a pointer to type
|
|
* specific extra info. Char types receive CHARSET_INFO in it.
|
|
*/
|
|
typedef int Cmp(const void* info, const void* p1, uint n1, const void* p2, uint n2);
|
|
|
|
/**
|
|
* Prototype for "like" comparison. Defined for string types. First
|
|
* argument can be fixed or var* type, second argument is fixed.
|
|
* Returns 0 on match, +1 on no match, and -1 on bad data.
|
|
*
|
|
* Uses default special chars ( \ % _ ).
|
|
*/
|
|
typedef int Like(const void* info, const void* p1, unsigned n1, const void* p2, unsigned n2);
|
|
|
|
/**
|
|
* Prototype for mask comparisons. Defined for bit type.
|
|
*
|
|
* If common portion of data AND Mask is equal to mask
|
|
* return 0, else return 1.
|
|
* If cmpZero, compare data AND Mask to zero.
|
|
*/
|
|
typedef int AndMask(const void* data, unsigned dataLen, const void* mask, unsigned maskLen, bool cmpZero);
|
|
|
|
struct Type {
|
|
enum Enum {
|
|
Undefined = NDB_TYPE_UNDEFINED,
|
|
Tinyint = NDB_TYPE_TINYINT,
|
|
Tinyunsigned = NDB_TYPE_TINYUNSIGNED,
|
|
Smallint = NDB_TYPE_SMALLINT,
|
|
Smallunsigned = NDB_TYPE_SMALLUNSIGNED,
|
|
Mediumint = NDB_TYPE_MEDIUMINT,
|
|
Mediumunsigned = NDB_TYPE_MEDIUMUNSIGNED,
|
|
Int = NDB_TYPE_INT,
|
|
Unsigned = NDB_TYPE_UNSIGNED,
|
|
Bigint = NDB_TYPE_BIGINT,
|
|
Bigunsigned = NDB_TYPE_BIGUNSIGNED,
|
|
Float = NDB_TYPE_FLOAT,
|
|
Double = NDB_TYPE_DOUBLE,
|
|
Olddecimal = NDB_TYPE_OLDDECIMAL,
|
|
Char = NDB_TYPE_CHAR,
|
|
Varchar = NDB_TYPE_VARCHAR,
|
|
Binary = NDB_TYPE_BINARY,
|
|
Varbinary = NDB_TYPE_VARBINARY,
|
|
Datetime = NDB_TYPE_DATETIME,
|
|
Date = NDB_TYPE_DATE,
|
|
Blob = NDB_TYPE_BLOB,
|
|
Text = NDB_TYPE_TEXT,
|
|
Bit = NDB_TYPE_BIT,
|
|
Longvarchar = NDB_TYPE_LONGVARCHAR,
|
|
Longvarbinary = NDB_TYPE_LONGVARBINARY,
|
|
Time = NDB_TYPE_TIME,
|
|
Year = NDB_TYPE_YEAR,
|
|
Timestamp = NDB_TYPE_TIMESTAMP,
|
|
Olddecimalunsigned = NDB_TYPE_OLDDECIMALUNSIGNED,
|
|
Decimal = NDB_TYPE_DECIMAL,
|
|
Decimalunsigned = NDB_TYPE_DECIMALUNSIGNED,
|
|
Time2 = NDB_TYPE_TIME2,
|
|
Datetime2 = NDB_TYPE_DATETIME2,
|
|
Timestamp2 = NDB_TYPE_TIMESTAMP2
|
|
};
|
|
Enum m_typeId; // redundant
|
|
Cmp* m_cmp; // comparison method
|
|
Like* m_like; // "like" comparison method
|
|
AndMask* m_mask; // Mask comparison method
|
|
};
|
|
|
|
/**
|
|
* Get type by id. Can return the Undefined type.
|
|
*/
|
|
static const Type& getType(Uint32 typeId);
|
|
|
|
/**
|
|
* Check character set.
|
|
*/
|
|
static uint check_column_for_pk(Uint32 typeId, const void* info);
|
|
static uint check_column_for_hash_index(Uint32 typeId, const void* info);
|
|
static uint check_column_for_ordered_index(Uint32 typeId, const void* info);
|
|
|
|
/**
|
|
* Get number of length bytes and length from variable length string.
|
|
* Returns false on error (invalid data). For other types returns
|
|
* zero length bytes and the fixed attribute length.
|
|
*/
|
|
static bool get_var_length(Uint32 typeId, const void* p, unsigned attrlen, Uint32& lb, Uint32& len);
|
|
|
|
/**
|
|
* Temporary workaround for bug#7284.
|
|
*/
|
|
static int strnxfrm_bug7284(CHARSET_INFO* cs, unsigned char* dst, unsigned dstLen, const unsigned char*src, unsigned srcLen);
|
|
|
|
/**
|
|
* Wrapper for 'strnxfrm' who change prototype in 5.6
|
|
*/
|
|
static size_t ndb_strnxfrm(struct charset_info_st * cs,
|
|
uchar *dst, size_t dstlen,
|
|
const uchar *src, size_t srclen);
|
|
|
|
/**
|
|
* Convert attribute data to/from network byte order
|
|
* This method converts the passed data of the passed type
|
|
* between host and network byte order.
|
|
* On little-endian (network order) hosts, it has no effect.
|
|
*/
|
|
static void convertByteOrder(Uint32 typeId,
|
|
Uint32 typeLog2Size,
|
|
Uint32 arrayType,
|
|
Uint32 arraySize,
|
|
uchar* data,
|
|
Uint32 dataByteSize);
|
|
|
|
/**
|
|
* Unpack and pack date/time types. There is no check that the data
|
|
* is valid for MySQL. Random input gives equally random output.
|
|
* Fractional seconds wl#946 introduce new formats (type names with
|
|
* suffix 2). The methods for these take an extra precision argument
|
|
* with range 0-6 which translates to 0-3 bytes.
|
|
*/
|
|
struct Year {
|
|
uint year;
|
|
};
|
|
struct Date {
|
|
uint year, month, day;
|
|
};
|
|
struct Time {
|
|
uint sign; // as in Time2
|
|
uint hour, minute, second;
|
|
};
|
|
struct Datetime {
|
|
uint year, month, day;
|
|
uint hour, minute, second;
|
|
};
|
|
struct Timestamp {
|
|
uint second;
|
|
};
|
|
struct Time2 {
|
|
uint sign;
|
|
uint interval;
|
|
uint hour, minute, second;
|
|
uint fraction;
|
|
};
|
|
struct Datetime2 {
|
|
uint sign;
|
|
uint year, month, day;
|
|
uint hour, minute, second;
|
|
uint fraction;
|
|
};
|
|
struct Timestamp2 {
|
|
uint second;
|
|
uint fraction;
|
|
};
|
|
// bytes to struct
|
|
static void unpack_year(Year&, const uchar*);
|
|
static void unpack_date(Date&, const uchar*);
|
|
static void unpack_time(Time&, const uchar*);
|
|
static void unpack_datetime(Datetime&, const uchar*);
|
|
static void unpack_timestamp(Timestamp&, const uchar*);
|
|
static void unpack_time2(Time2&, const uchar*, uint prec);
|
|
static void unpack_datetime2(Datetime2&, const uchar*, uint prec);
|
|
static void unpack_timestamp2(Timestamp2&, const uchar*, uint prec);
|
|
// struct to bytes
|
|
static void pack_year(const Year&, uchar*);
|
|
static void pack_date(const Date&, uchar*);
|
|
static void pack_time(const Time&, uchar*);
|
|
static void pack_datetime(const Datetime&, uchar*);
|
|
static void pack_timestamp(const Timestamp&, uchar*);
|
|
static void pack_time2(const Time2&, uchar*, uint prec);
|
|
static void pack_datetime2(const Datetime2&, uchar*, uint prec);
|
|
static void pack_timestamp2(const Timestamp2&, uchar*, uint prec);
|
|
|
|
private:
|
|
friend class NdbPack;
|
|
/**
|
|
* List of all types. Must match Type::Enum.
|
|
*/
|
|
static const Type m_typeList[];
|
|
/**
|
|
* Comparison methods.
|
|
*/
|
|
static Cmp cmpTinyint;
|
|
static Cmp cmpTinyunsigned;
|
|
static Cmp cmpSmallint;
|
|
static Cmp cmpSmallunsigned;
|
|
static Cmp cmpMediumint;
|
|
static Cmp cmpMediumunsigned;
|
|
static Cmp cmpInt;
|
|
static Cmp cmpUnsigned;
|
|
static Cmp cmpBigint;
|
|
static Cmp cmpBigunsigned;
|
|
static Cmp cmpFloat;
|
|
static Cmp cmpDouble;
|
|
static Cmp cmpOlddecimal;
|
|
static Cmp cmpChar;
|
|
static Cmp cmpVarchar;
|
|
static Cmp cmpBinary;
|
|
static Cmp cmpVarbinary;
|
|
static Cmp cmpDatetime;
|
|
static Cmp cmpDate;
|
|
static Cmp cmpBlob;
|
|
static Cmp cmpText;
|
|
static Cmp cmpBit;
|
|
static Cmp cmpLongvarchar;
|
|
static Cmp cmpLongvarbinary;
|
|
static Cmp cmpTime;
|
|
static Cmp cmpYear;
|
|
static Cmp cmpTimestamp;
|
|
static Cmp cmpOlddecimalunsigned;
|
|
static Cmp cmpDecimal;
|
|
static Cmp cmpDecimalunsigned;
|
|
static Cmp cmpTime2;
|
|
static Cmp cmpDatetime2;
|
|
static Cmp cmpTimestamp2;
|
|
//
|
|
static Like likeChar;
|
|
static Like likeBinary;
|
|
static Like likeVarchar;
|
|
static Like likeVarbinary;
|
|
static Like likeLongvarchar;
|
|
static Like likeLongvarbinary;
|
|
//
|
|
static AndMask maskBit;
|
|
};
|
|
|
|
#endif
|