Skip to content
ClickHouse Docs
ClickHouse DocsClickHouse Docs
49.6kGet Started

Funções de busca em strings

View as MarkdownEdit this pageReport an issueSet up docs MCP

Todas as funções nesta seção fazem buscas com diferenciação entre maiúsculas e minúsculas por padrão. A busca sem diferenciar maiúsculas de minúsculas geralmente é oferecida por variantes separadas da função.

As funções nesta seção também pressupõem que a string pesquisada (chamada nesta seção de haystack) e a string de busca (chamada nesta seção de needle) sejam textos codificados em byte único. Se essa suposição for violada, nenhuma exceção é gerada e os resultados são indefinidos. A busca com strings codificadas em UTF-8 geralmente é oferecida por variantes separadas da função. Da mesma forma, se uma variante de função UTF-8 for usada e as strings de entrada não forem texto codificado em UTF-8, nenhuma exceção é gerada e os resultados são indefinidos. Observe que nenhuma normalização Unicode automática é realizada; no entanto, você pode usar as funções normalizeUTF8*() para isso.

Funções gerais de strings e funções de substituição em strings são descritas separadamente.

countMatches

Introduzido em: v21.1.0

Retorna o número de correspondências de uma expressão regular em uma string.

Sintaxe

countMatches(haystack, pattern)

Argumentos

  • haystack — A string na qual pesquisar. String
  • pattern — Padrão de expressão regular. String

Valor retornado

Retorna o número de correspondências encontradas. UInt64

Exemplos

Contar sequências de dígitos

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

countMatchesCaseInsensitive

Introduzido em: v21.1.0

Semelhante a countMatches, mas faz correspondência sem diferenciar maiúsculas de minúsculas.

Sintaxe

countMatchesCaseInsensitive(haystack, pattern)

Argumentos

  • haystack — A string na qual pesquisar. String
  • pattern — Padrão de expressão regular. const String

Valor retornado

Retorna o número de correspondências encontradas. UInt64

Exemplos

Contagem sem diferenciar maiúsculas de minúsculas

SELECT countMatchesCaseInsensitive('Hello HELLO world', 'hello')
┌─countMatchesCaseInsensitive('Hello HELLO world', 'hello')─┐
│                                                         2 │
└───────────────────────────────────────────────────────────┘

countSubstrings

Introduzido em: v21.1.0

Retorna quantas vezes a substring needle ocorre na string haystack.

Sintaxe

countSubstrings(haystack, needle[, start_pos])

Argumentos

  • haystack — String em que a busca é realizada. String ou Enum. - needle — Substring a ser pesquisada. String. - start_pos — Posição (baseada em 1) em haystack na qual a busca se inicia. UInt. Opcional.

Valor retornado

O número de ocorrências. UInt64

Exemplos

Exemplo de uso

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

Com o argumento start_pos

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

countSubstringsCaseInsensitive

Introduzido em: v21.1.0

Semelhante a countSubstrings, mas conta sem diferenciar maiúsculas de minúsculas.

Sintaxe

countSubstringsCaseInsensitive(haystack, needle[, start_pos])

Argumentos

  • haystack — String em que a busca é realizada. String ou Enum
  • needle — Substring a ser buscada. String
  • start_pos — Opcional. Posição (baseada em 1) em haystack na qual a busca começa. UInt*

Valor retornado

Retorna o número de ocorrências da substring em haystack. UInt64

Exemplos

Exemplo de uso

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

Com o argumento start_pos

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

countSubstringsCaseInsensitiveUTF8

Introduzido em: v21.1.0

Como countSubstrings, mas conta sem diferenciar maiúsculas de minúsculas e pressupõe que o haystack seja uma string UTF-8.

Sintaxe

countSubstringsCaseInsensitiveUTF8(haystack, needle[, start_pos])

Argumentos

  • haystack — String UTF-8 na qual a busca é realizada. String ou Enum
  • needle — Substring a ser pesquisada. String
  • start_pos — Opcional. Posição (começando em 1) em haystack na qual a busca se inicia. UInt*

Valor retornado

Retorna o número de ocorrências de needle em haystack. UInt64

Exemplos

Exemplo de uso

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

Com o argumento start_pos

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

extract

Introduzido em: v1.1.0

Extrai a primeira correspondência de uma expressão regular em uma string. Se 'haystack' não corresponder a 'pattern', uma string vazia será retornada.

Esta função usa a biblioteca de expressões regulares RE2. Consulte re2 para conhecer a sintaxe compatível.

Se a expressão regular tiver grupos de captura (subpadrões), a função faz a correspondência da string de entrada com o primeiro grupo de captura.

Sintaxe

extract(haystack, pattern)

Argumentos

  • haystack — String de onde extrair. String
  • pattern — Expressão regular, normalmente contendo um grupo de captura. const String

Valor retornado

Retorna o fragmento extraído como string. String

Exemplos

Extrair domínio de um e-mail

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

Sem correspondência, retorna string vazia

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

extractAll

Introduzido em: v1.1.0

Semelhante a extract, mas retorna um array com todas as correspondências de uma expressão regular em uma string. Se 'haystack' não corresponder à regex 'pattern', será retornado um array vazio.

Se a expressão regular tiver grupos de captura (subpadrões), a função faz a correspondência da string de entrada com o primeiro grupo de captura.

Sintaxe

extractAll(haystack, pattern)

Argumentos

  • haystack — String da qual os fragmentos são extraídos. String
  • pattern — Expressão regular, opcionalmente contendo grupos de captura. const String

Valor retornado

Retorna um array com os fragmentos extraídos. Array(String)

Exemplos

Extrair todos os números

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

Extrair usando um grupo de captura

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

Introduzido em: v20.5.0

Encontra todos os grupos em uma string usando a expressão regular fornecida e retorna um array de arrays, em que cada array contém todas as capturas do mesmo grupo de captura, organizadas pelo número do grupo.

Sintaxe

extractAllGroupsHorizontal(s, regexp)

Argumentos

Valor retornado

Retorna um array de arrays, em que cada array interno contém todas as capturas de um grupo de captura em todas as correspondências. O primeiro array interno contém todas as capturas do grupo 1, o segundo do grupo 2, e assim por diante. Se nenhuma correspondência for encontrada, retorna um array vazio. Array(Array(String))

Exemplos

Exemplo de uso

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

Introduzido em: v20.5.0

Extrai os grupos de captura da primeira substring correspondente a uma expressão regular. Para extrair grupos de todas as correspondências, use extractAllGroupsHorizontal ou extractAllGroupsVertical.

Sintaxe

extractGroups(s, regexp)

Argumentos

Valor retornado

Se a expressão regular encontrar correspondência, retorna um array contendo os grupos capturados (1 a N, em que N é o número de grupos de captura em regexp) da primeira correspondência. Se não houver correspondência, retorna um array vazio. Array(String)

Exemplos

Exemplo de uso

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

Introduzido em: v25.10.0

Semelhante a hasAnyTokens, mas retorna 1 se todos os tokens na string ou array needle corresponderem à string input, e 0 caso contrário. Se input for uma coluna, retorna todas as linhas que satisfazem essa condição.

Antes de realizar a busca, a função tokeniza

  • o argumento input (sempre), e
  • o argumento needle (se fornecido como String) usa o tokenizador especificado para o índice de texto. Se a coluna não tiver nenhum índice de texto definido, o tokenizador splitByNonAlpha será usado. Se o argumento needle for do tipo Array(String), cada elemento do array será tratado como um token — não haverá tokenização adicional. Se o índice de texto tiver uma expressão de pré-processador configurada, o pré-processador será aplicado ao needle (se fornecido como String) antes da tokenização. Se o índice de texto tiver uma expressão de pós-processador configurada, o pós-processador será aplicado aos tokens de needle e aos tokens de input (isto é, a ambos após a tokenização).

Tokens duplicados são ignorados. Por exemplo, needles = ['ClickHouse', 'ClickHouse'] é tratado da mesma forma que ['ClickHouse'].

Sintaxe

hasAllTokens(input, needles[, tokenizer])

Aliases: hasAllToken

Argumentos

Valor retornado

Retorna 1 se todas as needles corresponderem. 0 caso contrário. UInt8

Exemplos

Uso básico com uma string de busca

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

Especifique needles a serem pesquisadas AS-IS (sem tokenização) em um array

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

Gere needles usando a função 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 │
└─────────┘

Use um tokenizador personalizado com o 3º argumento

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

Exemplos de uso de colunas array e 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'});

Exemplo com uma coluna do tipo 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 │
└─────────┘

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

Exemplo com 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

Introduzido em: v25.10.0

Retorna 1 se pelo menos um token da string ou array needle corresponder à string input, e 0 caso contrário. Se input for uma coluna, retorna todas as linhas que satisfazem essa condição.

Antes de realizar a busca, a função tokeniza

  • o argumento input (sempre), e
  • o argumento needle (se fornecido como String) usando o tokenizador especificado para o índice de texto. Se a coluna não tiver um índice de texto definido, o tokenizador splitByNonAlpha será usado. Se o argumento needle for do tipo Array(String), cada elemento do array será tratado como um token — não haverá tokenização adicional. Se o índice de texto tiver uma expressão de pré-processador configurada, o pré-processador será aplicado a needle (se fornecido como String) antes da tokenização. Se o índice de texto tiver uma expressão de pós-processador configurada, o pós-processador será aplicado aos tokens de needle e aos tokens de input (ou seja, a ambos após a tokenização).

Tokens duplicados são ignorados. Por exemplo, ['ClickHouse', 'ClickHouse'] é tratado da mesma maneira que ['ClickHouse'].

Sintaxe

hasAnyTokens(input, needles[, tokenizer])

Aliases: hasAnyToken

Argumentos

Valor retornado

Retorna 1 se houver pelo menos uma correspondência. Caso contrário, 0. UInt8

Exemplos

Uso básico com uma string como "needle"

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

Especifique needles a serem pesquisadas como estão (sem tokenização) em um array

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

Gere needles usando a função 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 │
└─────────┘

Exemplos de uso de colunas array e 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'});

Exemplo com uma coluna de 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 │
└─────────┘

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

Exemplo com 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

Introduzido em: v26.4.0

Verifica se o input contém todos os tokens da phrase em ordem consecutiva.

Antes da pesquisa, a função tokeniza os argumentos input e phrase usando o tokenizador especificado para o índice de texto. Se a coluna não tiver nenhum índice de texto definido, o tokenizador splitByNonAlpha será usado — a menos que um tokenizador seja fornecido como terceiro argumento opcional. O argumento tokenizer deve ser um de splitByNonAlpha, splitByString, splitByRegexp, ngrams, asciiCJK ou icu. Observe que splitByRegexp não é compatível com hasPhrase quando o índice de texto também define um pós-processador.

Diferentemente de hasToken, hasAnyTokens e hasAllTokens, hasPhrase exige que os tokens apareçam na mesma ordem e sem nenhum token entre eles. Por exemplo, hasPhrase('the quick brown fox', 'quick fox') retorna 0 porque "brown" aparece entre "quick" e "fox".

Sintaxe

hasPhrase(input, phrase[, tokenizer])

Aliases: matchPhrase

Argumentos

Valor retornado

Retorna 1 se a frase for encontrada como uma sequência contínua de tokens; caso contrário, retorna 0. UInt8

Exemplos

Correspondência por frase

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

Tokens não consecutivos

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

hasSubsequence

Introduzido em: v23.7.0

Verifica se uma needle é uma subsequência de uma haystack. Uma subsequência de uma string é uma sequência que pode ser derivada de outra string pela remoção de alguns caracteres, ou de nenhum, sem alterar a ordem dos caracteres restantes.

Sintaxe

hasSubsequence(haystack, needle)

Argumentos

  • haystack — String em que a subsequência será pesquisada. String
  • needle — Subsequência a ser pesquisada. String

Valor retornado

Retorna 1 se needle for uma subsequência de haystack; caso contrário, retorna 0. UInt8

Exemplos

Verificação básica de subsequência

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

Nenhuma subsequência encontrada

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

hasSubsequenceCaseInsensitive

Introduzido em: v23.7.0

Como hasSubsequence, mas faz a busca sem diferenciar maiúsculas de minúsculas.

Sintaxe

hasSubsequenceCaseInsensitive(haystack, needle)

Argumentos

  • haystack — String em que a busca é realizada. String
  • needle — Subsequência a ser procurada. String

Valor retornado

Retorna 1 se needle for uma subsequência de haystack e 0 caso contrário. UInt8

Exemplos

Exemplo de uso

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

hasSubsequenceCaseInsensitiveUTF8

Introduzido em: v23.7.0

Como hasSubsequenceUTF8, mas faz a busca sem diferenciar maiúsculas de minúsculas.

Sintaxe

hasSubsequenceCaseInsensitiveUTF8(haystack, needle)

Argumentos

  • haystack — String codificada em UTF-8 na qual a busca é realizada. String
  • needle — Subsequência codificada em UTF-8 a ser buscada. String

Valor retornado

Retorna 1 se needle for uma subsequência de haystack, 0 caso contrário. UInt8

Exemplos

Exemplo de uso

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

hasSubsequenceUTF8

Introduzido em: v23.7.0

Como hasSubsequence, mas considera que haystack e needle são strings codificadas em UTF-8.

Sintaxe

hasSubsequenceUTF8(haystack, needle)

Argumentos

  • haystack — A string em que a busca é feita. String
  • needle — A subsequência a ser procurada. String

Valor retornado

Retorna 1 se needle for uma subsequência de haystack; caso contrário, 0. UInt8

Exemplos

Exemplo de uso

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

Subsequência não correspondente

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

hasToken

Introduzido em: v20.1.0

Verifica se o token informado está presente no haystack.

Usa splitByNonAlpha como tokenizador, ou seja, um token é definido como a maior subsequência possível de caracteres consecutivos [0-9A-Za-z_] (números, caracteres ASCII e underscore).

Sintaxe

hasToken(haystack, token)

Argumentos

  • haystack — String na qual será feita a busca. String
  • token — Token a ser procurado. const String

Valor retornado

Retorna 1 se o token for encontrado; caso contrário, 0. UInt8

Exemplos

Busca por token

SELECT hasToken('clickhouse test', 'test')
┌─hasToken('clickhouse test', 'test')─┐
│                                   1 │
└─────────────────────────────────────┘

hasTokenCaseInsensitive

Introduzido em: v20.1.0

Realiza uma busca sem diferenciar maiúsculas de minúsculas por needle em haystack usando o índice tokenbf_v1.

Sintaxe

hasTokenCaseInsensitive(haystack, needle)

Argumentos

  • Nenhum.

Valor retornado

Exemplos

hasTokenCaseInsensitiveOrNull

Introduzido em: v23.1.0

Realiza uma busca por needle em haystack sem diferenciar maiúsculas de minúsculas, usando o índice tokenbf_v1. Retorna NULL se needle estiver malformado.

Sintaxe

hasTokenCaseInsensitiveOrNull(haystack, needle)

Argumentos

  • Nenhum.

Valor retornado

Exemplos

hasTokenOrNull

Introduzido em: v20.1.0

Semelhante a hasToken, mas retorna NULL se o token estiver malformado.

Sintaxe

hasTokenOrNull(haystack, token)

Argumentos

  • haystack — String na qual será feita a busca. Deve ser constante. String
  • token — Token a ser buscado. const String

Valor retornado

Retorna 1 se o token for encontrado, 0 caso contrário, NULL se o token estiver malformado. Nullable(UInt8)

Exemplos

Exemplo de uso

SELECT hasTokenOrNull('apple banana cherry', 'ban ana');
┌─hasTokenOrNull('apple banana cherry', 'ban ana')─┐
│                                             ᴺᵁᴸᴸ │
└──────────────────────────────────────────────────┘

highlight

Introduzido em: v26.4.0

Destaca ocorrências de termos de busca em uma string, envolvendo-as com tags HTML.

A função realiza correspondência ASCII sem diferenciar maiúsculas de minúsculas. Se vários termos de busca se sobrepuserem ou estiverem adjacentes no texto, as regiões correspondentes serão mescladas em um único trecho destacado.

Sintaxe

highlight(haystack, needles[, open_tag, close_tag])

Argumentos

  • haystack — O texto no qual pesquisar. String ou FixedString
  • needles — Um array de termos de pesquisa a serem destacados. const Array(String)
  • open_tag — A tag de abertura a ser inserida antes de cada ocorrência. Padrão: <em>. const String
  • close_tag — A tag de fechamento a ser inserida após cada ocorrência. Padrão: </em>. const String

Valor retornado

Retorna o texto de entrada com os termos encontrados delimitados pelas tags especificadas. String

Exemplos

Destaque básico

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

Tags personalizadas

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

ilike

Introduzido em: v20.6.0

Como like, mas faz a busca sem diferenciar maiúsculas de minúsculas. Suporta a cláusula opcional ESCAPE (consulte like).

Sintaxe

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

Argumentos

  • haystack — String em que a busca é realizada. String ou FixedString
  • pattern — padrão LIKE usado para correspondência. String
  • escape_character — String opcional de um único caractere usada como caractere de escape em vez de \. Padrão: \. String

Valor retornado

Retorna 1 se a string corresponder ao padrão LIKE (sem diferenciar maiúsculas de minúsculas); caso contrário, 0. UInt8

Exemplos

Exemplo de uso

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

like

Introduzido em: v1.1.0

Retorna se a string haystack corresponde à expressão LIKE pattern.

Uma expressão LIKE pode conter caracteres normais e os seguintes metassímbolos:

  • % indica uma quantidade arbitrária de caracteres arbitrários (incluindo zero caracteres).
  • _ indica um único caractere arbitrário.
  • \ é usado para escapar os literais %, _ e \.

A correspondência é baseada em UTF-8; por exemplo, _ corresponde ao ponto de código Unicode ¥, que em UTF-8 é representado por dois bytes.

Se o haystack ou a expressão LIKE não forem UTF-8 válidos, o comportamento será indefinido.

Nenhuma normalização Unicode automática é realizada; você pode usar as funções normalizeUTF8* para isso.

Para corresponder a %, _ e \ literais (que são metacaracteres de LIKE), prefixe-os com uma barra invertida: \%, \_ e \\. A barra invertida perde seu significado especial (ou seja, é interpretada literalmente) se preceder um caractere diferente de %, _ ou \.

Para expressões LIKE no formato %needle%, a função é tão rápida quanto a função position. Todas as outras expressões LIKE são convertidas internamente em uma expressão regular e executadas com desempenho semelhante ao da função match.

cláusula ESCAPE

A cláusula ESCAPE opcional especifica um caractere de escape personalizado (deve ser um único caractere ASCII). Quando especificado, o caractere de escape personalizado substitui a barra invertida padrão para escapar os metacaracteres % e _. O caractere de escape pode escapar três coisas: % (porcentagem literal), _ (sublinhado literal) e ele mesmo (caractere de escape literal). Quando um caractere de escape personalizado é usado, a barra invertida não tem significado especial e é tratada como um caractere literal.

Sintaxe

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

Argumentos

  • haystack — String em que a busca é realizada. String ou FixedString
  • pattern — Padrão LIKE usado na correspondência. Pode conter % (corresponde a qualquer número de caracteres), _ (corresponde a um único caractere) e \ para escape. String
  • escape_character — String opcional de um único caractere a ser usada como caractere de escape em vez de \. Padrão: \. String

Valor retornado

Retorna 1 se a string corresponder ao padrão LIKE; caso contrário, 0. UInt8

Exemplos

Exemplo de uso

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

Curinga de caractere único

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

Padrão não correspondente

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

Cláusula ESCAPE

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

locate

Introduzido em: v18.16.0

Como position, mas com os argumentos haystack e locate em ordem inversa.

Sintaxe

locate(needle, haystack[, start_pos])

Argumentos

  • needle — Substring a ser procurada. String
  • haystack — String na qual a busca é realizada. String ou Enum
  • start_pos — Opcional. Posição (baseada em 1) em haystack a partir da qual a busca começa. UInt

Valor retornado

Retorna a posição inicial em bytes, contando a partir de 1, se a substring for encontrada; 0 se a substring não for encontrada. UInt64

Exemplos

Uso básico

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

match

Introduzido em: v1.1.0

Verifica se uma string fornecida corresponde ao padrão de expressão regular informado.

Esta função usa a biblioteca de expressões regulares RE2. Consulte re2 para ver a sintaxe compatível.

A correspondência funciona assumindo UTF-8; por exemplo, ¥ usa dois bytes internamente, mas a correspondência o trata como um único ponto de código. A expressão regular não deve conter bytes NULL. Se o haystack ou o padrão não forem UTF-8 válidos, o comportamento será indefinido.

Ao contrário do comportamento padrão do re2, . corresponde a quebras de linha. Para desativar isso, prefixe o padrão com (?-s).

O padrão não é ancorado. Para corresponder à string inteira, ancore o padrão usando ^ e $.

Se você só quiser procurar substrings, use as funções like ou position, que são muito mais rápidas do que esta função.

Sintaxe alternativa do operador: haystack REGEXP pattern ou haystack ~ pattern (estilo PostgreSQL).

Sintaxe

match(haystack, pattern)

Aliases: REGEXP_MATCHES

Argumentos

  • haystack — String na qual o padrão é buscado. String
  • pattern — Padrão de expressão regular. Pode ser uma constante ou vir de uma coluna. String

Valor retornado

Retorna 1 se o padrão corresponder, 0 caso contrário. UInt8

Exemplos

Correspondência de padrões simples

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

Padrão não corresponde

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

Correspondência com substring

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

matchCaseInsensitive

Introduzido em: v26.8.0

Semelhante a match, mas faz correspondência sem diferenciar maiúsculas de minúsculas.

Esta função usa a biblioteca de expressões regulares RE2. Consulte re2 para ver a sintaxe compatível.

Sintaxe alternativa do operador: haystack ~* pattern (no estilo PostgreSQL).

Sintaxe

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

Argumentos

  • haystack — String na qual o padrão é buscado. String
  • pattern — Padrão de expressão regular. Pode ser uma constante ou vir de uma coluna. String

Valor retornado

Retorna 1 se o padrão corresponder sem diferenciar maiúsculas de minúsculas, 0 caso contrário. UInt8

Exemplos

Exemplo de uso

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

multiFuzzyMatchAllIndices

Introduzido em: v20.1.0

Semelhante a multiFuzzyMatchAny, mas retorna o array com todos os índices, em qualquer ordem, que correspondem ao haystack dentro de uma distância de edição constante.

Sintaxe

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

Argumentos

  • haystack — String na qual a busca é realizada. String
  • distance — A distância máxima de edição para correspondência aproximada. UInt8
  • pattern — Array de padrões a serem correspondidos. Array(String)

Valor retornado

Retorna um array com todos os índices (a partir de 1) que correspondem ao haystack dentro da distância de edição especificada, em qualquer ordem. Retorna um array vazio se nenhuma correspondência for encontrada. Array(UInt64)

Exemplos

Exemplo de uso

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

multiFuzzyMatchAny

Introduzido em: v20.1.0

Como multiMatchAny, mas retorna 1 se algum padrão corresponder à haystack dentro de uma distância de edição constante. Esta função depende de uma funcionalidade experimental da biblioteca hyperscan e pode ser lenta em alguns casos extremos. O desempenho depende do valor da distância de edição e dos padrões usados, mas o custo é sempre maior em comparação com as variantes sem correspondência difusa.

Sintaxe

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

Argumentos

  • haystack — String na qual a busca é realizada. String
  • distance — A distância máxima de edição para correspondência aproximada. UInt8
  • pattern — Opcional. Um array de padrões para comparar. Array(String)

Valor retornado

Retorna 1 se algum padrão corresponder ao haystack dentro da distância de edição especificada; caso contrário, 0. UInt8

Exemplos

Exemplo de uso

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

multiFuzzyMatchAnyIndex

Introduzido em: v20.1.0

Como multiFuzzyMatchAny, mas retorna qualquer índice que corresponda ao haystack com uma distância de edição constante.

Sintaxe

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

Argumentos

  • haystack — String na qual a busca é realizada. String
  • distance — A distância máxima de edição para correspondência aproximada. UInt8
  • pattern — Array de padrões para correspondência. Array(String)

Valor retornado

Retorna o índice (a partir de 1) de qualquer padrão que corresponda ao haystack dentro da distância de edição especificada; caso contrário, 0. UInt64

Exemplos

Exemplo de uso

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

multiMatchAllIndices

Introduzido em: v20.1.0

Como multiMatchAny, mas retorna o array com todos os índices que correspondem ao haystack, em qualquer ordem.

Sintaxe

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

Argumentos

  • haystack — String em que a busca é realizada. String
  • pattern — Expressões regulares usadas na correspondência. String

Valor retornado

Array com todos os índices (a partir de 1) que encontram correspondência no haystack, em qualquer ordem. Retorna um array vazio se nenhuma correspondência for encontrada. Array(UInt64)

Exemplos

Exemplo de uso

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

multiMatchAny

Introduzido em: v20.1.0

Verifica se pelo menos um entre vários padrões de expressão regular corresponde à string de entrada.

Se você quiser apenas pesquisar várias substrings em uma string, pode usar a função multiSearchAny — ela funciona muito mais rápido do que esta função.

Sintaxe

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

Argumentos

  • haystack — String em que os padrões são buscados. String
  • pattern1[, pattern2, ...] — Um array de um ou mais padrões de expressão regular. Array(String)

Valor retornado

Retorna 1 se algum padrão corresponder, 0 caso contrário. UInt8

Exemplos

Correspondência com múltiplos padrões

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

Nenhum padrão corresponde

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

multiMatchAnyIndex

Introduzido em: v20.1.0

Como multiMatchAny, mas retorna qualquer índice que corresponda à string de entrada.

Sintaxe

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

Argumentos

  • haystack — String na qual a busca é realizada. String
  • pattern — Expressões regulares a serem correspondidas. Array(String)

Valor retornado

Retorna o índice (a partir de 1) do primeiro padrão que corresponde, ou 0 se nenhuma correspondência for encontrada. UInt64

Exemplos

Exemplo de uso

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

multiSearchAllPositions

Introduzido em: v20.1.0

Como position, mas retorna um array com as posições (em bytes, começando em 1) de várias substrings needle em uma string haystack.

Todas as funções multiSearch*() suportam no máximo 2^8 needles.

Sintaxe

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

Argumentos

  • haystack — String na qual a busca é feita. String
  • needle1[, needle2, ...] — Um array com uma ou mais substrings a serem buscadas. Array(String)

Valor retornado

Retorna um array com a posição inicial em bytes, contada a partir de 1, se a substring for encontrada, ou 0 se a substring não for encontrada. Array(UInt64)

Exemplos

Busca por múltiplas substrings

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

multiSearchAllPositionsCaseInsensitive

Introduzido em: v20.1.0

Como multiSearchAllPositions, mas não diferencia maiúsculas de minúsculas.

Sintaxe

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

Argumentos

  • haystack — String na qual a busca é realizada. String
  • needle1[, needle2, ...] — Um array de uma ou mais substrings a serem pesquisadas. Array(String)

Valor retornado

Retorna um array com a posição inicial em bytes, contando a partir de 1 (se a substring for encontrada), ou 0 se a substring não for encontrada. Array(UInt64)

Exemplos

Multibusca sem distinção entre maiúsculas e minúsculas

SELECT multiSearchAllPositionsCaseInsensitive('ClickHouse',['c','h'])
┌─multiSearchAllPositionsCaseInsensitive('ClickHouse', ['c', 'h'])─┐
│ [1,6]                                                            │
└──────────────────────────────────────────────────────────────────┘

multiSearchAllPositionsCaseInsensitiveUTF8

Introduzido em: v20.1.0

Como multiSearchAllPositionsUTF8, mas não diferencia maiúsculas de minúsculas.

Sintaxe

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

Argumentos

  • haystack — string codificada em UTF-8 na qual a busca é realizada. String
  • needle — substrings codificadas em UTF-8 que serão buscadas. Array(String)

Valor retornado

Array com as posições iniciais em bytes, contadas a partir de 1 (se a substring for encontrada). Retorna 0 se a substring não for encontrada. Array

Exemplos

Busca UTF-8 sem diferenciar maiúsculas de minúsculas

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

multiSearchAllPositionsUTF8

Introduzido em: v20.1.0

Como multiSearchAllPositions, mas pressupõe que haystack e as substrings needle sejam strings codificadas em UTF-8.

Sintaxe

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

Argumentos

  • haystack — String codificada em UTF-8 na qual a busca é realizada. String
  • needle1[, needle2, ...] — Um array de substrings codificadas em UTF-8 a serem procuradas. Array(String)

Valor retornado

Retorna um array com as posições iniciais, em bytes e contadas a partir de 1 (se a substring for encontrada), ou 0, se a substring não for encontrada. Array

Exemplos

Busca múltipla em UTF-8

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

multiSearchAny

Introduzido em: v20.1.0

Verifica se pelo menos uma das várias strings needle corresponde à string haystack.

As funções multiSearchAnyCaseInsensitive, multiSearchAnyUTF8 e multiSearchAnyCaseInsensitiveUTF8 fornecem variantes sem distinção entre maiúsculas e minúsculas e/ou em UTF-8 desta função.

Sintaxe

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

Argumentos

  • haystack — String em que a busca é realizada. String
  • needle1[, needle2, ...] — Um array de substrings a serem pesquisadas. Array(String)

Valor retornado

Retorna 1 se houver pelo menos uma correspondência; caso contrário, 0. UInt8

Exemplos

Busca por qualquer correspondência

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

multiSearchAnyCaseInsensitive

Introduzido em: v20.1.0

Como multiSearchAny, mas sem diferenciar maiúsculas de minúsculas.

Sintaxe

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

Argumentos

  • haystack — String em que a busca é realizada. String
  • needle — Substrings a serem pesquisadas. Array(String)

Valor retornado

Retorna 1 se houver pelo menos uma correspondência sem distinção entre maiúsculas e minúsculas; caso contrário, retorna 0. UInt8

Exemplos

Busca sem distinção entre maiúsculas e minúsculas

SELECT multiSearchAnyCaseInsensitive('ClickHouse',['c','h'])
┌─multiSearchAnyCaseInsensitive('ClickHouse', ['c', 'h'])─┐
│                                                       1 │
└─────────────────────────────────────────────────────────┘

multiSearchAnyCaseInsensitiveUTF8

Introduzido em: v20.1.0

Como multiSearchAnyUTF8, mas sem diferenciar maiúsculas de minúsculas.

Sintaxe

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

Argumentos

  • haystack — string UTF-8 na qual a busca é realizada. String
  • needle — substrings UTF-8 a serem procuradas. Array(String)

Valor retornado

Retorna 1 se houver pelo menos uma correspondência sem diferenciar maiúsculas de minúsculas; caso contrário, retorna 0. UInt8

Exemplos

Dada a string UTF-8 'Здравствуйте', verifique se o caractere 'з' (minúsculo) está presente

SELECT multiSearchAnyCaseInsensitiveUTF8('Здравствуйте',['з'])
┌─multiSearchAnyCaseInsensitiveUTF8('Здравствуйте', ['з'])─┐
│                                                        1 │
└──────────────────────────────────────────────────────────┘

multiSearchAnyUTF8

Introduzido em: v20.1.0

Semelhante a multiSearchAny, mas assume que haystack e as substrings needle são strings codificadas em UTF-8.

Sintaxe

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

Argumentos

  • haystack — string em UTF-8 na qual a busca é realizada. String
  • needle — substrings em UTF-8 a serem buscadas. Array(String)

Valor retornado

Retorna 1 se houver pelo menos uma correspondência; caso contrário, retorna 0. UInt8

Exemplos

Dada '你好，世界' ('Olá, mundo') como uma string em UTF-8, verifique se a string contém algum caractere 你 ou 界

SELECT multiSearchAnyUTF8('你好，世界', ['你', '界']) AS result
┌─result─┐
│      1 │
└────────┘

multiSearchFirstIndex

Introduzido em: v20.1.0

Procura várias strings needle em uma string haystack (diferencia maiúsculas de minúsculas) e retorna o índice, com base em 1, da primeira needle encontrada.

Sintaxe

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

Argumentos

  • haystack — A string em que a busca será feita. String
  • needles — Array de strings a serem pesquisadas. Array(String)

Valor retornado

Retorna o índice com base em 1 (posição no array needles) da primeira needle encontrada em haystack. Retorna 0 se nenhuma needle for encontrada. A busca diferencia maiúsculas de minúsculas. UInt64

Exemplos

Exemplo de uso

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

Comportamento com diferenciação entre maiúsculas e minúsculas

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

Nenhuma correspondência encontrada

SELECT multiSearchFirstIndex('Hello World', ['goodbye', 'test']);
┌─multiSearchFirstIndex('Hello World', ['goodbye', 'test'])─┐
│                                                         0 │
└───────────────────────────────────────────────────────────┘

multiSearchFirstIndexCaseInsensitive

Introduzido em: v20.1.0

Retorna o índice i (a partir de 1) da needle&#95;i localizada mais à esquerda na string haystack e 0 caso contrário. Não diferencia maiúsculas de minúsculas.

Sintaxe

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

Argumentos

  • haystack — String em que a busca é realizada. String
  • needle — Substrings a serem buscadas. Array(String)

Valor retornado

Retorna o índice (a partir de 1) da substring encontrada mais à esquerda. Caso contrário, retorna 0 se não houver correspondência. UInt8

Exemplos

Exemplo de uso

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

multiSearchFirstIndexCaseInsensitiveUTF8

Introduzido em: v20.1.0

Procura várias strings needle em uma string haystack, sem diferenciar maiúsculas de minúsculas e com suporte à codificação UTF-8, e retorna o índice, começando em 1, da primeira needle encontrada.

Sintaxe

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

Argumentos

  • haystack — A string em que a busca é feita. String
  • needles — Array de strings a serem buscadas. Array(String)

Valor retornado

Retorna o índice com base em 1 (posição no array needles) da primeira string encontrada em haystack. Retorna 0 se nenhuma string for encontrada. A busca não diferencia maiúsculas de minúsculas e respeita a codificação de caracteres UTF-8. UInt64

Exemplos

Exemplo de uso

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

Tratamento de maiúsculas/minúsculas em UTF-8

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

Nenhuma correspondência encontrada

SELECT multiSearchFirstIndexCaseInsensitiveUTF8('Hello World', ['goodbye', 'test']);
┌─multiSearchFirstIndexCaseInsensitiveUTF8('Hello World', ['goodbye', 'test'])─┐
│                                                                            0 │
└──────────────────────────────────────────────────────────────────────────────┘

multiSearchFirstIndexUTF8

Introduzido em: v20.1.0

Retorna o índice i (a partir de 1) da needle_i encontrada na posição mais à esquerda na string haystack, e 0 caso contrário. Pressupõe que haystack e needle sejam strings codificadas em UTF-8.

Sintaxe

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

Argumentos

  • haystack — string em UTF-8 na qual a busca é realizada. String
  • needle — Array de substrings em UTF-8 a serem procuradas. Array(String)

Valor retornado

Retorna o índice (a partir de 1) da needle encontrada mais à esquerda. Caso contrário, retorna 0 se não houver correspondência. UInt8

Exemplos

Exemplo de uso

SELECT multiSearchFirstIndexUTF8('Здравствуйте мир', ['мир', 'здравствуйте']);
┌─multiSearchFirstIndexUTF8('Здравствуйте мир', ['мир', 'здравствуйте'])─┐
│                                                                      1 │
└────────────────────────────────────────────────────────────────────────┘

multiSearchFirstPosition

Introduzido em: v20.1.0

Como position, mas retorna a posição mais à esquerda em uma string haystack que corresponde a qualquer uma de várias strings needle.

As funções multiSearchFirstPositionCaseInsensitive, multiSearchFirstPositionUTF8 e multiSearchFirstPositionCaseInsensitiveUTF8 fornecem variantes sem distinção entre maiúsculas e minúsculas e/ou em UTF-8 desta função.

Sintaxe

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

Argumentos

  • haystack — String na qual a busca é realizada. String
  • needle1[, needle2, ...] — Um array de uma ou mais substrings a serem buscadas. Array(String)

Valor retornado

Retorna o deslocamento da ocorrência mais à esquerda em uma string haystack que corresponda a qualquer uma de várias strings needle; caso contrário, 0, se não houver correspondência. UInt64

Exemplos

Busca da primeira posição

SELECT multiSearchFirstPosition('Hello World',['llo', 'Wor', 'ld'])
┌─multiSearchFirstPosition('Hello World', ['llo', 'Wor', 'ld'])─┐
│                                                             3 │
└───────────────────────────────────────────────────────────────┘

multiSearchFirstPositionCaseInsensitive

Introduzido em: v20.1.0

Como multiSearchFirstPosition, mas não diferencia maiúsculas de minúsculas.

Sintaxe

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

Argumentos

  • haystack — String em que a busca é realizada. String
  • needle — Array de substrings a serem buscadas. Array(String)

Valor retornado

Retorna o deslocamento na string haystack que corresponde a qualquer uma das strings needle. Retorna 0 se não houver correspondência. UInt64

Exemplos

Primeira posição sem diferenciar maiúsculas de minúsculas

SELECT multiSearchFirstPositionCaseInsensitive('HELLO WORLD',['wor', 'ld', 'ello'])
┌─multiSearchFirstPositionCaseInsensitive('HELLO WORLD', ['wor', 'ld', 'ello'])─┐
│                                                                             2 │
└───────────────────────────────────────────────────────────────────────────────┘

multiSearchFirstPositionCaseInsensitiveUTF8

Introduzido em: v20.1.0

Como multiSearchFirstPosition, mas considera haystack e needle como strings UTF-8 e não diferencia maiúsculas de minúsculas.

Sintaxe

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

Argumentos

  • haystack — string UTF-8 na qual a busca é realizada. String
  • needle — Array de substrings UTF-8 a serem procuradas. Array(String)

Valor retornado

Retorna o deslocamento mais à esquerda em uma string haystack que corresponde a qualquer uma das várias strings needle, sem diferenciar maiúsculas de minúsculas. Retorna 0 se não houver correspondência. UInt64

Exemplos

Encontre o deslocamento mais à esquerda na string UTF-8 'Здравствуй, мир' ('Hello, world') que corresponde a qualquer uma das substrings fornecidas

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

multiSearchFirstPositionUTF8

Introduzido em: v20.1.0

Assim como multiSearchFirstPosition, mas pressupõe que haystack e needle sejam strings UTF-8.

Sintaxe

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

Argumentos

  • haystack — string UTF-8 na qual a busca é realizada. String
  • needle — Array de substrings UTF-8 a serem procuradas. Array(String)

Valor retornado

Deslocamento da ocorrência mais à esquerda em uma string haystack que corresponde a qualquer uma das várias strings needle. Retorna 0 se não houver correspondência. UInt64

Exemplos

Encontre o deslocamento da ocorrência mais à esquerda na string UTF-8 'Здравствуй, мир' ('Hello, world') que corresponde a qualquer uma das strings needle fornecidas

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

ngramDistance

Introduzido em: v20.1.0

Calcula a distância de 4-gramas entre duas strings. Para isso, conta a diferença simétrica entre dois multiconjuntos de 4-gramas e a normaliza pela soma de suas cardinalidades. Quanto menor o valor retornado, mais semelhantes são as strings.

Para busca sem diferenciar maiúsculas de minúsculas e/ou no formato UTF-8, use as funções ngramDistanceCaseInsensitive, ngramDistanceUTF8, ngramDistanceCaseInsensitiveUTF8.

Sintaxe

ngramDistance(haystack, needle)

Argumentos

  • haystack — String para comparação. String
  • needle — String para comparação. String

Valor retornado

Retorna um valor Float32 entre 0 e 1. Quanto menor o valor retornado, mais semelhantes são as strings. Float32

Exemplos

Calcular a distância por 4-gramas

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

ngramDistanceCaseInsensitive

Introduzido em: v20.1.0

Fornece uma variante de ngramDistance sem diferenciar maiúsculas de minúsculas. Calcula a distância de 4-gramas entre duas strings, ignorando maiúsculas e minúsculas. Quanto menor o valor retornado, mais semelhantes são as strings.

Sintaxe

ngramDistanceCaseInsensitive(haystack, needle)

Argumentos

  • haystack — Primeira string de comparação. String
  • needle — Segunda string de comparação. String

Valor retornado

Retorna um número Float32 entre 0 e 1. Float32

Exemplos

Distância de 4-gramas sem diferenciar maiúsculas de minúsculas

SELECT ngramDistanceCaseInsensitive('ClickHouse','clickhouse')
┌─ngramDistanceCaseInsensitive('ClickHouse', 'clickhouse')─┐
│                                                        0 │
└──────────────────────────────────────────────────────────┘

ngramDistanceCaseInsensitiveUTF8

Introduzido em: v20.1.0

Fornece uma variante UTF-8 de ngramDistance sem diferenciar maiúsculas de minúsculas. Pressupõe que as strings needle e haystack sejam codificadas em UTF-8 e ignora maiúsculas e minúsculas. Calcula a distância de 3-gramas entre duas strings UTF-8, ignorando maiúsculas e minúsculas. Quanto menor o valor retornado, mais semelhantes são as strings.

Sintaxe

ngramDistanceCaseInsensitiveUTF8(haystack, needle)

Argumentos

  • haystack — Primeira string de comparação codificada em UTF-8. String
  • needle — Segunda string de comparação codificada em UTF-8. String

Valor retornado

Retorna um número Float32 entre 0 e 1. Float32

Exemplos

Distância UTF-8 de 3 gramas sem diferenciar maiúsculas de minúsculas

SELECT ngramDistanceCaseInsensitiveUTF8('abcde','CDE')
┌─ngramDistanceCaseInsensitiveUTF8('abcde', 'CDE')─┐
│                                              0.5 │
└──────────────────────────────────────────────────┘

ngramDistanceUTF8

Introduzido em: v20.1.0

Fornece uma variante em UTF-8 de ngramDistance. Pressupõe que as strings needle e haystack sejam codificadas em UTF-8. Calcula a distância de 3-gramas entre duas strings UTF-8. Quanto menor o valor retornado, mais semelhantes são as strings.

Sintaxe

ngramDistanceUTF8(haystack, needle)

Argumentos

  • haystack — Primeira string de comparação codificada em UTF-8. String
  • needle — Segunda string de comparação codificada em UTF-8. String

Valor retornado

Retorna um número Float32 entre 0 e 1. Float32

Exemplos

Distância de 3-gramas UTF-8

SELECT ngramDistanceUTF8('abcde','cde')
┌─ngramDistanceUTF8('abcde', 'cde')─┐
│                               0.5 │
└───────────────────────────────────┘

ngramSearch

Introduzido em: v20.1.0

Verifica se a distância de 4-gramas entre duas strings é menor ou igual a um determinado limiar.

Para busca sem distinção entre maiúsculas e minúsculas e/ou no formato UTF-8, use as funções ngramSearchCaseInsensitive, ngramSearchUTF8, ngramSearchCaseInsensitiveUTF8.

Sintaxe

ngramSearch(haystack, needle)

Argumentos

  • haystack — String a ser comparada. String
  • needle — String a ser comparada. String

Valor retornado

Retorna 1 se a distância de 4-gramas entre as strings for menor ou igual a um limiar (1.0 por padrão); caso contrário, retorna 0. UInt8

Exemplos

Busca com 4-gramas

SELECT ngramSearch('ClickHouse', 'Click')
┌─ngramSearch('ClickHouse', 'Click')─┐
│                                  1 │
└────────────────────────────────────┘

ngramSearchCaseInsensitive

Introduzido em: v20.1.0

Fornece uma variante de ngramSearch que não diferencia maiúsculas de minúsculas. Calcula a diferença não simétrica entre as strings needle e haystack, ou seja, o número de n-gramas da needle menos o número de n-gramas em comum, normalizado pelo número de n-gramas da needle. Verifica se a distância de 4-gramas entre duas strings é menor ou igual a um determinado limiar, ignorando maiúsculas e minúsculas.

Sintaxe

ngramSearchCaseInsensitive(haystack, needle)

Argumentos

  • haystack — String de comparação. String
  • needle — String de comparação. String

Valor retornado

Retorna 1 se a distância de 4-gramas entre as strings for menor ou igual ao limiar (1.0 por padrão); caso contrário, retorna 0. UInt8

Exemplos

Busca sem distinção entre maiúsculas e minúsculas usando 4-gramas

SELECT ngramSearchCaseInsensitive('Hello World','hello')
┌─ngramSearchCaseInsensitive('Hello World', 'hello')─┐
│                                                  1 │
└────────────────────────────────────────────────────┘

ngramSearchCaseInsensitiveUTF8

Introduzido em: v20.1.0

Fornece uma variante UTF-8 de ngramSearch sem diferenciar maiúsculas de minúsculas. Pressupõe que haystack e needle sejam strings UTF-8 e ignora diferenças entre maiúsculas e minúsculas. Verifica se a distância de 3-gramas entre duas strings UTF-8 é menor ou igual a um determinado limite, sem diferenciar maiúsculas de minúsculas.

Sintaxe

ngramSearchCaseInsensitiveUTF8(haystack, needle)

Argumentos

  • haystack — string em UTF-8 para comparação. String
  • needle — string em UTF-8 para comparação. String

Valor retornado

Retorna 1 se a distância de 3-gramas entre as strings for menor ou igual a um limiar (1.0 por padrão), 0 caso contrário. UInt8

Exemplos

Busca UTF-8 sem diferenciar maiúsculas de minúsculas usando 3-gramas

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

ngramSearchUTF8

Introduzido em: v20.1.0

Fornece uma variante UTF-8 de ngramSearch. Pressupõe que haystack e needle sejam strings em UTF-8. Verifica se a distância de 3-gramas entre duas strings em UTF-8 é menor ou igual a um determinado limiar.

Sintaxe

ngramSearchUTF8(haystack, needle)

Argumentos

  • haystack — string em UTF-8 para comparação. String
  • needle — string em UTF-8 para comparação. String

Valor retornado

Retorna 1 se a distância de 3-gramas entre as strings for menor ou igual a um limiar (1.0 por padrão); caso contrário, 0. UInt8

Exemplos

Busca em UTF-8 usando 3-gramas

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

notILike

Introduzido na versão: v20.6.0

Verifica se uma string não corresponde a um padrão, sem diferenciar maiúsculas de minúsculas. O padrão pode conter os caracteres especiais % e _ para correspondência com SQL LIKE. Suporta a cláusula opcional ESCAPE (consulte like).

Sintaxe

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

Argumentos

  • haystack — A string de entrada na qual a busca é feita. String ou FixedString
  • pattern — O padrão SQL LIKE usado para correspondência. % corresponde a qualquer número de caracteres (incluindo zero), _ corresponde a exatamente um caractere. String
  • escape_character — String opcional de um único caractere a ser usada como caractere de escape em vez de \. Padrão: \. String

Valor retornado

Retorna 1 se a string não corresponder ao padrão (sem diferenciar maiúsculas de minúsculas); caso contrário, 0. UInt8

Exemplos

Exemplo de uso

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

notLike

Introduzido em: v1.1.0

Semelhante a like, mas com o resultado negado. Oferece suporte à cláusula opcional ESCAPE (consulte like).

Sintaxe

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

Argumentos

  • haystack — String em que a busca é realizada. String e FixedString
  • pattern — Padrão LIKE para correspondência. String
  • escape_character — String opcional de um único caractere para usar como caractere de escape em vez de \. Padrão: \. String

Valor retornado

Retorna 1 se a string não corresponder ao padrão LIKE; caso contrário, 0. UInt8

Exemplos

Exemplo de uso

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

Padrão não correspondente

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

notMatch

Introduzido em: v26.8.0

Semelhante a match, mas nega o resultado: verifica se a string não corresponde ao padrão de expressão regular.

Esta função usa a biblioteca de expressões regulares RE2. Consulte re2 para ver a sintaxe compatível.

Sintaxe alternativa do operador: haystack !~ pattern (estilo PostgreSQL).

Sintaxe

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

Argumentos

  • haystack — String na qual o padrão é buscado. String
  • pattern — Padrão de expressão regular. Pode ser uma constante ou vir de uma coluna. String

Valor retornado

Retorna 0 se o padrão corresponder, 1 caso contrário. UInt8

Exemplos

Exemplo de uso

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

notMatchCaseInsensitive

Introduzido em: v26.8.0

Semelhante a matchCaseInsensitive, mas nega o resultado: verifica se a string não corresponde ao padrão de expressão regular sem diferenciar maiúsculas de minúsculas.

Esta função usa a biblioteca de expressões regulares RE2. Consulte re2 para ver a sintaxe compatível.

Sintaxe alternativa do operador: haystack !~* pattern (no estilo PostgreSQL).

Sintaxe

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

Argumentos

  • haystack — String na qual o padrão é buscado. String
  • pattern — Padrão de expressão regular. Pode ser uma constante ou vir de uma coluna. String

Valor retornado

Retorna 0 se o padrão corresponder sem diferenciar maiúsculas de minúsculas, 1 caso contrário. UInt8

Exemplos

Exemplo de uso

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

position

Introduzido na versão: v1.1.0

Retorna a posição (em bytes, começando em 1) de uma substring needle em uma string haystack.

Se a substring needle estiver vazia, aplicam-se as seguintes regras:

  • se nenhum start_pos for especificado: retorna 1
  • se start_pos = 0: retorna 1
  • se start_pos >= 1 e start_pos <= length(haystack) + 1: retorna start_pos
  • caso contrário: retorna 0

As mesmas regras também se aplicam às funções locate, positionCaseInsensitive, positionUTF8 e positionCaseInsensitiveUTF8.

Sintaxe

position(haystack, needle[, start_pos])

Argumentos

  • haystack — String em que a busca é realizada. String ou Enum
  • needle — Substring a ser procurada. String
  • start_pos — Posição em haystack (começando em 1) na qual a busca se inicia. Opcional. UInt

Valor retornado

Retorna a posição inicial em bytes, contando a partir de 1, se a substring for encontrada; caso contrário, retorna 0 se a substring não for encontrada. UInt64

Exemplos

Uso básico

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

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

Sintaxe de needle IN haystack

SELECT 6 = position('/' IN s) FROM (SELECT 'Hello/World' AS s)
┌─equals(6, position(s, '/'))─┐
│                           1 │
└─────────────────────────────┘

Subcadeia com needle vazio

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

Introduzido em: v1.1.0

Como position, mas sem diferenciar maiúsculas de minúsculas.

Sintaxe

positionCaseInsensitive(haystack, needle[, start_pos])

Aliases: instr

Argumentos

  • haystack — String em que a busca é realizada. String ou Enum
  • needle — Substring a ser procurada. String
  • start_pos — Opcional. Posição (indexada a partir de 1) em haystack na qual a busca começa. UInt*

Valor retornado

Retorna a posição inicial em bytes, contando a partir de 1, se a substring for encontrada; caso contrário, retorna 0. UInt64

Exemplos

Busca sem diferenciar maiúsculas de minúsculas

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

positionCaseInsensitiveUTF8

Introduzido em: v1.1.0

Como positionUTF8, mas faz a busca sem diferenciar letras maiúsculas de minúsculas.

Sintaxe

positionCaseInsensitiveUTF8(haystack, needle[, start_pos])

Argumentos

  • haystack — String na qual a busca é realizada. String ou Enum
  • needle — Substring a ser procurada. String
  • start_pos — Opcional. Posição (base 1) em haystack na qual a busca começa. UInt*

Valor retornado

Retorna a posição inicial, em bytes e contando a partir de 1, se a substring for encontrada; caso contrário, retorna 0. UInt64

Exemplos

Busca UTF-8 sem diferenciar maiúsculas de minúsculas

SELECT positionCaseInsensitiveUTF8('Привет мир', 'МИР')
┌─positionCaseInsensitiveUTF8('Привет мир', 'МИР')─┐
│                                                8 │
└──────────────────────────────────────────────────┘

positionUTF8

Introduzido em: v1.1.0

Como position, mas presume que haystack e needle sejam strings codificadas em UTF-8.

Sintaxe

positionUTF8(haystack, needle[, start_pos])

Argumentos

  • haystack — String na qual a busca é realizada. String ou Enum
  • needle — Substring a ser pesquisada. String
  • start_pos — Opcional. Posição (começando em 1) em haystack na qual a busca se inicia. UInt*

Valor retornado

Retorna a posição inicial em bytes, contando a partir de 1, se a substring for encontrada; caso contrário, retorna 0. UInt64

Exemplos

Contagem de caracteres UTF-8

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