Функции для поиска в строках

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

примечание

Регистронезависимый поиск следует правилам нижнего и верхнего регистра английского языка. Например, верхний регистр i в английском языке это I, в то время как в турецком языке это İ — результаты для языков, отличных от английского, могут быть непредсказуемыми.

Функции в этом разделе также предполагают, что искомая строка (в этом разделе обозначаемая как haystack) и строка поиска (в этом разделе обозначаемая как needle) являются текстом с кодировкой в один байт. Если это предположение нарушается, исключение не генерируется, а результаты будут неопределёнными. Поиск с использованием строк, закодированных в UTF-8, обычно предоставляется отдельными вариантами функций. Аналогично, если используется вариант функции UTF-8 и входные строки не являются текстом в кодировке UTF-8, исключение не генерируется и результаты также неопределённые. Обратите внимание, что автоматическая нормализация Unicode не выполняется, однако вы можете использовать функции normalizeUTF8*() для этого.

Общие функции строк и функции для замены в строках описаны отдельно.

position

Возвращает позицию (в байтах, начиная с 1) подстроки needle в строке haystack.

Синтаксис

position(haystack, needle[, start_pos])

Псевдоним:

position(needle IN haystack)

Аргументы

haystack — Строка, в которой выполняется поиск. String или Enum.
needle — Искомая подстрока. String.
start_pos – Позиция (начиная с 1) в haystack, с которой начинается поиск. UInt. Необязательный.

Возвращаемое значение

Начальная позиция в байтах и счёт с 1, если подстрока была найдена. UInt64.
0, если подстрока не найдена. UInt64.

Если подстрока needle пустая, действуют следующие правила:

если start_pos не был указан: вернуть 1
если start_pos = 0: вернуть 1
если start_pos >= 1 и start_pos <= length(haystack) + 1: вернуть start_pos
в противном случае: вернуть 0

Те же правила также применимы к функциям locate, positionCaseInsensitive, positionUTF8 и positionCaseInsensitiveUTF8.

Примеры

Запрос:

SELECT position('Hello, world!', '!');

Результат:

┌─position('Hello, world!', '!')─┐
│                             13 │
└────────────────────────────────┘

Пример с аргументом start_pos:

Запрос:

SELECT
    position('Hello, world!', 'o', 1),
    position('Hello, world!', 'o', 7)

Результат:

┌─position('Hello, world!', 'o', 1)─┬─position('Hello, world!', 'o', 7)─┐
│                                 5 │                                 9 │
└───────────────────────────────────┴───────────────────────────────────┘

Пример для синтаксиса needle IN haystack:

Запрос:

SELECT 6 = position('/' IN s) FROM (SELECT 'Hello/World' AS s);

Результат:

┌─equals(6, position(s, '/'))─┐
│                           1 │
└─────────────────────────────┘

Примеры с пустой подстрокой needle:

Запрос:

SELECT
    position('abc', ''),
    position('abc', '', 0),
    position('abc', '', 1),
    position('abc', '', 2),
    position('abc', '', 3),
    position('abc', '', 4),
    position('abc', '', 5)

Результат:

┌─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 │
└─────────────────────┴────────────────────────┴────────────────────────┴────────────────────────┴────────────────────────┴────────────────────────┴────────────────────────┘

locate

Как 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;

Синтаксис

locate(needle, haystack[, start_pos])

positionCaseInsensitive

Регистронезависимый вариант position.

Пример

Запрос:

SELECT positionCaseInsensitive('Hello, world!', 'hello');

Результат:

┌─positionCaseInsensitive('Hello, world!', 'hello')─┐
│                                                 1 │
└───────────────────────────────────────────────────┘

positionUTF8

Как position, но предполагает, что haystack и needle являются строками с кодировкой UTF-8.

Примеры

Функция positionUTF8 правильно считает символ ö (представленный двумя точками) как единую кодовую точку Unicode:

Запрос:

SELECT positionUTF8('Motörhead', 'r');

Результат:

┌─position('Motörhead', 'r')─┐
│                          5 │
└────────────────────────────┘

positionCaseInsensitiveUTF8

Как positionUTF8, но осуществляет регистронезависимый поиск.

multiSearchAllPositions

Как position, но возвращает массив позиций (в байтах, начиная с 1) для нескольких подстрок needle в строке haystack.

примечание

Все функции multiSearch*() поддерживают не более 2⁸ needles.

Синтаксис

multiSearchAllPositions(haystack, [needle1, needle2, ..., needleN])

Аргументы

haystack — Строка, в которой выполняется поиск. String.
needle — Искомые подстроки. Array.

Возвращаемое значение

Массив начальной позиции в байтах и счёт с 1, если подстрока была найдена.
0, если подстрока не найдена.

Пример

Запрос:

SELECT multiSearchAllPositions('Hello, World!', ['hello', '!', 'world']);

Результат:

┌─multiSearchAllPositions('Hello, World!', ['hello', '!', 'world'])─┐
│ [0,13,0]                                                          │
└───────────────────────────────────────────────────────────────────┘

multiSearchAllPositionsCaseInsensitive

Как multiSearchAllPositions, но игнорирует регистр.

Синтаксис

multiSearchAllPositionsCaseInsensitive(haystack, [needle1, needle2, ..., needleN])

Параметры

haystack — Строка, в которой выполняется поиск. String.
needle — Искомые подстроки. Array.

Возвращаемое значение

Массив начальной позиции в байтах и счёт с 1 (если подстрока была найдена).
0, если подстрока не найдена.

Пример

Запрос:

SELECT multiSearchAllPositionsCaseInsensitive('ClickHouse',['c','h']);

Результат:

["1","6"]

multiSearchAllPositionsUTF8

Как multiSearchAllPositions, но предполагает, что haystack и подстроки needle имеют кодировку UTF-8.

Синтаксис

multiSearchAllPositionsUTF8(haystack, [needle1, needle2, ..., needleN])

Параметры

haystack — Строка с кодировкой UTF-8, в которой выполняется поиск. String.
needle — Подстроки с кодировкой UTF-8 для поиска. Array.

Возвращаемое значение

Массив начальной позиции в байтах и счёт с 1 (если подстрока была найдена).
0, если подстрока не найдена.

Пример

При задании ClickHouse как строки в кодировке UTF-8, найдите позиции C (\x43) и H (\x48).

Запрос:

SELECT multiSearchAllPositionsUTF8('\x43\x6c\x69\x63\x6b\x48\x6f\x75\x73\x65',['\x43','\x48']);

Результат:

["1","6"]

multiSearchAllPositionsCaseInsensitiveUTF8

Как multiSearchAllPositionsUTF8, но игнорирует регистр.

Синтаксис

multiSearchAllPositionsCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])

Параметры

haystack — Строка с кодировкой UTF-8, в которой выполняется поиск. String.
needle — Подстроки с кодировкой UTF-8 для поиска. Array.

Возвращаемое значение

Массив начальной позиции в байтах и счёт с 1 (если подстрока была найдена).
0, если подстрока не найдена.

Пример

При задании ClickHouse как строки в кодировке UTF-8, найдите позиции c (\x63) и h (\x68).

Запрос:

SELECT multiSearchAllPositionsCaseInsensitiveUTF8('\x43\x6c\x69\x63\x6b\x48\x6f\x75\x73\x65',['\x63','\x68']);

Результат:

["1","6"]

multiSearchFirstPosition

Как position, но возвращает левый смещение в строке haystack, которое соответствует любой из нескольких строк needle.

Функции multiSearchFirstPositionCaseInsensitive, multiSearchFirstPositionUTF8 и multiSearchFirstPositionCaseInsensitiveUTF8 предоставляют регистронезависимые и/или UTF-8 варианты этой функции.

Синтаксис

multiSearchFirstPosition(haystack, [needle1, needle2, ..., needleN])

Параметры

haystack — Строка, в которой выполняется поиск. String.
needle — Искомые подстроки. Array.

Возвращаемое значение

Левый смещение в строке haystack, которое соответствует любой из нескольких строк needle.
0, если совпадений нет.

Пример

Запрос:

SELECT multiSearchFirstPosition('Hello World',['llo', 'Wor', 'ld']);

Результат:

multiSearchFirstPositionCaseInsensitive

Как multiSearchFirstPosition, но игнорирует регистр.

Синтаксис

multiSearchFirstPositionCaseInsensitive(haystack, [needle1, needle2, ..., needleN])

Параметры

haystack — Строка, в которой выполняется поиск. String.
needle — Массив подстрок для поиска. Array.

Возвращаемое значение

Левый смещение в строке haystack, которое соответствует любой из нескольких строк needle.
0, если совпадений нет.

Пример

Запрос:

SELECT multiSearchFirstPositionCaseInsensitive('HELLO WORLD',['wor', 'ld', 'ello']);

Результат:

multiSearchFirstPositionUTF8

Как multiSearchFirstPosition, но предполагает, что строки haystack и needle являются строками в кодировке UTF-8.

Синтаксис

multiSearchFirstPositionUTF8(haystack, [needle1, needle2, ..., needleN])

Параметры

haystack — Строка в кодировке UTF-8, в которой выполняется поиск. String.
needle — Массив подстрок в кодировке UTF-8 для поиска. Array.

Возвращаемое значение

Левый смещение в строке haystack, которое соответствует любой из нескольких строк needle.
0, если совпадений нет.

Пример

Найдите левый смещение в строке UTF-8 hello world, которое соответствует любой из данных подстрок.

Запрос:

SELECT multiSearchFirstPositionUTF8('\x68\x65\x6c\x6c\x6f\x20\x77\x6f\x72\x6c\x64',['wor', 'ld', 'ello']);

Результат:

multiSearchFirstPositionCaseInsensitiveUTF8

Как multiSearchFirstPosition, но предполагает, что строки haystack и needle являются строками в кодировке UTF-8 и игнорирует регистр.

Синтаксис

multiSearchFirstPositionCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])

Параметры

haystack — Строка в кодировке UTF-8, в которой выполняется поиск. String.
needle — Массив подстрок в кодировке UTF-8 для поиска. Array.

Возвращаемое значение

Левый смещение в строке haystack, которое соответствует любой из нескольких строк needle, игнорируя регистр.
0, если совпадений нет.

Пример

Найдите левый смещение в строке UTF-8 HELLO WORLD, которое соответствует любой из данных подстрок.

Запрос:

SELECT multiSearchFirstPositionCaseInsensitiveUTF8('\x48\x45\x4c\x4c\x4f\x20\x57\x4f\x52\x4c\x44',['wor', 'ld', 'ello']);

Результат:

multiSearchFirstIndex

Возвращает индекс i (начиная с 1) самой левой найденной подстроки needlei в строке haystack и 0 в противном случае.

Функции multiSearchFirstIndexCaseInsensitive, multiSearchFirstIndexUTF8 и multiSearchFirstIndexCaseInsensitiveUTF8 предоставляют регистронезависимые и/или UTF-8 варианты этой функции.

Синтаксис

multiSearchFirstIndex(haystack, [needle1, needle2, ..., needleN])

Параметры

haystack — Строка, в которой выполняется поиск. String.
needle — Искомые подстроки. Array.

Возвращаемое значение

индекс (начиная с 1) самой левой найденной подстроки. В противном случае 0, если совпадений нет. UInt8.

Пример

Запрос:

SELECT multiSearchFirstIndex('Hello World',['World','Hello']);

Результат:

multiSearchFirstIndexCaseInsensitive

Возвращает индекс i (начиная с 1) самой левой найденной подстроки needlei в строке haystack и 0 в противном случае. Игнорирует регистр.

Синтаксис

multiSearchFirstIndexCaseInsensitive(haystack, [needle1, needle2, ..., needleN])

Параметры

haystack — Строка, в которой выполняется поиск. String.
needle — Искомые подстроки. Array.

Возвращаемое значение

индекс (начиная с 1) самой левой найденной подстроки. В противном случае 0, если совпадений нет. UInt8.

Пример

Запрос:

SELECT multiSearchFirstIndexCaseInsensitive('hElLo WoRlD',['World','Hello']);

Результат:

multiSearchFirstIndexUTF8

Возвращает индекс i (начиная с 1) самой левой найденной подстроки needlei в строке haystack и 0 в противном случае. Предполагает, что строки haystack и needle являются строками в кодировке UTF-8.

Синтаксис

multiSearchFirstIndexUTF8(haystack, [needle1, needle2, ..., needleN])

Параметры

haystack — Строка в кодировке UTF-8, в которой выполняется поиск. String.
needle — Массив подстрок в кодировке UTF-8 для поиска. Array.

Возвращаемое значение

индекс (начиная с 1) самой левой найденной подстроки. В противном случае 0, если совпадений нет. UInt8.

Пример

При задании Hello World как строки в кодировке UTF-8, найдите первый индекс строк UTF-8 Hello и World.

Запрос:

SELECT multiSearchFirstIndexUTF8('\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64',['\x57\x6f\x72\x6c\x64','\x48\x65\x6c\x6c\x6f']);

Результат:

multiSearchFirstIndexCaseInsensitiveUTF8

Синтаксис

multiSearchFirstIndexCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])

Параметры

haystack — Строка в кодировке UTF-8, в которой выполняется поиск. String.
needle — Массив подстрок в кодировке UTF-8 для поиска. Array.

Возвращаемое значение

индекс (начиная с 1) самой левой найденной подстроки. В противном случае 0, если совпадений нет. UInt8.

Пример

При задании HELLO WORLD как строки в кодировке UTF-8, найдите первый индекс строк UTF-8 hello и world.

Запрос:

SELECT multiSearchFirstIndexCaseInsensitiveUTF8('\x48\x45\x4c\x4c\x4f\x20\x57\x4f\x52\x4c\x44',['\x68\x65\x6c\x6c\x6f','\x77\x6f\x72\x6c\x64']);

Результат:

multiSearchAny

Возвращает 1, если хотя бы одна строка needlei соответствует строке haystack, и 0 в противном случае.

Функции multiSearchAnyCaseInsensitive, multiSearchAnyUTF8 и multiSearchAnyCaseInsensitiveUTF8 предоставляют регистронезависимые и/или UTF-8 варианты этой функции.

Синтаксис

multiSearchAny(haystack, [needle1, needle2, ..., needleN])

Параметры

haystack — Строка, в которой выполняется поиск. String.
needle — Искомые подстроки. Array.

Возвращаемое значение

1, если было хотя бы одно совпадение.
0, если совпадений не было.

Пример

Запрос:

SELECT multiSearchAny('ClickHouse',['C','H']);

Результат:

multiSearchAnyCaseInsensitive

Как multiSearchAny, но игнорирует регистр.

Синтаксис

multiSearchAnyCaseInsensitive(haystack, [needle1, needle2, ..., needleN])

Параметры

haystack — Строка, в которой выполняется поиск. String.
needle — Искомые подстроки. Array

Возвращаемое значение

1, если было хотя бы одно совпадение, игнорируя регистр.
0, если совпадений не было.

Пример

Запрос:

SELECT multiSearchAnyCaseInsensitive('ClickHouse',['c','h']);

Результат:

multiSearchAnyUTF8

Как multiSearchAny, но предполагает, что строки haystack и подстроки needle находятся в кодировке UTF-8.

Синтаксис

multiSearchAnyUTF8(haystack, [needle1, needle2, ..., needleN])

Параметры

haystack — Строка в кодировке UTF-8, в которой выполняется поиск. String.
needle — Подстроки в кодировке UTF-8 для поиска. Array.

Возвращаемое значение

1, если было хотя бы одно совпадение.
0, если совпадений не было.

Пример

При задании ClickHouse как строки в кодировке UTF-8, проверьте, присутствуют ли буквы C (\x43) или H (\x48) в слове.

Запрос:

SELECT multiSearchAnyUTF8('\x43\x6c\x69\x63\x6b\x48\x6f\x75\x73\x65',['\x43','\x48']);

Результат:

multiSearchAnyCaseInsensitiveUTF8

Как multiSearchAnyUTF8, но игнорирует регистр.

Синтаксис

multiSearchAnyCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])

Параметры

haystack — Строка в кодировке UTF-8, в которой выполняется поиск. String.
needle — Подстроки в кодировке UTF-8 для поиска. Array.

Возвращаемое значение

1, если было хотя бы одно совпадение, игнорируя регистр.
0, если совпадений не было.

Пример

При задании ClickHouse как строки в кодировке UTF-8, проверьте, присутствует ли буква h (\x68) в слове, игнорируя регистр.

Запрос:

SELECT multiSearchAnyCaseInsensitiveUTF8('\x43\x6c\x69\x63\x6b\x48\x6f\x75\x73\x65',['\x68']);

Результат:

hasAnyTokens

примечание

Эту функцию можно использовать только при включенной настройке allow_experimental_full_text_index.

Возвращает 1, если хотя бы одна строка needlei соответствует колонке input, и 0 в противном случае.

Синтаксис

hasAnyTokens(input, ['needle1', 'needle2', ..., 'needleN'])

Параметры

input — Входная колонка. String или FixedString.
needles — Токены для поиска. Поддерживает не более 64 токенов. Array(String).

примечание

Колонка input должна иметь [текстовый индекс][../../engines/table-engines/mergetree-family/invertedindexes.md].

Строка input токенизируется с помощью токенизатора из определения индекса.

Каждый элемент массива needle токен_i считается единичным токеном, т.е. не подлежит дальнейшей токенизации. Например, если вы хотите выполнить поиск ClickHouse с индексом tokenizer = ngrams(5), при этом предоставив токены: ['Click', 'lickH', 'ickHo', 'ckHou', 'kHous', 'House']. Чтобы сгенерировать токены, вы можете использовать функцию tokens. Дубликаты токенов игнорируются, например, ['ClickHouse', 'ClickHouse'] — это то же самое, что и ['ClickHouse'].

Возвращаемое значение

1, если было хотя бы одно совпадение.
0 в противном случае.

Пример

Запрос:

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']);

Результат:

Сгенерировать токены с помощью функции tokens

Запрос:

SELECT count() FROM table WHERE hasAnyTokens(msg, tokens('a()d', 'splitByString', ['()', '\\']));

Результат:

hasAllTokens

примечание

Эту функцию можно использовать только при включенной настройке allow_experimental_full_text_index.

Как hasAnyTokens, но возвращает 1 только если все строки needlei соответствуют колонке input, и 0 в противном случае.

Синтаксис

hasAllTokens(input, ['needle1', 'needle2', ..., 'needleN'])

Параметры

input — Входная колонка. String или FixedString.
needles — Токены для поиска. Поддерживает не более 64 токенов. Array(String).

примечание

Колонка input должна иметь [текстовый индекс][../../engines/table-engines/mergetree-family/invertedindexes.md].

Строка input токенизируется с помощью токенизатора из определения индекса.

Возвращаемое значение

1, если все токены совпадают.
0 в противном случае.

Пример

Запрос:

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']);

Результат:

Сгенерировать токены с помощью функции tokens

Запрос:

SELECT count() FROM table WHERE hasAllTokens(msg, tokens('a()d', 'splitByString', ['()', '\\']));

Результат:

match

Возвращает, соответствует ли строка haystack регулярному выражению pattern в синтаксисе регулярного выражения re2.

Совпадение основывается на UTF-8, например, . соответствует кодовой точке Unicode ¥, которая в UTF-8 представляется с помощью двух байт. Регулярное выражение не должно содержать нулевых байтов. Если строка haystack или шаблон не являются допустимым UTF-8, поведение будет неопределенным.

В отличие от стандартного поведения re2, . соответствует разрывам строк. Чтобы отключить это, предварите шаблон с помощью (?-s).

Если вы хотите просто искать подстроки в строке, вы можете использовать функции like или position вместо этого — они работают гораздо быстрее, чем эта функция.

Синтаксис

match(haystack, pattern)

Псевдоним: haystack REGEXP pattern operator

multiMatchAny

Как match, но возвращает 1, если хотя бы один из шаблонов совпадает, и 0 в противном случае.

примечание

Функции из семейства multi[Fuzzy]Match*() используют библиотеку (Vectorscan)[https://github.com/VectorCamp/vectorscan]. Таким образом, они включены только если ClickHouse скомпилирован с поддержкой vectorscan.

Чтобы отключить все функции, использующие hyperscan, используйте настройку SET allow_hyperscan = 0;.

Из-за ограничений vectorscan длина строки haystack должна быть меньше 2³² байт.

Hyperscan в целом уязвим для атак отказа в обслуживании с использованием регулярных выражений (ReDoS) (например, см. (здесь)[https://www.usenix.org/conference/usenixsecurity22/presentation/turonova], (здесь)[https://doi.org/10.1007/s10664-021-10033-1] и (здесь)[https://doi.org/10.1145/3236024.3236027]. Пользователи должны тщательно проверять предоставленные шаблоны.

Если вы хотите просто искать несколько подстрок в строке, вы можете использовать функцию multiSearchAny вместо этого — она работает гораздо быстрее, чем эта функция.

Синтаксис

multiMatchAny(haystack, \[pattern<sub>1</sub>, pattern<sub>2</sub>, ..., pattern<sub>n</sub>\])

multiMatchAnyIndex

Как multiMatchAny, но возвращает любой индекс, который соответствует haystack.

Синтаксис

multiMatchAnyIndex(haystack, \[pattern<sub>1</sub>, pattern<sub>2</sub>, ..., pattern<sub>n</sub>\])

multiMatchAllIndices

Как multiMatchAny, но возвращает массив всех индексов, которые соответствуют haystack в любом порядке.

Синтаксис

multiMatchAllIndices(haystack, \[pattern<sub>1</sub>, pattern<sub>2</sub>, ..., pattern<sub>n</sub>\])

multiFuzzyMatchAny

Как multiMatchAny, но возвращает 1, если любой шаблон соответствует haystack в пределах постоянной редакционной дистанции. Эта функция полагается на экспериментальную функцию библиотеки hyperscan и может быть медленной для некоторых крайних случаев. Производительность зависит от значения расстояния редактирования и используемых шаблонов, но она всегда более затратна по сравнению с не-нечеткими вариантами.

примечание

Функции multiFuzzyMatch*() не поддерживают регулярные выражения UTF-8 (они обрабатываются как последовательность байтов) из-за ограничений hyperscan.

Синтаксис

multiFuzzyMatchAny(haystack, distance, \[pattern<sub>1</sub>, pattern<sub>2</sub>, ..., pattern<sub>n</sub>\])

multiFuzzyMatchAnyIndex

Как multiFuzzyMatchAny, но возвращает любой индекс, который соответствует haystack в пределах постоянной редакционной дистанции.

Синтаксис

multiFuzzyMatchAnyIndex(haystack, distance, \[pattern<sub>1</sub>, pattern<sub>2</sub>, ..., pattern<sub>n</sub>\])

multiFuzzyMatchAllIndices

Как multiFuzzyMatchAny, но возвращает массив всех индексов в любом порядке, которые соответствуют haystack в пределах постоянной редакционной дистанции.

Синтаксис

multiFuzzyMatchAllIndices(haystack, distance, \[pattern<sub>1</sub>, pattern<sub>2</sub>, ..., pattern<sub>n</sub>\])

extract

Возвращает первое совпадение регулярного выражения в строке. Если haystack не соответствует pattern, возвращается пустая строка.

Если регулярное выражение имеет захватывающие группы, функция сопоставляет входную строку с первой захватывающей группой.

Синтаксис

extract(haystack, pattern)

Аргументы*

haystack — Входная строка. String.
pattern — Регулярное выражение с синтаксисом регулярного выражения re2.

Возвращаемое значение

Первое совпадение регулярного выражения в строке haystack. String.

Пример

Запрос:

SELECT extract('number: 1, number: 2, number: 3', '\\d+') AS result;

Результат:

┌─result─┐
│ 1      │
└────────┘

extractAll

Возвращает массив всех совпадений регулярного выражения в строке. Если haystack не соответствует pattern, возвращается пустая строка.

Поведение по отношению к подшаблонам такое же, как и в функции extract.

Синтаксис

extractAll(haystack, pattern)

Аргументы*

haystack — Входная строка. String.
pattern — Регулярное выражение с синтаксисом регулярного выражения re2.

Возвращаемое значение

Массив совпадений регулярного выражения в строке haystack. Array(String).

Пример

Запрос:

SELECT extractAll('number: 1, number: 2, number: 3', '\\d+') AS result;

Результат:

┌─result────────┐
│ ['1','2','3'] │
└───────────────┘

extractAllGroupsHorizontal

Сопоставляет все группы строки haystack с помощью регулярного выражения pattern. Возвращает массив массивов, где первый массив включает все фрагменты, соответствующие первой группе, второй массив — соответствующие второй группе и т.д.

Эта функция медленнее, чем extractAllGroupsVertical.

Синтаксис

extractAllGroupsHorizontal(haystack, pattern)

Аргументы

haystack — Входная строка. String.
pattern — Регулярное выражение с синтаксисом регулярного выражения re2. Должно содержать группы, каждая группа заключена в скобки. Если pattern не содержит групп, будет выброшено исключение. String.

Возвращаемое значение

Массив массивов совпадений. Array.

примечание

Если haystack не соответствует pattern, возвращается массив пустых массивов.

Пример

SELECT extractAllGroupsHorizontal('abc=111, def=222, ghi=333', '("[^"]+"|\\w+)=("[^"]+"|\\w+)');

Результат:

┌─extractAllGroupsHorizontal('abc=111, def=222, ghi=333', '("[^"]+"|\\w+)=("[^"]+"|\\w+)')─┐
│ [['abc','def','ghi'],['111','222','333']]                                                │
└──────────────────────────────────────────────────────────────────────────────────────────┘

extractGroups

Сопоставляет все группы заданной входной строки с заданным регулярным выражением, возвращает массив массивов совпадений.

Синтаксис

extractGroups(haystack, pattern)

Аргументы

haystack — Входная строка. String.
pattern — Регулярное выражение с синтаксисом регулярного выражения re2. Должно содержать группы, каждая группа заключена в скобки. Если pattern не содержит групп, будет выброшено исключение. String.

Возвращаемое значение

Массив массивов совпадений. Array.

Пример

SELECT extractGroups('hello abc=111 world', '("[^"]+"|\\w+)=("[^"]+"|\\w+)') AS result;

Результат:

┌─result────────┐
│ ['abc','111'] │
└───────────────┘

extractAllGroupsVertical

Сопоставляет все группы строки haystack с помощью регулярного выражения pattern. Возвращает массив массивов, где каждый массив включает соответствующие фрагменты из каждой группы. Фрагменты сгруппированы в порядке появления в haystack.

Синтаксис

extractAllGroupsVertical(haystack, pattern)

Аргументы

haystack — Входная строка. String.
pattern — Регулярное выражение с синтаксисом регулярного выражения re2. Должно содержать группы, каждая группа заключена в скобки. Если pattern не содержит групп, будет выброшено исключение. String.

Возвращаемое значение

Массив массивов совпадений. Array.

примечание

Если haystack не соответствует pattern, возвращается пустой массив.

Пример

SELECT extractAllGroupsVertical('abc=111, def=222, ghi=333', '("[^"]+"|\\w+)=("[^"]+"|\\w+)');

Результат:

┌─extractAllGroupsVertical('abc=111, def=222, ghi=333', '("[^"]+"|\\w+)=("[^"]+"|\\w+)')─┐
│ [['abc','111'],['def','222'],['ghi','333']]                                            │
└────────────────────────────────────────────────────────────────────────────────────────┘

like

Возвращает, соответствует ли строка haystack выражению LIKE pattern.

Выражение LIKE может содержать обычные символы и следующие метасимволы:

% указывает на произвольное количество произвольных символов (включая ноль символов).
_ указывает на один произвольный символ.
\ предназначен для экранирования литералов %, _ и \.

Совпадение основывается на UTF-8, например, _ соответствует кодовой точке Unicode ¥, которая в UTF-8 представляется с помощью двух байт.

Если строка haystack или выражение LIKE не являются допустимым UTF-8, поведение будет неопределённым.

Автоматическая нормализация Unicode не выполняется, вы можете использовать функции normalizeUTF8*() для этого.

Чтобы сопоставить с литератом %, _ и \ (которые являются мета-символами LIKE), предваряйте их обратной косой чертой: \%, \_ и \\. Обратная косая черта теряет своё специальное значение (т.е. интерпретируется буквально), если она предшествует символу, отличному от %, _ или \. Обратите внимание, что ClickHouse требует, чтобы обратные косые черты в строках также были экранированы, поэтому на самом деле вам нужно записывать \\%, \\_ и \\\\.

Для выражений LIKE вида %needle% функция работает так же быстро, как функция position. Все остальные выражения LIKE внутренне конвертируются в регулярное выражение и выполняются с производительностью, аналогичной функции match.

Синтаксис

like(haystack, pattern)

Псевдоним: haystack LIKE pattern (оператор)

notLike

Как like, но отрицает результат.

Псевдоним: haystack NOT LIKE pattern (оператор)

ilike

Как like, но осуществляет регистронезависимый поиск.

Псевдоним: haystack ILIKE pattern (оператор)

notILike

Как ilike, но отрицает результат.

Псевдоним: haystack NOT ILIKE pattern (оператор)

ngramDistance

Вычисляет расстояние 4-грамм между строкой haystack и строкой needle. Для этого он подсчитывает симметричную разницу между двумя многоместами 4-грамм и нормализует её по сумму их кардинальностей. Возвращает значение Float32 от 0 до 1. Чем меньше результат, тем более похожи строки друг на друга.

Функции ngramDistanceCaseInsensitive, ngramDistanceUTF8, ngramDistanceCaseInsensitiveUTF8 предоставляют регистронезависимый и/или UTF-8 варианты этой функции.

Синтаксис

ngramDistance(haystack, needle)

Параметры

haystack: Первая сравниваемая строка. String literal
needle: Вторая сравниваемая строка. String literal

Возвращаемое значение

Значение от 0 до 1, представляющее степень схожести между двумя строками. Float32

Технические детали реализации

Эта функция выбросит исключение, если постоянные аргументы needle или haystack превышают 32 Кб по размеру. Если любые непостоянные аргументы haystack или needle превышают 32 Кб по размеру, то расстояние всегда будет равным 1.

Примеры

Чем более похожи две строки друг на друга, тем ближе результат будет к 0 (идентичны).

Запрос:

SELECT ngramDistance('ClickHouse','ClickHouse!');

Результат:

0.06666667

Чем менее похожи две строки, тем больше результат. Запрос:

SELECT ngramDistance('ClickHouse','House');

Результат:

0.5555556

ngramDistanceCaseInsensitive

Предоставляет регистронезависимый вариант ngramDistance.

Синтаксис

ngramDistanceCaseInsensitive(haystack, needle)

Параметры

haystack: Первая сравниваемая строка. String literal
needle: Вторая сравниваемая строка. String literal

Возвращаемое значение

Значение от 0 до 1, представляющее степень схожести между двумя строками. Float32

Примеры

С помощью ngramDistance различия в регистре повлияют на значение схожести:

Запрос:

SELECT ngramDistance('ClickHouse','clickhouse');

Результат:

0.71428573

С помощью ngramDistanceCaseInsensitive регистр игнорируется, поэтому две идентичные строки, различающиеся только регистром, теперь будут возвращать низкое значение схожести:

Запрос:

SELECT ngramDistanceCaseInsensitive('ClickHouse','clickhouse');

Результат:

ngramDistanceUTF8

Предоставляет вариант на UTF-8 для ngramDistance. Предполагает, что строки needle и haystack закодированы в UTF-8.

Синтаксис

ngramDistanceUTF8(haystack, needle)

Параметры

haystack: Первая строка для сравнения, закодированная в UTF-8. Строковый литерал
needle: Вторая строка для сравнения, закодированная в UTF-8. Строковый литерал

Возвращаемое значение

Значение от 0 до 1, представляющее схожесть между двумя строками. Float32

Пример

Запрос:

SELECT ngramDistanceUTF8('abcde','cde');

Результат:

0.5

ngramDistanceCaseInsensitiveUTF8

Предоставляет вариант без учета регистра для ngramDistanceUTF8.

Синтаксис

ngramDistanceCaseInsensitiveUTF8(haystack, needle)

Параметры

haystack: Первая строка для сравнения, закодированная в UTF-8. Строковый литерал
needle: Вторая строка для сравнения, закодированная в UTF-8. Строковый литерал

Возвращаемое значение

Значение от 0 до 1, представляющее схожесть между двумя строками. Float32

Пример

Запрос:

SELECT ngramDistanceCaseInsensitiveUTF8('abcde','CDE');

Результат:

0.5

ngramSearch

Как ngramDistance, но вычисляет нессимметричную разницу между строкой needle и строкой haystack, т.е. количество n-грамм из needle минус общее количество n-грамм, нормализованное по количеству n-грамм needle. Возвращает Float32 от 0 до 1. Чем больше результат, тем вероятнее, что needle содержится в haystack. Эта функция полезна для нечеткого поиска строк. Также смотрите функцию soundex.

Функции ngramSearchCaseInsensitive, ngramSearchUTF8, ngramSearchCaseInsensitiveUTF8 предоставляют варианты без учета регистра и/или UTF-8 этой функции.

Синтаксис

ngramSearch(haystack, needle)

Параметры

haystack: Первая строка для сравнения. Строковый литерал
needle: Вторая строка для сравнения. Строковый литерал

Возвращаемое значение

Значение от 0 до 1, представляющее вероятность того, что needle находится в haystack. Float32

Детали реализации

примечание

UTF-8 варианты используют 3-граммное расстояние. Эти расстояния n-грамм не идеально справедливы. Мы используем 2-байтовые хэши для хэширования n-грамм, а затем вычисляем (не-)симметрическую разницу между этими хэш-таблицами — возможны совпадения. В формате UTF-8 без учета регистра мы не используем справедливую функцию tolower — мы обнуляем 5-й бит (с начала) каждого байта кода и первый бит нулевого байта, если байтов больше одного — это работает для латиницы и в основном для всех кириллических букв.

Пример

Запрос:

SELECT ngramSearch('Hello World','World Hello');

Результат:

0.5

ngramSearchCaseInsensitive

Предоставляет вариант без учета регистра для ngramSearch.

Синтаксис

ngramSearchCaseInsensitive(haystack, needle)

Параметры

haystack: Первая строка для сравнения. Строковый литерал
needle: Вторая строка для сравнения. Строковый литерал

Возвращаемое значение

Значение от 0 до 1, представляющее вероятность того, что needle находится в haystack. Float32

Чем больше результат, тем вероятнее, что needle содержится в haystack.

Пример

Запрос:

SELECT ngramSearchCaseInsensitive('Hello World','hello');

Результат:

ngramSearchUTF8

Предоставляет вариант на UTF-8 для ngramSearch, в котором предполагается, что needle и haystack закодированы в UTF-8.

Синтаксис

ngramSearchUTF8(haystack, needle)

Параметры

haystack: Первая строка для сравнения, закодированная в UTF-8. Строковый литерал
needle: Вторая строка для сравнения, закодированная в UTF-8. Строковый литерал

Возвращаемое значение

Значение от 0 до 1, представляющее вероятность того, что needle находится в haystack. Float32

Чем больше результат, тем вероятнее, что needle содержится в haystack.

Пример

Запрос:

SELECT ngramSearchUTF8('абвгдеёжз', 'гдеёзд');

Результат:

0.5

ngramSearchCaseInsensitiveUTF8

Предоставляет вариант без учета регистра для ngramSearchUTF8, в котором needle и haystack.

Синтаксис

ngramSearchCaseInsensitiveUTF8(haystack, needle)

Параметры

haystack: Первая строка для сравнения, закодированная в UTF-8. Строковый литерал
needle: Вторая строка для сравнения, закодированная в UTF-8. Строковый литерал

Возвращаемое значение

Значение от 0 до 1, представляющее вероятность того, что needle находится в haystack. Float32

Чем больше результат, тем вероятнее, что needle содержится в haystack.

Пример

Запрос:

SELECT ngramSearchCaseInsensitiveUTF8('абвГДЕёжз', 'АбвгдЕЁжз');

Результат:

0.57142854

countSubstrings

Возвращает, как часто подстрока needle встречается в строке haystack.

Функции countSubstringsCaseInsensitive и countSubstringsCaseInsensitiveUTF8 предоставляют варианты без учета регистра и без учета регистра + UTF-8 этой функции соответственно.

Синтаксис

countSubstrings(haystack, needle[, start_pos])

Аргументы

haystack — Строка, в которой выполняется поиск. Строка или Enum.
needle — Подстрока для поиска. Строка.
start_pos – Позиция (1-индексированная) в haystack, с которой начинается поиск. UInt. Необязательный.

Возвращаемое значение

Количество вхождений. UInt64.

Примеры

SELECT countSubstrings('aaaa', 'aa');

Результат:

┌─countSubstrings('aaaa', 'aa')─┐
│                             2 │
└───────────────────────────────┘

Пример с аргументом start_pos:

SELECT countSubstrings('abc___abc', 'abc', 4);

Результат:

┌─countSubstrings('abc___abc', 'abc', 4)─┐
│                                      1 │
└────────────────────────────────────────┘

countSubstringsCaseInsensitive

Возвращает, как часто подстрока needle встречается в строке haystack. Игнорирует регистр.

Синтаксис

countSubstringsCaseInsensitive(haystack, needle[, start_pos])

Аргументы

haystack — Строка, в которой выполняется поиск. Строка или Enum.
needle — Подстрока для поиска. Строка.
start_pos – Позиция (1-индексированная) в haystack, с которой начинается поиск. UInt. Необязательный.

Возвращаемое значение

Количество вхождений. UInt64.

Примеры

Запрос:

SELECT countSubstringsCaseInsensitive('AAAA', 'aa');

Результат:

┌─countSubstringsCaseInsensitive('AAAA', 'aa')─┐
│                                            2 │
└──────────────────────────────────────────────┘

Пример с аргументом start_pos:

Запрос:

SELECT countSubstringsCaseInsensitive('abc___ABC___abc', 'abc', 4);

Результат:

┌─countSubstringsCaseInsensitive('abc___ABC___abc', 'abc', 4)─┐
│                                                           2 │
└─────────────────────────────────────────────────────────────┘

countSubstringsCaseInsensitiveUTF8

Возвращает, как часто подстрока needle встречается в строке haystack. Игнорирует регистр и предполагает, что haystack является строкой UTF-8.

Синтаксис

countSubstringsCaseInsensitiveUTF8(haystack, needle[, start_pos])

Аргументы

haystack — Строка UTF-8, в которой выполняется поиск. Строка или Enum.
needle — Подстрока для поиска. Строка.
start_pos – Позиция (1-индексированная) в haystack, с которой начинается поиск. UInt. Необязательный.

Возвращаемое значение

Количество вхождений. UInt64.

Примеры

Запрос:

SELECT countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА');

Результат:

┌─countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА')─┐
│                                                                  4 │
└────────────────────────────────────────────────────────────────────┘

Пример с аргументом start_pos:

Запрос:

SELECT countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА', 13);

Результат:

┌─countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА', 13)─┐
│                                                                      2 │
└────────────────────────────────────────────────────────────────────────┘

countMatches

Возвращает количество совпадений регулярного выражения для pattern в haystack.

Поведение этой функции зависит от версии ClickHouse:

в версиях < v25.6 countMatches прекратит подсчет при первом пустом совпадении, даже если шаблон принимает.
в версиях >= 25.6 countMatches продолжит выполнение при возникновении пустого совпадения. Унаследованное поведение можно восстановить, используя настройку count_matches_stop_at_empty_match = true;

Синтаксис

countMatches(haystack, pattern)

Аргументы

haystack — Строка, в которой ведется поиск. Строка.
pattern — Регулярное выражение с синтаксисом регулярных выражений re2. Строка.

Возвращаемое значение

Количество совпадений. UInt64.

Примеры

SELECT countMatches('foobar.com', 'o+');

Результат:

┌─countMatches('foobar.com', 'o+')─┐
│                                2 │
└──────────────────────────────────┘

SELECT countMatches('aaaa', 'aa');

Результат:

┌─countMatches('aaaa', 'aa')────┐
│                             2 │
└───────────────────────────────┘

countMatchesCaseInsensitive

Возвращает количество совпадений регулярного выражения для шаблона в haystack, похожий на countMatches, но с игнорированием регистра.

Синтаксис

countMatchesCaseInsensitive(haystack, pattern)

Аргументы

haystack — Строка, в которой ведется поиск. Строка.
pattern — Регулярное выражение с синтаксисом регулярных выражений re2. Строка.

Возвращаемое значение

Количество совпадений. UInt64.

Примеры

Запрос:

SELECT countMatchesCaseInsensitive('AAAA', 'aa');

Результат:

┌─countMatchesCaseInsensitive('AAAA', 'aa')────┐
│                                            2 │
└──────────────────────────────────────────────┘

regexpExtract

Извлекает первую строку в haystack, которая соответствует шаблону регулярного выражения и соответствует индексу группы регулярного выражения.

Синтаксис

regexpExtract(haystack, pattern[, index])

Псевдоним: REGEXP_EXTRACT(haystack, pattern[, index]).

Аргументы

haystack — Строка, в которой будет соответствовать регулярному выражению. Строка.
pattern — Строка, регулярное выражение, должно быть константой. Строка.
index – Целое число больше или равное 0, по умолчанию 1. Оно представляет, какую группу регулярного выражения нужно извлечь. UInt или Int. Необязательный.

Возвращаемое значение

pattern может содержать несколько групп регулярных выражений, index указывает, какую группу регулярного выражения нужно извлечь. Индекс 0 означает совпадение с целым регулярным выражением. Строка.

Примеры

SELECT
    regexpExtract('100-200', '(\\d+)-(\\d+)', 1),
    regexpExtract('100-200', '(\\d+)-(\\d+)', 2),
    regexpExtract('100-200', '(\\d+)-(\\d+)', 0),
    regexpExtract('100-200', '(\\d+)-(\\d+)');

Результат:

┌─regexpExtract('100-200', '(\\d+)-(\\d+)', 1)─┬─regexpExtract('100-200', '(\\d+)-(\\d+)', 2)─┬─regexpExtract('100-200', '(\\d+)-(\\d+)', 0)─┬─regexpExtract('100-200', '(\\d+)-(\\d+)')─┐
│ 100                                          │ 200                                          │ 100-200                                      │ 100                                       │
└──────────────────────────────────────────────┴──────────────────────────────────────────────┴──────────────────────────────────────────────┴───────────────────────────────────────────┘

hasSubsequence

Возвращает 1, если needle является подпоследовательностью haystack, или 0 в противном случае. Подпоследовательность строки - это последовательность, которая может быть получена из данной строки, удаляя ноль или более элементов, не меняя порядок оставшихся элементов. Синтаксис

hasSubsequence(haystack, needle)

Аргументы

haystack — Строка, в которой ведется поиск. Строка.
needle — Подпоследовательность для поиска. Строка.

Возвращаемое значение

1, если needle является подпоследовательностью haystack, и 0 в противном случае. UInt8.

Примеры

Запрос:

SELECT hasSubsequence('garbage', 'arg');

Результат:

┌─hasSubsequence('garbage', 'arg')─┐
│                                1 │
└──────────────────────────────────┘

hasSubsequenceCaseInsensitive

Как hasSubsequence, но выполняет поиск без учета регистра.

Синтаксис

hasSubsequenceCaseInsensitive(haystack, needle)

Аргументы

haystack — Строка, в которой ведется поиск. Строка.
needle — Подпоследовательность для поиска. Строка.

Возвращаемое значение

1, если needle является подпоследовательностью haystack, и 0 в противном случае. UInt8.

Примеры

Запрос:

SELECT hasSubsequenceCaseInsensitive('garbage', 'ARG');

Результат:

┌─hasSubsequenceCaseInsensitive('garbage', 'ARG')─┐
│                                               1 │
└─────────────────────────────────────────────────┘

hasSubsequenceUTF8

Как hasSubsequence, но предполагает, что haystack и needle являются строками, закодированными в UTF-8.

Синтаксис

hasSubsequenceUTF8(haystack, needle)

Аргументы

haystack — Строка, в которой ведется поиск. Закодированная в UTF-8 Строка.
needle — Подпоследовательность для поиска. Закодированная в UTF-8 Строка.

Возвращаемое значение

1, если needle является подпоследовательностью haystack, и 0 в противном случае. UInt8.

Запрос:

Примеры

SELECT hasSubsequenceUTF8('ClickHouse - столбцовая система управления базами данных', 'система');

Результат:

┌─hasSubsequenceUTF8('ClickHouse - столбцовая система управления базами данных', 'система')─┐
│                                                                                         1 │
└───────────────────────────────────────────────────────────────────────────────────────────┘

hasSubsequenceCaseInsensitiveUTF8

Как hasSubsequenceUTF8, но выполняет поиск без учета регистра.

Синтаксис

hasSubsequenceCaseInsensitiveUTF8(haystack, needle)

Аргументы

haystack — Строка, в которой ведется поиск. Закодированная в UTF-8 Строка.
needle — Подпоследовательность для поиска. Закодированная в UTF-8 Строка.

Возвращаемое значение

1, если needle является подпоследовательностью haystack, и 0 в противном случае. UInt8.

Примеры

Запрос:

SELECT hasSubsequenceCaseInsensitiveUTF8('ClickHouse - столбцовая система управления базами данных', 'СИСТЕМА');

Результат:

┌─hasSubsequenceCaseInsensitiveUTF8('ClickHouse - столбцовая система управления базами данных', 'СИСТЕМА')─┐
│                                                                                                        1 │
└──────────────────────────────────────────────────────────────────────────────────────────────────────────┘

hasToken

Возвращает 1, если данный токен присутствует в haystack, или 0 в противном случае.

Синтаксис

hasToken(haystack, token)

Параметры

haystack: Строка, в которой ведется поиск. Строка или Enum.
token: Подстрока максимальной длины между двумя не алфавитными ASCII-символами (или границами haystack).

Возвращаемое значение

1, если токен присутствует в haystack, и 0 в противном случае. UInt8.

Детали реализации

Токен должен быть константной строкой. Поддерживается специализированным индексом tokenbf_v1.

Пример

Запрос:

SELECT hasToken('Hello World','Hello');

hasTokenOrNull

Возвращает 1, если данный токен присутствует, 0 если отсутствует и null, если токен некорректный.

Синтаксис

hasTokenOrNull(haystack, token)

Параметры

haystack: Строка, в которой ведется поиск. Строка или Enum.
token: Подстрока максимальной длины между двумя не алфавитными ASCII-символами (или границами haystack).

Возвращаемое значение

1, если токен присутствует в haystack, 0 если он отсутствует и null, если токен некорректный.

Детали реализации

Токен должен быть константной строкой. Поддерживается специализированным индексом tokenbf_v1.

Пример

Где hasToken вызовет ошибку для некорректного токена, hasTokenOrNull вернет null для некорректного токена.

Запрос:

SELECT hasTokenOrNull('Hello World','Hello,World');

null

hasTokenCaseInsensitive

Возвращает 1, если данный токен присутствует в haystack, 0 в противном случае. Игнорирует регистр.

Синтаксис

hasTokenCaseInsensitive(haystack, token)

Параметры

haystack: Строка, в которой ведется поиск. Строка или Enum.
token: Подстрока максимальной длины между двумя не алфавитными ASCII-символами (или границами haystack).

Возвращаемое значение

1, если токен присутствует в haystack, 0 в противном случае. UInt8.

Детали реализации

Токен должен быть константной строкой. Поддерживается специализированным индексом tokenbf_v1.

Пример

Запрос:

SELECT hasTokenCaseInsensitive('Hello World','hello');

hasTokenCaseInsensitiveOrNull

Возвращает 1, если данный токен присутствует в haystack, 0 в противном случае. Игнорирует регистр и возвращает null, если токен некорректный.

Синтаксис

hasTokenCaseInsensitiveOrNull(haystack, token)

Параметры

haystack: Строка, в которой ведется поиск. Строка или Enum.
token: Подстрока максимальной длины между двумя не алфавитными ASCII-символами (или границами haystack).

Возвращаемое значение

1, если токен присутствует в haystack, 0 если токен отсутствует, иначе null, если токен некорректный. UInt8.

Детали реализации

Токен должен быть константной строкой. Поддерживается специализированным индексом tokenbf_v1.

Пример Где hasTokenCaseInsensitive вызовет ошибку для некорректного токена, hasTokenCaseInsensitiveOrNull вернет null для некорректного токена.

Запрос:

SELECT hasTokenCaseInsensitiveOrNull('Hello World','hello,world');

null

position​

locate​

positionCaseInsensitive​

positionUTF8​

positionCaseInsensitiveUTF8​

multiSearchAllPositions​

multiSearchAllPositionsCaseInsensitive​

multiSearchAllPositionsUTF8​

multiSearchAllPositionsCaseInsensitiveUTF8​

multiSearchFirstPosition​

multiSearchFirstPositionCaseInsensitive​

multiSearchFirstPositionUTF8​

multiSearchFirstPositionCaseInsensitiveUTF8​

multiSearchFirstIndex​

multiSearchFirstIndexCaseInsensitive​

multiSearchFirstIndexUTF8​

multiSearchFirstIndexCaseInsensitiveUTF8​

multiSearchAny​

multiSearchAnyCaseInsensitive​

multiSearchAnyUTF8​

multiSearchAnyCaseInsensitiveUTF8​

hasAnyTokens​

hasAllTokens​

match​

multiMatchAny​

multiMatchAnyIndex​

multiMatchAllIndices​

multiFuzzyMatchAny​

multiFuzzyMatchAnyIndex​

multiFuzzyMatchAllIndices​

extract​

extractAll​

extractAllGroupsHorizontal​

extractGroups​

extractAllGroupsVertical​

like​

notLike​

ilike​

notILike​

ngramDistance​

ngramDistanceCaseInsensitive​

ngramDistanceUTF8​

ngramDistanceCaseInsensitiveUTF8​

ngramSearch​

ngramSearchCaseInsensitive​

ngramSearchUTF8​

ngramSearchCaseInsensitiveUTF8​

countSubstrings​

countSubstringsCaseInsensitive​

countSubstringsCaseInsensitiveUTF8​

countMatches​

countMatchesCaseInsensitive​

regexpExtract​

hasSubsequence​

hasSubsequenceCaseInsensitive​

hasSubsequenceUTF8​

hasSubsequenceCaseInsensitiveUTF8​

hasToken​

hasTokenOrNull​

hasTokenCaseInsensitive​

hasTokenCaseInsensitiveOrNull​

position

locate

positionCaseInsensitive

positionUTF8

positionCaseInsensitiveUTF8

multiSearchAllPositions

multiSearchAllPositionsCaseInsensitive

multiSearchAllPositionsUTF8

multiSearchAllPositionsCaseInsensitiveUTF8

multiSearchFirstPosition

multiSearchFirstPositionCaseInsensitive

multiSearchFirstPositionUTF8

multiSearchFirstPositionCaseInsensitiveUTF8

multiSearchFirstIndex

multiSearchFirstIndexCaseInsensitive

multiSearchFirstIndexUTF8

multiSearchFirstIndexCaseInsensitiveUTF8

multiSearchAny

multiSearchAnyCaseInsensitive

multiSearchAnyUTF8

multiSearchAnyCaseInsensitiveUTF8

hasAnyTokens

hasAllTokens

match

multiMatchAny

multiMatchAnyIndex

multiMatchAllIndices

multiFuzzyMatchAny

multiFuzzyMatchAnyIndex

multiFuzzyMatchAllIndices

extract

extractAll

extractAllGroupsHorizontal

extractGroups

extractAllGroupsVertical

like

notLike

ilike

notILike

ngramDistance

ngramDistanceCaseInsensitive

ngramDistanceUTF8

ngramDistanceCaseInsensitiveUTF8

ngramSearch

ngramSearchCaseInsensitive

ngramSearchUTF8

ngramSearchCaseInsensitiveUTF8

countSubstrings

countSubstringsCaseInsensitive

countSubstringsCaseInsensitiveUTF8

countMatches

countMatchesCaseInsensitive

regexpExtract

hasSubsequence

hasSubsequenceCaseInsensitive

hasSubsequenceUTF8

hasSubsequenceCaseInsensitiveUTF8

hasToken

hasTokenOrNull

hasTokenCaseInsensitive

hasTokenCaseInsensitiveOrNull