Skip to content
ClickHouse Docs
ClickHouse DocsClickHouse Docs
49.6kGet Started

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

View as MarkdownEdit this pageReport an issueSet up docs MCP

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

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

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

countMatches

Добавленный в: v21.1.0

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

Синтаксис

countMatches(haystack, pattern)

Аргументы

  • haystack — Строка, в которой выполняется поиск. String
  • pattern — Шаблон регулярного выражения. String

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

Возвращает количество найденных совпадений. UInt64

Примеры

Подсчёт последовательностей цифр

SELECT countMatches('hello 123 world 456 test', '[0-9]+')
┌─countMatches('hello 123 world 456 test', '[0-9]+')─┐
│                                                  2 │
└────────────────────────────────────────────────────┘

countMatchesCaseInsensitive

Добавленный в: v21.1.0

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

Синтаксис

countMatchesCaseInsensitive(haystack, pattern)

Аргументы

  • haystack — Строка, в которой выполняется поиск. String
  • pattern — Шаблон регулярного выражения. const String

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

Возвращает количество найденных совпадений. UInt64

Примеры

Подсчёт без учёта регистра

SELECT countMatchesCaseInsensitive('Hello HELLO world', 'hello')
┌─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

Примеры

Пример использования

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

С аргументом start_pos

SELECT countSubstrings('abc___abc', 'abc', 4);
┌─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

Примеры

Пример использования

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

Добавленный в: 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

Примеры

Пример использования

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

С аргументом start_pos

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

extract

Добавленный в: v1.1.0

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

Эта функция использует библиотеку регулярных выражений RE2. Поддерживаемый синтаксис см. в re2.

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

Синтаксис

extract(haystack, pattern)

Аргументы

  • haystack — Строка, из которой извлекаются данные. String
  • pattern — Регулярное выражение, обычно содержащее группу захвата. const String

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

Возвращает извлечённый фрагмент в виде строки. String

Примеры

Извлечение домена из адреса электронной почты

SELECT extract('test@clickhouse.com', '.*@(.*)$')
┌─extract('test@clickhouse.com', '.*@(.*)$')─┐
│ clickhouse.com                             │
└────────────────────────────────────────────┘

Если совпадений нет, возвращается пустая строка

SELECT extract('test@clickhouse.com', 'no_match')
┌─extract('test@clickhouse.com', 'no_match')─┐
│                                            │
└────────────────────────────────────────────┘

extractAll

Добавленный в: v1.1.0

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

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

Синтаксис

extractAll(haystack, pattern)

Аргументы

  • haystack — Строка, из которой извлекаются фрагменты. String
  • pattern — Шаблон регулярного выражения, при необходимости содержащий группы захвата. const String

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

Возвращает массив извлечённых фрагментов. Array(String)

Примеры

Извлечение всех чисел

SELECT extractAll('hello 123 world 456', '[0-9]+')
┌─extractAll('hello 123 world 456', '[0-9]+')─┐
│ ['123','456']                               │
└─────────────────────────────────────────────┘

Извлечь с помощью группы захвата

SELECT extractAll('test@example.com, user@domain.org', '([a-zA-Z0-9]+)@')
┌─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))

Примеры

Пример использования

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

Примеры

Пример использования

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]+)');
['Server','nginx']

hasAllTokens

Добавленный в: v25.10.0

Аналогично hasAnyTokens, но возвращает 1, если все токены в строке или массиве needle совпадают со строкой input, и 0 в противном случае. Если input — столбец, возвращаются все строки, удовлетворяющие этому условию.

Перед поиском функция токенизирует

  • аргумент input (всегда), и
  • аргумент needle (если он задан как String) с использованием токенизатора, указанного для текстового индекса. Если для столбца не задан текстовый индекс, вместо него используется токенизатор splitByNonAlpha. Если аргумент needle имеет тип Array(String), каждый элемент массива рассматривается как токен — дополнительная токенизация не выполняется. Если для текстового индекса настроено выражение предобработчик, предобработчик применяется к needle (если он задан как String) перед токенизацией. Если для текстового индекса настроено выражение постпроцессор, постпроцессор применяется к токенам needle и токенам input (то есть к обоим после токенизации).

Повторяющиеся токены игнорируются. Например, needles = ['ClickHouse', 'ClickHouse'] обрабатывается так же, как ['ClickHouse'].

Синтаксис

hasAllTokens(input, needles[, tokenizer])

Псевдонимы: hasAllToken

Аргументы

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

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

Примеры

Базовое использование со строковым значением

DROP TABLE IF EXISTS doc;

CREATE TABLE doc (
    id UInt32,
    msg String,
    INDEX idx(msg) TYPE text(tokenizer = splitByString(['()', '\\']))
)
ENGINE = MergeTree
ORDER BY id;

INSERT INTO doc VALUES (1, '()a,\\bc()d'), (2, '()\\a()bc\\d'), (3, ',()a\\,bc,(),d,');

SELECT count() FROM doc WHERE hasAllTokens(msg, 'a\\d()');
┌─count()─┐
│       1 │
└─────────┘

Укажите needles для поиска в массиве AS-IS (без токенизации)

DROP TABLE IF EXISTS doc;

CREATE TABLE doc (
    id UInt32,
    msg String,
    INDEX idx(msg) TYPE text(tokenizer = splitByString(['()', '\\']))
)
ENGINE = MergeTree
ORDER BY id;

INSERT INTO doc VALUES (1, '()a,\\bc()d'), (2, '()\\a()bc\\d'), (3, ',()a\\,bc,(),d,');

SELECT count() FROM doc WHERE hasAllTokens(msg, ['a', 'd']);
┌─count()─┐
│       1 │
└─────────┘

Генерация needles с помощью функции tokens

DROP TABLE IF EXISTS doc;

CREATE TABLE doc (
    id UInt32,
    msg String,
    INDEX idx(msg) TYPE text(tokenizer = splitByString(['()', '\\']))
)
ENGINE = MergeTree
ORDER BY id;

INSERT INTO doc VALUES (1, '()a,\\bc()d'), (2, '()\\a()bc\\d'), (3, ',()a\\,bc,(),d,');

SELECT count() FROM doc WHERE hasAllTokens(msg, tokens('a()d', 'splitByString', ['()', '\\']));
┌─count()─┐
│       1 │
└─────────┘

Используйте пользовательский токенизатор через 3-й аргумент

SELECT hasAllTokens('abcdef', 'abc', 'ngrams(3)');
┌─hasAllTokens('abcdef', 'abc', 'ngrams(3)')─┐
│                                          1 │
└────────────────────────────────────────────┘

Примеры использования столбцов Array и Map

DROP TABLE IF EXISTS log;

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

Пример со столбцом типа Array

DROP TABLE IF EXISTS log;

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

SELECT count() FROM log WHERE hasAllTokens(tags, 'clickhouse');
┌─count()─┐
│       1 │
└─────────┘

Пример с mapKeys

DROP TABLE IF EXISTS log;

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

SELECT count() FROM log WHERE hasAllTokens(mapKeys(attributes), ['address', 'log_level']);
┌─count()─┐
│       1 │
└─────────┘

Пример использования mapValues

DROP TABLE IF EXISTS log;

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

SELECT count() FROM log WHERE hasAllTokens(mapValues(attributes), ['192.0.0.1', 'DEBUG']);
┌─count()─┐
│       0 │
└─────────┘

hasAnyTokens

Добавлено в: v25.10.0

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

Перед поиском функция токенизирует

  • аргумент input (всегда), и
  • аргумент needle (если он задан как String) с использованием токенизатора, указанного для текстового индекса. Если для столбца не определён текстовый индекс, вместо него используется токенизатор splitByNonAlpha. Если аргумент needle имеет тип Array(String), каждый элемент массива обрабатывается как токен — дополнительная токенизация не выполняется. Если для текстового индекса настроено выражение предобработчик, предобработчик применяется к needle (если он задан как String) перед токенизацией. Если для текстового индекса настроено выражение постпроцессор, постпроцессор применяется к токенам needle и input (то есть к обоим после токенизации).

Повторяющиеся токены игнорируются. Например, ['ClickHouse', 'ClickHouse'] обрабатывается так же, как ['ClickHouse'].

Синтаксис

hasAnyTokens(input, needles[, tokenizer])

Псевдонимы: hasAnyToken

Аргументы

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

Возвращает 1, если найдено хотя бы одно совпадение, иначе 0. UInt8

Примеры

Базовое использование со строковым искомым значением

DROP TABLE IF EXISTS doc;

CREATE TABLE doc (
    id UInt32,
    msg String,
    INDEX idx(msg) TYPE text(tokenizer = splitByString(['()', '\\']))
)
ENGINE = MergeTree
ORDER BY id;

INSERT INTO doc VALUES (1, '()a,\\bc()d'), (2, '()\\a()bc\\d'), (3, ',()a\\,bc,(),d,');

SELECT count() FROM doc WHERE hasAnyTokens(msg, 'a\\d()');
┌─count()─┐
│       3 │
└─────────┘

Укажите в массиве искомые строки, которые будут искаться КАК ЕСТЬ (без токенизации)

DROP TABLE IF EXISTS doc;

CREATE TABLE doc (
    id UInt32,
    msg String,
    INDEX idx(msg) TYPE text(tokenizer = splitByString(['()', '\\']))
)
ENGINE = MergeTree
ORDER BY id;

INSERT INTO doc VALUES (1, '()a,\\bc()d'), (2, '()\\a()bc\\d'), (3, ',()a\\,bc,(),d,');

SELECT count() FROM doc WHERE hasAnyTokens(msg, ['a', 'd']);
┌─count()─┐
│       3 │
└─────────┘

Сгенерируйте needle с помощью функции tokens

DROP TABLE IF EXISTS doc;

CREATE TABLE doc (
    id UInt32,
    msg String,
    INDEX idx(msg) TYPE text(tokenizer = splitByString(['()', '\\']))
)
ENGINE = MergeTree
ORDER BY id;

INSERT INTO doc VALUES (1, '()a,\\bc()d'), (2, '()\\a()bc\\d'), (3, ',()a\\,bc,(),d,');

SELECT count() FROM doc WHERE hasAnyTokens(msg, tokens('a()d', 'splitByString', ['()', '\\']));
┌─count()─┐
│       3 │
└─────────┘

Примеры использования столбцов типов Array и Map

DROP TABLE IF EXISTS log;

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

Пример со столбцом типа Array

DROP TABLE IF EXISTS log;

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

SELECT count() FROM log WHERE hasAnyTokens(tags, 'clickhouse');
┌─count()─┐
│       1 │
└─────────┘

Пример с использованием mapKeys

DROP TABLE IF EXISTS log;

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

SELECT count() FROM log WHERE hasAnyTokens(mapKeys(attributes), ['address', 'log_level']);
┌─count()─┐
│       2 │
└─────────┘

Пример с mapValues

DROP TABLE IF EXISTS log;

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

SELECT count() FROM log WHERE hasAnyTokens(mapValues(attributes), ['192.0.0.1', 'DEBUG']);
┌─count()─┐
│       2 │
└─────────┘

hasPhrase

Добавленный в: v26.4.0

Проверяет, содержит ли input все токены из phrase, идущие подряд.

Перед поиском функция токенизирует аргументы input и phrase с помощью токенизатора, указанного для текстового индекса. Если для столбца не определен текстовый индекс, вместо него используется токенизатор splitByNonAlpha — если только токенизатор не передан как необязательный третий аргумент. Аргумент токенизатора должен быть одним из следующих: splitByNonAlpha, splitByString, splitByRegexp, ngrams, asciiCJK или icu. Обратите внимание, что splitByRegexp не поддерживается для hasPhrase, когда текстовый индекс также определяет постпроцессор.

В отличие от 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

Примеры

Совпадение по фразе

SELECT hasPhrase('the quick brown fox jumps', 'quick brown')
┌─hasPhrase('the quick brown fox jumps', 'quick brown')─┐
│                                                     1 │
└───────────────────────────────────────────────────────┘

Несмежные токены

SELECT hasPhrase('the quick brown fox jumps', 'quick fox')
┌─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

Примеры

Базовая проверка подпоследовательности

SELECT hasSubsequence('Hello World', 'HlWrd')
┌─hasSubsequence('Hello World', 'HlWrd')─┐
│                                      1 │
└────────────────────────────────────────┘

Подпоследовательность не найдена

SELECT hasSubsequence('Hello World', 'xyz')
┌─hasSubsequence('Hello World', 'xyz')─┐
│                                    0 │
└──────────────────────────────────────┘

hasSubsequenceCaseInsensitive

Добавленный в: v23.7.0

Как hasSubsequence, но ищет без учета регистра.

Синтаксис

hasSubsequenceCaseInsensitive(haystack, needle)

Аргументы

  • haystack — Строка, в которой выполняется поиск. String
  • needle — Подпоследовательность, которую требуется найти. String

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

Возвращает 1, если needle является подпоследовательностью haystack, иначе — 0. UInt8

Примеры

Пример использования

SELECT hasSubsequenceCaseInsensitive('garbage', 'ARG');
┌─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

Примеры

Пример использования

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

hasSubsequenceUTF8

Добавленный в: v23.7.0

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

Синтаксис

hasSubsequenceUTF8(haystack, needle)

Аргументы

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

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

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

Примеры

Пример использования

SELECT hasSubsequenceUTF8('картошка', 'кошка');
┌─hasSubsequenceUTF8('картошка', 'кошка')─┐
│                                       1 │
└─────────────────────────────────────────┘

Несовпадающая подпоследовательность

SELECT hasSubsequenceUTF8('картошка', 'апельсин');
┌─hasSubsequenceUTF8('картошка', 'апельсин')─┐
│                                          0 │
└────────────────────────────────────────────┘

hasToken

Добавленный в: v20.1.0

Проверяет, содержится ли указанный токен в строке.

Использует splitByNonAlpha в качестве токенизатора, то есть токен определяется как максимально длинная подпоследовательность идущих подряд символов [0-9A-Za-z_] (цифры, символы ASCII и символ подчёркивания).

Синтаксис

hasToken(haystack, token)

Аргументы

  • haystack — Строка, в которой выполняется поиск. String
  • token — Токен, который нужно найти. const String

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

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

Примеры

Поиск токена

SELECT hasToken('clickhouse test', 'test')
┌─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)

Примеры

Пример использования

SELECT hasTokenOrNull('apple banana cherry', 'ban ana');
┌─hasTokenOrNull('apple banana cherry', '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

Примеры

Простое выделение

SELECT highlight('The quick brown fox', ['quick', 'fox'])
┌─highlight('The quick brown fox', ['quick', 'fox'])─┐
│ The <em>quick</em> brown <em>fox</em>              │
└────────────────────────────────────────────────────┘

Пользовательские теги

SELECT highlight('Hello World', ['hello'], '<b>', '</b>')
┌─highlight('Hello World', ['hello'], '<b>', '</b>')─┐
│ <b>Hello</b> World                                 │
└────────────────────────────────────────────────────┘

ilike

Добавленный в: v20.6.0

Как like, но выполняет регистронезависимый поиск. Поддерживает необязательное предложение ESCAPE (см. like).

Синтаксис

ilike(haystack, pattern[, escape_character])
-- haystack ILIKE pattern [ESCAPE 'escape_character']

Аргументы

  • haystack — строка, в которой выполняется поиск. String или FixedString
  • pattern — шаблон регулярного выражения LIKE, с которым выполняется сопоставление. String
  • escape_character — необязательная односимвольная строка, используемая в качестве символа экранирования вместо \. По умолчанию: \. String

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

Возвращает 1, если строка соответствует шаблону регулярного выражения LIKE без учёта регистра, иначе 0. UInt8

Примеры

Пример использования

SELECT ilike('ClickHouse', '%house%');
┌─ilike('ClickHouse', '%house%')─┐
│                              1 │
└────────────────────────────────┘

like

Добавленный в: v1.1.0

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

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

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

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

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

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

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

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

предложение ESCAPE

Необязательное предложение ESCAPE задаёт пользовательский символ экранирования (это должен быть один ASCII-символ). Если он указан, пользовательский символ экранирования заменяет используемую по умолчанию обратную косую черту для экранирования метасимволов % и _. Символ экранирования может экранировать три вещи: % (литеральный знак процента), _ (литеральное подчёркивание) и самого себя (литеральный символ экранирования). При использовании пользовательского символа экранирования обратная косая черта не имеет специального значения и интерпретируется как литеральный символ.

Синтаксис

like(haystack, pattern[, escape_character])
-- haystack LIKE pattern [ESCAPE 'escape_character']

Аргументы

  • haystack — строка, в которой выполняется поиск. String или FixedString
  • pattern — шаблон регулярного выражения LIKE для поиска совпадений. Может содержать % (соответствует любому количеству символов), _ (соответствует одному символу) и \ для экранирования. String
  • escape_character — необязательная строка из одного символа, используемая в качестве символа экранирования вместо \. По умолчанию: \. String

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

Возвращает 1, если строка соответствует шаблону регулярного выражения LIKE, в противном случае — 0. UInt8

Примеры

Пример использования

SELECT like('ClickHouse', '%House');
┌─like('ClickHouse', '%House')─┐
│                            1 │
└──────────────────────────────┘

Односимвольный подстановочный знак

SELECT like('ClickHouse', 'Click_ouse');
┌─like('ClickHouse', 'Click_ouse')─┐
│                                1 │
└──────────────────────────────────┘

Шаблон регулярного выражения без совпадения

SELECT like('ClickHouse', '%SQL%');
┌─like('ClickHouse', '%SQL%')─┐
│                           0 │
└─────────────────────────────┘

Предложение ESCAPE

SELECT '50%off' LIKE '50#%off' ESCAPE '#';
┌─like('50%off', '50#%off', '#')─┐
│                              1 │
└────────────────────────────────┘

locate

Добавленный в: v18.16.0

То же, что и position, но аргументы haystack и locate поменяны местами.

Синтаксис

locate(needle, haystack[, start_pos])

Аргументы

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

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

Возвращает начальную позицию в байтах (с отсчётом от 1), если подстрока найдена, и 0, если подстрока не найдена. UInt64

Примеры

Базовое использование

SELECT locate('ca', 'abcabc')
┌─locate('ca', 'abcabc')─┐
│                      3 │
└────────────────────────┘

match

Добавленный в: v1.1.0

Проверяет, соответствует ли указанная строка заданному шаблону регулярного выражения.

Эта функция использует библиотеку регулярных выражений RE2. Поддерживаемый синтаксис см. в re2.

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

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

Шаблон не привязан к началу и концу строки. Чтобы сопоставить строку целиком, явно добавьте якоря ^ и $.

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

Альтернативный синтаксис оператора: haystack REGEXP pattern или haystack ~ pattern (в стиле PostgreSQL).

Синтаксис

match(haystack, pattern)

Псевдонимы: REGEXP_MATCHES

Аргументы

  • haystack — Строка, в которой ищется шаблон. String
  • pattern — Шаблон регулярного выражения. Может быть константой или поступать из столбца. String

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

Возвращает 1, если найдено совпадение с шаблоном, иначе — 0. UInt8

Примеры

Простое сопоставление с шаблоном

SELECT match('Hello World', 'Hello.*')
┌─match('Hello World', 'Hello.*')─┐
│                               1 │
└─────────────────────────────────┘

Шаблон регулярного выражения не совпадает

SELECT match('Hello World', 'goodbye.*')
┌─match('Hello World', 'goodbye.*')─┐
│                                 0 │
└───────────────────────────────────┘

Поиск подстроки

SELECT match('abcde', 'b.*d'), match('abcde', '^b.*d$')
┌─match('abcde', 'b.*d')─┬─match('abcde', '^b.*d$')─┐
│                      1 │                        0 │
└────────────────────────┴──────────────────────────┘

matchCaseInsensitive

Добавленный в: v26.8.0

Аналогична match, но выполняет регистронезависимое сопоставление.

Эта функция использует библиотеку регулярных выражений RE2. Поддерживаемый синтаксис см. в re2.

Альтернативный синтаксис оператора: haystack ~* pattern (в стиле PostgreSQL).

Синтаксис

matchCaseInsensitive(haystack, pattern)
-- haystack ~* pattern

Аргументы

  • haystack — Строка, в которой ищется шаблон. String
  • pattern — Шаблон регулярного выражения. Может быть константой или поступать из столбца. String

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

Возвращает 1, если найдено регистронезависимое совпадение с шаблоном, иначе — 0. UInt8

Примеры

Пример использования

SELECT matchCaseInsensitive('Hello World', 'hello.*'), 'Hello World' ~
┌─matchCaseInsensitive('Hello World', 'hello.*')─┬─matchCaseInsensitive('Hello World', 'HELLO.*')─┐
│                                              1 │                                              1 │
└────────────────────────────────────────────────┴────────────────────────────────────────────────┘

multiFuzzyMatchAllIndices

Добавленный в: v20.1.0

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

Синтаксис

multiFuzzyMatchAllIndices(haystack, distance, [pattern1, pattern2, ..., patternN])

Аргументы

  • haystack — Строка, в которой выполняется поиск. String
  • distance — Максимальное расстояние редактирования для нечеткого сопоставления. UInt8
  • pattern — Массив шаблонов регулярного выражения для сопоставления. Array(String)

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

Возвращает массив всех индексов (начиная с 1) шаблонов регулярного выражения, которые соответствуют строке haystack в пределах указанного расстояния редактирования, в любом порядке. Если совпадений нет, возвращается пустой массив. Array(UInt64)

Примеры

Пример использования

SELECT multiFuzzyMatchAllIndices('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose', 'House']);
┌─multiFuzzyMatchAllIndices('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose', 'House'])─┐
│ [3,1,4,2]                                                                                     │
└───────────────────────────────────────────────────────────────────────────────────────────────┘

multiFuzzyMatchAny

Добавленный в: v20.1.0

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

Синтаксис

multiFuzzyMatchAny(haystack, distance, [pattern1, pattern2, ..., patternN])

Аргументы

  • haystack — Строка, в которой выполняется поиск. String
  • distance — Максимальное расстояние редактирования для нечеткого сопоставления. UInt8
  • pattern — Необязательно. Массив шаблонов регулярного выражения для сопоставления. Array(String)

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

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

Примеры

Пример использования

SELECT multiFuzzyMatchAny('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose']);
┌─multiFuzzyMatchAny('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose'])─┐
│                                                                             1 │
└───────────────────────────────────────────────────────────────────────────────┘

multiFuzzyMatchAnyIndex

Добавленный в: v20.1.0

Аналогично multiFuzzyMatchAny, но возвращает любой индекс, для которого haystack совпадает в пределах постоянного расстояния редактирования.

Синтаксис

multiFuzzyMatchAnyIndex(haystack, distance, [pattern1, pattern2, ..., patternn])

Аргументы

  • haystack — Строка, по которой выполняется поиск. String
  • distance — Максимальное расстояние редактирования для нечеткого сопоставления. UInt8
  • pattern — Массив шаблонов регулярного выражения для поиска совпадений. Array(String)

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

Возвращает индекс (начиная с 1) любого шаблона регулярного выражения, который совпадает с haystack в пределах указанного расстояния редактирования; в противном случае — 0. UInt64

Примеры

Пример использования

SELECT multiFuzzyMatchAnyIndex('ClickHouse', 2, ['ClckHouse', 'ClickHose', 'ClickHouse']);
┌─multiFuzzyMatchAnyIndex('ClickHouse', 2, ['ClckHouse', 'ClickHose', 'ClickHouse'])─┐
│                                                                                  2 │
└────────────────────────────────────────────────────────────────────────────────────┘

multiMatchAllIndices

Добавленный в: v20.1.0

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

Синтаксис

multiMatchAllIndices(haystack, [pattern1, pattern2, ..., patternn])

Аргументы

  • haystack — Строка, в которой выполняется поиск. String
  • pattern — Шаблоны регулярного выражения, с которыми выполняется сопоставление. String

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

Массив всех индексов (начиная с 1) шаблонов регулярного выражения, совпадающих с haystack, в произвольном порядке. Если совпадений не найдено, возвращается пустой массив. Array(UInt64)

Примеры

Пример использования

SELECT multiMatchAllIndices('ClickHouse', ['[0-9]', 'House', 'Click', 'ouse']);
┌─multiMatchAllIndices('ClickHouse', ['[0-9]', 'House', 'Click', 'ouse'])─┐
│ [3,2,4]                                                                 │
└─────────────────────────────────────────────────────────────────────────┘

multiMatchAny

Добавленный в: v20.1.0

Проверяет, соответствует ли исходной строке хотя бы один из нескольких шаблонов регулярного выражения.

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

Синтаксис

multiMatchAny(haystack, pattern1[, pattern2, ...])

Аргументы

  • haystack — Строка, в которой выполняется поиск. String
  • pattern1[, pattern2, ...] — Массив из одного или нескольких шаблонов регулярных выражений. Array(String)

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

Возвращает 1, если найдено совпадение хотя бы с одним шаблоном, в противном случае — 0. UInt8

Примеры

Сопоставление с несколькими шаблонами

SELECT multiMatchAny('Hello World', ['Hello.*', 'foo.*'])
┌─multiMatchAny('Hello World', ['Hello.*', 'foo.*'])─┐
│                                                  1 │
└────────────────────────────────────────────────────┘

Нет совпадений с шаблонами

SELECT multiMatchAny('Hello World', ['goodbye.*', 'foo.*'])
┌─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

Примеры

Пример использования

SELECT multiMatchAnyIndex('ClickHouse', ['[0-9]', 'House', 'Click']);
┌─multiMatchAnyIndex('ClickHouse', ['[0-9]', 'House', '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)

Примеры

Поиск по нескольким подстрокам

SELECT multiSearchAllPositions('Hello, World!', ['hello', '!', 'world'])
┌─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)

Примеры

Регистронезависимый поиск нескольких подстрок

SELECT multiSearchAllPositionsCaseInsensitive('ClickHouse',['c','h'])
┌─multiSearchAllPositionsCaseInsensitive('ClickHouse', ['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

SELECT multiSearchAllPositionsCaseInsensitiveUTF8('Здравствуй, мир!', ['здравствуй', 'МИР']);
┌─multiSearchAllPositionsCaseInsensitiveUTF8('Здравствуй, мир!', ['здравствуй', 'МИР'])─┐
│ [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

SELECT multiSearchAllPositionsUTF8('ClickHouse',['C','H'])
┌─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

Примеры

Поиск по любому совпадению

SELECT multiSearchAny('ClickHouse',['C','H'])
┌─multiSearchAny('ClickHouse', ['C', 'H'])─┐
│                                        1 │
└──────────────────────────────────────────┘

multiSearchAnyCaseInsensitive

Добавленный в: v20.1.0

Как multiSearchAny, но позволяет игнорировать регистр символов.

Синтаксис

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

Аргументы

  • haystack — Строка, в которой выполняется поиск. String
  • needle — Подстроки, которые требуется найти. Array(String)

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

Возвращает 1, если найдено хотя бы одно регистронезависимое совпадение, иначе — 0. UInt8

Примеры

Регистронезависимый поиск

SELECT multiSearchAnyCaseInsensitive('ClickHouse',['c','h'])
┌─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-строки 'Здравствуйте' проверьте, присутствует ли символ 'з' (в нижнем регистре)

SELECT multiSearchAnyCaseInsensitiveUTF8('Здравствуйте',['з'])
┌─multiSearchAnyCaseInsensitiveUTF8('Здравствуйте', ['з'])─┐
│                                                        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') проверьте, содержит ли строка символы 你 или 界

SELECT multiSearchAnyUTF8('你好，世界', ['你', '界']) AS result
┌─result─┐
│      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

Примеры

Пример использования

SELECT multiSearchFirstIndex('ClickHouse Database', ['Click', 'Database', 'Server']);
┌─multiSearchFirstIndex('ClickHouse Database', ['Click', 'Database', 'Server'])─┐
│                                                                             1 │
└───────────────────────────────────────────────────────────────────────────────┘

Поведение с учетом регистра

SELECT multiSearchFirstIndex('ClickHouse Database', ['CLICK', 'Database', 'Server']);
┌─multiSearchFirstIndex('ClickHouse Database', ['CLICK', 'Database', 'Server'])─┐
│                                                                             2 │
└───────────────────────────────────────────────────────────────────────────────┘

Совпадений не найдено

SELECT multiSearchFirstIndex('Hello World', ['goodbye', 'test']);
┌─multiSearchFirstIndex('Hello World', ['goodbye', '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

Примеры

Пример использования

SELECT multiSearchFirstIndexCaseInsensitive('hElLo WoRlD', ['World', 'Hello']);
┌─multiSearchFirstIndexCaseInsensitive('hElLo WoRlD', ['World', 'Hello'])─┐
│                                                                       1 │
└─────────────────────────────────────────────────────────────────────────┘

multiSearchFirstIndexCaseInsensitiveUTF8

Добавленный в: v20.1.0

Ищет несколько строк needle в строке haystack регистронезависимым способом с поддержкой кодировки UTF-8 и возвращает индекс первого найденного образца, начиная с 1.

Синтаксис

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

Аргументы

  • haystack — Строка, в которой выполняется поиск. String
  • needles — Массив строк, которые нужно найти. Array(String)

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

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

Примеры

Пример использования

SELECT multiSearchFirstIndexCaseInsensitiveUTF8('ClickHouse Database', ['CLICK', 'data', 'server']);
┌─multiSearchFirstIndexCaseInsensitiveUTF8('ClickHouse Database', ['CLICK', 'data', 'server'])─┐
│                                                                                            1 │
└──────────────────────────────────────────────────────────────────────────────────────────────┘

Работа с регистром UTF-8

SELECT multiSearchFirstIndexCaseInsensitiveUTF8('Привет Мир', ['мир', 'ПРИВЕТ']);
┌─multiSearchFirstIndexCaseInsensitiveUTF8('Привет Мир', ['мир', 'ПРИВЕТ'])─┐
│                                                                         1 │
└───────────────────────────────────────────────────────────────────────────┘

Совпадений не найдено

SELECT multiSearchFirstIndexCaseInsensitiveUTF8('Hello World', ['goodbye', 'test']);
┌─multiSearchFirstIndexCaseInsensitiveUTF8('Hello World', ['goodbye', '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

Примеры

Пример использования

SELECT multiSearchFirstIndexUTF8('Здравствуйте мир', ['мир', 'здравствуйте']);
┌─multiSearchFirstIndexUTF8('Здравствуйте мир', ['мир', 'здравствуйте'])─┐
│                                                                      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

Примеры

Поиск первой позиции

SELECT multiSearchFirstPosition('Hello World',['llo', 'Wor', 'ld'])
┌─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

Примеры

Первая позиция при регистронезависимом поиске

SELECT multiSearchFirstPositionCaseInsensitive('HELLO WORLD',['wor', 'ld', 'ello'])
┌─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'), соответствующего любой из заданных подстрок

SELECT multiSearchFirstPositionCaseInsensitiveUTF8('Здравствуй, мир', ['МИР', 'вст', 'Здра'])
┌─multiSearchFirstPositionCaseInsensitiveUTF8('Здравствуй, мир', ['МИР', 'вст', 'Здра'])─┐
│                                                                                      1 │
└────────────────────────────────────────────────────────────────────────────────────────┘

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

SELECT multiSearchFirstPositionUTF8('Здравствуй, мир',['мир', 'вст', 'авст'])
┌─multiSearchFirstPositionUTF8('Здравствуй, мир', ['мир', 'вст', 'авст'])─┐
│                                                                       4 │
└─────────────────────────────────────────────────────────────────────────┘

ngramDistance

Добавленный в: v20.1.0

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

Для регистронезависимого поиска и/или в формате UTF8 используйте функции ngramDistanceCaseInsensitive, ngramDistanceUTF8, ngramDistanceCaseInsensitiveUTF8.

Синтаксис

ngramDistance(haystack, needle)

Аргументы

  • haystack — строка для сравнения. String
  • needle — строка для сравнения. String

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

Возвращает число типа Float32 в диапазоне от 0 до 1. Чем меньше возвращаемое значение, тем более похожи строки. Float32

Примеры

Вычисление 4-граммного расстояния

SELECT ngramDistance('ClickHouse', 'ClickHouses')
┌─ngramDistance('ClickHouse', 'ClickHouses')─┐
│                                 0.06666667 │
└────────────────────────────────────────────┘

ngramDistanceCaseInsensitive

Добавленный в: v20.1.0

Предоставляет регистронезависимый вариант ngramDistance. Вычисляет 4-граммное расстояние между двумя строками без учета регистра. Чем меньше возвращаемое значение, тем больше строки похожи друг на друга.

Синтаксис

ngramDistanceCaseInsensitive(haystack, needle)

Аргументы

  • haystack — Первая строка для сравнения. String
  • needle — Вторая строка для сравнения. String

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

Возвращает значение типа Float32 в диапазоне от 0 до 1. Float32

Примеры

Регистронезависимое 4-граммное расстояние

SELECT ngramDistanceCaseInsensitive('ClickHouse','clickhouse')
┌─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

SELECT ngramDistanceCaseInsensitiveUTF8('abcde','CDE')
┌─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

SELECT ngramDistanceUTF8('abcde','cde')
┌─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-грамм

SELECT ngramSearch('ClickHouse', 'Click')
┌─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-грамм

SELECT ngramSearchCaseInsensitive('Hello World','hello')
┌─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-грамм

SELECT ngramSearchCaseInsensitiveUTF8('абвГДЕёжз', 'АбвгдЕЁжз')
┌─ngramSearchCaseInsensitiveUTF8('абвГДЕёжз', 'АбвгдЕЁжз')─┐
│                                               0.57142854 │
└──────────────────────────────────────────────────────────┘

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-грамм

SELECT ngramSearchUTF8('абвгдеёжз', 'гдеёзд')
┌─ngramSearchUTF8('абвгдеёжз', 'гдеёзд')─┐
│                                    0.5 │
└────────────────────────────────────────┘

notILike

Добавленный в: v20.6.0

Проверяет, что строка не соответствует шаблону регистронезависимым образом. Шаблон может содержать специальные символы % и _ для сопоставления по SQL LIKE. Поддерживает необязательное предложение ESCAPE (см. like).

Синтаксис

notILike(haystack, pattern[, escape_character])
-- haystack NOT ILIKE pattern [ESCAPE 'escape_character']

Аргументы

  • haystack — Входная строка, в которой выполняется поиск. String или FixedString
  • pattern — Шаблон SQL LIKE для сопоставления. % соответствует любому количеству символов (включая ноль), _ — ровно одному символу. String
  • escape_character — Необязательная строка из одного символа, используемая в качестве символа экранирования вместо \. По умолчанию: \. String

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

Возвращает 1, если строка не соответствует шаблону при регистронезависимом сравнении, в противном случае — 0. UInt8

Примеры

Пример использования

SELECT notILike('ClickHouse', '%house%');
┌─notILike('ClickHouse', '%house%')─┐
│                                 0 │
└───────────────────────────────────┘

notLike

Добавленный в: v1.1.0

Аналогична like, но с отрицанием результата. Поддерживает необязательное предложение ESCAPE (см. like).

Синтаксис

notLike(haystack, pattern[, escape_character])
-- haystack NOT LIKE pattern [ESCAPE 'escape_character']

Аргументы

  • haystack — Строка, в которой выполняется поиск. String или FixedString
  • pattern — Шаблон LIKE для сопоставления. String
  • escape_character — Необязательная строка из одного символа, используемая в качестве символа экранирования вместо \. По умолчанию: \. String

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

Возвращает 1, если строка не соответствует шаблону LIKE, иначе — 0. UInt8

Примеры

Пример использования

SELECT notLike('ClickHouse', '%House%');
┌─notLike('ClickHouse', '%House%')─┐
│                                0 │
└──────────────────────────────────┘

Несовпадающий шаблон регулярного выражения

SELECT notLike('ClickHouse', '%SQL%');
┌─notLike('ClickHouse', '%SQL%')─┐
│                              1 │
└────────────────────────────────┘

notMatch

Добавленный в: v26.8.0

Аналогична match, но инвертирует результат: проверяет, что строка не соответствует шаблону регулярного выражения.

Эта функция использует библиотеку регулярных выражений RE2. Поддерживаемый синтаксис см. в re2.

Альтернативный синтаксис оператора: haystack !~ pattern (в стиле PostgreSQL).

Синтаксис

notMatch(haystack, pattern)
-- haystack !~ pattern

Аргументы

  • haystack — Строка, в которой ищется шаблон. String
  • pattern — Шаблон регулярного выражения. Может быть константой или поступать из столбца. String

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

Возвращает 0, если найдено совпадение с шаблоном, иначе — 1. UInt8

Примеры

Пример использования

SELECT notMatch('Hello World', 'Hello.*'), 'Hello World' !
┌─notMatch('Hello World', 'Hello.*')─┬─notMatch('Hello World', 'goodbye.*')─┐
│                                  0 │                                    1 │
└────────────────────────────────────┴──────────────────────────────────────┘

notMatchCaseInsensitive

Добавленный в: v26.8.0

Аналогична matchCaseInsensitive, но инвертирует результат: проверяет, что строка регистронезависимо не соответствует шаблону регулярного выражения.

Эта функция использует библиотеку регулярных выражений RE2. Поддерживаемый синтаксис см. в re2.

Альтернативный синтаксис оператора: haystack !~* pattern (в стиле PostgreSQL).

Синтаксис

notMatchCaseInsensitive(haystack, pattern)
-- haystack !~* pattern

Аргументы

  • haystack — Строка, в которой ищется шаблон. String
  • pattern — Шаблон регулярного выражения. Может быть константой или поступать из столбца. String

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

Возвращает 0, если найдено регистронезависимое совпадение с шаблоном, иначе — 1. UInt8

Примеры

Пример использования

SELECT notMatchCaseInsensitive('Hello World', 'hello.*'), 'Hello World' !
┌─notMatchCaseInsensitive('Hello World', 'hello.*')─┬─notMatchCaseInsensitive('Hello World', 'GOODBYE.*')─┐
│                                                 0 │                                                   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

Примеры

Базовое использование

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

Пустая искомая подстрока

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

positionCaseInsensitive

Добавленный в: v1.1.0

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

Синтаксис

positionCaseInsensitive(haystack, needle[, start_pos])

Псевдонимы: instr

Аргументы

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

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

Возвращает начальную позицию в байтах с отсчётом от 1, если подстрока найдена; в противном случае — 0. UInt64

Примеры

Регистронезависимый поиск

SELECT positionCaseInsensitive('Hello, world!', 'hello')
┌─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

SELECT positionCaseInsensitiveUTF8('Привет мир', 'МИР')
┌─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

SELECT positionUTF8('Motörhead', 'r')
┌─positionUTF8('Motörhead', 'r')─┐
│                              5 │
└────────────────────────────────┘
Navigation