MySQL 源码｜词法解析中的 CHARSET_INFO 结构体及衍生函数

MySQL 源码｜词法解析中的 CHARSET_INFO 结构体及衍生函数

源码位置：（版本 = MySQL 8.0.37）

• include/mysql/strings/m_ctype.h
• strings/CHARSET_INFO.txt

CHARSET_INFO 结构体是一个包含了用于字符集处理、校对规则的数据结构。对于不同的数据集，MySQL 会加载不同的 CHARSET_INFO 实例：

extern MYSQL_STRINGS_EXPORT CHARSET_INFO my_charset_bin;
extern MYSQL_STRINGS_EXPORT CHARSET_INFO my_charset_latin1;
extern MYSQL_STRINGS_EXPORT CHARSET_INFO my_charset_filename;
extern MYSQL_STRINGS_EXPORT CHARSET_INFO my_charset_utf8mb4_0900_ai_ci;
extern MYSQL_STRINGS_EXPORT CHARSET_INFO my_charset_utf8mb4_0900_bin;

extern MYSQL_STRINGS_EXPORT CHARSET_INFO my_charset_latin1_bin;
extern MYSQL_STRINGS_EXPORT CHARSET_INFO my_charset_utf32_unicode_ci;
extern MYSQL_STRINGS_EXPORT CHARSET_INFO my_charset_utf8mb3_general_ci;
extern MYSQL_STRINGS_EXPORT CHARSET_INFO my_charset_utf8mb3_tolower_ci;
extern MYSQL_STRINGS_EXPORT CHARSET_INFO my_charset_utf8mb3_unicode_ci;
extern MYSQL_STRINGS_EXPORT CHARSET_INFO my_charset_utf8mb3_bin;
extern MYSQL_STRINGS_EXPORT CHARSET_INFO my_charset_utf8mb4_bin;
extern MYSQL_STRINGS_EXPORT CHARSET_INFO my_charset_utf8mb4_general_ci;

CHARSET_INFO 结构体在 include/mysql/strings/m_ctype.h 中被定义，但是其中的数据成员都在 strings/CHARSET_INFO.txt 中被说明，而不是被直接实现。

/* See strings/CHARSET_INFO.txt about information on this structure  */
struct CHARSET_INFO {
  unsigned number;
  unsigned primary_number;
  unsigned binary_number;
  unsigned state;
  const char *csname;
  const char *m_coll_name;
  const char *comment;
  const char *tailoring;
  struct Coll_param *coll_param;
  const uint8_t *ctype;
  const uint8_t *to_lower;
  const uint8_t *to_upper;
  const uint8_t *sort_order;
  struct MY_UCA_INFO *uca; /* This can be changed in apply_one_rule() */
  const uint16_t *tab_to_uni;
  const MY_UNI_IDX *tab_from_uni;
  const MY_UNICASE_INFO *caseinfo;
  const struct lex_state_maps_st *state_maps; /* parser internal data */
  const uint8_t *ident_map;                   /* parser internal data */
  unsigned strxfrm_multiply;
  uint8_t caseup_multiply;
  uint8_t casedn_multiply;
  unsigned mbminlen;
  unsigned mbmaxlen;
  unsigned mbmaxlenlen;
  my_wc_t min_sort_char;
  my_wc_t max_sort_char; /* For LIKE optimization */
  uint8_t pad_char;
  bool escape_with_backslash_is_dangerous;
  uint8_t levels_for_compare;

  MY_CHARSET_HANDLER *cset;
  MY_COLLATION_HANDLER *coll;

  /**
    If this collation is PAD_SPACE, it collates as if all inputs were
    padded with a given number of spaces at the end (see the "num_codepoints"
    flag to strnxfrm). NO_PAD simply compares unextended strings.

    Note that this is fundamentally about the behavior of coll->strnxfrm.
  */
  enum Pad_attribute pad_attribute;
};

重要数据成员

ident_map：判断字符是否为 SQL 字符

uint8_t ident_map[256];

Parser maps
-----------
state_map[]
ident_map[]

These maps are used to quickly identify whether a character is an
identifier part, a digit, a special character, or a part of another
SQL language lexical item.

Probably can be combined with ctype array in the future.
But for some reasons these two arrays are used in the parser,
while a separate ctype[] array is used in the other part of the
code, like fulltext, etc.

这个数组用于快速判断一个字符是否为标识符、数字、特殊字符的一部分，还是 SQL 语句的其他组成部分。可以用来判断当前 token 是否已经结束。

ctype：记录每个字符的类型

  const uint8_t *ctype;

  ctype      - pointer to array[257] of "type of characters"
               bit mask for each character, e.g., whether a 
               character is a digit, letter, separator, etc.

               Monty 2004-10-21:
                 If you look at the macros, we use ctype[(char)+1].
                 ctype[0] is traditionally in most ctype libraries
                 reserved for EOF (-1). The idea is that you can use
                 the result from fgetc() directly with ctype[]. As
                 we have to be compatible with external ctype[] versions,
                 it's better to do it the same way as they do...

ctype 数据成员中记录了每个数据从字符的类型，该类型使用存储在二进制数中的每个位表示，具体地：

static constexpr uint8_t MY_CHAR_U   =   01; /* Upper case */
static constexpr uint8_t MY_CHAR_L   =   02; /* Lower case */
static constexpr uint8_t MY_CHAR_NMR =   04; /* Numeral (digit) */
static constexpr uint8_t MY_CHAR_SPC =  010; /* Spacing character */
static constexpr uint8_t MY_CHAR_PNT =  020; /* Punctuation */
static constexpr uint8_t MY_CHAR_CTR =  040; /* Control character */
static constexpr uint8_t MY_CHAR_B   = 0100; /* Blank */
static constexpr uint8_t MY_CHAR_X   = 0200; /* heXadecimal digit */

字符类型判断和转换函数

my_isascii(char ch)：判断 ch 是否为 ASCII 字符

inline bool my_isascii(char ch) { return (ch & ~0177) == 0; }

my_toupper(const CHARSET_INFO *cs, char ch)：将字符 ch 转换为大写格式

通过调用 CHARSET_INFO 结构体的 to_upper 数据成员，实现将英文小写转换为英文大写。

inline char my_toupper(const CHARSET_INFO *cs, char ch) {
  return static_cast<char>(cs->to_upper[static_cast<uint8_t>(ch)]);
}

my_tolower(const CHARSET_INFO *cs, char ch)：将字符 ch 转换为小写格式

通过调用 CHARSET_INFO 结构体的 to_lower 数据成员，实现将英文大写转换为英文小写。

inline char my_tolower(const CHARSET_INFO *cs, char ch) {
  return static_cast<char>(cs->to_lower[static_cast<uint8_t>(ch)]);
}

my_isalpha(const CHARSET_INFO *cs, char ch)：判断字符 ch 是否为英文字母

通过调用 CHARSET_INFO 结构体的 ctype 数据成员，判断 ch 是否为英文小写字母或英文大写字母。

inline bool my_isalpha(const CHARSET_INFO *cs, char ch) {
  return ((cs->ctype + 1)[static_cast<uint8_t>(ch)] &
          (MY_CHAR_U | MY_CHAR_L)) != 0;
}

my_isupper(const CHARSET_INFO *cs, char c)：判断字符 ch 是否为大写英文字母

通过调用 CHARSET_INFO 结构体的 ctype 数据成员，判断 ch 是否为大写英文字母。

inline bool my_isupper(const CHARSET_INFO *cs, char ch) {
  return ((cs->ctype + 1)[static_cast<uint8_t>(ch)] & MY_CHAR_U) != 0;
}

my_islower(const CHARSET_INFO *cs, char ch)：判断字符 ch 是否为小写英文字母

通过调用 CHARSET_INFO 结构体的 ctype 数据成员，判断 ch 是否为小写英文字母。

inline bool my_islower(const CHARSET_INFO *cs, char ch) {
  return ((cs->ctype + 1)[static_cast<uint8_t>(ch)] & MY_CHAR_L) != 0;
}

my_isdigit(const CHARSET_INFO *cs, char ch)：判断字符 ch 是否为数字

通过调用 CHARSET_INFO 结构体的 ctype 数据成员，判断 ch 是否为数字。

inline bool my_isdigit(const CHARSET_INFO *cs, char ch) {
  return ((cs->ctype + 1)[static_cast<uint8_t>(ch)] & MY_CHAR_NMR) != 0;
}

my_isxdigit(const CHARSET_INFO *cs, char ch)：判断 ch 是否为十六进制数

通过调用 CHARSET_INFO 结构体的 ctype 数据成员，判断 ch 是否为十六进制数字（[0-9A-Fa-f]）。

inline bool my_isxdigit(const CHARSET_INFO *cs, char ch) {
  return ((cs->ctype + 1)[static_cast<uint8_t>(ch)] & MY_CHAR_X) != 0;
}

my_isalnum(const CHARSET_INFO *cs, char ch)：判断字符 ch 是否为英文字母或数字

通过调用 CHARSET_INFO 结构体的 ctype 数据成员，判断 ch 是否为英文字母或数字。

inline bool my_isalnum(const CHARSET_INFO *cs, char ch) {
  return ((cs->ctype + 1)[static_cast<uint8_t>(ch)] &
          (MY_CHAR_U | MY_CHAR_L | MY_CHAR_NMR)) != 0;
}

my_isspace(const CHARSET_INFO *cs, char ch)：判断字符 ch 是否为空白字符

通过调用 CHARSET_INFO 结构体的 ctype 数据成员，判断 ch 是否为空白字符。

inline bool my_isspace(const CHARSET_INFO *cs, char ch) {
  return ((cs->ctype + 1)[static_cast<uint8_t>(ch)] & MY_CHAR_SPC) != 0;
}

my_ispunct(const CHARSET_INFO *cs, char ch)：判断字符 ch 是否为标点符号

通过调用 CHARSET_INFO 结构体的 ctype 数据成员，判断 ch 是否为标点符号字符。

inline bool my_ispunct(const CHARSET_INFO *cs, char ch) {
  return ((cs->ctype + 1)[static_cast<uint8_t>(ch)] & MY_CHAR_PNT) != 0;
}

my_isgraph(const CHARSET_INFO *cs, char ch)：判断字符 ch 是否为英文字母、数字或标点符号

通过调用 CHARSET_INFO 结构体的 ctype 数据成员，判断 ch 是否为英文字母、数字或标点符号。

inline bool my_isgraph(const CHARSET_INFO *cs, char ch) {
  return ((cs->ctype + 1)[static_cast<uint8_t>(ch)] &
          (MY_CHAR_PNT | MY_CHAR_U | MY_CHAR_L | MY_CHAR_NMR)) != 0;
}

my_iscntrl(const CHARSET_INFO *cs, char ch)：判断字符 ch 是否为控制字符

通过调用 CHARSET_INFO 结构体的 ctype 数据成员，判断 ch 是否为控制字符。

inline bool my_iscntrl(const CHARSET_INFO *cs, char ch) {
  return ((cs->ctype + 1)[static_cast<uint8_t>(ch)] & MY_CHAR_CTR) != 0;
}

my_isvar(const CHARSET_INFO *cs, char ch)：判断字符 ch 是否为标识符名称中的字符

通过调用 CHARSET_INFO 结构体的 ctype 数据成员，判断 ch 是否为标识符中的字符（英文字母、数字或下划线）。

inline bool my_isvar(const CHARSET_INFO *cs, char ch) {
  return my_isalnum(cs, ch) || (ch == '_');
}

my_isvar_start(const CHARSET_INFO *cs, char ch)：判断字符 ch 是否为标识符名称的开始字符

通过调用 CHARSET_INFO 结构体的 ctype 数据成员，判断 ch 是否为标识符的开始字符（英文字母或下划线）。

inline bool my_isvar_start(const CHARSET_INFO *cs, char ch) {
  return my_isalpha(cs, ch) || (ch == '_');
}

CHARSET_INFO 成员函数的接口

my_strnxfrm(...)：生成排序键

Makes a sort key suitable for memcmp() corresponding to the given string.

生成一个与给定字符串相对应的、适合用于 memcmp() 函数的排序键。

inline size_t my_strnxfrm(const CHARSET_INFO *cs, uint8_t *dst, size_t dstlen,
                          const uint8_t *src, size_t srclen) {
  return cs->coll->strnxfrm(cs, dst, dstlen, dstlen, src, srclen, 0);
}

my_strnncoll(...)：使用给定规则集比较两个字符串

Compares two strings according to the given collation.

使用给定的规则集比较两个字符串。

inline int my_strnncoll(const CHARSET_INFO *cs, const uint8_t *a,
                        size_t a_length, const uint8_t *b, size_t b_length) {
  return cs->coll->strnncoll(cs, a, a_length, b, b_length, false);
}

my_like_range(...)：为优化器创建 LIKE range

Creates a LIKE range, for optimizer.

inline bool my_like_range(const CHARSET_INFO *cs, const char *s,
                          size_t s_length, char w_prefix, char w_one,
                          char w_many, size_t res_length, char *min_str,
                          char *max_str, size_t *min_len, size_t *max_len) {
  return cs->coll->like_range(cs, s, s_length, w_prefix, w_one, w_many,
                              res_length, min_str, max_str, min_len, max_len);
}

my_wildcmp(...)：执行通配符比较

Wildcard comparison, for LIKE.

执行 LIKE 用于使用的通配符比较逻辑。

inline int my_wildcmp(const CHARSET_INFO *cs, const char *str,
                      const char *str_end, const char *wildstr,
                      const char *wildend, int escape, int w_one, int w_many) {
  return cs->coll->wildcmp(cs, str, str_end, wildstr, wildend, escape, w_one,
                           w_many);
}

my_strcasecmp(...)：比较两个以 ASCIII 编码 0 为截止符号的字符串

0-terminated string comparison.

比较两个以 ASCIII 编码 0 为截止符号的字符串。

inline int my_strcasecmp(const CHARSET_INFO *cs, const char *s1,
                         const char *s2) {
  return cs->coll->strcasecmp(cs, s1, s2);
}

my_charpos(...)：计算指定字符串的偏移位置

calculates the offset of the given position in the string. Used in SQL functions LEFT(), RIGHT(), SUBSTRING(), INSERT().

执行 LEFT()、RIGHT()、SUBSTRING() 和 INSERT() 函数使用的计算字符串偏移位置的逻辑。

inline size_t my_charpos(const CHARSET_INFO *cs, const char *beg,
                         const char *end, size_t pos) {
  return cs->cset->charpos(cs, beg, end, pos);
}

inline size_t my_charpos(const CHARSET_INFO *cs, const unsigned char *beg,
                         const unsigned char *end, size_t pos) {
  return cs->cset->charpos(cs, pointer_cast<const char *>(beg),
                           pointer_cast<const char *>(end), pos);
}

use_mb(...)：获取当前字符集是否有多字节字符

ismbchar 函数是用于检查提供的字符串是否是一个多字节字符序列的逻辑，如果该函数为 nullptr 则说明该字符集不支持多字节字符。

inline bool use_mb(const CHARSET_INFO *cs) {
  return cs->cset->ismbchar != nullptr;
}

my_ismbchar(...)：判断当前字符串是否是多字节序列

Detects whether the given string is a multi-byte sequence.

检测在指针 str 到指针 strend 之间的字符串是否为多字节序列。

inline unsigned my_ismbchar(const CHARSET_INFO *cs, const char *str,
                            const char *strend) {
  return cs->cset->ismbchar(cs, str, strend);
}

inline unsigned my_ismbchar(const CHARSET_INFO *cs, const uint8_t *str,
                            const uint8_t *strend) {
  return cs->cset->ismbchar(cs, pointer_cast<const char *>(str),
                            pointer_cast<const char *>(strend));
}

my_mbcharlen(...)：获取以给定字符开头的多字节序列长度

Returns length of multi-byte sequence starting with the given character.

返回以提供字符 first_byte 开始的多字节序列的长度。

inline unsigned my_mbcharlen(const CHARSET_INFO *cs, unsigned first_byte) {
  return cs->cset->mbcharlen(cs, first_byte);
}

my_mbcharlen_2(...)：获取以两个引导字节开始的 GB18030 字符的长度

返回以字符 first_byte 和 second_byte 引导的 GB18030 字符的长度。

/**
  Get the length of gb18030 code by the given two leading bytes

  @param[in] cs charset_info
  @param[in] first_byte first byte of gb18030 code
  @param[in] second_byte second byte of gb18030 code
  @return    the length of gb18030 code starting with given two bytes,
             the length would be 2 or 4 for valid gb18030 code,
             or 0 for invalid gb18030 code
*/
inline unsigned my_mbcharlen_2(const CHARSET_INFO *cs, uint8_t first_byte,
                               uint8_t second_byte) {
  return cs->cset->mbcharlen(cs,
                             ((first_byte & 0xFF) << 8) + (second_byte & 0xFF));
}

my_mbmaxlenlen(...)：返回当前字符集用于确定多字节字符长度的最大字节数

Maximum leading bytes of a sequence to determine the length of the multi-byte sequence length.

返回当前字符集用于确定多字节字符长度的最大字节数。如果是 GB18030 编码为返回 2，其他编码返回 1。

/**
  Get the maximum length of leading bytes needed to determine the length of a
  multi-byte gb18030 code

  @param[in] cs charset_info
  @return    number of leading bytes we need, would be 2 for gb18030
             and 1 for all other charsets
*/
inline unsigned my_mbmaxlenlen(const CHARSET_INFO *cs) {
  return cs->mbmaxlenlen;
}

my_ismb1st(...)：返回当前字节是否可能是多字节字符的引导字节

判断对于当前字符集来说，字节 leading_byte 是否可能是多字节序列的引导字节。对于 GB18030 字符集来说，需要 2 个字符才能判断多字节序列的长度，因此我们无法通过一个字节就判断它是否为一个多字节序列。

/**
  Judge if the given byte is a possible leading byte for a charset.
  For gb18030 whose mbmaxlenlen is 2, we can't determine the length of
  a multi-byte character by looking at the first byte only

  @param[in] cs charset_info
  @param[in] leading_byte possible leading byte
  @return    true if it is, otherwise false
*/
inline bool my_ismb1st(const CHARSET_INFO *cs, unsigned leading_byte) {
  return my_mbcharlen(cs, leading_byte) > 1 ||
         (my_mbmaxlenlen(cs) == 2 && my_mbcharlen(cs, leading_byte) == 0);
}

my_caseup_str(...)：将字符串转换为英文大写格式

Converts the given 0-terminated string to uppercase.

将以 ASCIII 编码 0 为截止符号的字符串转换为英文大写格式。

inline size_t my_caseup_str(const CHARSET_INFO *cs, char *str) {
  return cs->cset->caseup_str(cs, str);
}

my_casedn_str(...)：将字符串转换为英文小写格式

Converts the given 0-terminated string to lowercase.

将以 ASCIII 编码 0 为截止符号的字符串转换为英文大写格式。

inline size_t my_casedn_str(const CHARSET_INFO *cs, char *str) {
  return cs->cset->casedn_str(cs, str);
}

my_strntol(...)：将以 str 指针开始，长度为 length 的字符串转换为 long 类型整数

inline long my_strntol(const CHARSET_INFO *cs, const char *str, size_t length,
                       int base, const char **end, int *err) {
  return cs->cset->strntol(cs, str, length, base, end, err);
}

my_strntoul(...)：将以 str 指针开始，长度为 length 的字符串转换为无符号 long 类型整数

inline unsigned long my_strntoul(const CHARSET_INFO *cs, const char *str,
                                 size_t length, int base, const char **end,
                                 int *err) {
  return cs->cset->strntoul(cs, str, length, base, end, err);
}

my_strntoll(...)：将以 str 指针开始，长度为 length 的字符串转换为 int64_t 类型整数

inline int64_t my_strntoll(const CHARSET_INFO *cs, const char *str,
                           size_t length, int base, const char **end,
                           int *err) {
  return cs->cset->strntoll(cs, str, length, base, end, err);
}

my_strntoull(...)：将以 str 指针开始，长度为 length 的字符串转换为无符号的 uint64_t 类型整数

inline uint64_t my_strntoull(const CHARSET_INFO *cs, const char *str,
                             size_t length, int base, const char **end,
                             int *err) {
  return cs->cset->strntoull(cs, str, length, base, end, err);
}

my_strntod(...)：将以 str 指针开始，长度为 length 的字符串转换为 double 类型浮点数

inline double my_strntod(const CHARSET_INFO *cs, const char *str, size_t length,
                         const char **end, int *err) {
  return cs->cset->strntod(cs, str, length, end, err);
}