Перейти к основному содержанию
Все функции в этом разделе по умолчанию выполняют поиск с учетом регистра. Регистронезависимый поиск обычно реализован в виде отдельных вариантов функций.
Регистронезависимый поиск следует правилам преобразования символов в нижний и верхний регистр, принятым в английском языке. Например, прописная буква для i в английском языке — I, тогда как в турецком языке — İ; поэтому для языков, отличных от английского, результаты могут быть неожиданными.
Функции в этом разделе также предполагают, что строка, в которой выполняется поиск (в этом разделе она обозначается как haystack), и искомая строка (в этом разделе она обозначается как needle) представляют собой текст в однобайтовой кодировке. Если это предположение нарушено, исключение не сгенерируется, а результаты не определены. Поиск по строкам в кодировке UTF-8 обычно реализован в виде отдельных вариантов функций. Аналогично, если используется вариант функции для UTF-8, а входные строки не являются текстом в кодировке UTF-8, исключение не сгенерируется, а результаты не определены. Обратите внимание, что автоматическая нормализация Unicode не выполняется, однако для этого можно использовать функции normalizeUTF8*(). Общие функции для работы со строками и функции замены в строках описаны отдельно.
Приведенная ниже документация сгенерирована на основе системной таблицы system.functions.

​
countMatches

Добавленный в: v21.1.0 Возвращает количество совпадений регулярного выражения в строке.
Поведение зависит от версииПоведение этой функции зависит от версии ClickHouse:
  • в версиях < v25.6 функция прекращает подсчёт на первом пустом совпадении, даже если шаблон регулярного выражения его допускает.
  • в версиях >= 25.6 функция продолжает работу при возникновении пустого совпадения. Прежнее поведение можно восстановить с помощью настройки count_matches_stop_at_empty_match = true;
Синтаксис 
countMatches(haystack, pattern)
Аргументы
  • haystack — Строка, в которой выполняется поиск. String
  • pattern — Шаблон регулярного выражения. String
Возвращаемое значение Возвращает количество найденных совпадений. UInt64 Примеры Подсчёт последовательностей цифр
Query
SELECT countMatches('hello 123 world 456 test', '[0-9]+')
Response
┌─countMatches('hello 123 world 456 test', '[0-9]+')─┐
│                                                   2 │
└─────────────────────────────────────────────────────┘

​
countMatchesCaseInsensitive

Добавленный в: v21.1.0 Как countMatches, но выполняет поиск без учета регистра. Синтаксис 
countMatchesCaseInsensitive(haystack, pattern)
Аргументы
  • haystack — Строка, в которой выполняется поиск. String
  • pattern — Шаблон регулярного выражения. const String
Возвращаемое значение Возвращает количество найденных совпадений. UInt64 Примеры Подсчёт без учёта регистра
Query
SELECT countMatchesCaseInsensitive('Hello HELLO world', 'hello')
Response
┌─countMatchesCaseInsensitive('Hello HELLO world', 'hello')─┐
│                                                         2 │
└───────────────────────────────────────────────────────────┘

​
countSubstrings

Добавленный в: v21.1.0 Возвращает, сколько раз подстрока needle встречается в строке haystack. Синтаксис 
countSubstrings(haystack, needle[, start_pos])
Аргументы
  • haystack — Строка, в которой выполняется поиск. String или Enum. - needle — Подстрока, которую требуется найти. String. - start_pos — Позиция (нумерация начинается с 1) в haystack, с которой начинается поиск. UInt. Необязательный.
Возвращаемое значение Количество вхождений. UInt64 Примеры Пример использования
Query
SELECT countSubstrings('aaaa', 'aa');
Response
┌─countSubstrings('aaaa', 'aa')─┐
│                             2 │
└───────────────────────────────┘
С аргументом start_pos
Query
SELECT countSubstrings('abc___abc', 'abc', 4);
Response
┌─countSubstrings('abc___abc', 'abc', 4)─┐
│                                      1 │
└────────────────────────────────────────┘

​
countSubstringsCaseInsensitive

Добавленный в: v21.1.0 Как countSubstrings, но считает без учета регистра. Синтаксис 
countSubstringsCaseInsensitive(haystack, needle[, start_pos])
Аргументы
  • haystack — Строка, в которой выполняется поиск. String или Enum
  • needle — Искомая подстрока. String
  • start_pos — Необязательно. Позиция (с отсчётом от 1) в haystack, с которой начинается поиск. UInt*
Возвращаемое значение Возвращает количество вхождений needle в haystack. UInt64 Примеры Пример использования
Query
SELECT countSubstringsCaseInsensitive('AAAA', 'aa');
Response
┌─countSubstri⋯AAA', 'aa')─┐
│                        2 │
└──────────────────────────┘
С аргументом start_pos
Query
SELECT countSubstringsCaseInsensitive('abc___ABC___abc', 'abc', 4);
Response
┌─countSubstri⋯, 'abc', 4)─┐
│                        2 │
└──────────────────────────┘

​
countSubstringsCaseInsensitiveUTF8

Добавленный в: v21.1.0 Аналогично countSubstrings, но выполняет регистронезависимый подсчёт и предполагает, что haystack — строка UTF-8. Синтаксис 
countSubstringsCaseInsensitiveUTF8(haystack, needle[, start_pos])
Аргументы
  • haystack — UTF-8-строка, в которой выполняется поиск. String или Enum
  • needle — Подстрока, которую нужно найти. String
  • start_pos — Необязательно. Позиция (начиная с 1) в haystack, с которой начинается поиск. UInt*
Возвращаемое значение Возвращает количество вхождений needle в haystack. UInt64 Примеры Пример использования
Query
SELECT countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА');
Response
┌─countSubstri⋯шка', 'КА')─┐
│                        4 │
└──────────────────────────┘
С аргументом start_pos
Query
SELECT countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА', 13);
Response
┌─countSubstri⋯, 'КА', 13)─┐
│                        2 │
└──────────────────────────┘

​
extract

Добавленный в: v1.1.0 Извлекает первое совпадение с регулярным выражением из строки. Если ‘haystack’ не соответствует ‘pattern’, возвращается пустая строка. Эта функция использует библиотеку регулярных выражений RE2. Поддерживаемый синтаксис см. в re2. Если регулярное выражение содержит группы захвата (подшаблоны), функция сопоставляет входную строку с первой группой захвата. Синтаксис 
extract(haystack, pattern)
Аргументы
  • haystack — Строка, из которой извлекаются данные. String
  • pattern — Регулярное выражение, обычно содержащее группу захвата. const String
Возвращаемое значение Возвращает извлечённый фрагмент в виде строки. String Примеры Извлечение домена из адреса электронной почты
Query
SELECT extract('test@clickhouse.com', '.*@(.*)$')
Response
┌─extract('test@clickhouse.com', '.*@(.*)$')─┐
│ clickhouse.com                            │
└───────────────────────────────────────────┘
Если совпадений нет, возвращается пустая строка
Query
SELECT extract('test@clickhouse.com', 'no_match')
Response
┌─extract('test@clickhouse.com', 'no_match')─┐
│                                            │
└────────────────────────────────────────────┘

​
extractAll

Добавленный в: v1.1.0 Как extract, но возвращает массив всех совпадений шаблона регулярного выражения в строке. Если ‘haystack’ не соответствует regex ‘pattern’, возвращается пустой массив. Если регулярное выражение содержит группы захвата (подшаблоны), функция сопоставляет входную строку с первой группой захвата. Синтаксис 
extractAll(haystack, pattern)
Аргументы
  • haystack — Строка, из которой извлекаются фрагменты. String
  • pattern — Шаблон регулярного выражения, при необходимости содержащий группы захвата. const String
Возвращаемое значение Возвращает массив извлечённых фрагментов. Array(String) Примеры Извлечение всех чисел
Query
SELECT extractAll('hello 123 world 456', '[0-9]+')
Response
┌─extractAll('hello 123 world 456', '[0-9]+')─┐
│ ['123','456']                               │
└─────────────────────────────────────────────┘
Извлечь с помощью группы захвата
Query
SELECT extractAll('test@example.com, user@domain.org', '([a-zA-Z0-9]+)@')
Response
┌─extractAll('test@example.com, user@domain.org', '([a-zA-Z0-9]+)@')─┐
│ ['test','user']                                                    │
└────────────────────────────────────────────────────────────────────┘

​
extractAllGroupsHorizontal

Добавленный в: v20.5.0 Сопоставляет все группы в строке с помощью указанного регулярного выражения и возвращает массив массивов, где каждый массив содержит все совпадения одной и той же группы захвата, упорядоченные по номеру группы. Синтаксис 
extractAllGroupsHorizontal(s, regexp)
Аргументы
  • s — Входная строка, из которой выполняется извлечение. String или FixedString
  • regexp — Регулярное выражение для поиска совпадений. const String или const FixedString
Возвращаемое значение Возвращает массив массивов, где каждый внутренний массив содержит все подстроки, захваченные одной группой захвата во всех совпадениях. Первый внутренний массив содержит все захваченные подстроки из группы 1, второй — из группы 2 и т. д. Если совпадения не найдены, возвращается пустой массив. Array(Array(String)) Примеры Пример использования
Query
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
[['Server','Date','Content-Type','Connection'],['nginx','Tue, 22 Jan 2019 00:26:14 GMT','text/html; charset=UTF-8','keep-alive']]

​
extractGroups

Добавленный в: v20.5.0 Извлекает группы захвата из первой подстроки, соответствующей регулярному выражению. Чтобы извлечь группы из всех совпадений, используйте extractAllGroupsHorizontal или extractAllGroupsVertical. Синтаксис 
extractGroups(s, regexp)
Аргументы
  • s — Входная строка, из которой выполняется извлечение. String или FixedString
  • regexp — Регулярное выражение. Должно содержать как минимум одну группу захвата. Константа. const String или const FixedString
Возвращаемое значение Если регулярное выражение найдено, возвращается массив, содержащий группы захвата (1–N, где N — число групп захвата в regexp) из первого совпадения. Если совпадений нет, возвращается пустой массив. Array(String) Примеры Пример использования
Query
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
['Server','nginx']

​
hasAllTokens

Добавленный в: v25.10.0 Аналогично hasAnyTokens, но возвращает 1, если все токены строки или массива needle совпадают со строкой input, и 0 в противном случае. Если input является столбцом, возвращает все строки, удовлетворяющие этому условию.
Для столбца input должен быть определён текстовый индекс для достижения оптимальной производительности. Если текстовый индекс не определён, функция выполняет полное сканирование столбца, которое на порядки медленнее, чем поиск по индексу.
Перед поиском функция токенизирует
  • аргумент input (всегда), и
  • аргумент needle (если он задан как String) с использованием токенизатора, указанного для текстового индекса. Если для столбца не задан текстовый индекс, вместо него используется токенизатор splitByNonAlpha. Если аргумент needle имеет тип Array(String), каждый элемент массива рассматривается как токен — дополнительная токенизация не выполняется.
Повторяющиеся токены игнорируются. Например, needles = [‘ClickHouse’, ‘ClickHouse’] обрабатывается так же, как [‘ClickHouse’]. Синтаксис 
hasAllTokens(input, needles)
Псевдонимы: hasAllToken Аргументы
  • input — Входной столбец. String или FixedString или Array(String) или Array(FixedString)
  • needles — Искомые токены. String или Array(String)
  • tokenizer — токенизатор, который следует использовать. Допустимые аргументы: splitByNonAlpha, splitByString, asciiCJK, ngrams, sparseGrams и array. Необязательный параметр; если он явно не задан, по умолчанию используется splitByNonAlpha. const String
Возвращаемое значение Возвращает 1, если все искомые подстроки найдены, иначе 0. UInt8 Примеры Базовое использование со строковой подстрокой для поиска
Query
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
┌─count()─┐
│       1 │
└─────────┘
Укажите искомые подстроки в массиве как есть (без токенизации)
Query
SELECT count() FROM table WHERE hasAllTokens(msg, ['a', 'd']);
Response
┌─count()─┐
│       1 │
└─────────┘
Генерация искомых подстрок с помощью функции tokens
Query
SELECT count() FROM table WHERE hasAllTokens(msg, tokens('a()d', 'splitByString', ['()', '\\']));
Response
┌─count()─┐
│       1 │
└─────────┘
Использование пользовательского токенизатора через 3-й аргумент
Query
SELECT hasAllTokens('abcdef', 'abc', 'ngrams(3)');
Response
┌─hasAllTokens('abcdef', 'abc', 'ngrams(3)')─┐
│                                            1 │
└──────────────────────────────────────────────┘
Примеры использования для столбцов типа array и map
Query
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
Пример сo столбцом типа Array
Query
SELECT count() FROM log WHERE hasAllTokens(tags, 'clickhouse');
Response
┌─count()─┐
│       1 │
└─────────┘
Пример с mapKeys
Query
SELECT count() FROM log WHERE hasAllTokens(mapKeys(attributes), ['address', 'log_level']);
Response
┌─count()─┐
│       1 │
└─────────┘
Пример с mapValues
Query
SELECT count() FROM log WHERE hasAllTokens(mapValues(attributes), ['192.0.0.1', 'DEBUG']);
Response
┌─count()─┐
│       0 │
└─────────┘

​
hasAnyTokens

Добавленный в: v25.10.0 Возвращает 1, если хотя бы один токен из строки или массива needle совпадает со строкой input, и 0 в противном случае. Если input является столбцом, возвращает все строки, удовлетворяющие данному условию.
Для оптимальной производительности для столбца input следует определить текстовый индекс. Если текстовый индекс не определён, функция выполняет полное сканирование столбца, которое на порядки медленнее, чем поиск по индексу.
Перед поиском функция токенизирует
  • аргумент input (всегда), и
  • аргумент needle (если он задан как String) с использованием токенизатора, указанного для текстового индекса. Если для столбца не определён текстовый индекс, вместо него используется токенизатор splitByNonAlpha. Если аргумент needle имеет тип Array(String), каждый элемент массива обрабатывается как токен — дополнительная токенизация не выполняется.
Повторяющиеся токены игнорируются. Например, [‘ClickHouse’, ‘ClickHouse’] обрабатывается так же, как [‘ClickHouse’]. Синтаксис 
hasAnyTokens(input, needles)
Псевдонимы: hasAnyToken Аргументы Возвращаемое значение Возвращает 1, если найдено хотя бы одно совпадение, иначе 0. UInt8 Примеры Базовое использование со строковым needle
Query
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
┌─count()─┐
│       3 │
└─────────┘
Укажите искомые подстроки (needle) в массиве как есть, без токенизации (AS-IS)
Query
SELECT count() FROM table WHERE hasAnyTokens(msg, ['a', 'd']);
Response
┌─count()─┐
│       3 │
└─────────┘
Генерация искомых подстрок с помощью функции tokens
Query
SELECT count() FROM table WHERE hasAnyTokens(msg, tokens('a()d', 'splitByString', ['()', '\\']));
Response
┌─count()─┐
│       3 │
└─────────┘
Примеры использования для столбцов типа array и map
Query
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
Пример со столбцом типа Array
Query
SELECT count() FROM log WHERE hasAnyTokens(tags, 'clickhouse');
Response
┌─count()─┐
│       1 │
└─────────┘
Пример с mapKeys
Query
SELECT count() FROM log WHERE hasAnyTokens(mapKeys(attributes), ['address', 'log_level']);
Response
┌─count()─┐
│       2 │
└─────────┘
Пример с mapValues
Query
SELECT count() FROM log WHERE hasAnyTokens(mapValues(attributes), ['192.0.0.1', 'DEBUG']);
Response
┌─count()─┐
│       2 │
└─────────┘

​
hasPhrase

Добавленный в: v26.4.0 Проверяет, содержит ли haystack все токены из фразы в заданной последовательности. Перед поиском функция токенизирует аргументы input и phrase с помощью токенизатора, указанного в необязательном третьем аргументе. Аргумент токенизатора должен быть одним из следующих: splitByNonAlpha, splitByString, ngrams или asciiCJK. Если токенизатор не указан, по умолчанию используется splitByNonAlpha. В отличие от hasToken, hasAnyTokens и hasAllTokens, hasPhrase требует, чтобы токены шли в том же порядке и без каких-либо токенов между ними. Например, hasPhrase('the quick brown fox', 'quick fox') возвращает 0, поскольку “brown” находится между “quick” и “fox”. Синтаксис 
hasPhrase(input, phrase[, tokenizer])
Псевдонимы: matchPhrase Аргументы
  • input — Входной столбец. String или FixedString
  • phrase — Искомая фраза. const String
  • tokenizer — Используемый токенизатор. Необязательный параметр, по умолчанию — splitByNonAlpha. const String
Возвращаемое значение Возвращает 1, если фраза найдена как непрерывная последовательность токенов, иначе 0. UInt8 Примеры Совпадение по фразе
Query
SELECT hasPhrase('the quick brown fox jumps', 'quick brown')
Response
┌─hasPhrase('the quick brown fox jumps', 'quick brown')─┐
│                                                      1 │
└────────────────────────────────────────────────────────┘
Несмежные токены
Query
SELECT hasPhrase('the quick brown fox jumps', 'quick fox')
Response
┌─hasPhrase('the quick brown fox jumps', 'quick fox')─┐
│                                                    0 │
└──────────────────────────────────────────────────────┘

​
hasSubsequence

Добавленный в: v23.7.0 Проверяет, является ли needle подпоследовательностью haystack. Подпоследовательность строки — это последовательность, которую можно получить из другой строки, удалив некоторые или не удалив ни одного символа без изменения порядка оставшихся символов. Синтаксис 
hasSubsequence(haystack, needle)
Аргументы
  • haystack — Строка, в которой ищется подпоследовательность. String
  • needle — Подпоследовательность, которую нужно найти. String
Возвращаемое значение Возвращает 1, если needle является подпоследовательностью haystack, и 0 в противном случае. UInt8 Примеры Базовая проверка подпоследовательности
Query
SELECT hasSubsequence('Hello World', 'HlWrd')
Response
┌─hasSubsequence('Hello World', 'HlWrd')─┐
│                                      1 │
└────────────────────────────────────────┘
Подпоследовательность не найдена
Query
SELECT hasSubsequence('Hello World', 'xyz')
Response
┌─hasSubsequence('Hello World', 'xyz')─┐
│                                    0 │
└──────────────────────────────────────┘

​
hasSubsequenceCaseInsensitive

Добавленный в: v23.7.0 Как hasSubsequence, но ищет без учета регистра. Синтаксис 
hasSubsequenceCaseInsensitive(haystack, needle)
Аргументы
  • haystack — Строка, в которой выполняется поиск. String
  • needle — Подпоследовательность, которую требуется найти. String
Возвращаемое значение Возвращает 1, если needle является подпоследовательностью haystack, иначе — 0. UInt8 Примеры Пример использования
Query
SELECT hasSubsequenceCaseInsensitive('garbage', 'ARG');
Response
┌─hasSubsequenceCaseInsensitive('garbage', 'ARG')─┐
│                                               1 │
└─────────────────────────────────────────────────┘

​
hasSubsequenceCaseInsensitiveUTF8

Добавленный в: v23.7.0 Аналогично hasSubsequenceUTF8, но поиск выполняется регистронезависимо. Синтаксис 
hasSubsequenceCaseInsensitiveUTF8(haystack, needle)
Аргументы
  • haystack — строка в кодировке UTF-8, в которой выполняется поиск. String
  • needle — строка-подпоследовательность в кодировке UTF-8, которую требуется найти. String
Возвращаемое значение Возвращает 1, если needle является подпоследовательностью haystack, иначе 0. UInt8 Примеры Пример использования
Query
SELECT hasSubsequenceCaseInsensitiveUTF8('ClickHouse - столбцовая система управления базами данных', 'СИСТЕМА');
Response
┌─hasSubsequen⋯ 'СИСТЕМА')─┐
│                        1 │
└──────────────────────────┘

​
hasSubsequenceUTF8

Добавленный в: v23.7.0 Как hasSubsequence, но предполагается, что haystack и needle — строки в кодировке UTF-8. Синтаксис 
hasSubsequenceUTF8(haystack, needle)
Аргументы
  • haystack — Строка, в которой выполняется поиск. String
  • needle — Искомая подпоследовательность. String
Возвращаемое значение Возвращает 1, если needle является подпоследовательностью haystack, в противном случае — 0. UInt8 Примеры Пример использования
Query
SELECT hasSubsequenceUTF8('картошка', 'кошка');
Response
┌─hasSubsequen⋯', 'кошка')─┐
│                        1 │
└──────────────────────────┘
Несовпадающая подпоследовательность
Query
SELECT hasSubsequenceUTF8('картошка', 'апельсин');
Response
┌─hasSubsequen⋯'апельсин')─┐
│                        0 │
└──────────────────────────┘

​
hasToken

Добавленный в: v20.1.0 Проверяет, содержится ли указанный токен в строке. Использует splitByNonAlpha в качестве токенизатора, то есть токен определяется как максимально длинная подпоследовательность идущих подряд символов [0-9A-Za-z_] (цифры, символы ASCII и символ подчёркивания). Синтаксис 
hasToken(haystack, token)
Аргументы
  • haystack — Строка, в которой выполняется поиск. String
  • token — Токен, который нужно найти. const String
Возвращаемое значение Возвращает 1, если токен найден, и 0 в противном случае. UInt8 Примеры Поиск токена
Query
SELECT hasToken('clickhouse test', 'test')
Response
┌─hasToken('clickhouse test', 'test')─┐
│                                   1 │
└─────────────────────────────────────┘

​
hasTokenCaseInsensitive

Добавленный в: v20.1.0 Выполняет регистронезависимый поиск needle в haystack с использованием индекса tokenbf_v1. Синтаксис 
hasTokenCaseInsensitive(haystack, needle)
Аргументы
  • Отсутствуют.
Возвращаемое значение Примеры

​
hasTokenCaseInsensitiveOrNull

Добавленный в: v23.1.0 Выполняет регистронезависимый поиск needle в haystack с использованием индекса tokenbf_v1. Возвращает NULL, если needle некорректно сформирован. Синтаксис 
hasTokenCaseInsensitiveOrNull(haystack, needle)
Аргументы
  • Отсутствуют.
Возвращаемое значение Примеры

​
hasTokenOrNull

Добавленный в: v20.1.0 Как hasToken, но возвращает NULL, если токен некорректно сформирован. Синтаксис 
hasTokenOrNull(haystack, token)
Аргументы
  • haystack — Строка, в которой выполняется поиск. Должна быть константой. String
  • token — Токен, который нужно найти. const String
Возвращаемое значение Возвращает 1, если токен найден, иначе 0; null, если токен некорректен. Nullable(UInt8) Примеры Пример использования
Query
SELECT hasTokenOrNull('apple banana cherry', 'ban ana');
Response
┌─hasTokenOrNu⋯ 'ban ana')─┐
│                     ᴺᵁᴸᴸ │
└──────────────────────────┘

​
highlight

Добавленный в: v26.4.0 Выделяет вхождения поисковых запросов в текстовой строке, оборачивая их в HTML-теги. Функция выполняет регистронезависимый поиск ASCII. Если несколько поисковых запросов перекрываются или расположены в тексте вплотную друг к другу, совпавшие области объединяются в один выделенный фрагмент. Синтаксис 
highlight(haystack, needles[, open_tag, close_tag])
Аргументы
  • haystack — Текст, в котором выполняется поиск. String или FixedString
  • needles — Массив строк поиска, которые нужно выделить. const Array(String)
  • open_tag — Открывающий тег, вставляемый перед каждым совпадением. По умолчанию: <em>. const String
  • close_tag — Закрывающий тег, вставляемый после каждого совпадения. По умолчанию: </em>. const String
Возвращаемое значение Возвращает исходный текст, в котором найденные строки поиска обёрнуты в указанные теги. String Примеры Простое выделение
Query
SELECT highlight('The quick brown fox', ['quick', 'fox'])
Response
┌─highlight('The quick brown fox', ['quick', 'fox'])─┐
│ The <em>quick</em> brown <em>fox</em>              │
└────────────────────────────────────────────────────┘
Пользовательские теги
Query
SELECT highlight('Hello World', ['hello'], '<b>', '</b>')
Response
┌─highlight('Hello World', ['hello'], '<b>', '</b>')─┐
│ <b>Hello</b> World                                 │
└────────────────────────────────────────────────────┘

​
ilike

Добавленный в: v20.6.0 Как like, но выполняет регистронезависимый поиск. Синтаксис 
ilike(haystack, pattern)
-- haystack ILIKE pattern
Аргументы
  • haystack — строка, в которой выполняется поиск. String или FixedString
  • pattern — шаблон регулярного выражения LIKE, с которым выполняется сопоставление. String
Возвращаемое значение Возвращает 1, если строка соответствует шаблону регулярного выражения LIKE без учёта регистра, иначе 0. UInt8 Примеры Пример использования
Query
SELECT ilike('ClickHouse', '%house%');
Response
┌─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 обратные косые черты в строках также нужно экранировать в соответствии с синтаксисом строк, поэтому фактически нужно писать \\%, \\_ и \\\\.
Для выражений LIKE вида %needle% функция работает так же быстро, как функция position. Все остальные выражения LIKE внутренне преобразуются в регулярное выражение и выполняются с производительностью, аналогичной функции match. Синтаксис 
like(haystack, pattern)
-- haystack LIKE pattern
Аргументы
  • haystack — строка, в которой выполняется поиск. String или FixedString
  • pattern — шаблон регулярного выражения LIKE для поиска совпадений. Может содержать % (соответствует любому количеству символов), _ (соответствует одному символу) и \ для экранирования. String
Возвращаемое значение Возвращает 1, если строка соответствует шаблону регулярного выражения LIKE, в противном случае — 0. UInt8 Примеры Пример использования
Query
SELECT like('ClickHouse', '%House');
Response
┌─like('ClickHouse', '%House')─┐
│                            1 │
└──────────────────────────────┘
Односимвольный подстановочный знак
Query
SELECT like('ClickHouse', 'Click_ouse');
Response
┌─like('ClickH⋯lick_ouse')─┐
│                        1 │
└──────────────────────────┘
Шаблон регулярного выражения без совпадения
Query
SELECT like('ClickHouse', '%SQL%');
Response
┌─like('ClickHouse', '%SQL%')─┐
│                           0 │
└─────────────────────────────┘

​
locate

Добавленный в: v18.16.0 То же, что и 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])
Аргументы
  • needle — Искомая подстрока. String
  • haystack — Строка, в которой выполняется поиск. String или Enum
  • start_pos — Необязательно. Позиция в haystack (с отсчётом от 1), с которой начинается поиск. UInt
Возвращаемое значение Возвращает начальную позицию в байтах (с отсчётом от 1), если подстрока найдена, и 0, если подстрока не найдена. UInt64 Примеры Базовое использование
Query
SELECT locate('ca', 'abcabc')
Response
┌─locate('ca', 'abcabc')─┐
│                      3 │
└────────────────────────┘

​
match

Добавленный в: v1.1.0 Проверяет, соответствует ли указанная строка заданному шаблону регулярного выражения. Эта функция использует библиотеку регулярных выражений RE2. Поддерживаемый синтаксис см. в re2. Сопоставление выполняется в предположении UTF-8; например, ¥ внутри занимает два байта, но при сопоставлении считается одной кодовой точкой. Регулярное выражение не должно содержать null-байты. Если haystack или шаблон регулярного выражения не являются корректным UTF-8, поведение не определено. В отличие от поведения re2 по умолчанию, . соответствует символам перевода строки. Чтобы отключить это, добавьте в начало шаблона (?-s). Шаблон не привязан к началу и концу строки. Чтобы сопоставить строку целиком, явно добавьте якоря ^ и $. Если вам нужно просто искать подстроки, вместо этой функции можно использовать like или position — они работают значительно быстрее. Альтернативный синтаксис оператора: haystack REGEXP pattern. Синтаксис 
match(haystack, pattern)
Псевдонимы: REGEXP_MATCHES Аргументы
  • haystack — Строка, в которой ищется шаблон. String
  • pattern — Шаблон регулярного выражения. const String
Возвращаемое значение Возвращает 1, если найдено совпадение с шаблоном, иначе — 0. UInt8 Примеры Простое сопоставление с шаблоном
Query
SELECT match('Hello World', 'Hello.*')
Response
┌─match('Hello World', 'Hello.*')─┐
│                               1 │
└─────────────────────────────────┘
Шаблон регулярного выражения не совпадает
Query
SELECT match('Hello World', 'goodbye.*')
Response
┌─match('Hello World', 'goodbye.*')─┐
│                                 0 │
└───────────────────────────────────┘
Поиск подстроки
Query
SELECT match('abcde', 'b.*d'), match('abcde', '^b.*d$')
Response
┌─match('abcde', 'b.*d')─┬─match('abcde', '^b.*d$')─┐
│                       1 │                         0 │
└─────────────────────────┴───────────────────────────┘

​
multiFuzzyMatchAllIndices

Добавленный в: v20.1.0 Как multiFuzzyMatchAny, но возвращает массив всех индексов в произвольном порядке, совпадающих со строкой haystack в пределах постоянного расстояния редактирования. Синтаксис 
multiFuzzyMatchAllIndices(haystack, distance, [pattern1, pattern2, ..., patternN])
Аргументы
  • haystack — Строка, в которой выполняется поиск. String
  • distance — Максимальное расстояние редактирования для нечеткого сопоставления. UInt8
  • pattern — Массив шаблонов регулярного выражения для сопоставления. Array(String)
Возвращаемое значение Возвращает массив всех индексов (начиная с 1) шаблонов регулярного выражения, которые соответствуют строке haystack в пределах указанного расстояния редактирования, в любом порядке. Если совпадений нет, возвращается пустой массив. Array(UInt64) Примеры Пример использования
Query
SELECT multiFuzzyMatchAllIndices('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose', 'House']);
Response
┌─multiFuzzyMa⋯, 'House'])─┐
│ [3,1,4,2]                │
└──────────────────────────┘

​
multiFuzzyMatchAny

Добавленный в: v20.1.0 Как multiMatchAny, но возвращает 1, если любой шаблон регулярного выражения совпадает со строкой в пределах фиксированного расстояния редактирования. Эта функция использует экспериментальную возможность библиотеки hyperscan и в некоторых пограничных случаях может работать медленно. Производительность зависит от значения расстояния редактирования и используемых шаблонов регулярного выражения, но по сравнению с вариантами без нечёткого сопоставления она всегда ниже.
Семейство функций multiFuzzyMatch*() не поддерживает регулярные выражения UTF-8 (они обрабатываются как последовательность байтов) из-за ограничений hyperscan.
Синтаксис 
multiFuzzyMatchAny(haystack, distance, [pattern1, pattern2, ..., patternN])
Аргументы
  • haystack — Строка, в которой выполняется поиск. String
  • distance — Максимальное расстояние редактирования для нечеткого сопоставления. UInt8
  • pattern — Необязательно. Массив шаблонов регулярного выражения для сопоставления. Array(String)
Возвращаемое значение Возвращает 1, если хотя бы один шаблон регулярного выражения совпадает со строкой haystack в пределах указанного расстояния редактирования, в противном случае — 0. UInt8 Примеры Пример использования
Query
SELECT multiFuzzyMatchAny('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose']);
Response
┌─multiFuzzyMa⋯lickHose'])─┐
│                        1 │
└──────────────────────────┘

​
multiFuzzyMatchAnyIndex

Добавленный в: v20.1.0 Аналогично multiFuzzyMatchAny, но возвращает любой индекс, для которого haystack совпадает в пределах постоянного расстояния редактирования. Синтаксис 
multiFuzzyMatchAnyIndex(haystack, distance, [pattern1, pattern2, ..., patternn])
Аргументы
  • haystack — Строка, по которой выполняется поиск. String
  • distance — Максимальное расстояние редактирования для нечеткого сопоставления. UInt8
  • pattern — Массив шаблонов регулярного выражения для поиска совпадений. Array(String)
Возвращаемое значение Возвращает индекс (начиная с 1) любого шаблона регулярного выражения, который совпадает с haystack в пределах указанного расстояния редактирования; в противном случае — 0. UInt64 Примеры Пример использования
Query
SELECT multiFuzzyMatchAnyIndex('ClickHouse', 2, ['ClckHouse', 'ClickHose', 'ClickHouse']);
Response
┌─multiFuzzyMa⋯ickHouse'])─┐
│                        2 │
└──────────────────────────┘

​
multiMatchAllIndices

Добавленный в: v20.1.0 Как и multiMatchAny, но возвращает массив всех индексов, совпадающих с haystack, в любом порядке. Синтаксис 
multiMatchAllIndices(haystack, [pattern1, pattern2, ..., patternn])
Аргументы
  • haystack — Строка, в которой выполняется поиск. String
  • pattern — Шаблоны регулярного выражения, с которыми выполняется сопоставление. String
Возвращаемое значение Массив всех индексов (начиная с 1) шаблонов регулярного выражения, совпадающих с haystack, в произвольном порядке. Если совпадений не найдено, возвращается пустой массив. Array(UInt64) Примеры Пример использования
Query
SELECT multiMatchAllIndices('ClickHouse', ['[0-9]', 'House', 'Click', 'ouse']);
Response
┌─multiMatchAl⋯', 'ouse'])─┐
│ [3, 2, 4]                │
└──────────────────────────┘

​
multiMatchAny

Добавленный в: v20.1.0 Проверяет, соответствует ли исходной строке хотя бы один из нескольких шаблонов регулярного выражения. Если вам нужно искать в строке только несколько подстрок, вместо этого можно использовать функцию multiSearchAny — она работает гораздо быстрее. Синтаксис 
multiMatchAny(haystack, pattern1[, pattern2, ...])
Аргументы
  • haystack — Строка, в которой выполняется поиск. String
  • pattern1[, pattern2, ...] — Массив из одного или нескольких шаблонов регулярных выражений. Array(String)
Возвращаемое значение Возвращает 1, если найдено совпадение хотя бы с одним шаблоном, в противном случае — 0. UInt8 Примеры Сопоставление с несколькими шаблонами
Query
SELECT multiMatchAny('Hello World', ['Hello.*', 'foo.*'])
Response
┌─multiMatchAny('Hello World', ['Hello.*', 'foo.*'])─┐
│                                                  1 │
└────────────────────────────────────────────────────┘
Нет совпадений с шаблонами
Query
SELECT multiMatchAny('Hello World', ['goodbye.*', 'foo.*'])
Response
┌─multiMatchAny('Hello World', ['goodbye.*', 'foo.*'])─┐
│                                                    0 │
└──────────────────────────────────────────────────────┘

​
multiMatchAnyIndex

Добавленный в: v20.1.0 Аналогична multiMatchAny, но возвращает любой индекс, совпадающий со строкой haystack. Синтаксис 
multiMatchAnyIndex(haystack, [pattern1, pattern2, ..., patternn])
Аргументы
  • haystack — Строка, в которой выполняется поиск. String
  • pattern — Регулярные выражения, с которыми выполняется сопоставление. Array(String)
Возвращаемое значение Возвращает индекс (начиная с 1) первого шаблона регулярного выражения, который совпал, или 0, если совпадений не найдено. UInt64 Примеры Пример использования
Query
SELECT multiMatchAnyIndex('ClickHouse', ['[0-9]', 'House', 'Click']);
Response
┌─multiMatchAn⋯, 'Click'])─┐
│                        3 │
└──────────────────────────┘

​
multiSearchAllPositions

Добавленный в: v20.1.0 Аналогично position, но возвращает массив позиций (в байтах, начиная с 1) для нескольких подстрок needle в строке haystack. Все функции multiSearch*() поддерживают не более 2^8 подстрок needle. Синтаксис 
multiSearchAllPositions(haystack, needle1[, needle2, ...])
Аргументы
  • haystack — Строка, в которой выполняется поиск. String
  • needle1[, needle2, ...] — Массив из одной или нескольких подстрок, которые нужно найти. Array(String)
Возвращаемое значение Возвращает массив начальных позиций в байтах с отсчётом от 1, если подстрока найдена, и 0, если подстрока не найдена. Array(UInt64) Примеры Поиск по нескольким подстрокам
Query
SELECT multiSearchAllPositions('Hello, World!', ['hello', '!', 'world'])
Response
┌─multiSearchAllPositions('Hello, World!', ['hello', '!', 'world'])─┐
│ [0,13,0]                                                          │
└───────────────────────────────────────────────────────────────────┘

​
multiSearchAllPositionsCaseInsensitive

Добавленный в: v20.1.0 Аналогично multiSearchAllPositions, но игнорирует регистр. Синтаксис 
multiSearchAllPositionsCaseInsensitive(haystack, needle1[, needle2, ...])
Аргументы
  • haystack — Строка, в которой выполняется поиск. String
  • needle1[, needle2, ...] — Массив из одной или нескольких подстрок, которые нужно найти. Array(String)
Возвращаемое значение Возвращает массив начальных позиций в байтах, начиная с 1 (если подстрока найдена), и 0, если подстрока не найдена. Array(UInt64) Примеры Регистронезависимый поиск нескольких подстрок
Query
SELECT multiSearchAllPositionsCaseInsensitive('ClickHouse',['c','h'])
Response
┌─multiSearchA⋯['c', 'h'])─┐
│ [1,6]                    │
└──────────────────────────┘

​
multiSearchAllPositionsCaseInsensitiveUTF8

Добавленный в: v20.1.0 Как multiSearchAllPositionsUTF8, но позволяет игнорировать регистр. Синтаксис 
multiSearchAllPositionsCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
Аргументы
  • haystack — строка в кодировке UTF-8, в которой выполняется поиск. String
  • needle — подстроки в кодировке UTF-8, которые нужно найти. Array(String)
Возвращаемое значение Массив, содержащий начальные позиции в байтах, отсчитываемые от 1 (если подстрока найдена). Возвращает 0, если подстрока не найдена. Array Примеры Регистронезависимый поиск UTF-8
Query
SELECT multiSearchAllPositionsCaseInsensitiveUTF8('Здравствуй, мир!', ['здравствуй', 'МИР']);
Response
┌─multiSearchA⋯й', 'МИР'])─┐
│ [1, 13]                  │
└──────────────────────────┘

​
multiSearchAllPositionsUTF8

Добавленный в: v20.1.0 Аналогично multiSearchAllPositions, но предполагается, что haystack и подстроки needle являются строками в кодировке UTF-8. Синтаксис 
multiSearchAllPositionsUTF8(haystack, needle1[, needle2, ...])
Аргументы
  • haystack — строка в кодировке UTF-8, в которой выполняется поиск. String
  • needle1[, needle2, ...] — массив подстрок в кодировке UTF-8, которые нужно найти. Array(String)
Возвращаемое значение Возвращает массив начальных позиций в байтах, начиная с 1 (если подстрока найдена), или 0, если подстрока не найдена. Array Примеры Множественный поиск UTF-8
Query
SELECT multiSearchAllPositionsUTF8('ClickHouse',['C','H'])
Response
┌─multiSearchAllPositionsUTF8('ClickHouse', ['C', 'H'])─┐
│ [1,6]                                                 │
└───────────────────────────────────────────────────────┘

​
multiSearchAny

Добавленный в: v20.1.0 Проверяет, совпадает ли хотя бы одна из строк needle со строкой haystack. Функции multiSearchAnyCaseInsensitive, multiSearchAnyUTF8 и multiSearchAnyCaseInsensitiveUTF8 предоставляют регистронезависимые варианты и/или варианты с поддержкой UTF-8 для этой функции. Синтаксис 
multiSearchAny(haystack, needle1[, needle2, ...])
Аргументы
  • haystack — Строка, в которой выполняется поиск. String
  • needle1[, needle2, ...] — Массив подстрок, которые нужно найти. Array(String)
Возвращаемое значение Возвращает 1, если найдено хотя бы одно совпадение, иначе — 0. UInt8 Примеры Поиск по любому совпадению
Query
SELECT multiSearchAny('ClickHouse',['C','H'])
Response
┌─multiSearchAny('ClickHouse', ['C', 'H'])─┐
│                                        1 │
└──────────────────────────────────────────┘

​
multiSearchAnyCaseInsensitive

Добавленный в: v20.1.0 Как multiSearchAny, но позволяет игнорировать регистр символов. Синтаксис 
multiSearchAnyCaseInsensitive(haystack, [needle1, needle2, ..., needleN])
Аргументы
  • haystack — Строка, в которой выполняется поиск. String
  • needle — Подстроки, которые требуется найти. Array(String)
Возвращаемое значение Возвращает 1, если найдено хотя бы одно регистронезависимое совпадение, иначе — 0. UInt8 Примеры Регистронезависимый поиск
Query
SELECT multiSearchAnyCaseInsensitive('ClickHouse',['c','h'])
Response
┌─multiSearchAnyCaseInsensitive('ClickHouse', ['c', 'h'])─┐
│                                                       1 │
└─────────────────────────────────────────────────────────┘

​
multiSearchAnyCaseInsensitiveUTF8

Добавленный в: v20.1.0 То же, что и multiSearchAnyUTF8, но игнорирует регистр. Синтаксис 
multiSearchAnyCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
Аргументы
  • haystack — UTF-8-строка, в которой выполняется поиск. String
  • needle — UTF-8-подстроки, которые нужно найти. Array(String)
Возвращаемое значение Возвращает 1, если найдено хотя бы одно регистронезависимое совпадение, в противном случае — 0. UInt8 Примеры Для UTF-8-строки ‘Здравствуйте’ проверьте, присутствует ли символ ‘з’ (в нижнем регистре)
Query
SELECT multiSearchAnyCaseInsensitiveUTF8('Здравствуйте',['з'])
Response
┌─multiSearchA⋯те', ['з'])─┐
│                        1 │
└──────────────────────────┘

​
multiSearchAnyUTF8

Добавленный в: v20.1.0 Как и multiSearchAny, но предполагает, что haystack является UTF-8-строкой, а подстроки needle — UTF-8-подстроками. Синтаксис 
multiSearchAnyUTF8(haystack, [needle1, needle2, ..., needleN])
Аргументы
  • haystack — UTF-8-строка, в которой выполняется поиск. String
  • needle — UTF-8-подстроки, которые требуется найти. Array(String)
Возвращаемое значение Возвращает 1, если найдено хотя бы одно совпадение, в противном случае — 0. UInt8 Примеры Для UTF-8-строки ‘你好，世界’ (‘Hello, world’) проверьте, содержит ли строка символы 你 или 界
Query
SELECT multiSearchAnyUTF8('你好，世界', ['你', '界'])
Response
┌─multiSearchA⋯你', '界'])─┐
│                        1 │
└──────────────────────────┘

​
multiSearchFirstIndex

Добавленный в: v20.1.0 Выполняет поиск нескольких строк needle в строке haystack (с учетом регистра) и возвращает индекс первой найденной строки needle, начиная с 1. Синтаксис 
multiSearchFirstIndex(haystack, [needle1, needle2, ..., needleN])
Аргументы
  • haystack — Строка, в которой выполняется поиск. String
  • needles — Массив строк, которые нужно найти. Array(String)
Возвращаемое значение Возвращает индекс первой строки из needles, найденной в haystack (позиция в массиве needles, начиная с 1). Возвращает 0, если ни одна из строк из needles не найдена. Поиск чувствителен к регистру. UInt64 Примеры Пример использования
Query
SELECT multiSearchFirstIndex('ClickHouse Database', ['Click', 'Database', 'Server']);
Response
┌─multiSearchF⋯ 'Server'])─┐
│                        1 │
└──────────────────────────┘
Поведение с учетом регистра
Query
SELECT multiSearchFirstIndex('ClickHouse Database', ['CLICK', 'Database', 'Server']);
Response
┌─multiSearchF⋯ 'Server'])─┐
│                        2 │
└──────────────────────────┘
Совпадений не найдено
Query
SELECT multiSearchFirstIndex('Hello World', ['goodbye', 'test']);
Response
┌─multiSearchF⋯', 'test'])─┐
│                        0 │
└──────────────────────────┘

​
multiSearchFirstIndexCaseInsensitive

Добавленный в: v20.1.0 Возвращает индекс i (начиная с 1) самого левого вхождения needle&#95;i в строке haystack; если совпадение не найдено, возвращает 0. Игнорирует регистр. Синтаксис 
multiSearchFirstIndexCaseInsensitive(haystack, [needle1, needle2, ..., needleN]
Аргументы
  • haystack — Строка, в которой выполняется поиск. String
  • needle — Подстроки, которые нужно найти. Array(String)
Возвращаемое значение Возвращает индекс (начиная с 1) самого левого найденного needle. Если совпадений нет, возвращает 0. UInt8 Примеры Пример использования
Query
SELECT multiSearchFirstIndexCaseInsensitive('hElLo WoRlD', ['World', 'Hello']);
Response
┌─multiSearchF⋯, 'Hello'])─┐
│                        1 │
└──────────────────────────┘

​
multiSearchFirstIndexCaseInsensitiveUTF8

Добавленный в: v20.1.0 Ищет несколько строк-образцов в исходной строке регистронезависимым способом с поддержкой кодировки UTF-8 и возвращает индекс первого найденного образца, начиная с 1. Синтаксис 
multiSearchFirstIndexCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
Аргументы
  • haystack — Строка, в которой выполняется поиск. String
  • needles — Массив строк, которые нужно найти. Array(String)
Возвращаемое значение Возвращает 1-индексированный индекс (позицию в массиве needles) первой строки из needles, найденной в haystack. Возвращает 0, если не найдено ни одной строки. Поиск регистронезависим и выполняется с учетом кодировки UTF-8. UInt64 Примеры Пример использования
Query
SELECT multiSearchFirstIndexCaseInsensitiveUTF8('ClickHouse Database', ['CLICK', 'data', 'server']);
Response
┌─multiSearchF⋯ 'server'])─┐
│                        1 │
└──────────────────────────┘
Работа с регистром UTF-8
Query
SELECT multiSearchFirstIndexCaseInsensitiveUTF8('Привет Мир', ['мир', 'ПРИВЕТ']);
Response
┌─multiSearchF⋯ 'ПРИВЕТ'])─┐
│                        1 │
└──────────────────────────┘
Совпадений не найдено
Query
SELECT multiSearchFirstIndexCaseInsensitiveUTF8('Hello World', ['goodbye', 'test']);
Response
┌─multiSearchF⋯', 'test'])─┐
│                        0 │
└──────────────────────────┘

​
multiSearchFirstIndexUTF8

Добавленный в: v20.1.0 Возвращает индекс i (начиная с 1) самого левого найденного needle&#95;i в строке haystack; в противном случае возвращает 0. Предполагается, что haystack и needle — UTF-8-строки. Синтаксис 
multiSearchFirstIndexUTF8(haystack, [needle1, needle2, ..., needleN])
Аргументы
  • haystack — UTF-8-строка, в которой выполняется поиск. String
  • needle — массив UTF-8-подстрок, которые нужно найти. Array(String)
Возвращаемое значение Возвращает индекс (начиная с 1) крайнего левого найденного needle. Если совпадений нет, возвращает 0. UInt8 Примеры Пример использования
Query
SELECT multiSearchFirstIndexUTF8('Здравствуйте мир', ['мир', 'здравствуйте']);
Response
┌─multiSearchF⋯вствуйте'])─┐
│                        1 │
└──────────────────────────┘

​
multiSearchFirstPosition

Добавленный в: v20.1.0 Как position, но возвращает смещение самого первого вхождения в строке haystack, соответствующего любой из нескольких строк needle. Функции multiSearchFirstPositionCaseInsensitive, multiSearchFirstPositionUTF8 и multiSearchFirstPositionCaseInsensitiveUTF8 предоставляют регистронезависимый и/или UTF-8 варианты этой функции. Синтаксис 
multiSearchFirstPosition(haystack, needle1[, needle2, ...])
Аргументы
  • haystack — Строка, в которой выполняется поиск. String
  • needle1[, needle2, ...] — Массив из одной или нескольких подстрок, которые нужно найти. Array(String)
Возвращаемое значение Возвращает смещение самого левого совпадения в строке haystack с любой из подстрок needle, либо 0, если совпадений нет. UInt64 Примеры Поиск первой позиции
Query
SELECT multiSearchFirstPosition('Hello World',['llo', 'Wor', 'ld'])
Response
┌─multiSearchFirstPosition('Hello World', ['llo', 'Wor', 'ld'])─┐
│                                                             3 │
└───────────────────────────────────────────────────────────────┘

​
multiSearchFirstPositionCaseInsensitive

Добавленный в: v20.1.0 Аналогично multiSearchFirstPosition, но игнорирует регистр. Синтаксис 
multiSearchFirstPositionCaseInsensitive(haystack, [needle1, needle2, ..., needleN])
Аргументы
  • haystack — Строка, в которой выполняется поиск. String
  • needle — Массив подстрок, которые требуется найти. Array(String)
Возвращаемое значение Возвращает смещение первого вхождения в строке haystack, совпадающего с любой из строк needle. Возвращает 0, если совпадений нет. UInt64 Примеры Первая позиция при регистронезависимом поиске
Query
SELECT multiSearchFirstPositionCaseInsensitive('HELLO WORLD',['wor', 'ld', 'ello'])
Response
┌─multiSearchFirstPositionCaseInsensitive('HELLO WORLD', ['wor', 'ld', 'ello'])─┐
│                                                                             2 │
└───────────────────────────────────────────────────────────────────────────────┘

​
multiSearchFirstPositionCaseInsensitiveUTF8

Добавленный в: v20.1.0 Аналогично multiSearchFirstPosition, но предполагается, что haystack и needle — строки UTF-8, при этом регистр игнорируется. Синтаксис 
multiSearchFirstPositionCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
Аргументы
  • haystack — UTF-8-строка, в которой выполняется поиск. String
  • needle — массив UTF-8-подстрок для поиска. Array(String)
Возвращаемое значение Возвращает смещение самого левого вхождения в строке haystack, соответствующего любой из строк needle, без учета регистра. Возвращает 0, если совпадений нет. UInt64 Примеры Найдите смещение самого левого вхождения в UTF-8-строке ‘Здравствуй, мир’ (‘Hello, world’), соответствующего любой из заданных подстрок
Query
SELECT multiSearchFirstPositionCaseInsensitiveUTF8('Здравствуй, мир', ['МИР', 'вст', 'Здра'])
Response
┌─multiSearchFirstPositionCaseInsensitiveUTF8('Здравствуй, мир', ['мир', 'вст', 'Здра'])─┐
│                                                                                      3 │
└────────────────────────────────────────────────────────────────────────────────────────┘

​
multiSearchFirstPositionUTF8

Добавленный в: v20.1.0 Аналогично multiSearchFirstPosition, но предполагается, что haystack и needle — строки в кодировке UTF-8. Синтаксис 
multiSearchFirstPositionUTF8(haystack, [needle1, needle2, ..., needleN])
Аргументы
  • haystack — строка UTF-8, в которой выполняется поиск. String
  • needle — массив UTF-8-подстрок, которые нужно найти. Array(String)
Возвращаемое значение Смещение самого левого вхождения в строке haystack, совпадающего с любой из строк needle. Возвращает 0, если совпадений нет. UInt64 Примеры Найдите смещение самого левого вхождения в строке UTF-8 ‘Здравствуй, мир’ (‘Hello, world’), совпадающего с любой из заданных строк needle
Query
SELECT multiSearchFirstPositionUTF8('Здравствуй, мир',['мир', 'вст', 'авст'])
Response
┌─multiSearchFirstPositionUTF8('Здравствуй, мир', ['мир', 'вст', 'авст'])─┐
│                                                                       3 │
└─────────────────────────────────────────────────────────────────────────┘

​
ngramDistance

Добавленный в: v20.1.0 Вычисляет 4-граммное расстояние между двумя строками. Для этого вычисляется симметрическая разность двух мультимножеств 4-грамм и нормализуется по сумме их мощностей. Чем меньше возвращаемое значение, тем более похожи строки. Для регистронезависимого поиска и/или в формате UTF8 используйте функции ngramDistanceCaseInsensitive, ngramDistanceUTF8, ngramDistanceCaseInsensitiveUTF8. Синтаксис 
ngramDistance(haystack, needle)
Аргументы
  • haystack — строка для сравнения. String
  • needle — строка для сравнения. String
Возвращаемое значение Возвращает число типа Float32 в диапазоне от 0 до 1. Чем меньше возвращаемое значение, тем более похожи строки. Float32 Примеры Вычисление 4-граммного расстояния
Query
SELECT ngramDistance('ClickHouse', 'ClickHouses')
Response
┌─ngramDistance('ClickHouse', 'ClickHouses')─┐
│                                        0.1 │
└────────────────────────────────────────────┘

​
ngramDistanceCaseInsensitive

Добавленный в: v20.1.0 Предоставляет регистронезависимый вариант ngramDistance. Вычисляет 4-граммное расстояние между двумя строками без учета регистра. Чем меньше возвращаемое значение, тем больше строки похожи друг на друга. Синтаксис 
ngramDistanceCaseInsensitive(haystack, needle)
Аргументы
  • haystack — Первая строка для сравнения. String
  • needle — Вторая строка для сравнения. String
Возвращаемое значение Возвращает значение типа Float32 в диапазоне от 0 до 1. Float32 Примеры Регистронезависимое 4-граммное расстояние
Query
SELECT ngramDistanceCaseInsensitive('ClickHouse','clickhouse')
Response
┌─ngramDistanceCaseInsensitive('ClickHouse','clickhouse')─┐
│                                                       0 │
└─────────────────────────────────────────────────────────┘

​
ngramDistanceCaseInsensitiveUTF8

Добавленный в: v20.1.0 Предоставляет регистронезависимый UTF-8-вариант ngramDistance. Предполагается, что строки needle и haystack закодированы в UTF-8, при этом регистр игнорируется. Вычисляет 3-граммное расстояние между двумя UTF-8-строками без учета регистра. Чем меньше возвращаемое значение, тем больше сходство между строками. Синтаксис 
ngramDistanceCaseInsensitiveUTF8(haystack, needle)
Аргументы
  • haystack — Первая строка для сравнения в кодировке UTF-8. String
  • needle — Вторая строка для сравнения в кодировке UTF-8. String
Возвращаемое значение Возвращает число типа Float32 в диапазоне от 0 до 1. Float32 Примеры Регистронезависимое 3-граммное расстояние UTF-8
Query
SELECT ngramDistanceCaseInsensitiveUTF8('abcde','CDE')
Response
┌─ngramDistanceCaseInsensitiveUTF8('abcde','CDE')─┐
│                                             0.5 │
└─────────────────────────────────────────────────┘

​
ngramDistanceUTF8

Добавленный в: v20.1.0 Предоставляет вариант ngramDistance для строк UTF-8. Предполагается, что строки needle и haystack закодированы в UTF-8. Вычисляет 3-граммное расстояние между двумя строками UTF-8. Чем меньше возвращаемое значение, тем больше похожи строки. Синтаксис 
ngramDistanceUTF8(haystack, needle)
Аргументы
  • haystack — Первая строка для сравнения в кодировке UTF-8. String
  • needle — Вторая строка для сравнения в кодировке UTF-8. String
Возвращаемое значение Возвращает число типа Float32 в диапазоне от 0 до 1. Float32 Примеры 3-граммное расстояние в UTF-8
Query
SELECT ngramDistanceUTF8('abcde','cde')
Response
┌─ngramDistanceUTF8('abcde','cde')─┐
│                               0.5 │
└───────────────────────────────────┘

​
ngramSearch

Добавленный в: v20.1.0 Проверяет, меньше или равно ли 4-граммное расстояние между двумя строками заданному пороговому значению. Для регистронезависимого поиска и/или в формате UTF8 используйте функции ngramSearchCaseInsensitive, ngramSearchUTF8, ngramSearchCaseInsensitiveUTF8. Синтаксис 
ngramSearch(haystack, needle)
Аргументы
  • haystack — строка для сравнения. String
  • needle — строка для сравнения. String
Возвращаемое значение Возвращает 1, если 4-граммное расстояние между строками меньше или равно порогу (1.0 по умолчанию), в противном случае — 0. UInt8 Примеры Поиск с использованием 4-грамм
Query
SELECT ngramSearch('ClickHouse', 'Click')
Response
┌─ngramSearch('ClickHouse', 'Click')─┐
│                                  1 │
└────────────────────────────────────┘

​
ngramSearchCaseInsensitive

Добавленный в: v20.1.0 Представляет собой регистронезависимый вариант ngramSearch. Вычисляет несимметрическую разность между строкой needle и строкой haystack, то есть число n-грамм в needle минус число общих n-грамм, нормализованное по числу n-грамм в needle. Проверяет, что 4-граммное расстояние между двумя строками меньше или равно заданному порогу без учета регистра. Синтаксис 
ngramSearchCaseInsensitive(haystack, needle)
Аргументы
  • haystack — строка для сравнения. String
  • needle — строка для сравнения. String
Возвращаемое значение Возвращает 1, если 4-граммное расстояние между строками меньше или равно пороговому значению (1.0 по умолчанию), иначе — 0. UInt8 Примеры Регистронезависимый поиск с помощью 4-грамм
Query
SELECT ngramSearchCaseInsensitive('Hello World','hello')
Response
┌─ngramSearchCaseInsensitive('Hello World','hello')─┐
│                                                  1 │
└────────────────────────────────────────────────────┘

​
ngramSearchCaseInsensitiveUTF8

Добавленный в: v20.1.0 Предоставляет регистронезависимую UTF-8-версию ngramSearch. Предполагает, что haystack и needle являются строками UTF-8, и игнорирует регистр. Проверяет, что 3-граммное расстояние между двумя строками UTF-8 меньше или равно заданному порогу без учёта регистра. Синтаксис 
ngramSearchCaseInsensitiveUTF8(haystack, needle)
Аргументы
  • haystack — UTF-8-строка для сравнения. String
  • needle — UTF-8-строка для сравнения. String
Возвращаемое значение Возвращает 1, если 3-граммное расстояние между строками меньше или равно пороговому значению (по умолчанию 1.0), в противном случае — 0. UInt8 Примеры Регистронезависимый поиск UTF-8 с использованием 3-грамм
Query
SELECT ngramSearchCaseInsensitiveUTF8('абвГДЕёжз', 'АбвгдЕЁжз')
Response
┌─ngramSearchCaseInsensitiveUTF8('абвГДЕёжз', 'АбвгдЕЁжз')─┐
│                                                        1 │
└──────────────────────────────────────────────────────────┘

​
ngramSearchUTF8

Добавленный в: v20.1.0 Предоставляет вариант функции ngramSearch для UTF-8. Предполагается, что haystack и needle — строки UTF-8. Проверяет, что 3-граммное расстояние между двумя строками UTF-8 меньше или равно заданному порогу. Синтаксис 
ngramSearchUTF8(haystack, needle)
Аргументы
  • haystack — UTF-8-строка для сравнения. String
  • needle — UTF-8-строка для сравнения. String
Возвращаемое значение Возвращает 1, если 3-граммное расстояние между строками меньше или равно пороговому значению (по умолчанию 1.0), иначе — 0. UInt8 Примеры Поиск по UTF-8 с использованием 3-грамм
Query
SELECT ngramSearchUTF8('абвгдеёжз', 'гдеёзд')
Response
┌─ngramSearchUTF8('абвгдеёжз', 'гдеёзд')─┐
│                                      1 │
└────────────────────────────────────────┘

​
notILike

Добавленный в: v20.6.0 Проверяет, что строка не соответствует шаблону без учёта регистра. Шаблон может содержать специальные символы % и _ для сопоставления по SQL LIKE. Синтаксис 
notILike(haystack, pattern)
Аргументы
  • haystack — Входная строка, в которой выполняется поиск. String или FixedString
  • pattern — Шаблон SQL LIKE для сопоставления. % соответствует любому количеству символов (включая ноль), _ — ровно одному символу. String
Возвращаемое значение Возвращает 1, если строка не соответствует шаблону при регистронезависимом сравнении, в противном случае — 0. UInt8 Примеры Пример использования
Query
SELECT notILike('ClickHouse', '%house%');
Response
┌─notILike('Cl⋯ '%house%')─┐
│                        0 │
└──────────────────────────┘

​
notLike

Добавленный в: v1.1.0 Аналогична like, но с отрицанием результата. Синтаксис 
notLike(haystack, pattern)
-- haystack NOT LIKE pattern
Аргументы
  • haystack — Строка, в которой выполняется поиск. String или FixedString
  • pattern — Шаблон LIKE для сопоставления. String
Возвращаемое значение Возвращает 1, если строка не соответствует шаблону LIKE, иначе — 0. UInt8 Примеры Пример использования
Query
SELECT notLike('ClickHouse', '%House%');
Response
┌─notLike('Cli⋯ '%House%')─┐
│                        0 │
└──────────────────────────┘
Несовпадающий шаблон регулярного выражения
Query
SELECT notLike('ClickHouse', '%SQL%');
Response
┌─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, positionCaseInsensitive, positionUTF8 и positionCaseInsensitiveUTF8. Синтаксис 
position(haystack, needle[, start_pos])
Аргументы
  • haystack — Строка, в которой выполняется поиск. String или Enum
  • needle — Искомая подстрока. String
  • start_pos — Позиция в haystack (нумерация с 1), с которой начинается поиск. Необязательный параметр. UInt
Возвращаемое значение Возвращает начальную позицию в байтах, считая от 1, если подстрока найдена; в противном случае — 0. UInt64 Примеры Базовое использование
Query
SELECT position('Hello, world!', '!')
Response
┌─position('Hello, world!', '!')─┐
│                             13 │
└────────────────────────────────┘
С аргументом start_pos
Query
SELECT position('Hello, world!', 'o', 1), position('Hello, world!', 'o', 7)
Response
┌─position('Hello, world!', 'o', 1)─┬─position('Hello, world!', 'o', 7)─┐
│                                 5 │                                 9 │
└───────────────────────────────────┴───────────────────────────────────┘
Синтаксис needle IN haystack
Query
SELECT 6 = position('/' IN s) FROM (SELECT 'Hello/World' AS s)
Response
┌─equals(6, position(s, '/'))─┐
│                           1 │
└─────────────────────────────┘
Пустая искомая подстрока
Query
SELECT position('abc', ''), position('abc', '', 0), position('abc', '', 1), position('abc', '', 2), position('abc', '', 3), position('abc', '', 4), position('abc', '', 5)
Response
┌─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, но регистронезависимый. Синтаксис 
positionCaseInsensitive(haystack, needle[, start_pos])
Псевдонимы: instr Аргументы
  • haystack — Строка, в которой выполняется поиск. String или Enum
  • needle — Подстрока, которую нужно найти. String
  • start_pos — Необязательно. Позиция (нумерация начинается с 1) в haystack, с которой начинается поиск. UInt*
Возвращаемое значение Возвращает начальную позицию в байтах с отсчётом от 1, если подстрока найдена; в противном случае — 0. UInt64 Примеры Регистронезависимый поиск
Query
SELECT positionCaseInsensitive('Hello, world!', 'hello')
Response
┌─positionCaseInsensitive('Hello, world!', 'hello')─┐
│                                                 1 │
└───────────────────────────────────────────────────┘

​
positionCaseInsensitiveUTF8

Добавленный в: v1.1.0 Как positionUTF8, но выполняет поиск без учета регистра. Синтаксис 
positionCaseInsensitiveUTF8(haystack, needle[, start_pos])
Аргументы
  • haystack — Строка, в которой выполняется поиск. String или Enum
  • needle — Искомая подстрока. String
  • start_pos — Необязательно. Позиция (отсчёт с 1) в haystack, с которой начинается поиск. UInt*
Возвращаемое значение Возвращает начальную позицию в байтах с отсчётом от 1, если подстрока найдена; в противном случае возвращает 0. UInt64 Примеры Регистронезависимый поиск UTF-8
Query
SELECT positionCaseInsensitiveUTF8('Привет мир', 'МИР')
Response
┌─positionCaseInsensitiveUTF8('Привет мир', 'МИР')─┐
│                                                8 │
└──────────────────────────────────────────────────┘

​
positionUTF8

Добавленный в: v1.1.0 Аналогично position, но предполагает, что haystack и needle — строки в кодировке UTF-8. Синтаксис 
positionUTF8(haystack, needle[, start_pos])
Аргументы
  • haystack — Строка, в которой выполняется поиск. String или Enum
  • needle — Искомая подстрока. String
  • start_pos — Необязательно. Позиция в haystack (нумерация с 1), с которой начинается поиск. UInt*
Возвращаемое значение Возвращает начальную позицию в байтах с отсчётом от 1, если подстрока найдена, иначе — 0. UInt64 Примеры Подсчёт символов UTF-8
Query
SELECT positionUTF8('Motörhead', 'r')
Response
┌─position('Motörhead', 'r')─┐
│                          5 │
└────────────────────────────┘
Последнее изменение 10 июня 2026 г.