Skip to content
ClickHouse Docs
ClickHouse DocsClickHouse Docs
49.6kGet Started

Funções de divisão de strings

View as MarkdownEdit this pageReport an issueSet up docs MCP

alphaTokens

Introduzido em: v1.1.0

Seleciona substrings formadas por bytes consecutivos nos intervalos a-z e A-Z e retorna um array com as substrings selecionadas.

Sintaxe

alphaTokens(s[, max_substrings])

Aliases: splitByAlpha

Argumentos

  • s — A string a ser dividida. String
  • max_substrings — Opcional. Quando max_substrings > 0, o número de substrings retornadas não será maior que max_substrings; caso contrário, a função retornará o máximo de substrings possível. Int64

Valor retornado

Retorna um array com as substrings selecionadas de s. Array(String)

Exemplos

Exemplo de uso

SELECT alphaTokens('abca1abc');
┌─alphaTokens('abca1abc')─┐
│ ['abca','abc']          │
└─────────────────────────┘

arrayStringConcat

Introduzido em: v1.1.0

Concatena as representações em string dos valores listados no array usando o separador fornecido, que é um parâmetro opcional definido como uma string vazia por padrão.

Sintaxe

arrayStringConcat(arr[, separator])

Aliases: array_to_string

Argumentos

  • arr — O array a ser concatenado. Array(T)
  • separator — Opcional. String usada como separador. Por padrão, é uma string vazia. const String

Valor retornado

Retorna a string concatenada. String

Exemplos

Exemplo de uso

SELECT arrayStringConcat(['12/05/2021', '12:50:00'], ' ') AS DateString;
┌─DateString──────────┐
│ 12/05/2021 12:50:00 │
└─────────────────────┘

extractAllGroupsVertical

Introduzido em: v20.5.0

Encontra todos os grupos em uma string usando uma expressão regular e retorna um array de arrays, em que cada array contém os fragmentos correspondentes de cada grupo, agrupados pela ordem em que aparecem na string de entrada.

Sintaxe

extractAllGroupsVertical(s, regexp)

Aliases: extractAllGroups

Argumentos

Valor retornado

Retorna um array de arrays, em que cada array interno contém os grupos capturados em uma correspondência. Cada correspondência produz um array com elementos correspondentes aos grupos de captura na expressão regular (grupo 1, grupo 2 etc.). 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 extractAllGroupsVertical(s, '< ([\\w\\-]+): ([^\\r\\n]+)');
[['Server','nginx'],['Date','Tue, 22 Jan 2019 00:26:14 GMT'],['Content-Type','text/html; charset=UTF-8'],['Connection','keep-alive']]

naiveBayesNgrams

Introduzido em: v26.7.0

Divide o texto em n-gramas usando a mesma tokenização de um dicionário Naive Bayes (o layout NAIVE_BAYES): modo byte, codepoint ou token, com padding de borda opcional. Use-o para gerar os dados de treinamento pré-agregados (ngram, class_id, count) consumidos por esse dicionário, para que os n-gramas de treinamento correspondam exatamente ao que naiveBayesClassifier produz durante a consulta.

Sintaxe

naiveBayesNgrams(text, n, mode[, start_token, end_token])

Argumentos

  • text — Texto a ser dividido em n-gramas. String
  • n — Tamanho do n-grama, de 1 a 1024. const UInt
  • mode — Modo de tokenização: 'byte', 'codepoint' ou 'token'. const String
  • start_token — Opcional. Token de borda adicionado ao início da entrada (n-1) vezes; um número para 'byte'/'codepoint', um literal para 'token'. Vazio significa sem padding. const String
  • end_token — Opcional. Token de borda adicionado ao final da entrada (n-1) vezes. const String

Valor retornado

Os n-gramas do texto de entrada. Array(String)

Exemplos

Bigramas de token

SELECT naiveBayesNgrams('the cat sat', 2, 'token');
['the cat','cat sat']

Bigramas de token com padding nas bordas

SELECT naiveBayesNgrams('cat', 2, 'token', '<s>', '</s>');
['<s> cat','cat </s>']

Bigramas de bytes com preenchimento nas bordas (resultado mostrado em hexadecimal)

SELECT arrayMap(x -> hex(x), naiveBayesNgrams('xy', 2, 'byte', '0x01', '0xFF'));
['0178','7879','79FF']

Bigramas de pontos de código com preenchimento nas bordas (resultado mostrado em hexadecimal)

SELECT arrayMap(x -> hex(x), naiveBayesNgrams('ab', 2, 'codepoint', '0x10FFFE', '0x10FFFF'));
['F48FBFBE61','6162','62F48FBFBF']

ngrams

Introduzido em: v21.11.0

Divide uma string UTF-8 em n-gramas de tamanho N.

Sintaxe

ngrams(s, N)

Argumentos

Valor retornado

Retorna um array com n-gramas. Array(String)

Exemplos

Exemplo de uso

SELECT ngrams('ClickHouse', 3);
['Cli','lic','ick','ckH','kHo','Hou','ous','use']

reverseBySeparator

Introduzido em: v26.2.0

Inverte a ordem das substrings em uma string, separadas por um separador especificado. Esta função divide a string pelo separador, inverte a ordem das partes resultantes e as une novamente usando o mesmo separador. Ela é útil para fazer o parsing de nomes de domínio, caminhos de arquivo ou outros dados hierárquicos em que seja necessário inverter a ordem dos componentes.

Exemplos:

  • reverseBySeparator('www.google.com') retorna 'com.google.www'
  • reverseBySeparator('a/b/c', '/') retorna 'c/b/a'
  • reverseBySeparator('x::y::z', '::') retorna 'z::y::x'

Sintaxe

reverseBySeparator(string[, separator])

Argumentos

  • string — A string de entrada para inverter a ordem de suas partes. String
  • separator — A string separadora usada para identificar as partes. Se não for fornecida, usa '.' (ponto). Padrão: '.' String

Valor retornado

Retorna uma string com as substrings ordenadas da direita para a esquerda da string original, unidas pelo mesmo separador. String

Exemplos

Reversão básica de domínio

SELECT reverseBySeparator('www.google.com')
com.google.www

Inversão de path

SELECT reverseBySeparator('a/b/c', '/')
c/b/a

Separador personalizado

SELECT reverseBySeparator('x::y::z', '::')
z::y::x

Caso limite com pontos

SELECT reverseBySeparator('.a.b.', '.')
.b.a.

Um único elemento

SELECT reverseBySeparator('single')
single

Separador vazio

SELECT reverseBySeparator('abcde', '')
edcba

splitByChar

Introduzido em: v1.1.0

Divide uma string em um array de substrings usando como separador a string constante especificada separator, que deve ter exatamente um caractere. Substrings vazias podem ser retornadas se o separador ocorrer no início ou no fim da string, ou se houver vários separadores consecutivos.

Substrings vazias podem ser retornadas quando:

  • Um separador ocorre no início ou no fim da string
  • Há vários separadores consecutivos
  • A string original s está vazia

Sintaxe

splitByChar(separator, s[, max_substrings])

Argumentos

  • separator — O separador deve ser um caractere de um único byte. String
  • s — A string a ser dividida. String
  • max_substrings — Opcional. Se max_substrings > 0, o array retornado conterá no máximo max_substrings substrings; caso contrário, a função retornará o máximo possível de substrings. O valor padrão é 0. Int64

Valor retornado

Retorna um array das substrings selecionadas. Array(String)

Exemplos

Exemplo de uso

SELECT splitByChar(',', '1,2,3,abcde');
┌─splitByChar(',', '1,2,3,abcde')─┐
│ ['1','2','3','abcde']           │
└─────────────────────────────────┘

splitByNonAlpha

Introduzido em: v21.9.0

Divide uma string em um array de substrings, usando caracteres de espaço em branco e de pontuação como separadores.

Sintaxe

splitByNonAlpha(s[, max_substrings])

Argumentos

  • s — A string a ser dividida. String
  • max_substrings — Opcional. Quando max_substrings > 0, o número de substrings retornadas não será maior que max_substrings; caso contrário, a função retornará o maior número possível de substrings. Valor padrão: 0. Int64

Valor retornado

Retorna um array com as substrings selecionadas de s. Array(String)

Exemplos

Exemplo de uso

SELECT splitByNonAlpha('user@domain.com');
['user','domain','com']

splitByRegexp

Introduzido em: v21.6.0

Divide uma string separada pela expressão regular fornecida em um array de substrings. Se a expressão regular fornecida estiver vazia, a string será dividida em um array de caracteres individuais. Se nenhuma correspondência for encontrada para a expressão regular, a string não será dividida.

Substrings vazias podem ser retornadas quando:

  • uma correspondência não vazia da expressão regular ocorre no início ou no fim da string
  • há várias correspondências não vazias consecutivas da expressão regular
  • a string original está vazia enquanto a expressão regular não está vazia.

Sintaxe

splitByRegexp(regexp, s[, max_substrings])

Argumentos

  • regexp — Expressão regular. Constante. String ou FixedString
  • s — A string a ser dividida. String
  • max_substrings — Opcional. Quando max_substrings > 0, as substrings retornadas não excederão max_substrings; caso contrário, a função retornará o maior número possível de substrings. Valor padrão: 0. Int64

Valor retornado

Retorna um array com as substrings selecionadas de s. Array(String)

Exemplos

Exemplo de uso

SELECT splitByRegexp('\\d+', 'a12bc23de345f');
┌─splitByRegexp('\\d+', 'a12bc23de345f')─┐
│ ['a','bc','de','f']                    │
└────────────────────────────────────────┘

Expressão regular vazia

SELECT splitByRegexp('', 'abcde');
┌─splitByRegexp('', 'abcde')─┐
│ ['a','b','c','d','e']      │
└────────────────────────────┘

splitByString

Introduzido em: v1.1.0

Divide uma string usando um separator constante composto por vários caracteres em um array de substrings. Se a string separator estiver vazia, ela dividirá a string s em um array de caracteres individuais.

Substrings vazias podem ser retornadas quando:

  • Um separador não vazio aparece no início ou no fim da string
  • Há vários separadores não vazios consecutivos
  • A string original s está vazia enquanto o separador não está vazio

Sintaxe

splitByString(separator, s[, max_substrings])

Argumentos

  • separator — O separador. String
  • s — A string a ser dividida. String
  • max_substrings — Opcional. Quando max_substrings > 0, as substrings retornadas não serão mais numerosas que max_substrings; caso contrário, a função retornará o maior número possível de substrings. Valor padrão: 0. Int64

Valor retornado

Retorna um array com as substrings selecionadas de s Array(String)

Exemplos

Exemplo de uso

SELECT splitByString(', ', '1, 2 3, 4,5, abcde');
┌─splitByString(', ', '1, 2 3, 4,5, abcde')─┐
│ ['1','2 3','4,5','abcde']                 │
└───────────────────────────────────────────┘

Separador vazio

SELECT splitByString('', 'abcde');
┌─splitByString('', 'abcde')─┐
│ ['a','b','c','d','e']      │
└────────────────────────────┘

splitByWhitespace

Introduzido na versão: v21.9.0

Divide uma string separada por caracteres de espaço em branco em um array de substrings.

Sintaxe

splitByWhitespace(s[, max_substrings])

Argumentos

  • s — A string a ser dividida. String
  • max_substrings — Opcional. Quando max_substrings > 0, a quantidade de substrings retornadas não será maior que max_substrings; caso contrário, a função retornará o maior número possível de substrings. Valor padrão: 0. Int64

Valor retornado

Retorna um array com as substrings selecionadas de s. Array(String)

Exemplos

Exemplo de uso

SELECT splitByWhitespace('  1!  a,  b.  ');
['1!','a,','b.']

tokens

Introduzido em: v21.11.0

Divide uma string em tokens usando o tokenizador informado.

Tokenizadores disponíveis:

  • splitByNonAlpha divide strings em caracteres ASCII não alfanuméricos (veja também a função splitByNonAlpha).
  • splitByString(S) divide strings usando determinadas strings separadoras S definidas pelo usuário (veja também a função splitByString). Os separadores podem ser especificados com um parâmetro opcional, por exemplo, tokens(value, 'splitByString', [', ', '; ', '\n', '\\']). Observe que cada string pode ser composta por vários caracteres (', ' no exemplo). A lista padrão de separadores, se não for especificada explicitamente, é um único espaço em branco [' '].
  • splitByRegexp(re) divide strings usando um separador de expressão regular re definido pelo usuário (veja também a função splitByRegexp). A expressão regular é obrigatória, por exemplo, tokens(value, 'splitByRegexp', '[^\p{L}\p{N}#+]+'). Diferentemente de splitByString, um separador de expressão regular pode preservar tokens que contêm caracteres especiais (como C++ ou C#).
  • asciiCJK divide strings em tokens usando regras de fronteira de palavras do Unicode (semelhantes ao UAX #29). Caracteres ASCII alfanuméricos e sublinhados formam tokens com conectores (: para letras, . e ' para caracteres do mesmo tipo). Caracteres Unicode não ASCII se tornam tokens de um único caractere.
  • chinese segmenta texto em chinês em palavras usando um dicionário e um modelo oculto de Markov (o algoritmo segue o jieba; o dicionário embutido e os dados do modelo são derivados do cppjieba). Diferentemente de asciiCJK, que trata cada caractere não ASCII como um token de um único caractere, chinese agrupa caracteres chineses consecutivos em palavras, o que gera tokens mais significativos e maior qualidade de busca para texto em chinês. Um argumento opcional de granularity pode ser coarse_grained (o padrão) ou fine_grained; este último também enumera subpalavras sobrepostas, melhorando a revocação ao custo de um índice maior.
  • icu(locale) divide strings em tokens de palavras usando a segmentação de palavras Unicode (UAX #29) da biblioteca ICU. Para scripts sem espaço em branco entre palavras (por exemplo, chinês, japonês e tailandês), o ICU aplica segmentação baseada em dicionário, de modo que esse texto é dividido em palavras significativas. locale é a localidade do ICU passada ao segmentador (a segmentação é principalmente orientada por script e dicionário; a localidade seleciona a personalização específica de localidade do ICU); ela é obrigatória e passada como um argumento separado, por exemplo, tokens(value, 'icu', 'ja').
  • japanese divide texto em japonês em palavras usando o analisador morfológico MeCab. Requer um dicionário configurado na configuração do servidor (consulte a documentação de índice de texto).
  • ngrams(N) divide strings em N-gramas de mesmo tamanho (veja também a função ngrams). O comprimento do ngram pode ser especificado com um parâmetro inteiro opcional entre 1 e 8, por exemplo, tokens(value, 'ngrams', 3). O tamanho padrão do ngram, se não for especificado explicitamente, é 3.
  • sparseGrams(min_length, max_length, min_cutoff_length) divide strings em n-gramas de comprimento variável, com no mínimo min_length e no máximo max_length caracteres (inclusive) (veja também a função sparseGrams). A menos que sejam especificados explicitamente, min_length e max_length assumem os valores padrão 3 e 100. Se o parâmetro min_cutoff_length for fornecido, apenas n-gramas com comprimento maior ou igual a min_cutoff_length serão retornados. Em comparação com ngrams(N), o tokenizador sparseGrams produz N-gramas de comprimento variável, permitindo uma representação mais flexível do texto original. Por exemplo, tokens(value, 'sparseGrams', 3, 5, 4) gera internamente 3-, 4- e 5-gramas a partir da string de entrada, mas apenas os 4- e 5-gramas são retornados.
  • array não realiza tokenização, ou seja, o valor de cada linha é um token (veja também a função array). Para compatibilidade com outros sistemas, keyword está disponível como um alias de array.

No caso do tokenizador splitByString, se os tokens não formarem um código de prefixo, provavelmente você desejará que correspondências com separadores mais longos tenham prioridade. Para isso, passe os separadores em ordem decrescente de comprimento. Por exemplo, com separators = ['%21', '%'], a string %21abc seria tokenizada como ['abc'], enquanto separators = ['%', '%21'] resultaria em ['21ac'] (o que provavelmente não é o que você desejava).

Sintaxe

tokens(value) -- 'splitByNonAlpha' tokenizer
tokens(value, 'splitByNonAlpha')
tokens(value, 'splitByString'[, separators])
tokens(value, 'splitByRegexp', regexp)
tokens(value, 'asciiCJK')
tokens(value, 'chinese'[, granularity])
tokens(value, 'icu', locale)
tokens(value, 'japanese')
tokens(value, 'ngrams'[, n])
tokens(value, 'sparseGrams'[, min_length, max_length[, min_cutoff_length]])
tokens(value, 'array')

Argumentos

  • value — A string de entrada. String ou FixedString
  • tokenizer — O tokenizador a ser usado. Os argumentos válidos são splitByNonAlpha, splitByString, splitByRegexp, asciiCJK, chinese, icu, japanese, ngrams, sparseGrams e array. Opcional; se não for definido explicitamente, o valor padrão é splitByNonAlpha. const String
  • locale — Relevante apenas se o argumento tokenizer for icu: a localidade obrigatória, por exemplo, 'ja'. const String
  • n — Relevante apenas se o argumento tokenizer for ngrams: um parâmetro opcional que define o comprimento dos ngrams. Se não for definido explicitamente, o valor padrão é 3. const UInt8
  • separators — Relevante apenas se o argumento tokenizer for split: um parâmetro opcional que define as strings separadoras. Se não for definido explicitamente, o valor padrão é [' ']. const Array(String)
  • regexp — Relevante apenas se o argumento tokenizer for splitByRegexp: um parâmetro obrigatório que define o separador de expressão regular. const String
  • min_length — Relevante apenas se o argumento tokenizer for sparseGrams: um parâmetro opcional que define o comprimento mínimo do grama; o valor padrão é 3. const UInt8
  • max_length — Relevante apenas se o argumento tokenizer for sparseGrams: um parâmetro opcional que define o comprimento máximo do grama; o valor padrão é 100. const UInt8
  • min_cutoff_length — Relevante apenas se o argumento tokenizer for sparseGrams: um parâmetro opcional que define o comprimento mínimo de corte. const UInt8
  • granularity — Relevante apenas se o argumento tokenizer for chinese: um parâmetro opcional, coarse_grained (padrão) ou fine_grained, que controla a granularidade da segmentação. const String

Valor retornado

Retorna o array resultante de tokens da string de entrada. Array

Exemplos

Tokenizador padrão

SELECT tokens('test1,;\\\\ test2,;\\\\ test3,;\\\\   test4') AS tokens;
['test1','test2','test3','test4']

Tokenizador de n-gramas

SELECT tokens('abc def', 'ngrams', 3) AS tokens;
['abc','bc ','c d',' de','def']

tokensForLikePattern

Introduzido em: v26.3.0

Divide uma string de padrão LIKE em tokens usando o tokenizador especificado.

Ao contrário da função tokens, esta função reconhece a semântica dos padrões LIKE (como caracteres curinga no início e no fim) e aplica regras específicas do tokenizador para extrair tokens relevantes para correspondência de padrões.

Ela oferece suporte aos mesmos conjuntos de argumentos que a função tokens, com algumas exceções: os tokenizadores chinese e icu não são compatíveis aqui. A tokenização de padrões LIKE é relevante apenas para tokenizadores que optam explicitamente pela semântica LIKE (supportsStringLike()). Chamar tokensForLikePattern com um tokenizador sem suporte lança BAD_ARGUMENTS; use tokens simples em vez disso.

Os argumentos adicionais após tokenizer são interpretados de acordo com o tokenizador selecionado (por exemplo, n para ngrams, separators para splitByString e min_length / max_length [/ min_cutoff_length] para sparseGrams).

Esta função se destina principalmente a depuração e testes e é usada internamente para analisar o comportamento da tokenização de padrões LIKE.

Sintaxe

tokensForLikePattern(value[, tokenizer[, tokenizer_specific_arguments...]])

Argumentos

  • value — A string de entrada. String ou FixedString
  • tokenizer — O tokenizador a ser usado. Os argumentos válidos são splitByNonAlpha, splitByString, asciiCJK, ngrams, sparseGrams e array. Opcional; se não for definido explicitamente, o valor padrão será splitByNonAlpha. const String
  • locale — Relevante apenas se o argumento tokenizer for icu: a localidade obrigatória, por exemplo, 'ja'. const String
  • n — Relevante apenas se o argumento tokenizer for ngrams: um parâmetro opcional que define o comprimento dos ngrams. Se não for definido explicitamente, o valor padrão será 3. const UInt8
  • separators — Relevante apenas se o argumento tokenizer for split: um parâmetro opcional que define as strings separadoras. Se não for definido explicitamente, o valor padrão será [' ']. const Array(String)
  • regexp — Relevante apenas se o argumento tokenizer for splitByRegexp: um parâmetro obrigatório que define o separador de expressão regular. const String
  • min_length — Relevante apenas se o argumento tokenizer for sparseGrams: um parâmetro opcional que define o comprimento mínimo do gram; o valor padrão é 3. const UInt8
  • max_length — Relevante apenas se o argumento tokenizer for sparseGrams: um parâmetro opcional que define o comprimento máximo do gram; o valor padrão é 100. const UInt8
  • min_cutoff_length — Relevante apenas se o argumento tokenizer for sparseGrams: um parâmetro opcional que define o comprimento mínimo de corte. const UInt8
  • granularity — Relevante apenas se o argumento tokenizer for chinese: um parâmetro opcional, coarse_grained (padrão) ou fine_grained, que controla a granularidade da segmentação. const String

Valor retornado

Retorna o array resultante de tokens da string de entrada. Array

Exemplos

Tokenizador padrão

SELECT tokensForLikePattern('%test1,test2,test3%') AS tokens;
['test2']
Navigation