### 12.8.2正则表达式

[](<>)[](<>)[](<>)[](<>)

[](<>)

**表12.14正则表达式函数和运算符**

| 名称 | 描述 |
| --- | --- |
| [`不是REGEXP`](regexp.html#operator_not-regexp) | REGEXP的否定 |
| [`REGEXP`](regexp.html#operator_regexp) | 字符串是否匹配正则表达式 |
| [`REGEXP_INSTR（）`](regexp.html#function_regexp-instr) | 匹配正则表达式的子字符串的起始索引 |
| [`REGEXP_LIKE（）`](regexp.html#function_regexp-like) | 字符串是否匹配正则表达式 |
| [`REGEXP_REPLACE（）`](regexp.html#function_regexp-replace) | 替换匹配正则表达式的子字符串 |
| [`REGEXP_SUBSTR（）`](regexp.html#function_regexp-substr) | 返回匹配正则表达式的子字符串 |
| [`像`](regexp.html#operator_regexp) | 字符串是否匹配正则表达式 |

正则表达式是为复杂搜索指定模式的强大方式。本节讨论可用于正则表达式匹配的函数和运算符，并举例说明可用于正则表达式操作的一些特殊字符和构造。另见[第3.3.4.7节“模式匹配”](pattern-matching.html).

MySQL使用International Components for Unicode（ICU）实现正则表达式支持，ICU提供完全的Unicode支持，并且是多字节安全的。（在MySQL 8.0.4之前，MySQL使用了Henry Spencer的正则表达式实现，它以字节方式运行，并且不是多字节安全的。有关使用正则表达式的应用程序可能受到实现更改影响的方式的信息，请参阅[正则表达式兼容性注意事项](regexp.html#regexp-compatibility).)

在MySQL 8.0.22之前，可以对这些函数使用二进制字符串参数，但它们会产生不一致的结果。在MySQL 8.0.22及更高版本中，任何MySQL正则表达式函数都不允许使用二进制字符串[`字符集不匹配`](https://dev.mysql.com/doc/mysql-errors/8.0/en/server-error-reference.html#error_er_character_set_mismatch).

-   [正则表达式函数和运算符描述](regexp.html#regexp-operator-descriptions)

-   [正则表达式语法](regexp.html#regexp-syntax)

-   [正则表达式资源控制](regexp.html#regexp-resource-control)

-   [正则表达式兼容性注意事项](regexp.html#regexp-compatibility)

#### 正则表达式函数和运算符描述

-   [](<>)

    [`*`expr`*不是REGEXP*`拍打`*`](regexp.html#operator_not-regexp), [`*`expr`*不像*`拍打`*`](regexp.html#operator_not-regexp)

    [](<>)

    这和`不是(*`expr`*REGEXP*`拍打`*)`.

-   [](<>)

    [`*`expr`*REGEXP*`拍打`*`](regexp.html#operator_regexp), [`*`expr`*像*`拍打`*`](regexp.html#operator_regexp)

    [](<>)[](<>)

    如果字符串*`expr`*匹配模式指定的正则表达式*`拍打`*，否则为0。如果*`expr`*或*`拍打`*是`无效的`，返回值为`无效的`.

    [`REGEXP`](regexp.html#operator_regexp)和[`像`](regexp.html#operator_regexp)是的同义词[`REGEXP_LIKE（）`](regexp.html#function_regexp-like).

    有关如何进行匹配的其他信息，请参阅的说明[`REGEXP_LIKE（）`](regexp.html#function_regexp-like).

    ```
    mysql> SELECT 'Michael!' REGEXP '.*';
    +------------------------+
    | 'Michael!' REGEXP '.*' |
    +------------------------+
    |                      1 |
    +------------------------+
    mysql> SELECT 'new*\n*line' REGEXP 'new\\*.\\*line';
    +---------------------------------------+
    | 'new*\n*line' REGEXP 'new\\*.\\*line' |
    +---------------------------------------+
    |                                     0 |
    +---------------------------------------+
    mysql> SELECT 'a' REGEXP '^[a-d]';
    +---------------------+
    | 'a' REGEXP '^[a-d]' |
    +---------------------+
    |                   1 |
    +---------------------+
    ```

-   [](<>)

    [`雷格普仪器(*`expr`*, *`拍打`*[, *`销售时点情报系统`*[, *`发生`*[, *`返回选项`*[, *`匹配类型`*]]]])`](regexp.html#function_regexp-instr)

    [](<>)

    返回字符串子字符串的起始索引*`expr`*与模式指定的正则表达式匹配的*`拍打`*，如果没有匹配项，则为0。如果*`expr`*或*`拍打`*是`无效的`，返回值为`无效的`.字符索引从1开始。

    [`REGEXP_INSTR（）`](regexp.html#function_regexp-instr)采用以下可选参数：

    -   *`销售时点情报系统`*当前位置*`expr`*开始搜索的时间。如果省略，默认值为1。

    -   *`发生`*：要搜索的匹配项的哪个匹配项。如果省略，默认值为1。

    -   *`返回选项`*：返回哪种类型的位置。如果该值为0，[`REGEXP_INSTR（）`](regexp.html#function_regexp-instr)返回匹配子字符串的第一个字符的位置。如果该值为1，[`REGEXP_INSTR（）`](regexp.html#function_regexp-instr)返回匹配子字符串后面的位置。如果省略，默认值为0。

    -   *`匹配类型`*：指定如何执行匹配的字符串。其含义如下所述：[`REGEXP_LIKE（）`](regexp.html#function_regexp-like).

        有关如何进行匹配的其他信息，请参阅的说明[`REGEXP_LIKE（）`](regexp.html#function_regexp-like).

    ```
    mysql> SELECT REGEXP_INSTR('dog cat dog', 'dog');
    +------------------------------------+
    | REGEXP_INSTR('dog cat dog', 'dog') |
    +------------------------------------+
    |                                  1 |
    +------------------------------------+
    mysql> SELECT REGEXP_INSTR('dog cat dog', 'dog', 2);
    +---------------------------------------+
    | REGEXP_INSTR('dog cat dog', 'dog', 2) |
    +---------------------------------------+
    |                                     9 |
    +---------------------------------------+
    mysql> SELECT REGEXP_INSTR('aa aaa aaaa', 'a{2}');
    +-------------------------------------+
    | REGEXP_INSTR('aa aaa aaaa', 'a{2}') |
    +-------------------------------------+
    |                                   1 |
    +-------------------------------------+
    mysql> SELECT REGEXP_INSTR('aa aaa aaaa', 'a{4}');
    +-------------------------------------+
    | REGEXP_INSTR('aa aaa aaaa', 'a{4}') |
    +-------------------------------------+
    |                                   8 |
    +-------------------------------------+
    ```

-   [](<>)

    [`REGEXP_-LIKE(*`expr`*, *`拍打`*[, *`匹配类型`*])`](regexp.html#function_regexp-like)

    [](<>)

    如果字符串*`expr`*匹配模式指定的正则表达式*`拍打`*，否则为0。如果*`expr`*或*`拍打`*是`无效的`，返回值为`无效的`.

    模式可以是一个扩展正则表达式，其语法将在中讨论[正则表达式语法](regexp.html#regexp-syntax).模式不必是文本字符串。例如，可以将其指定为字符串表达式或表列。

    可选的*`匹配类型`*参数是一个字符串，可以包含指定如何执行匹配的以下任何或所有字符：

    -   `c`：区分大小写匹配。

    -   `我`：不区分大小写的匹配。

    -   `m`：多行模式。识别字符串中的行终止符。默认行为是仅在字符串表达式的开始和结束处匹配行终止符。

    -   `n`当前位置`.`字符匹配行终止符。默认值为`.`在一条线的尽头停下来。

    -   `u`：仅限Unix行结尾。只有换行符被识别为以`.`, `^`和`$`匹配操作员。

        如果在中指定了指定矛盾选项的字符*`匹配类型`*，最右边的优先。

        默认情况下，正则表达式操作使用*`expr`*和*`拍打`*确定字符类型并执行比较时的参数。如果参数具有不同的字符集或排序规则，则强制性规则适用，如中所述[第10.8.4节，“表达式中的排序强制性”](charset-collation-coercibility.html).参数可以使用显式排序指示符指定，以更改比较行为。

    ```
    mysql> SELECT REGEXP_LIKE('CamelCase', 'CAMELCASE');
    +---------------------------------------+
    | REGEXP_LIKE('CamelCase', 'CAMELCASE') |
    +---------------------------------------+
    |                                     1 |
    +---------------------------------------+
    mysql> SELECT REGEXP_LIKE('CamelCase', 'CAMELCASE' COLLATE utf8mb4_0900_as_cs);
    +------------------------------------------------------------------+
    | REGEXP_LIKE('CamelCase', 'CAMELCASE' COLLATE utf8mb4_0900_as_cs) |
    +------------------------------------------------------------------+
    |                                                                0 |
    +------------------------------------------------------------------+
    ```

    *`匹配类型`*可与`c`或`我`字符以覆盖默认的区分大小写。例外情况：如果任何一个参数是二进制字符串，则这些参数将以区分大小写的方式作为二进制字符串处理，即使*`匹配类型`*包含`我`性格

    笔记

    MySQL在字符串中使用C转义语法（例如，`\n`表示换行符）。如果你想*`expr`*或*`拍打`*参数以包含文字`\`，你必须加倍。（除非[`没有反斜杠逃脱`](sql-mode.html#sqlmode_no_backslash_escapes)SQL模式已启用，在这种情况下不使用转义字符。）

    ```
    mysql> SELECT REGEXP_LIKE('Michael!', '.*');
    +-------------------------------+
    | REGEXP_LIKE('Michael!', '.*') |
    +-------------------------------+
    |                             1 |
    +-------------------------------+
    mysql> SELECT REGEXP_LIKE('new*\n*line', 'new\\*.\\*line');
    +----------------------------------------------+
    | REGEXP_LIKE('new*\n*line', 'new\\*.\\*line') |
    +----------------------------------------------+
    |                                            0 |
    +----------------------------------------------+
    mysql> SELECT REGEXP_LIKE('a', '^[a-d]');
    +----------------------------+
    | REGEXP_LIKE('a', '^[a-d]') |
    +----------------------------+
    |                          1 |
    +----------------------------+
    ```

    ```
    mysql> SELECT REGEXP_LIKE('abc', 'ABC');
    +---------------------------+
    | REGEXP_LIKE('abc', 'ABC') |
    +---------------------------+
    |                         1 |
    +---------------------------+
    mysql> SELECT REGEXP_LIKE('abc', 'ABC', 'c');
    +--------------------------------+
    | REGEXP_LIKE('abc', 'ABC', 'c') |
    +--------------------------------+
    |                              0 |
    +--------------------------------+
    ```

-   [](<>)

    [`REGEXP_替换(*`expr`*, *`拍打`*, *`回复`*[, *`销售时点情报系统`*[, *`发生`*[, *`匹配类型`*]]])`](regexp.html#function_regexp-replace)

    [](<>)

    替换字符串中出现的内容*`expr`*与模式指定的正则表达式匹配*`拍打`*用替换字符串*`回复`*，并返回结果字符串。如果*`expr`*, *`拍打`*或*`回复`*是`无效的`，返回值为`无效的`.

    [`REGEXP_REPLACE（）`](regexp.html#function_regexp-replace)采用以下可选参数：

    -   *`销售时点情报系统`*当前位置*`expr`*开始搜索的时间。如果省略，默认值为1。

    -   *`发生`*：要替换的匹配项的哪个匹配项。如果省略，默认值为0（这意味着“替换所有事件”）。

    -   *`匹配类型`*：指定如何执行匹配的字符串。其含义如下所述：[`REGEXP_LIKE（）`](regexp.html#function_regexp-like).

        在MySQL 8.0.17之前，此函数返回的结果使用`UTF-16`字符集；在MySQL 8.0.17及更高版本中，使用了搜索匹配项的表达式的字符集和排序规则。（臭虫94203，臭虫29308212）

        有关如何进行匹配的其他信息，请参阅的说明[`REGEXP_LIKE（）`](regexp.html#function_regexp-like).

    ```
    mysql> SELECT REGEXP_REPLACE('a b c', 'b', 'X');
    +-----------------------------------+
    | REGEXP_REPLACE('a b c', 'b', 'X') |
    +-----------------------------------+
    | a X c                             |
    +-----------------------------------+
    mysql> SELECT REGEXP_REPLACE('abc def ghi', '[a-z]+', 'X', 1, 3);
    +----------------------------------------------------+
    | REGEXP_REPLACE('abc def ghi', '[a-z]+', 'X', 1, 3) |
    +----------------------------------------------------+
    | abc def X                                          |
    +----------------------------------------------------+
    ```

-   [](<>)

    [`REGEXP_SUBSTR(*`expr`*, *`拍打`*[, *`销售时点情报系统`*[, *`发生`*[, *`匹配类型`*]]])`](regexp.html#function_regexp-substr)

    [](<>)

    返回字符串的子字符串*`expr`*与模式指定的正则表达式匹配的*`拍打`*, `无效的`如果没有对手。如果*`expr`*或*`拍打`*是`无效的`，返回值为`无效的`.

    [`REGEXP_SUBSTR（）`](regexp.html#function_regexp-substr)采用以下可选参数：

    -   *`销售时点情报系统`*当前位置*`expr`*开始搜索的时间。如果省略，默认值为1。

    -   *`发生`*：要搜索的匹配项的哪个匹配项。如果省略，默认值为1。

    -   *`匹配类型`*：指定如何执行匹配的字符串。其含义如下所述：[`REGEXP_LIKE（）`](regexp.html#function_regexp-like).

        在MySQL 8.0.17之前，此函数返回的结果使用`UTF-16`字符集；在MySQL 8.0.17及更高版本中，使用了搜索匹配项的表达式的字符集和排序规则。（臭虫94203，臭虫29308212）

        有关如何进行匹配的其他信息，请参阅的说明[`REGEXP_LIKE（）`](regexp.html#function_regexp-like).

    ```
    mysql> SELECT REGEXP_SUBSTR('abc def ghi', '[a-z]+');
    +----------------------------------------+
    | REGEXP_SUBSTR('abc def ghi', '[a-z]+') |
    +----------------------------------------+
    | abc                                    |
    +----------------------------------------+
    mysql> SELECT REGEXP_SUBSTR('abc def ghi', '[a-z]+', 1, 3);
    +----------------------------------------------+
    | REGEXP_SUBSTR('abc def ghi', '[a-z]+', 1, 3) |
    +----------------------------------------------+
    | ghi                                          |
    +----------------------------------------------+
    ```

#### 正则表达式语法

正则表达式描述一组字符串。最简单的正则表达式中没有特殊字符。例如，正则表达式`你好`比赛`你好`没有别的了。

非平凡的正则表达式使用某些特殊的构造，以便它们可以匹配多个字符串。例如，正则表达式`你好|世界`包含`|`交替运算符，并匹配`你好`或`世界`.

作为一个更复杂的例子，正则表达式`B[an]*s`匹配任何字符串`香蕉`, `巴亚斯`, `学士学位`，以及任何其他以`B`，以`s`，并包含任意数量的`A.`或`n`介于两者之间的角色。

下面的列表介绍了可以在正则表达式中使用的一些基本特殊字符和构造。有关用于实现正则表达式支持的ICU库支持的完整正则表达式语法的信息，请访问[Unicode网站的国际组件](https://unicode-org.github.io/icu/userguide/).

-   `^`

    匹配字符串的开头。

    ```
    mysql> SELECT REGEXP_LIKE('fo\nfo', '^fo$');                   -> 0
    mysql> SELECT REGEXP_LIKE('fofo', '^fo');                      -> 1
    ```

-   `$`

    匹配字符串的结尾。

    ```
    mysql> SELECT REGEXP_LIKE('fo\no', '^fo\no$');                 -> 1
    mysql> SELECT REGEXP_LIKE('fo\no', '^fo$');                    -> 0
    ```

-   `.`

    匹配任何字符（包括回车符和换行符），但要在字符串中间匹配这些字符，`m`（多行）匹配控制字符或`（？m）`必须提供内部模式修改器）。

    ```
    mysql> SELECT REGEXP_LIKE('fofo', '^f.*$');                    -> 1
    mysql> SELECT REGEXP_LIKE('fo\r\nfo', '^f.*$');                -> 0
    mysql> SELECT REGEXP_LIKE('fo\r\nfo', '^f.*$', 'm');           -> 1
    mysql> SELECT REGEXP_LIKE('fo\r\nfo', '(?m)^f.*$');           -> 1
    ```

-   `a*`

    匹配任何零或更多的序列`A.`角色。

    ```
    mysql> SELECT REGEXP_LIKE('Ban', '^Ba*n');                     -> 1
    mysql> SELECT REGEXP_LIKE('Baaan', '^Ba*n');                   -> 1
    mysql> SELECT REGEXP_LIKE('Bn', '^Ba*n');                      -> 1
    ```

-   `a+`

    匹配一个或多个序列`A.`角色。

    ```
    mysql> SELECT REGEXP_LIKE('Ban', '^Ba+n');                     -> 1
    mysql> SELECT REGEXP_LIKE('Bn', '^Ba+n');                      -> 0
    ```

-   `A.`

    匹配0或1`A.`性格

    ```
    mysql> SELECT REGEXP_LIKE('Bn', '^Ba?n');                      -> 1
    mysql> SELECT REGEXP_LIKE('Ban', '^Ba?n');                     -> 1
    mysql> SELECT REGEXP_LIKE('Baan', '^Ba?n');                    -> 0
    ```

-   `德| abc`

    交替；匹配两个序列中的任何一个`判定元件`或`abc`.

    ```
    mysql> SELECT REGEXP_LIKE('pi', 'pi|apa');                     -> 1
    mysql> SELECT REGEXP_LIKE('axe', 'pi|apa');                    -> 0
    mysql> SELECT REGEXP_LIKE('apa', 'pi|apa');                    -> 1
    mysql> SELECT REGEXP_LIKE('apa', '^(pi|apa)$');                -> 1
    mysql> SELECT REGEXP_LIKE('pi', '^(pi|apa)$');                 -> 1
    mysql> SELECT REGEXP_LIKE('pix', '^(pi|apa)$');                -> 0
    ```

-   `（abc）*`

    匹配序列的零个或多个实例`abc`.

    ```
    mysql> SELECT REGEXP_LIKE('pi', '^(pi)*$');                    -> 1
    mysql> SELECT REGEXP_LIKE('pip', '^(pi)*$');                   -> 0
    mysql> SELECT REGEXP_LIKE('pipi', '^(pi)*$');                  -> 1
    ```

-   `{1}`, `{2,3}`

    重复`{*`n`*}`和`{*`m`*,*`n`*}`表示法提供了一种更通用的方式来编写正则表达式，这些正则表达式与模式的前一个原子（或“片段”）的多次出现相匹配。*`m`*和*`n`*是整数。

    -   `a*`

        可以写成`a{0，}`.

    -   `a+`

        可以写成`a{1，}`.

    -   `A.`

        可以写成`a{0,1}`.

        更准确地说，`a{*`n`*}`完全匹配*`n`*实例`A.`. `一种{*`n`*,}`火柴*`n`*或更多实例`一种`.`一种{*`米`*,*`n`*}`火柴*`米`*通过*`n`*的实例`一种`， 包括的。如果两者*`米`*和*`n`*给出，*`米`*必须小于或等于*`n`*.

    ```
    mysql> SELECT REGEXP_LIKE('abcde', 'a[bcd]{2}e');              -> 0
    mysql> SELECT REGEXP_LIKE('abcde', 'a[bcd]{3}e');              -> 1
    mysql> SELECT REGEXP_LIKE('abcde', 'a[bcd]{1,10}e');           -> 1
    ```

-   `[a-dX]`,`[^a-dX]`

    匹配任何是（或不是，如果`^`被使用）要么`一种`,`b`,`c`,`d`要么`X`.一种`-`两个其他字符之间的字符形成一个匹配从第一个字符到第二个字符的所有字符的范围。例如，`[0-9]`匹配任何十进制数字。包括文字`]`字符，它必须紧跟在左括号之后`[`.包括文字`-`字符，必须先写或最后写。任何在 a 中没有定义的特殊含义的字符`[]`pair 只匹配它自己。

    ```
    mysql> SELECT REGEXP_LIKE('aXbc', '[a-dXYZ]');                 -> 1
    mysql> SELECT REGEXP_LIKE('aXbc', '^[a-dXYZ]$');               -> 0
    mysql> SELECT REGEXP_LIKE('aXbc', '^[a-dXYZ]+$');              -> 1
    mysql> SELECT REGEXP_LIKE('aXbc', '^[^a-dXYZ]+$');             -> 0
    mysql> SELECT REGEXP_LIKE('gheis', '^[^a-dXYZ]+$');            -> 1
    mysql> SELECT REGEXP_LIKE('gheisa', '^[^a-dXYZ]+$');           -> 0
    ```

-   `[=character_class=]`

    在括号表达式内（使用`[`和`]`),`[=character_class=]`表示一个等价类。它匹配具有相同排序规则值的所有字符，包括它自己。例如，如果`○`和`(+)`是等价类的成员，`[[=o=]]`,`[[=(+)=]]`， 和`[o(+)]`都是同义词。等价类不能用作范围的端点。

-   `[:character_class:]`

    在括号表达式内（使用`[`和`]`),`[:character_class:]`表示匹配属于该类的所有字符的字符类。下表列出了标准类名称。这些名称代表定义在`ctype(3)`手册页。特定的语言环境可能会提供其他类名。字符类不能用作范围的端点。

    | 字符类名称 | 意义 |
    | ----- | --- |
    | `铝` | 字母数字字符 |
    | `α` | 字母字符 |
    | `空白的` | 空白字符 |
    | `控制` | 控制字符 |
    | `数字` | 数字字符 |
    | `图形` | 图形字符 |
    | `降低` | 小写字母字符 |
    | `打印` | 图形或空格字符 |
    | `点点` | 标点符号 |
    | `空间` | 空格、制表符、换行符和回车符 |
    | `上` | 大写字母字符 |
    | `数字` | 十六进制数字字符 |

    ```
    mysql> SELECT REGEXP_LIKE('justalnums', '[[:alnum:]]+');       -> 1
    mysql> SELECT REGEXP_LIKE('!!', '[[:alnum:]]+');               -> 0
    ```

    要在正则表达式中使用特殊字符的文字实例，请在其前面加上两个反斜杠 (\\） 人物。MySQL 解析器解释其中一个反斜杠，而正则表达式库解释另一个。例如，匹配字符串`1+2`包含特殊的`+`字符，只有以下正则表达式中的最后一个是正确的：


```
mysql> SELECT REGEXP_LIKE('1+2', '1+2');                       -> 0
mysql> SELECT REGEXP_LIKE('1+2', '1\+2');                      -> 0
mysql> SELECT REGEXP_LIKE('1+2', '1\\+2');                     -> 1
```

#### 正则表达式资源控制

[`正则表达式_LIKE()`](regexp.html#function_regexp-like)和类似的函数使用可以通过设置系统变量来控制的资源：

-   匹配引擎将内存用于其内部堆栈。要以字节为单位控制堆栈的最大可用内存，请设置[`regexp_stack_limit`](server-system-variables.html#sysvar_regexp_stack_limit)系统变量。

-   匹配引擎分步运行。要控制引擎执行的最大步数（从而间接控制执行时间），请设置[`regexp_time_limit`](server-system-variables.html#sysvar_regexp_time_limit)系统变量。由于此限制以步数表示，因此它仅间接影响执行时间。通常，它是毫秒级的。

#### 正则表达式兼容性注意事项

在 MySQL 8.0.4 之前，MySQL 使用 Henry Spencer 正则表达式库来支持正则表达式操作，而不是 International Components for Unicode (ICU)。以下讨论描述了 Spencer 和 ICU 库之间可能影响应用程序的差异：

-   使用 Spencer 库，[`正则表达式`](regexp.html#operator_regexp)和[`力克`](regexp.html#operator_regexp)运算符以字节方式工作，因此它们不是多字节安全的，并且可能会在使用多字节字符集时产生意外结果。此外，这些运算符通过字节值比较字符，即使给定的排序规则将它们视为相等，重音字符也可能不会比较相等。

    ICU 具有完整的 Unicode 支持并且是多字节安全的。它的正则表达式函数将所有字符串视为`UTF-16`.您应该记住，位置索引基于 16 位块而不是代码点。这意味着，当传递给此类函数时，使用多个块的字符可能会产生意想不到的结果，如下所示：

    ```
    mysql> SELECT REGEXP_INSTR('🍣🍣b', 'b');
    +--------------------------+
    | REGEXP_INSTR('??b', 'b') |
    +--------------------------+
    |                        5 |
    +--------------------------+
    1 row in set (0.00 sec)

    mysql> SELECT REGEXP_INSTR('🍣🍣bxxx', 'b', 4);
    +--------------------------------+
    | REGEXP_INSTR('??bxxx', 'b', 4) |
    +--------------------------------+
    |                              5 |
    +--------------------------------+
    1 row in set (0.00 sec)
    ```

    Unicode 基本多语言平面中的字符（包括大多数现代语言使用的字符）在这方面是安全的：

    ```
    mysql> SELECT REGEXP_INSTR('бжb', 'b');
    +----------------------------+
    | REGEXP_INSTR('бжb', 'b')   |
    +----------------------------+
    |                          3 |
    +----------------------------+
    1 row in set (0.00 sec)

    mysql> SELECT REGEXP_INSTR('עבb', 'b');
    +----------------------------+
    | REGEXP_INSTR('עבb', 'b')   |
    +----------------------------+
    |                          3 |
    +----------------------------+
    1 row in set (0.00 sec)

    mysql> SELECT REGEXP_INSTR('µå周çб', '周');
    +------------------------------------+
    | REGEXP_INSTR('µå周çб', '周')       |
    +------------------------------------+
    |                                  3 |
    +------------------------------------+
    1 row in set (0.00 sec)
    ```

    表情符号，例如“寿司”字符`🍣`前两个示例中使用的 (U+1F363) 不包含在基本多语言平面中，而是包含在 Unicode 的补充多语言平面中。表情符号和其他 4 字节字符可能会出现另一个问题[`REGEXP_SUBSTR()`](regexp.html#function_regexp-substr)或类似的功能开始在字符中间进行搜索。以下示例中的两个语句中的每一个都从第一个参数中的第二个 2 字节位置开始。第一条语句适用于仅由 2 字节 (BMP) 字符组成的字符串。第二条语句包含 4 字节字符，这些字符在结果中被错误解释，因为前两个字节被剥离，因此剩余的字符数据未对齐。

    ```
    mysql> SELECT REGEXP_SUBSTR('周周周周', '.*', 2);
    +----------------------------------------+
    | REGEXP_SUBSTR('周周周周', '.*', 2)     |
    +----------------------------------------+
    | 周周周                                 |
    +----------------------------------------+
    1 row in set (0.00 sec)

    mysql> SELECT REGEXP_SUBSTR('🍣🍣🍣🍣', '.*', 2);
    +--------------------------------+
    | REGEXP_SUBSTR('????', '.*', 2) |
    +--------------------------------+
    | ?㳟揘㳟揘㳟揘                  |
    +--------------------------------+
    1 row in set (0.00 sec)
    ```

-   为了`.`运算符，Spencer 库匹配字符串表达式中任何位置的行终止符（回车符、换行符），包括中间。要将字符串中间的行终止符与 ICU 匹配，请指定`m`匹配控制字符。

-   Spencer库支持单词开始和结束边界标记(`[[:<:]]`和`[[:>:]]`符号）。ICU没有。对于ICU，你可以使用`\b`匹配单词边界；加倍反斜杠，因为MySQL将其解释为字符串中的转义字符。

-   Spencer库支持对元素括号表达式进行排序(`[.字符。]`符号）。ICU没有。

-   重复计数(`{n}`和`{m，n}`表示法），斯宾塞库的最大值为255。ICU没有这样的限制，尽管可以通过设置[`regexp_时间限制`](server-system-variables.html#sysvar_regexp_time_limit)系统变量。

-   ICU将括号解释为元字符。指定文字开括号或右括号的步骤`(`在正则表达式中，必须对其进行转义：

    ```
    mysql> SELECT REGEXP_LIKE('(', '(');
    ERROR 3692 (HY000): Mismatched parenthesis in regular expression.
    mysql> SELECT REGEXP_LIKE('(', '\\(');
    +-------------------------+
    | REGEXP_LIKE('(', '\\(') |
    +-------------------------+
    |                       1 |
    +-------------------------+
    mysql> SELECT REGEXP_LIKE(')', ')');
    ERROR 3692 (HY000): Mismatched parenthesis in regular expression.
    mysql> SELECT REGEXP_LIKE(')', '\\)');
    +-------------------------+
    | REGEXP_LIKE(')', '\\)') |
    +-------------------------+
    |                       1 |
    +-------------------------+
    ```

-   ICU还将方括号解释为元字符，但只有开头的方括号需要转义才能用作文字字符：

    ```
    mysql> SELECT REGEXP_LIKE('[', '[');
    ERROR 3696 (HY000): The regular expression contains an
    unclosed bracket expression.
    mysql> SELECT REGEXP_LIKE('[', '\\[');
    +-------------------------+
    | REGEXP_LIKE('[', '\\[') |
    +-------------------------+
    |                       1 |
    +-------------------------+
    mysql> SELECT REGEXP_LIKE(']', ']');
    +-----------------------+
    | REGEXP_LIKE(']', ']') |
    +-----------------------+
    |                     1 |
    +-----------------------+
    ```
