> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-fix-nav-issues.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
> Документация по функциям поиска в строках
# Функции поиска в строках
Все функции в этом разделе по умолчанию выполняют поиск с учетом регистра. Регистронезависимый поиск обычно реализован в виде отдельных вариантов функций.
Регистронезависимый поиск следует правилам преобразования символов в нижний и верхний регистр, принятым в английском языке. Например, прописная буква для `i` в английском языке —
`I`, тогда как в турецком языке — `İ`; поэтому для языков, отличных от английского, результаты могут быть неожиданными.
Функции в этом разделе также предполагают, что строка, в которой выполняется поиск (в этом разделе она обозначается как `haystack`), и искомая строка (в этом разделе она обозначается как `needle`) представляют собой текст в однобайтовой кодировке. Если это предположение
нарушено, исключение не сгенерируется, а результаты не определены. Поиск по строкам в кодировке UTF-8 обычно реализован в виде отдельных вариантов
функций. Аналогично, если используется вариант функции для UTF-8, а входные строки не являются текстом в кодировке UTF-8, исключение не сгенерируется, а
результаты не определены. Обратите внимание, что автоматическая нормализация Unicode не выполняется, однако для этого можно использовать
функции [normalizeUTF8\*()](/ru/reference/functions/regular-functions/string-functions#normalizeUTF8NFC).
[Общие функции для работы со строками](/ru/reference/functions/regular-functions/string-functions) и [функции замены в строках](/ru/reference/functions/regular-functions/string-replace-functions) описаны отдельно.
Приведенная ниже документация сгенерирована на основе системной таблицы `system.functions`.
{/*AUTOGENERATED_START*/}
## countMatches
Добавленный в: v21.1.0
Возвращает количество совпадений регулярного выражения в строке.
**Поведение зависит от версии**
Поведение этой функции зависит от версии ClickHouse:
* в версиях \< v25.6 функция прекращает подсчёт на первом пустом совпадении, даже если шаблон регулярного выражения его допускает.
* в версиях >= 25.6 функция продолжает работу при возникновении пустого совпадения. Прежнее поведение можно восстановить с помощью настройки `count_matches_stop_at_empty_match = true`;
**Синтаксис**
```sql theme={null}
countMatches(haystack, pattern)
```
**Аргументы**
* `haystack` — Строка, в которой выполняется поиск. [`String`](/ru/reference/data-types/string)
* `pattern` — Шаблон регулярного выражения. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает количество найденных совпадений. [`UInt64`](/ru/reference/data-types/int-uint)
**Примеры**
**Подсчёт последовательностей цифр**
```sql title=Query theme={null}
SELECT countMatches('hello 123 world 456 test', '[0-9]+')
```
```response title=Response theme={null}
┌─countMatches('hello 123 world 456 test', '[0-9]+')─┐
│ 2 │
└─────────────────────────────────────────────────────┘
```
## countMatchesCaseInsensitive
Добавленный в: v21.1.0
Как [`countMatches`](#countMatches), но выполняет поиск без учета регистра.
**Синтаксис**
```sql theme={null}
countMatchesCaseInsensitive(haystack, pattern)
```
**Аргументы**
* `haystack` — Строка, в которой выполняется поиск. [`String`](/ru/reference/data-types/string)
* `pattern` — Шаблон регулярного выражения. [`const String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает количество найденных совпадений. [`UInt64`](/ru/reference/data-types/int-uint)
**Примеры**
**Подсчёт без учёта регистра**
```sql title=Query theme={null}
SELECT countMatchesCaseInsensitive('Hello HELLO world', 'hello')
```
```response title=Response theme={null}
┌─countMatchesCaseInsensitive('Hello HELLO world', 'hello')─┐
│ 2 │
└───────────────────────────────────────────────────────────┘
```
## countSubstrings
Добавленный в: v21.1.0
Возвращает, сколько раз подстрока `needle` встречается в строке `haystack`.
**Синтаксис**
```sql theme={null}
countSubstrings(haystack, needle[, start_pos])
```
**Аргументы**
* `haystack` — Строка, в которой выполняется поиск. [String](/ru/reference/data-types/string) или [Enum](/ru/reference/data-types/enum). - `needle` — Подстрока, которую требуется найти. [String](/ru/reference/data-types/string). - `start_pos` — Позиция (нумерация начинается с 1) в `haystack`, с которой начинается поиск. [UInt](/ru/reference/data-types/int-uint). Необязательный.
**Возвращаемое значение**
Количество вхождений. [`UInt64`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT countSubstrings('aaaa', 'aa');
```
```response title=Response theme={null}
┌─countSubstrings('aaaa', 'aa')─┐
│ 2 │
└───────────────────────────────┘
```
**С аргументом start\_pos**
```sql title=Query theme={null}
SELECT countSubstrings('abc___abc', 'abc', 4);
```
```response title=Response theme={null}
┌─countSubstrings('abc___abc', 'abc', 4)─┐
│ 1 │
└────────────────────────────────────────┘
```
## countSubstringsCaseInsensitive
Добавленный в: v21.1.0
Как [`countSubstrings`](#countSubstrings), но считает без учета регистра.
**Синтаксис**
```sql theme={null}
countSubstringsCaseInsensitive(haystack, needle[, start_pos])
```
**Аргументы**
* `haystack` — Строка, в которой выполняется поиск. [`String`](/ru/reference/data-types/string) или [`Enum`](/ru/reference/data-types/enum)
* `needle` — Искомая подстрока. [`String`](/ru/reference/data-types/string)
* `start_pos` — Необязательно. Позиция (с отсчётом от 1) в `haystack`, с которой начинается поиск. [`UInt*`](/ru/reference/data-types/int-uint)
**Возвращаемое значение**
Возвращает количество вхождений `needle` в `haystack`. [`UInt64`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT countSubstringsCaseInsensitive('AAAA', 'aa');
```
```response title=Response theme={null}
┌─countSubstri⋯AAA', 'aa')─┐
│ 2 │
└──────────────────────────┘
```
**С аргументом start\_pos**
```sql title=Query theme={null}
SELECT countSubstringsCaseInsensitive('abc___ABC___abc', 'abc', 4);
```
```response title=Response theme={null}
┌─countSubstri⋯, 'abc', 4)─┐
│ 2 │
└──────────────────────────┘
```
## countSubstringsCaseInsensitiveUTF8
Добавленный в: v21.1.0
Аналогично [`countSubstrings`](#countSubstrings), но выполняет регистронезависимый подсчёт и предполагает, что haystack — строка UTF-8.
**Синтаксис**
```sql theme={null}
countSubstringsCaseInsensitiveUTF8(haystack, needle[, start_pos])
```
**Аргументы**
* `haystack` — UTF-8-строка, в которой выполняется поиск. [`String`](/ru/reference/data-types/string) или [`Enum`](/ru/reference/data-types/enum)
* `needle` — Подстрока, которую нужно найти. [`String`](/ru/reference/data-types/string)
* `start_pos` — Необязательно. Позиция (начиная с 1) в `haystack`, с которой начинается поиск. [`UInt*`](/ru/reference/data-types/int-uint)
**Возвращаемое значение**
Возвращает количество вхождений `needle` в `haystack`. [`UInt64`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА');
```
```response title=Response theme={null}
┌─countSubstri⋯шка', 'КА')─┐
│ 4 │
└──────────────────────────┘
```
**С аргументом start\_pos**
```sql title=Query theme={null}
SELECT countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА', 13);
```
```response title=Response theme={null}
┌─countSubstri⋯, 'КА', 13)─┐
│ 2 │
└──────────────────────────┘
```
Добавленный в: v1.1.0
Извлекает первое совпадение с регулярным выражением из строки.
Если 'haystack' не соответствует 'pattern', возвращается пустая строка.
Эта функция использует библиотеку регулярных выражений RE2. Поддерживаемый синтаксис см. в [re2](https://github.com/google/re2/wiki/Syntax).
Если регулярное выражение содержит группы захвата (подшаблоны), функция сопоставляет входную строку с первой группой захвата.
**Синтаксис**
```sql theme={null}
extract(haystack, pattern)
```
**Аргументы**
* `haystack` — Строка, из которой извлекаются данные. [`String`](/ru/reference/data-types/string)
* `pattern` — Регулярное выражение, обычно содержащее группу захвата. [`const String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает извлечённый фрагмент в виде строки. [`String`](/ru/reference/data-types/string)
**Примеры**
**Извлечение домена из адреса электронной почты**
```sql title=Query theme={null}
SELECT extract('test@clickhouse.com', '.*@(.*)$')
```
```response title=Response theme={null}
┌─extract('test@clickhouse.com', '.*@(.*)$')─┐
│ clickhouse.com │
└───────────────────────────────────────────┘
```
**Если совпадений нет, возвращается пустая строка**
```sql title=Query theme={null}
SELECT extract('test@clickhouse.com', 'no_match')
```
```response title=Response theme={null}
┌─extract('test@clickhouse.com', 'no_match')─┐
│ │
└────────────────────────────────────────────┘
```
Добавленный в: v1.1.0
Как [`extract`](#extract), но возвращает массив всех совпадений шаблона регулярного выражения в строке.
Если 'haystack' не соответствует regex 'pattern', возвращается пустой массив.
Если регулярное выражение содержит группы захвата (подшаблоны), функция сопоставляет входную строку с первой группой захвата.
**Синтаксис**
```sql theme={null}
extractAll(haystack, pattern)
```
**Аргументы**
* `haystack` — Строка, из которой извлекаются фрагменты. [`String`](/ru/reference/data-types/string)
* `pattern` — Шаблон регулярного выражения, при необходимости содержащий группы захвата. [`const String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает массив извлечённых фрагментов. [`Array(String)`](/ru/reference/data-types/array)
**Примеры**
**Извлечение всех чисел**
```sql title=Query theme={null}
SELECT extractAll('hello 123 world 456', '[0-9]+')
```
```response title=Response theme={null}
┌─extractAll('hello 123 world 456', '[0-9]+')─┐
│ ['123','456'] │
└─────────────────────────────────────────────┘
```
**Извлечь с помощью группы захвата**
```sql title=Query theme={null}
SELECT extractAll('test@example.com, user@domain.org', '([a-zA-Z0-9]+)@')
```
```response title=Response theme={null}
┌─extractAll('test@example.com, user@domain.org', '([a-zA-Z0-9]+)@')─┐
│ ['test','user'] │
└────────────────────────────────────────────────────────────────────┘
```
Добавленный в: v20.5.0
Сопоставляет все группы в строке с помощью указанного регулярного выражения и возвращает массив массивов, где каждый массив содержит все совпадения одной и той же группы захвата, упорядоченные по номеру группы.
**Синтаксис**
```sql theme={null}
extractAllGroupsHorizontal(s, regexp)
```
**Аргументы**
* `s` — Входная строка, из которой выполняется извлечение. [`String`](/ru/reference/data-types/string) или [`FixedString`](/ru/reference/data-types/fixedstring)
* `regexp` — Регулярное выражение для поиска совпадений. [`const String`](/ru/reference/data-types/string) или [`const FixedString`](/ru/reference/data-types/fixedstring)
**Возвращаемое значение**
Возвращает массив массивов, где каждый внутренний массив содержит все подстроки, захваченные одной группой захвата во всех совпадениях. Первый внутренний массив содержит все захваченные подстроки из группы 1, второй — из группы 2 и т. д. Если совпадения не найдены, возвращается пустой массив. [`Array(Array(String))`](/ru/reference/data-types/array)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
WITH '< Server: nginx
< Date: Tue, 22 Jan 2019 00:26:14 GMT
< Content-Type: text/html; charset=UTF-8
< Connection: keep-alive
' AS s
SELECT extractAllGroupsHorizontal(s, '< ([\\w\\-]+): ([^\\r\\n]+)');
```
```response title=Response theme={null}
[['Server','Date','Content-Type','Connection'],['nginx','Tue, 22 Jan 2019 00:26:14 GMT','text/html; charset=UTF-8','keep-alive']]
```
Добавленный в: v20.5.0
Извлекает группы захвата из первой подстроки, соответствующей регулярному выражению. Чтобы извлечь группы из всех совпадений, используйте [`extractAllGroupsHorizontal`](#extractAllGroupsHorizontal) или [`extractAllGroupsVertical`](/ru/reference/functions/regular-functions/splitting-merging-functions#extractAllGroupsVertical).
**Синтаксис**
```sql theme={null}
extractGroups(s, regexp)
```
**Аргументы**
* `s` — Входная строка, из которой выполняется извлечение. [`String`](/ru/reference/data-types/string) или [`FixedString`](/ru/reference/data-types/fixedstring)
* `regexp` — Регулярное выражение. Должно содержать как минимум одну группу захвата. Константа. [`const String`](/ru/reference/data-types/string) или [`const FixedString`](/ru/reference/data-types/fixedstring)
**Возвращаемое значение**
Если регулярное выражение найдено, возвращается массив, содержащий группы захвата (`1`–`N`, где `N` — число групп захвата в `regexp`) из первого совпадения. Если совпадений нет, возвращается пустой массив. [`Array(String)`](/ru/reference/data-types/array)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
WITH '< Server: nginx
< Date: Tue, 22 Jan 2019 00:26:14 GMT
< Content-Type: text/html; charset=UTF-8
< Connection: keep-alive
' AS s
SELECT extractGroups(s, '< ([\\w\\-]+): ([^\\r\\n]+)');
```
```response title=Response theme={null}
['Server','nginx']
```
## hasAllTokens
Добавленный в: v25.10.0
Аналогично [`hasAnyTokens`](#hasAnyTokens), но возвращает 1, если все токены строки или массива `needle` совпадают со строкой `input`, и 0 в противном случае. Если `input` является столбцом, возвращает все строки, удовлетворяющие этому условию.
Для столбца `input` должен быть определён [текстовый индекс](/ru/reference/engines/table-engines/mergetree-family/textindexes) для достижения оптимальной производительности.
Если текстовый индекс не определён, функция выполняет полное сканирование столбца, которое на порядки медленнее, чем поиск по индексу.
Перед поиском функция токенизирует
* аргумент `input` (всегда), и
* аргумент `needle` (если он задан как [String](/ru/reference/data-types/string))
с использованием токенизатора, указанного для текстового индекса.
Если для столбца не задан текстовый индекс, вместо него используется токенизатор `splitByNonAlpha`.
Если аргумент `needle` имеет тип [Array(String)](/ru/reference/data-types/array), каждый элемент массива рассматривается как токен — дополнительная токенизация не выполняется.
Повторяющиеся токены игнорируются.
Например, needles = \['ClickHouse', 'ClickHouse'] обрабатывается так же, как \['ClickHouse'].
**Синтаксис**
```sql theme={null}
hasAllTokens(input, needles)
```
**Псевдонимы**: `hasAllToken`
**Аргументы**
* `input` — Входной столбец. [`String`](/ru/reference/data-types/string) или [`FixedString`](/ru/reference/data-types/fixedstring) или [`Array(String)`](/ru/reference/data-types/array) или [`Array(FixedString)`](/ru/reference/data-types/array)
* `needles` — Искомые токены. [`String`](/ru/reference/data-types/string) или [`Array(String)`](/ru/reference/data-types/array)
* `tokenizer` — токенизатор, который следует использовать. Допустимые аргументы: `splitByNonAlpha`, `splitByString`, `asciiCJK`, `ngrams`, `sparseGrams` и `array`. Необязательный параметр; если он явно не задан, по умолчанию используется `splitByNonAlpha`. [`const String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает 1, если все искомые подстроки найдены, иначе 0. [`UInt8`](/ru/reference/data-types/int-uint)
**Примеры**
**Базовое использование со строковой подстрокой для поиска**
```sql title=Query theme={null}
CREATE TABLE table (
id UInt32,
msg String,
INDEX idx(msg) TYPE text(tokenizer = splitByString(['()', '\\']))
)
ENGINE = MergeTree
ORDER BY id;
INSERT INTO table VALUES (1, '()a,\\bc()d'), (2, '()\\a()bc\\d'), (3, ',()a\\,bc,(),d,');
SELECT count() FROM table WHERE hasAllTokens(msg, 'a\\d()');
```
```response title=Response theme={null}
┌─count()─┐
│ 1 │
└─────────┘
```
**Укажите искомые подстроки в массиве как есть (без токенизации)**
```sql title=Query theme={null}
SELECT count() FROM table WHERE hasAllTokens(msg, ['a', 'd']);
```
```response title=Response theme={null}
┌─count()─┐
│ 1 │
└─────────┘
```
**Генерация искомых подстрок с помощью функции `tokens`**
```sql title=Query theme={null}
SELECT count() FROM table WHERE hasAllTokens(msg, tokens('a()d', 'splitByString', ['()', '\\']));
```
```response title=Response theme={null}
┌─count()─┐
│ 1 │
└─────────┘
```
**Использование пользовательского токенизатора через 3-й аргумент**
```sql title=Query theme={null}
SELECT hasAllTokens('abcdef', 'abc', 'ngrams(3)');
```
```response title=Response theme={null}
┌─hasAllTokens('abcdef', 'abc', 'ngrams(3)')─┐
│ 1 │
└──────────────────────────────────────────────┘
```
**Примеры использования для столбцов типа array и map**
```sql title=Query theme={null}
CREATE TABLE log (
id UInt32,
tags Array(String),
attributes Map(String, String),
INDEX idx_tags (tags) TYPE text(tokenizer = splitByNonAlpha),
INDEX idx_attributes_keys mapKeys(attributes) TYPE text(tokenizer = array),
INDEX idx_attributes_vals mapValues(attributes) TYPE text(tokenizer = array)
)
ENGINE = MergeTree
ORDER BY id;
INSERT INTO log VALUES
(1, ['clickhouse', 'clickhouse cloud'], {'address': '192.0.0.1', 'log_level': 'INFO'}),
(2, ['chdb'], {'embedded': 'true', 'log_level': 'DEBUG'});
```
```response title=Response theme={null}
```
**Пример сo столбцом типа Array**
```sql title=Query theme={null}
SELECT count() FROM log WHERE hasAllTokens(tags, 'clickhouse');
```
```response title=Response theme={null}
┌─count()─┐
│ 1 │
└─────────┘
```
**Пример с mapKeys**
```sql title=Query theme={null}
SELECT count() FROM log WHERE hasAllTokens(mapKeys(attributes), ['address', 'log_level']);
```
```response title=Response theme={null}
┌─count()─┐
│ 1 │
└─────────┘
```
**Пример с mapValues**
```sql title=Query theme={null}
SELECT count() FROM log WHERE hasAllTokens(mapValues(attributes), ['192.0.0.1', 'DEBUG']);
```
```response title=Response theme={null}
┌─count()─┐
│ 0 │
└─────────┘
```
## hasAnyTokens
Добавленный в: v25.10.0
Возвращает 1, если хотя бы один токен из строки или массива `needle` совпадает со строкой `input`, и 0 в противном случае. Если `input` является столбцом, возвращает все строки, удовлетворяющие данному условию.
Для оптимальной производительности для столбца `input` следует определить [текстовый индекс](/ru/reference/engines/table-engines/mergetree-family/textindexes).
Если текстовый индекс не определён, функция выполняет полное сканирование столбца, которое на порядки медленнее, чем поиск по индексу.
Перед поиском функция токенизирует
* аргумент `input` (всегда), и
* аргумент `needle` (если он задан как [String](/ru/reference/data-types/string))
с использованием токенизатора, указанного для текстового индекса.
Если для столбца не определён текстовый индекс, вместо него используется токенизатор `splitByNonAlpha`.
Если аргумент `needle` имеет тип [Array(String)](/ru/reference/data-types/array), каждый элемент массива обрабатывается как токен — дополнительная токенизация не выполняется.
Повторяющиеся токены игнорируются.
Например, \['ClickHouse', 'ClickHouse'] обрабатывается так же, как \['ClickHouse'].
**Синтаксис**
```sql theme={null}
hasAnyTokens(input, needles)
```
**Псевдонимы**: `hasAnyToken`
**Аргументы**
* `input` — Входной столбец. [`String`](/ru/reference/data-types/string) или [`FixedString`](/ru/reference/data-types/fixedstring) или [`Nullable(String)`](/ru/reference/data-types/nullable) или [`Nullable(FixedString)`](/ru/reference/data-types/nullable) или [`Array(String)`](/ru/reference/data-types/array) или [`Array(FixedString)`](/ru/reference/data-types/array) или [`Array(Nullable(String))`](/ru/reference/data-types/array) или [`Array(Nullable(FixedString))`](/ru/reference/data-types/array)
* `needles` — Искомые токены. [`String`](/ru/reference/data-types/string) или [`Array(String)`](/ru/reference/data-types/array)
* `tokenizer` — токенизатор, который следует использовать. Допустимые аргументы: `splitByNonAlpha`, `splitByString`, `asciiCJK`, `ngrams`, `sparseGrams` и `array`. Необязательный параметр; если явно не задан, по умолчанию используется `splitByNonAlpha`. [`const String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает `1`, если найдено хотя бы одно совпадение, иначе `0`. [`UInt8`](/ru/reference/data-types/int-uint)
**Примеры**
**Базовое использование со строковым needle**
```sql title=Query theme={null}
CREATE TABLE table (
id UInt32,
msg String,
INDEX idx(msg) TYPE text(tokenizer = splitByString(['()', '\\']))
)
ENGINE = MergeTree
ORDER BY id;
INSERT INTO table VALUES (1, '()a,\\bc()d'), (2, '()\\a()bc\\d'), (3, ',()a\\,bc,(),d,');
SELECT count() FROM table WHERE hasAnyTokens(msg, 'a\\d()');
```
```response title=Response theme={null}
┌─count()─┐
│ 3 │
└─────────┘
```
**Укажите искомые подстроки (needle) в массиве как есть, без токенизации (AS-IS)**
```sql title=Query theme={null}
SELECT count() FROM table WHERE hasAnyTokens(msg, ['a', 'd']);
```
```response title=Response theme={null}
┌─count()─┐
│ 3 │
└─────────┘
```
**Генерация искомых подстрок с помощью функции `tokens`**
```sql title=Query theme={null}
SELECT count() FROM table WHERE hasAnyTokens(msg, tokens('a()d', 'splitByString', ['()', '\\']));
```
```response title=Response theme={null}
┌─count()─┐
│ 3 │
└─────────┘
```
**Примеры использования для столбцов типа array и map**
```sql title=Query theme={null}
CREATE TABLE log (
id UInt32,
tags Array(String),
attributes Map(String, String),
INDEX idx_tags (tags) TYPE text(tokenizer = splitByNonAlpha),
INDEX idx_attributes_keys mapKeys(attributes) TYPE text(tokenizer = array),
INDEX idx_attributes_vals mapValues(attributes) TYPE text(tokenizer = array)
)
ENGINE = MergeTree
ORDER BY id;
INSERT INTO log VALUES
(1, ['clickhouse', 'clickhouse cloud'], {'address': '192.0.0.1', 'log_level': 'INFO'}),
(2, ['chdb'], {'embedded': 'true', 'log_level': 'DEBUG'});
```
```response title=Response theme={null}
```
**Пример со столбцом типа Array**
```sql title=Query theme={null}
SELECT count() FROM log WHERE hasAnyTokens(tags, 'clickhouse');
```
```response title=Response theme={null}
┌─count()─┐
│ 1 │
└─────────┘
```
**Пример с mapKeys**
```sql title=Query theme={null}
SELECT count() FROM log WHERE hasAnyTokens(mapKeys(attributes), ['address', 'log_level']);
```
```response title=Response theme={null}
┌─count()─┐
│ 2 │
└─────────┘
```
**Пример с mapValues**
```sql title=Query theme={null}
SELECT count() FROM log WHERE hasAnyTokens(mapValues(attributes), ['192.0.0.1', 'DEBUG']);
```
```response title=Response theme={null}
┌─count()─┐
│ 2 │
└─────────┘
```
## hasPhrase
Добавленный в: v26.4.0
Проверяет, содержит ли `haystack` все токены из фразы в заданной последовательности.
Перед поиском функция токенизирует аргументы `input` и `phrase` с помощью токенизатора, указанного в необязательном третьем аргументе.
Аргумент токенизатора должен быть одним из следующих: `splitByNonAlpha`, `splitByString`, `ngrams` или `asciiCJK`.
Если токенизатор не указан, по умолчанию используется `splitByNonAlpha`.
В отличие от [`hasToken`](#hasToken), [`hasAnyTokens`](#hasAnyTokens) и [`hasAllTokens`](#hasAllTokens), `hasPhrase` требует, чтобы токены шли в том же порядке
и без каких-либо токенов между ними. Например, `hasPhrase('the quick brown fox', 'quick fox')` возвращает 0,
поскольку "brown" находится между "quick" и "fox".
**Синтаксис**
```sql theme={null}
hasPhrase(input, phrase[, tokenizer])
```
**Псевдонимы**: `matchPhrase`
**Аргументы**
* `input` — Входной столбец. [`String`](/ru/reference/data-types/string) или [`FixedString`](/ru/reference/data-types/fixedstring)
* `phrase` — Искомая фраза. [`const String`](/ru/reference/data-types/string)
* `tokenizer` — Используемый токенизатор. Необязательный параметр, по умолчанию — `splitByNonAlpha`. [`const String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает `1`, если фраза найдена как непрерывная последовательность токенов, иначе `0`. [`UInt8`](/ru/reference/data-types/int-uint)
**Примеры**
**Совпадение по фразе**
```sql title=Query theme={null}
SELECT hasPhrase('the quick brown fox jumps', 'quick brown')
```
```response title=Response theme={null}
┌─hasPhrase('the quick brown fox jumps', 'quick brown')─┐
│ 1 │
└────────────────────────────────────────────────────────┘
```
**Несмежные токены**
```sql title=Query theme={null}
SELECT hasPhrase('the quick brown fox jumps', 'quick fox')
```
```response title=Response theme={null}
┌─hasPhrase('the quick brown fox jumps', 'quick fox')─┐
│ 0 │
└──────────────────────────────────────────────────────┘
```
## hasSubsequence
Добавленный в: v23.7.0
Проверяет, является ли needle подпоследовательностью haystack.
Подпоследовательность строки — это последовательность, которую можно получить из другой строки, удалив некоторые или не удалив ни одного символа без изменения порядка оставшихся символов.
**Синтаксис**
```sql theme={null}
hasSubsequence(haystack, needle)
```
**Аргументы**
* `haystack` — Строка, в которой ищется подпоследовательность. [`String`](/ru/reference/data-types/string)
* `needle` — Подпоследовательность, которую нужно найти. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает `1`, если needle является подпоследовательностью haystack, и `0` в противном случае. [`UInt8`](/ru/reference/data-types/int-uint)
**Примеры**
**Базовая проверка подпоследовательности**
```sql title=Query theme={null}
SELECT hasSubsequence('Hello World', 'HlWrd')
```
```response title=Response theme={null}
┌─hasSubsequence('Hello World', 'HlWrd')─┐
│ 1 │
└────────────────────────────────────────┘
```
**Подпоследовательность не найдена**
```sql title=Query theme={null}
SELECT hasSubsequence('Hello World', 'xyz')
```
```response title=Response theme={null}
┌─hasSubsequence('Hello World', 'xyz')─┐
│ 0 │
└──────────────────────────────────────┘
```
## hasSubsequenceCaseInsensitive
Добавленный в: v23.7.0
Как [`hasSubsequence`](#hasSubsequence), но ищет без учета регистра.
**Синтаксис**
```sql theme={null}
hasSubsequenceCaseInsensitive(haystack, needle)
```
**Аргументы**
* `haystack` — Строка, в которой выполняется поиск. [`String`](/ru/reference/data-types/string)
* `needle` — Подпоследовательность, которую требуется найти. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает 1, если needle является подпоследовательностью haystack, иначе — 0. [`UInt8`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT hasSubsequenceCaseInsensitive('garbage', 'ARG');
```
```response title=Response theme={null}
┌─hasSubsequenceCaseInsensitive('garbage', 'ARG')─┐
│ 1 │
└─────────────────────────────────────────────────┘
```
## hasSubsequenceCaseInsensitiveUTF8
Добавленный в: v23.7.0
Аналогично [`hasSubsequenceUTF8`](#hasSubsequenceUTF8), но поиск выполняется регистронезависимо.
**Синтаксис**
```sql theme={null}
hasSubsequenceCaseInsensitiveUTF8(haystack, needle)
```
**Аргументы**
* `haystack` — строка в кодировке UTF-8, в которой выполняется поиск. [`String`](/ru/reference/data-types/string)
* `needle` — строка-подпоследовательность в кодировке UTF-8, которую требуется найти. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает 1, если `needle` является подпоследовательностью `haystack`, иначе 0. [`UInt8`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT hasSubsequenceCaseInsensitiveUTF8('ClickHouse - столбцовая система управления базами данных', 'СИСТЕМА');
```
```response title=Response theme={null}
┌─hasSubsequen⋯ 'СИСТЕМА')─┐
│ 1 │
└──────────────────────────┘
```
## hasSubsequenceUTF8
Добавленный в: v23.7.0
Как [`hasSubsequence`](/ru/reference/functions/regular-functions/string-search-functions#hasSubsequence), но предполагается, что haystack и needle — строки в кодировке UTF-8.
**Синтаксис**
```sql theme={null}
hasSubsequenceUTF8(haystack, needle)
```
**Аргументы**
* `haystack` — Строка, в которой выполняется поиск. [`String`](/ru/reference/data-types/string)
* `needle` — Искомая подпоследовательность. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает `1`, если `needle` является подпоследовательностью `haystack`, в противном случае — `0`. [`UInt8`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT hasSubsequenceUTF8('картошка', 'кошка');
```
```response title=Response theme={null}
┌─hasSubsequen⋯', 'кошка')─┐
│ 1 │
└──────────────────────────┘
```
**Несовпадающая подпоследовательность**
```sql title=Query theme={null}
SELECT hasSubsequenceUTF8('картошка', 'апельсин');
```
```response title=Response theme={null}
┌─hasSubsequen⋯'апельсин')─┐
│ 0 │
└──────────────────────────┘
```
## hasToken
Добавленный в: v20.1.0
Проверяет, содержится ли указанный токен в строке.
Использует [splitByNonAlpha](/ru/reference/functions/regular-functions/splitting-merging-functions#splitByNonAlpha) в качестве токенизатора, то есть токен определяется как максимально длинная подпоследовательность идущих подряд символов `[0-9A-Za-z_]` (цифры, символы ASCII и символ подчёркивания).
**Синтаксис**
```sql theme={null}
hasToken(haystack, token)
```
**Аргументы**
* `haystack` — Строка, в которой выполняется поиск. [`String`](/ru/reference/data-types/string)
* `token` — Токен, который нужно найти. [`const String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает `1`, если токен найден, и `0` в противном случае. [`UInt8`](/ru/reference/data-types/int-uint)
**Примеры**
**Поиск токена**
```sql title=Query theme={null}
SELECT hasToken('clickhouse test', 'test')
```
```response title=Response theme={null}
┌─hasToken('clickhouse test', 'test')─┐
│ 1 │
└─────────────────────────────────────┘
```
## hasTokenCaseInsensitive
Добавленный в: v20.1.0
Выполняет регистронезависимый поиск needle в haystack с использованием индекса tokenbf\_v1.
**Синтаксис**
```sql theme={null}
hasTokenCaseInsensitive(haystack, needle)
```
**Аргументы**
* Отсутствуют.
**Возвращаемое значение**
**Примеры**
## hasTokenCaseInsensitiveOrNull
Добавленный в: v23.1.0
Выполняет регистронезависимый поиск needle в haystack с использованием индекса tokenbf\_v1. Возвращает NULL, если needle некорректно сформирован.
**Синтаксис**
```sql theme={null}
hasTokenCaseInsensitiveOrNull(haystack, needle)
```
**Аргументы**
* Отсутствуют.
**Возвращаемое значение**
**Примеры**
## hasTokenOrNull
Добавленный в: v20.1.0
Как [`hasToken`](#hasToken), но возвращает NULL, если токен некорректно сформирован.
**Синтаксис**
```sql theme={null}
hasTokenOrNull(haystack, token)
```
**Аргументы**
* `haystack` — Строка, в которой выполняется поиск. Должна быть константой. [`String`](/ru/reference/data-types/string)
* `token` — Токен, который нужно найти. [`const String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает `1`, если токен найден, иначе `0`; `null`, если токен некорректен. [`Nullable(UInt8)`](/ru/reference/data-types/nullable)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT hasTokenOrNull('apple banana cherry', 'ban ana');
```
```response title=Response theme={null}
┌─hasTokenOrNu⋯ 'ban ana')─┐
│ ᴺᵁᴸᴸ │
└──────────────────────────┘
```
## highlight
Добавленный в: v26.4.0
Выделяет вхождения поисковых запросов в текстовой строке, оборачивая их в HTML-теги.
Функция выполняет регистронезависимый поиск ASCII. Если несколько поисковых запросов перекрываются или расположены в тексте вплотную друг к другу, совпавшие области объединяются в один выделенный фрагмент.
**Синтаксис**
```sql theme={null}
highlight(haystack, needles[, open_tag, close_tag])
```
**Аргументы**
* `haystack` — Текст, в котором выполняется поиск. [`String`](/ru/reference/data-types/string) или [`FixedString`](/ru/reference/data-types/fixedstring)
* `needles` — Массив строк поиска, которые нужно выделить. [`const Array(String)`](/ru/reference/data-types/array)
* `open_tag` — Открывающий тег, вставляемый перед каждым совпадением. По умолчанию: ``. [`const String`](/ru/reference/data-types/string)
* `close_tag` — Закрывающий тег, вставляемый после каждого совпадения. По умолчанию: ``. [`const String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает исходный текст, в котором найденные строки поиска обёрнуты в указанные теги. [`String`](/ru/reference/data-types/string)
**Примеры**
**Простое выделение**
```sql title=Query theme={null}
SELECT highlight('The quick brown fox', ['quick', 'fox'])
```
```response title=Response theme={null}
┌─highlight('The quick brown fox', ['quick', 'fox'])─┐
│ The quick brown fox │
└────────────────────────────────────────────────────┘
```
**Пользовательские теги**
```sql title=Query theme={null}
SELECT highlight('Hello World', ['hello'], '', '')
```
```response title=Response theme={null}
┌─highlight('Hello World', ['hello'], '', '')─┐
│ Hello World │
└────────────────────────────────────────────────────┘
```
## ilike
Добавленный в: v20.6.0
Как [`like`](#like), но выполняет регистронезависимый поиск.
**Синтаксис**
```sql theme={null}
ilike(haystack, pattern)
-- haystack ILIKE pattern
```
**Аргументы**
* `haystack` — строка, в которой выполняется поиск. [`String`](/ru/reference/data-types/string) или [`FixedString`](/ru/reference/data-types/fixedstring)
* `pattern` — шаблон регулярного выражения LIKE, с которым выполняется сопоставление. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает `1`, если строка соответствует шаблону регулярного выражения LIKE без учёта регистра, иначе `0`. [`UInt8`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT ilike('ClickHouse', '%house%');
```
```response title=Response theme={null}
┌─ilike('ClickHouse', '%house%')─┐
│ 1 │
└────────────────────────────────┘
```
## like
Добавленный в: v1.1.0
Возвращает, соответствует ли строка `haystack` выражению `LIKE` `pattern`.
Выражение `LIKE` может содержать обычные символы и следующие метасимволы:
* `%` обозначает любое количество любых символов (включая ноль символов).
* `_` обозначает один любой символ.
* `\` используется для экранирования литеральных `%`, `_` и `\`.
Сопоставление выполняется на основе UTF-8: например, `_` соответствует кодовой точке Unicode `¥`, которая в UTF-8 представлена двумя байтами.
Если `haystack` или выражение `LIKE` не являются корректным UTF-8, поведение не определено.
Автоматическая нормализация Unicode не выполняется; для этого можно использовать функции `normalizeUTF8*`.
Чтобы сопоставлять литеральные `%`, `_` и `\` (которые являются метасимволами `LIKE`), поставьте перед ними обратную косую черту: `\%`, `\_` и `\\`.
Обратная косая черта теряет своё специальное значение (то есть интерпретируется буквально), если стоит перед символом, отличным от `%`, `_` или `\`.
В ClickHouse обратные косые черты в строках также нужно экранировать [в соответствии с синтаксисом строк](/ru/reference/syntax#string), поэтому фактически нужно писать `\\%`, `\\_` и `\\\\`.
Для выражений `LIKE` вида `%needle%` функция работает так же быстро, как функция `position`.
Все остальные выражения `LIKE` внутренне преобразуются в регулярное выражение и выполняются с производительностью, аналогичной функции `match`.
**Синтаксис**
```sql theme={null}
like(haystack, pattern)
-- haystack LIKE pattern
```
**Аргументы**
* `haystack` — строка, в которой выполняется поиск. [`String`](/ru/reference/data-types/string) или [`FixedString`](/ru/reference/data-types/fixedstring)
* `pattern` — шаблон регулярного выражения `LIKE` для поиска совпадений. Может содержать `%` (соответствует любому количеству символов), `_` (соответствует одному символу) и `\` для экранирования. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает `1`, если строка соответствует шаблону регулярного выражения `LIKE`, в противном случае — `0`. [`UInt8`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT like('ClickHouse', '%House');
```
```response title=Response theme={null}
┌─like('ClickHouse', '%House')─┐
│ 1 │
└──────────────────────────────┘
```
**Односимвольный подстановочный знак**
```sql title=Query theme={null}
SELECT like('ClickHouse', 'Click_ouse');
```
```response title=Response theme={null}
┌─like('ClickH⋯lick_ouse')─┐
│ 1 │
└──────────────────────────┘
```
**Шаблон регулярного выражения без совпадения**
```sql title=Query theme={null}
SELECT like('ClickHouse', '%SQL%');
```
```response title=Response theme={null}
┌─like('ClickHouse', '%SQL%')─┐
│ 0 │
└─────────────────────────────┘
```
## locate
Добавленный в: v18.16.0
То же, что и [`position`](#position), но аргументы `haystack` и `locate` поменяны местами.
**Поведение зависит от версии**
Поведение этой функции зависит от версии ClickHouse:
* в версиях \< v24.3 `locate` был псевдонимом функции `position` и принимал аргументы `(haystack, needle[, start_pos])`.
* в версиях >= 24.3 `locate` — отдельная функция (для лучшей совместимости с MySQL) и принимает аргументы `(needle, haystack[, start_pos])`.
Предыдущее поведение можно восстановить с помощью настройки `function_locate_has_mysql_compatible_argument_order = false`.
**Синтаксис**
```sql theme={null}
locate(needle, haystack[, start_pos])
```
**Аргументы**
* `needle` — Искомая подстрока. [`String`](/ru/reference/data-types/string)
* `haystack` — Строка, в которой выполняется поиск. [`String`](/ru/reference/data-types/string) или [`Enum`](/ru/reference/data-types/enum)
* `start_pos` — Необязательно. Позиция в `haystack` (с отсчётом от 1), с которой начинается поиск. [`UInt`](/ru/reference/data-types/int-uint)
**Возвращаемое значение**
Возвращает начальную позицию в байтах (с отсчётом от 1), если подстрока найдена, и `0`, если подстрока не найдена. [`UInt64`](/ru/reference/data-types/int-uint)
**Примеры**
**Базовое использование**
```sql title=Query theme={null}
SELECT locate('ca', 'abcabc')
```
```response title=Response theme={null}
┌─locate('ca', 'abcabc')─┐
│ 3 │
└────────────────────────┘
```
## match
Добавленный в: v1.1.0
Проверяет, соответствует ли указанная строка заданному шаблону регулярного выражения.
Эта функция использует библиотеку регулярных выражений RE2. Поддерживаемый синтаксис см. в [re2](https://github.com/google/re2/wiki/Syntax).
Сопоставление выполняется в предположении UTF-8; например, `¥` внутри занимает два байта, но при сопоставлении считается одной кодовой точкой.
Регулярное выражение не должно содержать null-байты.
Если haystack или шаблон регулярного выражения не являются корректным UTF-8, поведение не определено.
В отличие от поведения re2 по умолчанию, `.` соответствует символам перевода строки. Чтобы отключить это, добавьте в начало шаблона `(?-s)`.
Шаблон не привязан к началу и концу строки. Чтобы сопоставить строку целиком, явно добавьте якоря `^` и `$`.
Если вам нужно просто искать подстроки, вместо этой функции можно использовать [`like`](#like) или [`position`](#position) — они работают значительно быстрее.
Альтернативный синтаксис оператора: `haystack REGEXP pattern`.
**Синтаксис**
```sql theme={null}
match(haystack, pattern)
```
**Псевдонимы**: `REGEXP_MATCHES`
**Аргументы**
* `haystack` — Строка, в которой ищется шаблон. [`String`](/ru/reference/data-types/string)
* `pattern` — Шаблон регулярного выражения. [`const String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает `1`, если найдено совпадение с шаблоном, иначе — `0`. [`UInt8`](/ru/reference/data-types/int-uint)
**Примеры**
**Простое сопоставление с шаблоном**
```sql title=Query theme={null}
SELECT match('Hello World', 'Hello.*')
```
```response title=Response theme={null}
┌─match('Hello World', 'Hello.*')─┐
│ 1 │
└─────────────────────────────────┘
```
**Шаблон регулярного выражения не совпадает**
```sql title=Query theme={null}
SELECT match('Hello World', 'goodbye.*')
```
```response title=Response theme={null}
┌─match('Hello World', 'goodbye.*')─┐
│ 0 │
└───────────────────────────────────┘
```
**Поиск подстроки**
```sql title=Query theme={null}
SELECT match('abcde', 'b.*d'), match('abcde', '^b.*d$')
```
```response title=Response theme={null}
┌─match('abcde', 'b.*d')─┬─match('abcde', '^b.*d$')─┐
│ 1 │ 0 │
└─────────────────────────┴───────────────────────────┘
```
## multiFuzzyMatchAllIndices
Добавленный в: v20.1.0
Как [`multiFuzzyMatchAny`](#multiFuzzyMatchAny), но возвращает массив всех индексов в произвольном порядке, совпадающих со строкой haystack в пределах постоянного [расстояния редактирования](https://en.wikipedia.org/wiki/Edit_distance).
**Синтаксис**
```sql theme={null}
multiFuzzyMatchAllIndices(haystack, distance, [pattern1, pattern2, ..., patternN])
```
**Аргументы**
* `haystack` — Строка, в которой выполняется поиск. [`String`](/ru/reference/data-types/string)
* `distance` — Максимальное расстояние редактирования для нечеткого сопоставления. [`UInt8`](/ru/reference/data-types/int-uint)
* `pattern` — Массив шаблонов регулярного выражения для сопоставления. [`Array(String)`](/ru/reference/data-types/array)
**Возвращаемое значение**
Возвращает массив всех индексов (начиная с 1) шаблонов регулярного выражения, которые соответствуют строке `haystack` в пределах указанного расстояния редактирования, в любом порядке. Если совпадений нет, возвращается пустой массив. [`Array(UInt64)`](/ru/reference/data-types/array)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT multiFuzzyMatchAllIndices('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose', 'House']);
```
```response title=Response theme={null}
┌─multiFuzzyMa⋯, 'House'])─┐
│ [3,1,4,2] │
└──────────────────────────┘
```
## multiFuzzyMatchAny
Добавленный в: v20.1.0
Как [`multiMatchAny`](#multiMatchAny), но возвращает 1, если любой шаблон регулярного выражения совпадает со строкой в пределах фиксированного [расстояния редактирования](https://en.wikipedia.org/wiki/Edit_distance).
Эта функция использует экспериментальную возможность библиотеки [hyperscan](https://intel.github.io/hyperscan/dev-reference/compilation.html#approximate-matching) и в некоторых пограничных случаях может работать медленно.
Производительность зависит от значения расстояния редактирования и используемых шаблонов регулярного выражения, но по сравнению с вариантами без нечёткого сопоставления она всегда ниже.
Семейство функций `multiFuzzyMatch*()` не поддерживает регулярные выражения UTF-8 (они обрабатываются как последовательность байтов) из-за ограничений hyperscan.
**Синтаксис**
```sql theme={null}
multiFuzzyMatchAny(haystack, distance, [pattern1, pattern2, ..., patternN])
```
**Аргументы**
* `haystack` — Строка, в которой выполняется поиск. [`String`](/ru/reference/data-types/string)
* `distance` — Максимальное расстояние редактирования для нечеткого сопоставления. [`UInt8`](/ru/reference/data-types/int-uint)
* `pattern` — Необязательно. Массив шаблонов регулярного выражения для сопоставления. [`Array(String)`](/ru/reference/data-types/array)
**Возвращаемое значение**
Возвращает `1`, если хотя бы один шаблон регулярного выражения совпадает со строкой `haystack` в пределах указанного расстояния редактирования, в противном случае — `0`. [`UInt8`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT multiFuzzyMatchAny('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose']);
```
```response title=Response theme={null}
┌─multiFuzzyMa⋯lickHose'])─┐
│ 1 │
└──────────────────────────┘
```
## multiFuzzyMatchAnyIndex
Добавленный в: v20.1.0
Аналогично [`multiFuzzyMatchAny`](#multiFuzzyMatchAny), но возвращает любой индекс, для которого haystack совпадает в пределах постоянного [расстояния редактирования](https://en.wikipedia.org/wiki/Edit_distance).
**Синтаксис**
```sql theme={null}
multiFuzzyMatchAnyIndex(haystack, distance, [pattern1, pattern2, ..., patternn])
```
**Аргументы**
* `haystack` — Строка, по которой выполняется поиск. [`String`](/ru/reference/data-types/string)
* `distance` — Максимальное расстояние редактирования для нечеткого сопоставления. [`UInt8`](/ru/reference/data-types/int-uint)
* `pattern` — Массив шаблонов регулярного выражения для поиска совпадений. [`Array(String)`](/ru/reference/data-types/array)
**Возвращаемое значение**
Возвращает индекс (начиная с 1) любого шаблона регулярного выражения, который совпадает с `haystack` в пределах указанного расстояния редактирования; в противном случае — `0`. [`UInt64`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT multiFuzzyMatchAnyIndex('ClickHouse', 2, ['ClckHouse', 'ClickHose', 'ClickHouse']);
```
```response title=Response theme={null}
┌─multiFuzzyMa⋯ickHouse'])─┐
│ 2 │
└──────────────────────────┘
```
## multiMatchAllIndices
Добавленный в: v20.1.0
Как и [`multiMatchAny`](#multiMatchAny), но возвращает массив всех индексов, совпадающих с haystack, в любом порядке.
**Синтаксис**
```sql theme={null}
multiMatchAllIndices(haystack, [pattern1, pattern2, ..., patternn])
```
**Аргументы**
* `haystack` — Строка, в которой выполняется поиск. [`String`](/ru/reference/data-types/string)
* `pattern` — Шаблоны регулярного выражения, с которыми выполняется сопоставление. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Массив всех индексов (начиная с 1) шаблонов регулярного выражения, совпадающих с `haystack`, в произвольном порядке. Если совпадений не найдено, возвращается пустой массив. [`Array(UInt64)`](/ru/reference/data-types/array)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT multiMatchAllIndices('ClickHouse', ['[0-9]', 'House', 'Click', 'ouse']);
```
```response title=Response theme={null}
┌─multiMatchAl⋯', 'ouse'])─┐
│ [3, 2, 4] │
└──────────────────────────┘
```
## multiMatchAny
Добавленный в: v20.1.0
Проверяет, соответствует ли исходной строке хотя бы один из нескольких шаблонов регулярного выражения.
Если вам нужно искать в строке только несколько подстрок, вместо этого можно использовать функцию [`multiSearchAny`](#multiSearchAny) — она работает гораздо быстрее.
**Синтаксис**
```sql theme={null}
multiMatchAny(haystack, pattern1[, pattern2, ...])
```
**Аргументы**
* `haystack` — Строка, в которой выполняется поиск. [`String`](/ru/reference/data-types/string)
* `pattern1[, pattern2, ...]` — Массив из одного или нескольких шаблонов регулярных выражений. [`Array(String)`](/ru/reference/data-types/array)
**Возвращаемое значение**
Возвращает `1`, если найдено совпадение хотя бы с одним шаблоном, в противном случае — `0`. [`UInt8`](/ru/reference/data-types/int-uint)
**Примеры**
**Сопоставление с несколькими шаблонами**
```sql title=Query theme={null}
SELECT multiMatchAny('Hello World', ['Hello.*', 'foo.*'])
```
```response title=Response theme={null}
┌─multiMatchAny('Hello World', ['Hello.*', 'foo.*'])─┐
│ 1 │
└────────────────────────────────────────────────────┘
```
**Нет совпадений с шаблонами**
```sql title=Query theme={null}
SELECT multiMatchAny('Hello World', ['goodbye.*', 'foo.*'])
```
```response title=Response theme={null}
┌─multiMatchAny('Hello World', ['goodbye.*', 'foo.*'])─┐
│ 0 │
└──────────────────────────────────────────────────────┘
```
## multiMatchAnyIndex
Добавленный в: v20.1.0
Аналогична [`multiMatchAny`](#multiMatchAny), но возвращает любой индекс, совпадающий со строкой haystack.
**Синтаксис**
```sql theme={null}
multiMatchAnyIndex(haystack, [pattern1, pattern2, ..., patternn])
```
**Аргументы**
* `haystack` — Строка, в которой выполняется поиск. [`String`](/ru/reference/data-types/string)
* `pattern` — Регулярные выражения, с которыми выполняется сопоставление. [`Array(String)`](/ru/reference/data-types/array)
**Возвращаемое значение**
Возвращает индекс (начиная с 1) первого шаблона регулярного выражения, который совпал, или 0, если совпадений не найдено. [`UInt64`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT multiMatchAnyIndex('ClickHouse', ['[0-9]', 'House', 'Click']);
```
```response title=Response theme={null}
┌─multiMatchAn⋯, 'Click'])─┐
│ 3 │
└──────────────────────────┘
```
## multiSearchAllPositions
Добавленный в: v20.1.0
Аналогично [`position`](#position), но возвращает массив позиций (в байтах, начиная с 1) для нескольких подстрок `needle` в строке `haystack`.
Все функции `multiSearch*()` поддерживают не более 2^8 подстрок `needle`.
**Синтаксис**
```sql theme={null}
multiSearchAllPositions(haystack, needle1[, needle2, ...])
```
**Аргументы**
* `haystack` — Строка, в которой выполняется поиск. [`String`](/ru/reference/data-types/string)
* `needle1[, needle2, ...]` — Массив из одной или нескольких подстрок, которые нужно найти. [`Array(String)`](/ru/reference/data-types/array)
**Возвращаемое значение**
Возвращает массив начальных позиций в байтах с отсчётом от 1, если подстрока найдена, и `0`, если подстрока не найдена. [`Array(UInt64)`](/ru/reference/data-types/array)
**Примеры**
**Поиск по нескольким подстрокам**
```sql title=Query theme={null}
SELECT multiSearchAllPositions('Hello, World!', ['hello', '!', 'world'])
```
```response title=Response theme={null}
┌─multiSearchAllPositions('Hello, World!', ['hello', '!', 'world'])─┐
│ [0,13,0] │
└───────────────────────────────────────────────────────────────────┘
```
## multiSearchAllPositionsCaseInsensitive
Добавленный в: v20.1.0
Аналогично [`multiSearchAllPositions`](#multiSearchAllPositions), но игнорирует регистр.
**Синтаксис**
```sql theme={null}
multiSearchAllPositionsCaseInsensitive(haystack, needle1[, needle2, ...])
```
**Аргументы**
* `haystack` — Строка, в которой выполняется поиск. [`String`](/ru/reference/data-types/string)
* `needle1[, needle2, ...]` — Массив из одной или нескольких подстрок, которые нужно найти. [`Array(String)`](/ru/reference/data-types/array)
**Возвращаемое значение**
Возвращает массив начальных позиций в байтах, начиная с 1 (если подстрока найдена), и `0`, если подстрока не найдена. [`Array(UInt64)`](/ru/reference/data-types/array)
**Примеры**
**Регистронезависимый поиск нескольких подстрок**
```sql title=Query theme={null}
SELECT multiSearchAllPositionsCaseInsensitive('ClickHouse',['c','h'])
```
```response title=Response theme={null}
┌─multiSearchA⋯['c', 'h'])─┐
│ [1,6] │
└──────────────────────────┘
```
## multiSearchAllPositionsCaseInsensitiveUTF8
Добавленный в: v20.1.0
Как [`multiSearchAllPositionsUTF8`](#multiSearchAllPositionsUTF8), но позволяет игнорировать регистр.
**Синтаксис**
```sql theme={null}
multiSearchAllPositionsCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
```
**Аргументы**
* `haystack` — строка в кодировке UTF-8, в которой выполняется поиск. [`String`](/ru/reference/data-types/string)
* `needle` — подстроки в кодировке UTF-8, которые нужно найти. [`Array(String)`](/ru/reference/data-types/array)
**Возвращаемое значение**
Массив, содержащий начальные позиции в байтах, отсчитываемые от 1 (если подстрока найдена). Возвращает 0, если подстрока не найдена. [`Array`](/ru/reference/data-types/array)
**Примеры**
**Регистронезависимый поиск UTF-8**
```sql title=Query theme={null}
SELECT multiSearchAllPositionsCaseInsensitiveUTF8('Здравствуй, мир!', ['здравствуй', 'МИР']);
```
```response title=Response theme={null}
┌─multiSearchA⋯й', 'МИР'])─┐
│ [1, 13] │
└──────────────────────────┘
```
## multiSearchAllPositionsUTF8
Добавленный в: v20.1.0
Аналогично [`multiSearchAllPositions`](#multiSearchAllPositions), но предполагается, что `haystack` и подстроки `needle` являются строками в кодировке UTF-8.
**Синтаксис**
```sql theme={null}
multiSearchAllPositionsUTF8(haystack, needle1[, needle2, ...])
```
**Аргументы**
* `haystack` — строка в кодировке UTF-8, в которой выполняется поиск. [`String`](/ru/reference/data-types/string)
* `needle1[, needle2, ...]` — массив подстрок в кодировке UTF-8, которые нужно найти. [`Array(String)`](/ru/reference/data-types/array)
**Возвращаемое значение**
Возвращает массив начальных позиций в байтах, начиная с 1 (если подстрока найдена), или `0`, если подстрока не найдена. [`Array`](/ru/reference/data-types/array)
**Примеры**
**Множественный поиск UTF-8**
```sql title=Query theme={null}
SELECT multiSearchAllPositionsUTF8('ClickHouse',['C','H'])
```
```response title=Response theme={null}
┌─multiSearchAllPositionsUTF8('ClickHouse', ['C', 'H'])─┐
│ [1,6] │
└───────────────────────────────────────────────────────┘
```
## multiSearchAny
Добавленный в: v20.1.0
Проверяет, совпадает ли хотя бы одна из строк needle со строкой haystack.
Функции [`multiSearchAnyCaseInsensitive`](#multiSearchAnyCaseInsensitive), [`multiSearchAnyUTF8`](#multiSearchAnyUTF8) и [`multiSearchAnyCaseInsensitiveUTF8`](#multiSearchAnyCaseInsensitiveUTF8) предоставляют регистронезависимые варианты и/или варианты с поддержкой UTF-8 для этой функции.
**Синтаксис**
```sql theme={null}
multiSearchAny(haystack, needle1[, needle2, ...])
```
**Аргументы**
* `haystack` — Строка, в которой выполняется поиск. [`String`](/ru/reference/data-types/string)
* `needle1[, needle2, ...]` — Массив подстрок, которые нужно найти. [`Array(String)`](/ru/reference/data-types/array)
**Возвращаемое значение**
Возвращает `1`, если найдено хотя бы одно совпадение, иначе — `0`. [`UInt8`](/ru/reference/data-types/int-uint)
**Примеры**
**Поиск по любому совпадению**
```sql title=Query theme={null}
SELECT multiSearchAny('ClickHouse',['C','H'])
```
```response title=Response theme={null}
┌─multiSearchAny('ClickHouse', ['C', 'H'])─┐
│ 1 │
└──────────────────────────────────────────┘
```
## multiSearchAnyCaseInsensitive
Добавленный в: v20.1.0
Как [multiSearchAny](#multiSearchAny), но позволяет игнорировать регистр символов.
**Синтаксис**
```sql theme={null}
multiSearchAnyCaseInsensitive(haystack, [needle1, needle2, ..., needleN])
```
**Аргументы**
* `haystack` — Строка, в которой выполняется поиск. [`String`](/ru/reference/data-types/string)
* `needle` — Подстроки, которые требуется найти. [`Array(String)`](/ru/reference/data-types/array)
**Возвращаемое значение**
Возвращает `1`, если найдено хотя бы одно регистронезависимое совпадение, иначе — `0`. [`UInt8`](/ru/reference/data-types/int-uint)
**Примеры**
**Регистронезависимый поиск**
```sql title=Query theme={null}
SELECT multiSearchAnyCaseInsensitive('ClickHouse',['c','h'])
```
```response title=Response theme={null}
┌─multiSearchAnyCaseInsensitive('ClickHouse', ['c', 'h'])─┐
│ 1 │
└─────────────────────────────────────────────────────────┘
```
## multiSearchAnyCaseInsensitiveUTF8
Добавленный в: v20.1.0
То же, что и [multiSearchAnyUTF8](#multiSearchAnyUTF8), но игнорирует регистр.
**Синтаксис**
```sql theme={null}
multiSearchAnyCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
```
**Аргументы**
* `haystack` — UTF-8-строка, в которой выполняется поиск. [`String`](/ru/reference/data-types/string)
* `needle` — UTF-8-подстроки, которые нужно найти. [`Array(String)`](/ru/reference/data-types/array)
**Возвращаемое значение**
Возвращает `1`, если найдено хотя бы одно регистронезависимое совпадение, в противном случае — `0`. [`UInt8`](/ru/reference/data-types/int-uint)
**Примеры**
**Для UTF-8-строки 'Здравствуйте' проверьте, присутствует ли символ 'з' (в нижнем регистре)**
```sql title=Query theme={null}
SELECT multiSearchAnyCaseInsensitiveUTF8('Здравствуйте',['з'])
```
```response title=Response theme={null}
┌─multiSearchA⋯те', ['з'])─┐
│ 1 │
└──────────────────────────┘
```
## multiSearchAnyUTF8
Добавленный в: v20.1.0
Как и [multiSearchAny](#multiSearchAny), но предполагает, что `haystack` является UTF-8-строкой, а подстроки `needle` — UTF-8-подстроками.
**Синтаксис**
```sql theme={null}
multiSearchAnyUTF8(haystack, [needle1, needle2, ..., needleN])
```
**Аргументы**
* `haystack` — UTF-8-строка, в которой выполняется поиск. [`String`](/ru/reference/data-types/string)
* `needle` — UTF-8-подстроки, которые требуется найти. [`Array(String)`](/ru/reference/data-types/array)
**Возвращаемое значение**
Возвращает `1`, если найдено хотя бы одно совпадение, в противном случае — `0`. [`UInt8`](/ru/reference/data-types/int-uint)
**Примеры**
**Для UTF-8-строки '你好，世界' ('Hello, world') проверьте, содержит ли строка символы 你 или 界**
```sql title=Query theme={null}
SELECT multiSearchAnyUTF8('你好，世界', ['你', '界'])
```
```response title=Response theme={null}
┌─multiSearchA⋯你', '界'])─┐
│ 1 │
└──────────────────────────┘
```
## multiSearchFirstIndex
Добавленный в: v20.1.0
Выполняет поиск нескольких строк `needle` в строке `haystack` (с учетом регистра) и возвращает индекс первой найденной строки `needle`, начиная с 1.
**Синтаксис**
```sql theme={null}
multiSearchFirstIndex(haystack, [needle1, needle2, ..., needleN])
```
**Аргументы**
* `haystack` — Строка, в которой выполняется поиск. [`String`](/ru/reference/data-types/string)
* `needles` — Массив строк, которые нужно найти. [`Array(String)`](/ru/reference/data-types/array)
**Возвращаемое значение**
Возвращает индекс первой строки из `needles`, найденной в `haystack` (позиция в массиве `needles`, начиная с 1). Возвращает 0, если ни одна из строк из `needles` не найдена. Поиск чувствителен к регистру. [`UInt64`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT multiSearchFirstIndex('ClickHouse Database', ['Click', 'Database', 'Server']);
```
```response title=Response theme={null}
┌─multiSearchF⋯ 'Server'])─┐
│ 1 │
└──────────────────────────┘
```
**Поведение с учетом регистра**
```sql title=Query theme={null}
SELECT multiSearchFirstIndex('ClickHouse Database', ['CLICK', 'Database', 'Server']);
```
```response title=Response theme={null}
┌─multiSearchF⋯ 'Server'])─┐
│ 2 │
└──────────────────────────┘
```
**Совпадений не найдено**
```sql title=Query theme={null}
SELECT multiSearchFirstIndex('Hello World', ['goodbye', 'test']);
```
```response title=Response theme={null}
┌─multiSearchF⋯', 'test'])─┐
│ 0 │
└──────────────────────────┘
```
## multiSearchFirstIndexCaseInsensitive
Добавленный в: v20.1.0
Возвращает индекс `i` (начиная с 1) самого левого вхождения `needle_i` в строке `haystack`; если совпадение не найдено, возвращает 0.
Игнорирует регистр.
**Синтаксис**
```sql theme={null}
multiSearchFirstIndexCaseInsensitive(haystack, [needle1, needle2, ..., needleN]
```
**Аргументы**
* `haystack` — Строка, в которой выполняется поиск. [`String`](/ru/reference/data-types/string)
* `needle` — Подстроки, которые нужно найти. [`Array(String)`](/ru/reference/data-types/array)
**Возвращаемое значение**
Возвращает индекс (начиная с 1) самого левого найденного `needle`. Если совпадений нет, возвращает `0`. [`UInt8`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT multiSearchFirstIndexCaseInsensitive('hElLo WoRlD', ['World', 'Hello']);
```
```response title=Response theme={null}
┌─multiSearchF⋯, 'Hello'])─┐
│ 1 │
└──────────────────────────┘
```
## multiSearchFirstIndexCaseInsensitiveUTF8
Добавленный в: v20.1.0
Ищет несколько строк-образцов в исходной строке регистронезависимым способом с поддержкой кодировки UTF-8 и возвращает индекс первого найденного образца, начиная с 1.
**Синтаксис**
```sql theme={null}
multiSearchFirstIndexCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
```
**Аргументы**
* `haystack` — Строка, в которой выполняется поиск. [`String`](/ru/reference/data-types/string)
* `needles` — Массив строк, которые нужно найти. [`Array(String)`](/ru/reference/data-types/array)
**Возвращаемое значение**
Возвращает 1-индексированный индекс (позицию в массиве `needles`) первой строки из `needles`, найденной в `haystack`. Возвращает 0, если не найдено ни одной строки. Поиск регистронезависим и выполняется с учетом кодировки UTF-8. [`UInt64`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT multiSearchFirstIndexCaseInsensitiveUTF8('ClickHouse Database', ['CLICK', 'data', 'server']);
```
```response title=Response theme={null}
┌─multiSearchF⋯ 'server'])─┐
│ 1 │
└──────────────────────────┘
```
**Работа с регистром UTF-8**
```sql title=Query theme={null}
SELECT multiSearchFirstIndexCaseInsensitiveUTF8('Привет Мир', ['мир', 'ПРИВЕТ']);
```
```response title=Response theme={null}
┌─multiSearchF⋯ 'ПРИВЕТ'])─┐
│ 1 │
└──────────────────────────┘
```
**Совпадений не найдено**
```sql title=Query theme={null}
SELECT multiSearchFirstIndexCaseInsensitiveUTF8('Hello World', ['goodbye', 'test']);
```
```response title=Response theme={null}
┌─multiSearchF⋯', 'test'])─┐
│ 0 │
└──────────────────────────┘
```
## multiSearchFirstIndexUTF8
Добавленный в: v20.1.0
Возвращает индекс `i` (начиная с 1) самого левого найденного `needle_i` в строке `haystack`; в противном случае возвращает 0.
Предполагается, что `haystack` и `needle` — UTF-8-строки.
**Синтаксис**
```sql theme={null}
multiSearchFirstIndexUTF8(haystack, [needle1, needle2, ..., needleN])
```
**Аргументы**
* `haystack` — UTF-8-строка, в которой выполняется поиск. [`String`](/ru/reference/data-types/string)
* `needle` — массив UTF-8-подстрок, которые нужно найти. [`Array(String)`](/ru/reference/data-types/array)
**Возвращаемое значение**
Возвращает индекс (начиная с 1) крайнего левого найденного `needle`. Если совпадений нет, возвращает 0. [`UInt8`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT multiSearchFirstIndexUTF8('Здравствуйте мир', ['мир', 'здравствуйте']);
```
```response title=Response theme={null}
┌─multiSearchF⋯вствуйте'])─┐
│ 1 │
└──────────────────────────┘
```
## multiSearchFirstPosition
Добавленный в: v20.1.0
Как [`position`](#position), но возвращает смещение самого первого вхождения в строке `haystack`, соответствующего любой из нескольких строк `needle`.
Функции [`multiSearchFirstPositionCaseInsensitive`](#multiSearchFirstPositionCaseInsensitive), [`multiSearchFirstPositionUTF8`](#multiSearchFirstPositionUTF8) и [`multiSearchFirstPositionCaseInsensitiveUTF8`](#multiSearchFirstPositionCaseInsensitiveUTF8) предоставляют регистронезависимый и/или UTF-8 варианты этой функции.
**Синтаксис**
```sql theme={null}
multiSearchFirstPosition(haystack, needle1[, needle2, ...])
```
**Аргументы**
* `haystack` — Строка, в которой выполняется поиск. [`String`](/ru/reference/data-types/string)
* `needle1[, needle2, ...]` — Массив из одной или нескольких подстрок, которые нужно найти. [`Array(String)`](/ru/reference/data-types/array)
**Возвращаемое значение**
Возвращает смещение самого левого совпадения в строке `haystack` с любой из подстрок `needle`, либо `0`, если совпадений нет. [`UInt64`](/ru/reference/data-types/int-uint)
**Примеры**
**Поиск первой позиции**
```sql title=Query theme={null}
SELECT multiSearchFirstPosition('Hello World',['llo', 'Wor', 'ld'])
```
```response title=Response theme={null}
┌─multiSearchFirstPosition('Hello World', ['llo', 'Wor', 'ld'])─┐
│ 3 │
└───────────────────────────────────────────────────────────────┘
```
## multiSearchFirstPositionCaseInsensitive
Добавленный в: v20.1.0
Аналогично [multiSearchFirstPosition](#multiSearchFirstPosition), но игнорирует регистр.
**Синтаксис**
```sql theme={null}
multiSearchFirstPositionCaseInsensitive(haystack, [needle1, needle2, ..., needleN])
```
**Аргументы**
* `haystack` — Строка, в которой выполняется поиск. [`String`](/ru/reference/data-types/string)
* `needle` — Массив подстрок, которые требуется найти. [`Array(String)`](/ru/reference/data-types/array)
**Возвращаемое значение**
Возвращает смещение первого вхождения в строке `haystack`, совпадающего с любой из строк `needle`. Возвращает `0`, если совпадений нет. [`UInt64`](/ru/reference/data-types/int-uint)
**Примеры**
**Первая позиция при регистронезависимом поиске**
```sql title=Query theme={null}
SELECT multiSearchFirstPositionCaseInsensitive('HELLO WORLD',['wor', 'ld', 'ello'])
```
```response title=Response theme={null}
┌─multiSearchFirstPositionCaseInsensitive('HELLO WORLD', ['wor', 'ld', 'ello'])─┐
│ 2 │
└───────────────────────────────────────────────────────────────────────────────┘
```
## multiSearchFirstPositionCaseInsensitiveUTF8
Добавленный в: v20.1.0
Аналогично [multiSearchFirstPosition](#multiSearchFirstPosition), но предполагается, что `haystack` и `needle` — строки UTF-8, при этом регистр игнорируется.
**Синтаксис**
```sql theme={null}
multiSearchFirstPositionCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
```
**Аргументы**
* `haystack` — UTF-8-строка, в которой выполняется поиск. [`String`](/ru/reference/data-types/string)
* `needle` — массив UTF-8-подстрок для поиска. [`Array(String)`](/ru/reference/data-types/array)
**Возвращаемое значение**
Возвращает смещение самого левого вхождения в строке `haystack`, соответствующего любой из строк `needle`, без учета регистра. Возвращает `0`, если совпадений нет. [`UInt64`](/ru/reference/data-types/int-uint)
**Примеры**
**Найдите смещение самого левого вхождения в UTF-8-строке 'Здравствуй, мир' ('Hello, world'), соответствующего любой из заданных подстрок**
```sql title=Query theme={null}
SELECT multiSearchFirstPositionCaseInsensitiveUTF8('Здравствуй, мир', ['МИР', 'вст', 'Здра'])
```
```response title=Response theme={null}
┌─multiSearchFirstPositionCaseInsensitiveUTF8('Здравствуй, мир', ['мир', 'вст', 'Здра'])─┐
│ 3 │
└────────────────────────────────────────────────────────────────────────────────────────┘
```
## multiSearchFirstPositionUTF8
Добавленный в: v20.1.0
Аналогично [multiSearchFirstPosition](#multiSearchFirstPosition), но предполагается, что `haystack` и `needle` — строки в кодировке UTF-8.
**Синтаксис**
```sql theme={null}
multiSearchFirstPositionUTF8(haystack, [needle1, needle2, ..., needleN])
```
**Аргументы**
* `haystack` — строка UTF-8, в которой выполняется поиск. [`String`](/ru/reference/data-types/string)
* `needle` — массив UTF-8-подстрок, которые нужно найти. [`Array(String)`](/ru/reference/data-types/array)
**Возвращаемое значение**
Смещение самого левого вхождения в строке `haystack`, совпадающего с любой из строк `needle`. Возвращает `0`, если совпадений нет. [`UInt64`](/ru/reference/data-types/int-uint)
**Примеры**
**Найдите смещение самого левого вхождения в строке UTF-8 'Здравствуй, мир' ('Hello, world'), совпадающего с любой из заданных строк `needle`**
```sql title=Query theme={null}
SELECT multiSearchFirstPositionUTF8('Здравствуй, мир',['мир', 'вст', 'авст'])
```
```response title=Response theme={null}
┌─multiSearchFirstPositionUTF8('Здравствуй, мир', ['мир', 'вст', 'авст'])─┐
│ 3 │
└─────────────────────────────────────────────────────────────────────────┘
```
## ngramDistance
Добавленный в: v20.1.0
Вычисляет 4-граммное расстояние между двумя строками.
Для этого вычисляется симметрическая разность двух мультимножеств 4-грамм и нормализуется по сумме их мощностей.
Чем меньше возвращаемое значение, тем более похожи строки.
Для регистронезависимого поиска и/или в формате UTF8 используйте функции [`ngramDistanceCaseInsensitive`](#ngramDistanceCaseInsensitive), [`ngramDistanceUTF8`](#ngramDistanceUTF8), [`ngramDistanceCaseInsensitiveUTF8`](#ngramDistanceCaseInsensitiveUTF8).
**Синтаксис**
```sql theme={null}
ngramDistance(haystack, needle)
```
**Аргументы**
* `haystack` — строка для сравнения. [`String`](/ru/reference/data-types/string)
* `needle` — строка для сравнения. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает число типа Float32 в диапазоне от `0` до `1`. Чем меньше возвращаемое значение, тем более похожи строки. [`Float32`](/ru/reference/data-types/float)
**Примеры**
**Вычисление 4-граммного расстояния**
```sql title=Query theme={null}
SELECT ngramDistance('ClickHouse', 'ClickHouses')
```
```response title=Response theme={null}
┌─ngramDistance('ClickHouse', 'ClickHouses')─┐
│ 0.1 │
└────────────────────────────────────────────┘
```
## ngramDistanceCaseInsensitive
Добавленный в: v20.1.0
Предоставляет регистронезависимый вариант [`ngramDistance`](#ngramDistance).
Вычисляет 4-граммное расстояние между двумя строками без учета регистра.
Чем меньше возвращаемое значение, тем больше строки похожи друг на друга.
**Синтаксис**
```sql theme={null}
ngramDistanceCaseInsensitive(haystack, needle)
```
**Аргументы**
* `haystack` — Первая строка для сравнения. [`String`](/ru/reference/data-types/string)
* `needle` — Вторая строка для сравнения. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает значение типа Float32 в диапазоне от `0` до `1`. [`Float32`](/ru/reference/data-types/float)
**Примеры**
**Регистронезависимое 4-граммное расстояние**
```sql title=Query theme={null}
SELECT ngramDistanceCaseInsensitive('ClickHouse','clickhouse')
```
```response title=Response theme={null}
┌─ngramDistanceCaseInsensitive('ClickHouse','clickhouse')─┐
│ 0 │
└─────────────────────────────────────────────────────────┘
```
## ngramDistanceCaseInsensitiveUTF8
Добавленный в: v20.1.0
Предоставляет регистронезависимый UTF-8-вариант [`ngramDistance`](#ngramDistance).
Предполагается, что строки `needle` и `haystack` закодированы в UTF-8, при этом регистр игнорируется.
Вычисляет 3-граммное расстояние между двумя UTF-8-строками без учета регистра.
Чем меньше возвращаемое значение, тем больше сходство между строками.
**Синтаксис**
```sql theme={null}
ngramDistanceCaseInsensitiveUTF8(haystack, needle)
```
**Аргументы**
* `haystack` — Первая строка для сравнения в кодировке UTF-8. [`String`](/ru/reference/data-types/string)
* `needle` — Вторая строка для сравнения в кодировке UTF-8. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает число типа Float32 в диапазоне от `0` до `1`. [`Float32`](/ru/reference/data-types/float)
**Примеры**
**Регистронезависимое 3-граммное расстояние UTF-8**
```sql title=Query theme={null}
SELECT ngramDistanceCaseInsensitiveUTF8('abcde','CDE')
```
```response title=Response theme={null}
┌─ngramDistanceCaseInsensitiveUTF8('abcde','CDE')─┐
│ 0.5 │
└─────────────────────────────────────────────────┘
```
## ngramDistanceUTF8
Добавленный в: v20.1.0
Предоставляет вариант [`ngramDistance`](#ngramDistance) для строк UTF-8.
Предполагается, что строки `needle` и `haystack` закодированы в UTF-8.
Вычисляет 3-граммное расстояние между двумя строками UTF-8.
Чем меньше возвращаемое значение, тем больше похожи строки.
**Синтаксис**
```sql theme={null}
ngramDistanceUTF8(haystack, needle)
```
**Аргументы**
* `haystack` — Первая строка для сравнения в кодировке UTF-8. [`String`](/ru/reference/data-types/string)
* `needle` — Вторая строка для сравнения в кодировке UTF-8. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает число типа Float32 в диапазоне от `0` до `1`. [`Float32`](/ru/reference/data-types/float)
**Примеры**
**3-граммное расстояние в UTF-8**
```sql title=Query theme={null}
SELECT ngramDistanceUTF8('abcde','cde')
```
```response title=Response theme={null}
┌─ngramDistanceUTF8('abcde','cde')─┐
│ 0.5 │
└───────────────────────────────────┘
```
## ngramSearch
Добавленный в: v20.1.0
Проверяет, меньше или равно ли 4-граммное расстояние между двумя строками заданному пороговому значению.
Для регистронезависимого поиска и/или в формате UTF8 используйте функции `ngramSearchCaseInsensitive`, `ngramSearchUTF8`, `ngramSearchCaseInsensitiveUTF8`.
**Синтаксис**
```sql theme={null}
ngramSearch(haystack, needle)
```
**Аргументы**
* `haystack` — строка для сравнения. [`String`](/ru/reference/data-types/string)
* `needle` — строка для сравнения. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает `1`, если 4-граммное расстояние между строками меньше или равно порогу (`1.0` по умолчанию), в противном случае — `0`. [`UInt8`](/ru/reference/data-types/int-uint)
**Примеры**
**Поиск с использованием 4-грамм**
```sql title=Query theme={null}
SELECT ngramSearch('ClickHouse', 'Click')
```
```response title=Response theme={null}
┌─ngramSearch('ClickHouse', 'Click')─┐
│ 1 │
└────────────────────────────────────┘
```
## ngramSearchCaseInsensitive
Добавленный в: v20.1.0
Представляет собой регистронезависимый вариант [`ngramSearch`](#ngramSearch).
Вычисляет несимметрическую разность между строкой needle и строкой haystack, то есть число n-грамм в needle минус число общих n-грамм, нормализованное по числу n-грамм в needle.
Проверяет, что 4-граммное расстояние между двумя строками меньше или равно заданному порогу без учета регистра.
**Синтаксис**
```sql theme={null}
ngramSearchCaseInsensitive(haystack, needle)
```
**Аргументы**
* `haystack` — строка для сравнения. [`String`](/ru/reference/data-types/string)
* `needle` — строка для сравнения. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает `1`, если 4-граммное расстояние между строками меньше или равно пороговому значению (`1.0` по умолчанию), иначе — `0`. [`UInt8`](/ru/reference/data-types/int-uint)
**Примеры**
**Регистронезависимый поиск с помощью 4-грамм**
```sql title=Query theme={null}
SELECT ngramSearchCaseInsensitive('Hello World','hello')
```
```response title=Response theme={null}
┌─ngramSearchCaseInsensitive('Hello World','hello')─┐
│ 1 │
└────────────────────────────────────────────────────┘
```
## ngramSearchCaseInsensitiveUTF8
Добавленный в: v20.1.0
Предоставляет регистронезависимую UTF-8-версию [`ngramSearch`](#ngramSearch).
Предполагает, что `haystack` и `needle` являются строками UTF-8, и игнорирует регистр.
Проверяет, что 3-граммное расстояние между двумя строками UTF-8 меньше или равно заданному порогу без учёта регистра.
**Синтаксис**
```sql theme={null}
ngramSearchCaseInsensitiveUTF8(haystack, needle)
```
**Аргументы**
* `haystack` — UTF-8-строка для сравнения. [`String`](/ru/reference/data-types/string)
* `needle` — UTF-8-строка для сравнения. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает `1`, если 3-граммное расстояние между строками меньше или равно пороговому значению (по умолчанию `1.0`), в противном случае — `0`. [`UInt8`](/ru/reference/data-types/int-uint)
**Примеры**
**Регистронезависимый поиск UTF-8 с использованием 3-грамм**
```sql title=Query theme={null}
SELECT ngramSearchCaseInsensitiveUTF8('абвГДЕёжз', 'АбвгдЕЁжз')
```
```response title=Response theme={null}
┌─ngramSearchCaseInsensitiveUTF8('абвГДЕёжз', 'АбвгдЕЁжз')─┐
│ 1 │
└──────────────────────────────────────────────────────────┘
```
## ngramSearchUTF8
Добавленный в: v20.1.0
Предоставляет вариант функции `ngramSearch` для UTF-8.
Предполагается, что `haystack` и `needle` — строки UTF-8.
Проверяет, что 3-граммное расстояние между двумя строками UTF-8 меньше или равно заданному порогу.
**Синтаксис**
```sql theme={null}
ngramSearchUTF8(haystack, needle)
```
**Аргументы**
* `haystack` — UTF-8-строка для сравнения. [`String`](/ru/reference/data-types/string)
* `needle` — UTF-8-строка для сравнения. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает `1`, если 3-граммное расстояние между строками меньше или равно пороговому значению (по умолчанию `1.0`), иначе — `0`. [`UInt8`](/ru/reference/data-types/int-uint)
**Примеры**
**Поиск по UTF-8 с использованием 3-грамм**
```sql title=Query theme={null}
SELECT ngramSearchUTF8('абвгдеёжз', 'гдеёзд')
```
```response title=Response theme={null}
┌─ngramSearchUTF8('абвгдеёжз', 'гдеёзд')─┐
│ 1 │
└────────────────────────────────────────┘
```
## notILike
Добавленный в: v20.6.0
Проверяет, что строка не соответствует шаблону без учёта регистра. Шаблон может содержать специальные символы `%` и `_` для сопоставления по SQL LIKE.
**Синтаксис**
```sql theme={null}
notILike(haystack, pattern)
```
**Аргументы**
* `haystack` — Входная строка, в которой выполняется поиск. [`String`](/ru/reference/data-types/string) или [`FixedString`](/ru/reference/data-types/fixedstring)
* `pattern` — Шаблон SQL LIKE для сопоставления. `%` соответствует любому количеству символов (включая ноль), `_` — ровно одному символу. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает `1`, если строка не соответствует шаблону при регистронезависимом сравнении, в противном случае — `0`. [`UInt8`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT notILike('ClickHouse', '%house%');
```
```response title=Response theme={null}
┌─notILike('Cl⋯ '%house%')─┐
│ 0 │
└──────────────────────────┘
```
## notLike
Добавленный в: v1.1.0
Аналогична [`like`](#like), но с отрицанием результата.
**Синтаксис**
```sql theme={null}
notLike(haystack, pattern)
-- haystack NOT LIKE pattern
```
**Аргументы**
* `haystack` — Строка, в которой выполняется поиск. [`String`](/ru/reference/data-types/string) или [`FixedString`](/ru/reference/data-types/fixedstring)
* `pattern` — Шаблон `LIKE` для сопоставления. [`String`](/ru/reference/data-types/string)
**Возвращаемое значение**
Возвращает `1`, если строка не соответствует шаблону `LIKE`, иначе — `0`. [`UInt8`](/ru/reference/data-types/int-uint)
**Примеры**
**Пример использования**
```sql title=Query theme={null}
SELECT notLike('ClickHouse', '%House%');
```
```response title=Response theme={null}
┌─notLike('Cli⋯ '%House%')─┐
│ 0 │
└──────────────────────────┘
```
**Несовпадающий шаблон регулярного выражения**
```sql title=Query theme={null}
SELECT notLike('ClickHouse', '%SQL%');
```
```response title=Response theme={null}
┌─notLike('Cli⋯', '%SQL%')─┐
│ 1 │
└──────────────────────────┘
```
## position
Добавленный в: v1.1.0
Возвращает позицию (в байтах, начиная с 1) подстроки `needle` в строке `haystack`.
Если подстрока `needle` пустая, действуют следующие правила:
* если `start_pos` не указан: вернуть `1`
* если `start_pos = 0`: вернуть `1`
* если `start_pos >= 1` и `start_pos <= length(haystack) + 1`: вернуть `start_pos`
* в противном случае: вернуть `0`
Эти же правила применяются и к функциям [`locate`](#locate), [`positionCaseInsensitive`](#positionCaseInsensitive), [`positionUTF8`](#positionUTF8) и [`positionCaseInsensitiveUTF8`](#positionCaseInsensitiveUTF8).
**Синтаксис**
```sql theme={null}
position(haystack, needle[, start_pos])
```
**Аргументы**
* `haystack` — Строка, в которой выполняется поиск. [`String`](/ru/reference/data-types/string) или [`Enum`](/ru/reference/data-types/enum)
* `needle` — Искомая подстрока. [`String`](/ru/reference/data-types/string)
* `start_pos` — Позиция в `haystack` (нумерация с 1), с которой начинается поиск. Необязательный параметр. [`UInt`](/ru/reference/data-types/int-uint)
**Возвращаемое значение**
Возвращает начальную позицию в байтах, считая от 1, если подстрока найдена; в противном случае — `0`. [`UInt64`](/ru/reference/data-types/int-uint)
**Примеры**
**Базовое использование**
```sql title=Query theme={null}
SELECT position('Hello, world!', '!')
```
```response title=Response theme={null}
┌─position('Hello, world!', '!')─┐
│ 13 │
└────────────────────────────────┘
```
**С аргументом start\_pos**
```sql title=Query theme={null}
SELECT position('Hello, world!', 'o', 1), position('Hello, world!', 'o', 7)
```
```response title=Response theme={null}
┌─position('Hello, world!', 'o', 1)─┬─position('Hello, world!', 'o', 7)─┐
│ 5 │ 9 │
└───────────────────────────────────┴───────────────────────────────────┘
```
**Синтаксис needle IN haystack**
```sql title=Query theme={null}
SELECT 6 = position('/' IN s) FROM (SELECT 'Hello/World' AS s)
```
```response title=Response theme={null}
┌─equals(6, position(s, '/'))─┐
│ 1 │
└─────────────────────────────┘
```
**Пустая искомая подстрока**
```sql title=Query theme={null}
SELECT position('abc', ''), position('abc', '', 0), position('abc', '', 1), position('abc', '', 2), position('abc', '', 3), position('abc', '', 4), position('abc', '', 5)
```
```response title=Response theme={null}
┌─position('abc', '')─┬─position('abc', '', 0)─┬─position('abc', '', 1)─┬─position('abc', '', 2)─┬─position('abc', '', 3)─┬─position('abc', '', 4)─┬─position('abc', '', 5)─┐
│ 1 │ 1 │ 1 │ 2 │ 3 │ 4 │ 0 │
└─────────────────────┴────────────────────────┴────────────────────────┴────────────────────────┴────────────────────────┴────────────────────────┴────────────────────────┘
```
## positionCaseInsensitive
Добавленный в: v1.1.0
Аналог [`position`](#position), но регистронезависимый.
**Синтаксис**
```sql theme={null}
positionCaseInsensitive(haystack, needle[, start_pos])
```
**Псевдонимы**: `instr`
**Аргументы**
* `haystack` — Строка, в которой выполняется поиск. [`String`](/ru/reference/data-types/string) или [`Enum`](/ru/reference/data-types/enum)
* `needle` — Подстрока, которую нужно найти. [`String`](/ru/reference/data-types/string)
* `start_pos` — Необязательно. Позиция (нумерация начинается с 1) в `haystack`, с которой начинается поиск. [`UInt*`](/ru/reference/data-types/int-uint)
**Возвращаемое значение**
Возвращает начальную позицию в байтах с отсчётом от 1, если подстрока найдена; в противном случае — `0`. [`UInt64`](/ru/reference/data-types/int-uint)
**Примеры**
**Регистронезависимый поиск**
```sql title=Query theme={null}
SELECT positionCaseInsensitive('Hello, world!', 'hello')
```
```response title=Response theme={null}
┌─positionCaseInsensitive('Hello, world!', 'hello')─┐
│ 1 │
└───────────────────────────────────────────────────┘
```
## positionCaseInsensitiveUTF8
Добавленный в: v1.1.0
Как [`positionUTF8`](#positionUTF8), но выполняет поиск без учета регистра.
**Синтаксис**
```sql theme={null}
positionCaseInsensitiveUTF8(haystack, needle[, start_pos])
```
**Аргументы**
* `haystack` — Строка, в которой выполняется поиск. [`String`](/ru/reference/data-types/string) или [`Enum`](/ru/reference/data-types/enum)
* `needle` — Искомая подстрока. [`String`](/ru/reference/data-types/string)
* `start_pos` — Необязательно. Позиция (отсчёт с 1) в `haystack`, с которой начинается поиск. [`UInt*`](/ru/reference/data-types/int-uint)
**Возвращаемое значение**
Возвращает начальную позицию в байтах с отсчётом от 1, если подстрока найдена; в противном случае возвращает `0`. [`UInt64`](/ru/reference/data-types/int-uint)
**Примеры**
**Регистронезависимый поиск UTF-8**
```sql title=Query theme={null}
SELECT positionCaseInsensitiveUTF8('Привет мир', 'МИР')
```
```response title=Response theme={null}
┌─positionCaseInsensitiveUTF8('Привет мир', 'МИР')─┐
│ 8 │
└──────────────────────────────────────────────────┘
```
## positionUTF8
Добавленный в: v1.1.0
Аналогично [`position`](#position), но предполагает, что `haystack` и `needle` — строки в кодировке UTF-8.
**Синтаксис**
```sql theme={null}
positionUTF8(haystack, needle[, start_pos])
```
**Аргументы**
* `haystack` — Строка, в которой выполняется поиск. [`String`](/ru/reference/data-types/string) или [`Enum`](/ru/reference/data-types/enum)
* `needle` — Искомая подстрока. [`String`](/ru/reference/data-types/string)
* `start_pos` — Необязательно. Позиция в `haystack` (нумерация с 1), с которой начинается поиск. [`UInt*`](/ru/reference/data-types/int-uint)
**Возвращаемое значение**
Возвращает начальную позицию в байтах с отсчётом от 1, если подстрока найдена, иначе — `0`. [`UInt64`](/ru/reference/data-types/int-uint)
**Примеры**
**Подсчёт символов UTF-8**
```sql title=Query theme={null}
SELECT positionUTF8('Motörhead', 'r')
```
```response title=Response theme={null}
┌─position('Motörhead', 'r')─┐
│ 5 │
└────────────────────────────┘
```