Pular para o conteúdo principal
A documentação abaixo é gerada a partir da system table system.functions.

​
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
Query
SELECT alphaTokens('abca1abc');
Response
┌─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
Query
SELECT arrayStringConcat(['12/05/2021', '12:50:00'], ' ') AS DateString;
Response
┌─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
Query
WITH '< Server: nginx
< Date: Tue, 22 Jan 2019 00:26:14 GMT
< Content-Type: text/html; charset=UTF-8
< Connection: keep-alive
' AS s
SELECT extractAllGroupsVertical(s, '< ([\\w\\-]+): ([^\\r\\n]+)');
Response
[['Server','nginx'],['Date','Tue, 22 Jan 2019 00:26:14 GMT'],['Content-Type','text/html; charset=UTF-8'],['Connection','keep-alive']]

​
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
Query
SELECT ngrams('ClickHouse', 3);
Response
['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 delimitador especificado. Esta função divide a string pelo delimitador, inverte a ordem das partes resultantes e as une novamente usando o mesmo delimitador. 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
Query
SELECT reverseBySeparator('www.google.com')
Response
'com.google.www'
Inversão de path
Query
SELECT reverseBySeparator('a/b/c', '/')
Response
'c/b/a'
Separador personalizado
Query
SELECT reverseBySeparator('x::y::z', '::')
Response
'z::y::x'
Caso limite com pontos
Query
SELECT reverseBySeparator('.a.b.', '.')
Response
'.b.a.'
Um único elemento
Query
SELECT reverseBySeparator('single')
Response
'single'
Separador vazio
Query
SELECT reverseBySeparator('abcde', '')
Response
'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.
A configuração splitby_max_substrings_includes_remaining_string (padrão: 0) controla se a parte restante da string é incluída no último elemento do array resultante quando o argumento max_substrings > 0.
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
Query
SELECT splitByChar(',', '1,2,3,abcde');
Response
┌─splitByChar(⋯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.
A configuração splitby_max_substrings_includes_remaining_string (padrão: 0) controla se a string restante é incluída no último elemento do array resultante quando o argumento max_substrings > 0.
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
Query
SELECT splitByNonAlpha('user@domain.com');
Response
['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.
A configuração splitby_max_substrings_includes_remaining_string (padrão: 0) controla se a string restante é incluída no último elemento do array resultante quando o argumento max_substrings > 0.
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
Query
SELECT splitByRegexp('\\d+', 'a12bc23de345f');
Response
┌─splitByRegex⋯c23de345f')─┐
│ ['a12bc23de345f']        │
└──────────────────────────┘
Expressão regular vazia
Query
SELECT splitByRegexp('', 'abcde');
Response
┌─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
A configuração splitby_max_substrings_includes_remaining_string (padrão: 0) controla se a string restante é incluída no último elemento do array resultante quando o argumento max_substrings > 0.
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
Query
SELECT splitByString(', ', '1, 2 3, 4,5, abcde');
Response
┌─splitByStrin⋯4,5, abcde')─┐
│ ['1','2 3','4,5','abcde'] │
└───────────────────────────┘
Separador vazio
Query
SELECT splitByString('', 'abcde');
Response
┌─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.
A configuração splitby_max_substrings_includes_remaining_string (padrão: 0) controla se o restante da string é incluído no último elemento do array resultante quando o argumento max_substrings > 0.
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
Query
SELECT splitByWhitespace('  1!  a,  b.  ');
Response
['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 [' '].
  • 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.
  • ngrams(N) divide strings em N-grams 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-grams 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-grams com comprimento maior ou igual a min_cutoff_length serão retornados. Em comparação com ngrams(N), o tokenizador sparseGrams produz N-grams 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-grams a partir da string de entrada, mas apenas os 4- e 5-grams 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).
No caso do tokenizador splitByString, se os tokens não formarem um código de prefixo, provavelmente você vai querer que a correspondência priorize os separadores mais longos. 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'] seria tokenizada como ['21ac'] (o que provavelmente não é o que você queria). Sintaxe 
tokens(value) -- tokenizador 'splitByNonAlpha'
tokens(value, 'splitByNonAlpha')
tokens(value, 'splitByString'[, separators])
tokens(value, 'asciiCJK')
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, asciiCJK, ngrams, sparseGrams e array. Opcional; se não for definido explicitamente, o valor padrão é splitByNonAlpha. 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 de separação. Se não for definido explicitamente, o valor padrão é [' ']. const Array(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
Valor retornado Retorna o array resultante de tokens da string de entrada. Array Exemplos Tokenizador padrão
Query
SELECT tokens('test1,;\\\\ test2,;\\\\ test3,;\\\\   test4') AS tokens;
Response
['test1','test2','test3','test4']
Tokenizador de n-gramas
Query
SELECT tokens('abc def', 'ngrams', 3) AS tokens;
Response
['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; 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
  • 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)
  • 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
Valor retornado Retorna o array resultante de tokens da string de entrada. Array Exemplos Tokenizador padrão
Query
SELECT tokensForLikePattern('%test1,test2,test3%') AS tokens;
Response
['test2']
Última modificação em 10 de junho de 2026