Spec-Zone.ru › DuckDB

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

DuckDB предлагает операторы сопоставления шаблонов (LIKE, SIMILAR TO, GLOB), а также поддержку регулярных выражений через функции.

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

DuckDB использует библиотеку RE2 в качестве движка регулярных выражений. Синтаксис регулярных выражений см. в документации RE2.

Функции

Все функции принимают необязательный набор параметров.

Имя Описание
regexp_extract(string, pattern[, group = 0][, options]) Если string содержит регулярное выражение pattern, возвращает группу захвата, указанную необязательным параметром group. Значение group должно быть константой. Если необязательный параметр group не указан, он по умолчанию равен 0. Можно задать набор необязательных options.
regexp_extract(string, pattern, name_list[, options]) Если string содержит регулярное выражение pattern, возвращает группы захвата в виде структуры с соответствующими именами из name_list.
regexp_extract_all(string, regex[, group = 0][, options]) Разделяет string по regex и извлекает все вхождения group.
regexp_full_match(string, regex[, options]) Возвращает true, если всё string соответствует regex.
regexp_matches(string, pattern[, options]) Возвращает true, если string содержит регулярное выражение pattern, false в противном случае.
regexp_replace(string, pattern, replacement[, options]) Если string содержит регулярное выражение pattern, заменяет соответствующую часть на replacement.
regexp_split_to_array(string, regex[, options]) Псевдоним для string_split_regex. Разделяет string по regex.
regexp_split_to_table(string, regex[, options]) Разделяет string по regex и возвращает строку для каждой части.

regexp_extract(string, pattern[, group = 0][, options])

Описание Если string содержит регулярное выражение pattern, возвращает группу захвата, указанную необязательным параметром group. Значение group должно быть константой. Если необязательный параметр group не указан, он по умолчанию равен 0. Можно задать набор необязательных options.
Пример regexp_extract('abc', '([a-z])(b)', 1)
Результат a

regexp_extract(string, pattern, name_list[, options])

Описание Если string содержит регулярное выражение pattern, возвращает группы захвата в виде структуры с соответствующими именами из name_list. Можно задать набор необязательных options.
Пример regexp_extract('2023-04-15', '(\d+)-(\d+)-(\d+)', ['y', 'm', 'd'])
Результат {'y':'2023', 'm':'04', 'd':'15'}

regexp_extract_all(string, regex[, group = 0][, options])

Описание Разделяет string по regex и извлекает все вхождения group. Можно задать набор необязательных options.
Пример regexp_extract_all('hello_world', '([a-z ]+)_?', 1)
Результат [hello, world]

regexp_full_match(string, regex[, options])

Описание Возвращает true если всё string соответствует regex. Можно задать набор необязательных options.
Пример regexp_full_match('anabanana', '(an)*')
Результат false

regexp_matches(string, pattern[, options])

Описание Возвращает true если string содержит регулярное выражение pattern, в противном случае false. Можно задать набор необязательных options.
Пример regexp_matches('anabanana', '(an)*')
Результат true

regexp_replace(string, pattern, replacement[, options])

Описание Если string содержит регулярное выражение pattern, заменяет соответствующую часть на replacement. Можно задать набор необязательных options.
Пример regexp_replace('hello', '[lo]', '-')
Результат he-lo

regexp_split_to_array(string, regex[, options])

Описание Псевдоним для string_split_regex. Разделяет string по regex. Можно задать набор необязательных options.
Пример regexp_split_to_array('hello world; 42', ';? ')
Результат ['hello', 'world', '42']

regexp_split_to_table(string, regex[, options])

Описание Разделяет string по regex и возвращает строку для каждой части. Можно задать набор необязательных options.
Пример regexp_split_to_table('hello world; 42', ';? ')
Результат Три строки: 'hello', 'world', '42'

Функция regexp_matches похожа на оператор SIMILAR TO, но не требует совпадения всей строки. Вместо этого, regexp_matches возвращает true, если строка просто содержит шаблон (если не используются специальные маркеры ^ и $ для привязки регулярного выражения к началу и концу строки). Ниже приведены некоторые примеры:

SELECT regexp_matches('abc', 'abc');       -- true
SELECT regexp_matches('abc', '^abc$');     -- true
SELECT regexp_matches('abc', 'a');         -- true
SELECT regexp_matches('abc', '^a$');       -- false
SELECT regexp_matches('abc', '.*(b|d).*'); -- true
SELECT regexp_matches('abc', '(b|c).*');   -- true
SELECT regexp_matches('abc', '^(b|c).*');  -- false
SELECT regexp_matches('abc', '(?i)A');     -- true
SELECT regexp_matches('abc', 'A', 'i');    -- true

Параметры функций регулярных выражений

Функции регулярных выражений поддерживают следующие options.

Параметр Описание
'c' чувствительность к регистру
'i' нечувствительность к регистру
'l' сопоставление литералов, а не токенов регулярных выражений
'm', 'n', 'p' чувствительность к символам новой строки
'g' глобальная замена, доступна только для regexp_replace
's' нечувствительность к символам новой строки

Например:

SELECT regexp_matches('abcd', 'ABC', 'c'); -- false
SELECT regexp_matches('abcd', 'ABC', 'i'); -- true
SELECT regexp_matches('ab^/$cd', '^/$', 'l'); -- true
SELECT regexp_matches(E'hello\nworld', 'hello.world', 'p'); -- false
SELECT regexp_matches(E'hello\nworld', 'hello.world', 's'); -- true

Использование regexp_matches

Оператор regexp_matches будет оптимизирован до оператора LIKE когда это возможно. Для достижения наилучшей производительности, следует передать параметр 'c' (чувствительность к регистру), если это применимо. Обратите внимание, что по умолчанию библиотека RE2 не сопоставляет символ . с новой строкой.

Original Optimized equivalent
regexp_matches('hello world', '^hello', 'c') prefix('hello world', 'hello')
regexp_matches('hello world', 'world$', 'c') suffix('hello world', 'world')
regexp_matches('hello world', 'hello.world', 'c') LIKE 'hello_world'
regexp_matches('hello world', 'he.*rld', 'c') LIKE '%he%rld'

Использование regexp_replace

Функция regexp_replace может быть использована для замены части строки, которая соответствует шаблону регулярного выражения, на строку замены. Запись \d (где d — число, указывающее на группу) может быть использована для ссылки на группы, захваченные в регулярном выражении, в строке замены. Обратите внимание, что по умолчанию regexp_replace заменяет только первое вхождение регулярного выражения. Для замены всех вхождений используйте флаг глобальной замены (g)

Вот несколько примеров использования regexp_replace:

SELECT regexp_replace('abc', '(b|c)', 'X');        -- aXc
SELECT regexp_replace('abc', '(b|c)', 'X', 'g');   -- aXX
SELECT regexp_replace('abc', '(b|c)', '\1\1\1\1'); -- abbbbc
SELECT regexp_replace('abc', '(.*)c', '\1e');      -- abe
SELECT regexp_replace('abc', '(a)(b)', '\2\1');    -- bac

Использование regexp_extract

Функция regexp_extract используется для извлечения части строки, которая соответствует шаблону регулярного выражения. Конкретную захваченную группу в шаблоне можно извлечь, используя параметр group. Если group не указан, он по умолчанию равен 0, извлекая первое совпадение со всем шаблоном.

SELECT regexp_extract('abc', '.b.');           -- abc
SELECT regexp_extract('abc', '.b.', 0);        -- abc
SELECT regexp_extract('abc', '.b.', 1);        -- (empty)
SELECT regexp_extract('abc', '([a-z])(b)', 1); -- a
SELECT regexp_extract('abc', '([a-z])(b)', 2); -- b

Функция regexp_extract также поддерживает аргумент name_list, который является LIST строк. Используя name_list, функция regexp_extract вернёт соответствующие захваченные группы как поля STRUCT:

SELECT regexp_extract('2023-04-15', '(\d+)-(\d+)-(\d+)', ['y', 'm', 'd']);
{'y': 2023, 'm': 04, 'd': 15}
SELECT regexp_extract('2023-04-15 07:59:56', '^(\d+)-(\d+)-(\d+) (\d+):(\d+):(\d+)', ['y', 'm', 'd']);
{'y': 2023, 'm': 04, 'd': 15}
SELECT regexp_extract('duckdb_0_7_1', '^(\w+)_(\d+)_(\d+)', ['tool', 'major', 'minor', 'fix']);
Binder Error: Not enough group names in regexp_extract

Если количество имён столбцов меньше количества захваченных групп, то возвращаются только первые группы. Если количество имён столбцов больше, генерируется ошибка.

Ограничения

Регулярные выражения поддерживают только 9 захваченных групп: \1, \2, \3, …, \9. Захват групп с двумя и более цифрами не поддерживается.

© Copyright 2018–2024 Stichting DuckDB Foundation
Licensed under the MIT License.
https://duckdb.org/docs/sql/functions/regular_expressions.html

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API