14.8.2 Regular Expressions — MySQL 8.4

14.8.2 Регулярные выражения

Таблица 14.14 Функции и операторы регулярных выражений

Таблица 14.14 Функции и операторы регулярных выражений
Имя	Описание
`NOT REGEXP`	Отрицание REGEXP
`REGEXP`	Соответствует ли строка регулярному выражению
`REGEXP_INSTR()`	Начальный индекс подстроки, соответствующей регулярному выражению
`REGEXP_LIKE()`	Соответствует ли строка регулярному выражению
`REGEXP_REPLACE()`	Заменить подстроки, соответствующие регулярному выражению
`REGEXP_SUBSTR()`	Возвратить подстроку, соответствующую регулярному выражению
`RLIKE`	Соответствует ли строка регулярному выражению

Регулярное выражение — мощный способ задания шаблона для сложного поиска. В этом разделе рассматриваются функции и операторы, доступные для сопоставления с регулярными выражениями, и приведены примеры использования некоторых специальных символов и конструкций для работы с регулярными выражениями. См. также Раздел 5.3.4.7 «Сопоставление шаблонов».

MySQL реализует поддержку регулярных выражений с использованием International Components for Unicode (ICU), которое обеспечивает полную поддержку Unicode и является безопасным для многобайтовых символов.

Использование двоичной строки с любой из функций регулярных выражений MySQL отклоняется с ошибкой.

Описание функций и операторов регулярных выражений

expr NOT REGEXP pat, expr NOT RLIKE pat

Это то же самое, что и NOT (expr REGEXP pat).

expr REGEXP pat, expr RLIKE pat

Возвращает 1, если строка expr соответствует регулярному выражению, заданному шаблоном pat, и 0 в противном случае. Если expr или pat равны NULL, возвращаемое значение равно NULL.

REGEXP и RLIKE являются синонимами для REGEXP_LIKE().

Дополнительную информацию о том, как происходит сопоставление, см. в описании 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 |
+---------------------+

REGEXP_INSTR(expr, pat[, pos[, occurrence[, return_option[, match_type]]]])

Возвращает начальный индекс подстроки строки expr, которая соответствует регулярному выражению, заданному шаблоном pat, 0, если соответствия нет. Если expr или pat равны NULL, возвращаемое значение равно NULL. Индексы символов начинаются с 1.

REGEXP_INSTR() принимает следующие необязательные аргументы:
- pos: Позиция в expr, с которой следует начать поиск. Если опущен, по умолчанию используется 1.
- occurrence: Какой по счету экземпляр совпадения нужно искать. Если опущен, по умолчанию используется 1.
- return_option: Какой тип позиции вернуть. Если это значение равно 0, REGEXP_INSTR() возвращает позицию первого символа совпавшей подстроки. Если это значение равно 1, REGEXP_INSTR() возвращает позицию после совпавшей подстроки. Если опущен, по умолчанию используется 0.
- match_type: Строка, определяющая способ выполнения сопоставления. Значение аналогично описанному для REGEXP_LIKE().
Дополнительную информацию о том, как происходит сопоставление, см. в описании 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, pat[, match_type])

Возвращает 1, если строка expr соответствует регулярному выражению, заданному шаблоном pat, и 0 в противном случае. Если expr или pat равны NULL, возвращаемое значение равно NULL.

Шаблон может быть расширенным регулярным выражением, синтаксис которого описан в Синтаксисе регулярных выражений. Шаблон не обязательно должен быть строкой. Например, он может быть задан как строковое выражение или столбец таблицы.

Необязательный аргумент match_type — это строка, которая может содержать один или несколько следующих символов, определяющих способ выполнения сопоставления:
- c: Сопоставление регистрозависимое.
- i: Сопоставление регистронезависимое.
- m: Режим многострочного поиска. Учитываются разделители строк в строке. По умолчанию сопоставление разделителей строк происходит только в начале и в конце строкового выражения.
- n: Символ . соответствует разделителям строк. По умолчанию сопоставление . останавливается в конце строки.
- u: Только для Unix-подобных систем. Только символ новой строки распознается как разделитель строки операторами сопоставления ., ^ и $.
Если в match_type указаны противоречивые параметры, приоритет имеет последний.

По умолчанию операции с регулярными выражениями используют кодировку символов и сортировку аргументов expr и pat при определении типа символа и выполнении сравнения. Если у аргументов разные кодировки символов или сортировки, применяются правила приведения типов, описанные в Разделе 12.8.4, «Приведение типов сортировки в выражениях». Аргументы могут быть указаны с явными указателями сортировки для изменения поведения сравнения.
```
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 |
+------------------------------------------------------------------+
```
match_type можно указать с символами c или i для переопределения чувствительности к регистру по умолчанию. Исключение: если любой из аргументов является бинарной строкой, аргументы обрабатываются как бинарные строки, даже если match_type содержит символ i.

Примечание

MySQL использует синтаксис C-эскейпов в строках (например, \n для представления символа новой строки). Если вы хотите, чтобы ваш аргумент expr или pat содержал литеральную \, вы должны удвоить ее. (Исключение, если включен режим SQL NO_BACKSLASH_ESCAPES, в этом случае символ экранирования не используется.)
```
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_REPLACE(expr, pat, repl[, pos[, occurrence[, match_type]]])

Заменяет вхождения в строке expr, соответствующие регулярному выражению, заданному шаблоном pat, на строку замены repl и возвращает результирующую строку. Если expr, pat или repl равно NULL, возвращаемое значение равно NULL.

REGEXP_REPLACE() принимает следующие необязательные аргументы:
- pos: Позиция в expr, с которой следует начать поиск. Если опущен, по умолчанию используется 1.
- occurrence: Какой по счету экземпляр совпадения заменить. Если опущен, по умолчанию используется 0 (что означает «заменить все вхождения»).
- match_type: Строка, определяющая способ выполнения сопоставления. Значение аналогично описанному для REGEXP_LIKE().
Результат, возвращаемый этой функцией, использует кодировку символов и сортировку выражения, по которому производится поиск совпадений.

Дополнительную информацию о том, как происходит сопоставление, см. в описании 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, pat[, pos[, occurrence[, match_type]]])

Возвращает подстроку строки expr, соответствующую регулярному выражению, заданному шаблоном pat, NULL если совпадения нет. Если expr или pat равно NULL, возвращаемое значение равно NULL.

REGEXP_SUBSTR() принимает следующие необязательные аргументы:
- pos: Позиция в expr, с которой следует начать поиск. Если опущен, по умолчанию используется 1.
- occurrence: Какой по счету экземпляр совпадения нужно найти. Если опущен, по умолчанию используется 1.
- match_type: Строка, определяющая способ выполнения сопоставления. Значение аналогично описанному для REGEXP_LIKE().
Результат, возвращаемый этой функцией, использует кодировку символов и сортировку выражения, по которому производится поиск совпадений.

Дополнительную информацию о том, как происходит сопоставление, см. в описании 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                                          |
+----------------------------------------------+
```

Синтаксис регулярных выражений

Регулярное выражение описывает набор строк. Простейшим регулярным выражением является такое, в котором нет специальных символов. Например, регулярное выражение hello соответствует hello и ничему другому.

Нетривиальные регулярные выражения используют определенные специальные конструкции, чтобы они могли соответствовать более чем одной строке. Например, регулярное выражение hello|world содержит оператор альтернации | и соответствует либо строке hello, либо строке world.

В качестве более сложного примера, регулярное выражение B[an]*s соответствует любой из строк Bananas, Baaaaas, Bs, и любой другой строке, начинающейся с B, заканчивающейся на s и содержащей любое количество символов a или n между ними.

В следующем списке приведены некоторые основные специальные символы и конструкции, которые могут использоваться в регулярных выражениях. Для получения информации о полном синтаксисе регулярных выражений, поддерживаемом библиотекой ICU, используемой для реализации поддержки регулярных выражений, посетите веб-сайт International Components for Unicode.

^

Соответствует началу строки.

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?

Соответствует нулю или одному символу 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

de|abc

Альтернация; соответствует либо последовательности de, либо последовательности 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. a{n,} соответствует n или более экземплярам a. a{m,n} соответствует m по n экземплярам a включительно. Если и m, и n заданы, m должно быть меньше или равно 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]

Соответствует любому символу, который является (или не является, если используется ^) либо a, либо b, либо c, либо d, или X. Символ - между двумя другими символами образует диапазон, который соответствует всем символам от первого символа до второго. Например, [0-9] соответствует любой десятичной цифре. Для включения символа ], он должен сразу следовать за открывающей скобкой [. Для включения символа -, он должен быть написан первым или последним. Любой символ, который не имеет определенного специального значения внутри пары [], соответствует только самому себе.
```
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=]], [[=(+)=]] и [o(+)] являются синонимами. Класс эквивалентности не может использоваться в качестве конечной точки диапазона.

[:character_class:]

В выражении в квадратных скобках (записанном с использованием [ и ]), [:character_class:] представляет собой класс символов, который соответствует всем символам, принадлежащим этому классу. В следующей таблице перечислены стандартные имена классов. Эти имена обозначают классы символов, определенные в руководстве ctype(3). Конкретная локаль может предоставить другие имена классов. Класс символов не может использоваться в качестве конечной точки диапазона.

Имя класса символов	Значение
`alnum`	Алфавитно-цифровые символы
`alpha`	Алфавитные символы
`blank`	Пробельные символы
`cntrl`	Управляющие символы
`digit`	Цифровые символы
`graph`	Графические символы
`lower`	Алфавитные символы в нижнем регистре
`print`	Графические или пробельные символы
`punct`	Пунктуационные символы
`space`	Пробел, табуляция, новая строка и возврат каретки
`upper`	Алфавитные символы в верхнем регистре
`xdigit`	Символы шестнадцатеричных цифр

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

Управление ресурсами регулярных выражений

REGEXP_LIKE() и аналогичные функции используют ресурсы, которые можно контролировать, устанавливая системные переменные:

Движок поиска соответствует использует память для своего внутреннего стека. Для управления максимальным доступным объемом памяти для стека в байтах установите системную переменную regexp_stack_limit.
Движок поиска работает шагами. Чтобы управлять максимальным количеством шагов, выполняемых движком (и, таким образом, косвенно временем выполнения), установите системную переменную regexp_time_limit. Поскольку это ограничение выражается в количестве шагов, оно влияет на время выполнения только косвенно. Как правило, оно находится в порядке миллисекунд.