> ## Documentation Index > Fetch the complete documentation index at: https://private-7c7dfe99-fix-nav-issues.mintlify.site/llms.txt > Use this file to discover all available pages before exploring further. > Documentação sobre funções de divisão de strings # Funções de divisão de strings export const DeprecatedBadge = () => { return
Deprecated feature
; }; A documentação abaixo é gerada a partir da system table `system.functions`. {/*AUTOGENERATED_START*/}
## 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** ```sql theme={null} alphaTokens(s[, max_substrings]) ``` **Aliases**: `splitByAlpha` **Argumentos** * `s` — A string a ser dividida. [`String`](/pt-BR/reference/data-types/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`](/pt-BR/reference/data-types/int-uint) **Valor retornado** Retorna um array com as substrings selecionadas de `s`. [`Array(String)`](/pt-BR/reference/data-types/array) **Exemplos** **Exemplo de uso** ```sql title=Query theme={null} SELECT alphaTokens('abca1abc'); ``` ```response title=Response theme={null} ┌─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** ```sql theme={null} arrayStringConcat(arr[, separator]) ``` **Aliases**: `array_to_string` **Argumentos** * `arr` — O array a ser concatenado. [`Array(T)`](/pt-BR/reference/data-types/array) * `separator` — Opcional. String usada como separador. Por padrão, é uma string vazia. [`const String`](/pt-BR/reference/data-types/string) **Valor retornado** Retorna a string concatenada. [`String`](/pt-BR/reference/data-types/string) **Exemplos** **Exemplo de uso** ```sql title=Query theme={null} SELECT arrayStringConcat(['12/05/2021', '12:50:00'], ' ') AS DateString; ``` ```response title=Response theme={null} ┌─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** ```sql theme={null} extractAllGroupsVertical(s, regexp) ``` **Aliases**: `extractAllGroups` **Argumentos** * `s` — String de entrada da qual extrair. [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring) * `regexp` — Expressão regular usada para correspondência. [`const String`](/pt-BR/reference/data-types/string) ou [`const FixedString`](/pt-BR/reference/data-types/fixedstring) **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))`](/pt-BR/reference/data-types/array) **Exemplos** **Exemplo de uso** ```sql title=Query theme={null} 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 title=Response theme={null} [['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** ```sql theme={null} ngrams(s, N) ``` **Argumentos** * `s` — String de entrada. [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring) * `N` — O comprimento do n-grama. [`const UInt8/16/32/64`](/pt-BR/reference/data-types/int-uint) **Valor retornado** Retorna um array com n-gramas. [`Array(String)`](/pt-BR/reference/data-types/array) **Exemplos** **Exemplo de uso** ```sql title=Query theme={null} SELECT ngrams('ClickHouse', 3); ``` ```response title=Response theme={null} ['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](http://www.google.com)') retorna 'com.google.www' * reverseBySeparator('a/b/c', '/') retorna 'c/b/a' * reverseBySeparator('x::y::z', '::') retorna 'z::y::x' **Sintaxe** ```sql theme={null} reverseBySeparator(string[, separator]) ``` **Argumentos** * `string` — A string de entrada para inverter a ordem de suas partes. [`String`](/pt-BR/reference/data-types/string) * `separator` — A string separadora usada para identificar as partes. Se não for fornecida, usa '.' (ponto). Padrão: '.' [`String`](/pt-BR/reference/data-types/string) **Valor retornado** Retorna uma string com as substrings ordenadas da direita para a esquerda da string original, unidas pelo mesmo separador. [`String`](/pt-BR/reference/data-types/string) **Exemplos** **Reversão básica de domínio** ```sql title=Query theme={null} SELECT reverseBySeparator('www.google.com') ``` ```response title=Response theme={null} 'com.google.www' ``` **Inversão de path** ```sql title=Query theme={null} SELECT reverseBySeparator('a/b/c', '/') ``` ```response title=Response theme={null} 'c/b/a' ``` **Separador personalizado** ```sql title=Query theme={null} SELECT reverseBySeparator('x::y::z', '::') ``` ```response title=Response theme={null} 'z::y::x' ``` **Caso limite com pontos** ```sql title=Query theme={null} SELECT reverseBySeparator('.a.b.', '.') ``` ```response title=Response theme={null} '.b.a.' ``` **Um único elemento** ```sql title=Query theme={null} SELECT reverseBySeparator('single') ``` ```response title=Response theme={null} 'single' ``` **Separador vazio** ```sql title=Query theme={null} SELECT reverseBySeparator('abcde', '') ``` ```response title=Response theme={null} '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`](/pt-BR/reference/settings/session-settings#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** ```sql theme={null} splitByChar(separator, s[, max_substrings]) ``` **Argumentos** * `separator` — O separador deve ser um caractere de um único byte. [`String`](/pt-BR/reference/data-types/string) * `s` — A string a ser dividida. [`String`](/pt-BR/reference/data-types/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`](/pt-BR/reference/data-types/int-uint) **Valor retornado** Retorna um array das substrings selecionadas. [`Array(String)`](/pt-BR/reference/data-types/array) **Exemplos** **Exemplo de uso** ```sql title=Query theme={null} SELECT splitByChar(',', '1,2,3,abcde'); ``` ```response title=Response theme={null} ┌─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`](/pt-BR/reference/settings/session-settings#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** ```sql theme={null} splitByNonAlpha(s[, max_substrings]) ``` **Argumentos** * `s` — A string a ser dividida. [`String`](/pt-BR/reference/data-types/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`](/pt-BR/reference/data-types/int-uint) **Valor retornado** Retorna um array com as substrings selecionadas de `s`. [`Array(String)`](/pt-BR/reference/data-types/array) **Exemplos** **Exemplo de uso** ```sql title=Query theme={null} SELECT splitByNonAlpha('user@domain.com'); ``` ```response title=Response theme={null} ['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`](/pt-BR/reference/settings/session-settings#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** ```sql theme={null} splitByRegexp(regexp, s[, max_substrings]) ``` **Argumentos** * `regexp` — Expressão regular. Constante. [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring) * `s` — A string a ser dividida. [`String`](/pt-BR/reference/data-types/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`](/pt-BR/reference/data-types/int-uint) **Valor retornado** Retorna um array com as substrings selecionadas de `s`. [`Array(String)`](/pt-BR/reference/data-types/array) **Exemplos** **Exemplo de uso** ```sql title=Query theme={null} SELECT splitByRegexp('\\d+', 'a12bc23de345f'); ``` ```response title=Response theme={null} ┌─splitByRegex⋯c23de345f')─┐ │ ['a12bc23de345f'] │ └──────────────────────────┘ ``` **Expressão regular vazia** ```sql title=Query theme={null} SELECT splitByRegexp('', 'abcde'); ``` ```response title=Response theme={null} ┌─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`](/pt-BR/reference/settings/session-settings#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** ```sql theme={null} splitByString(separator, s[, max_substrings]) ``` **Argumentos** * `separator` — O separador. [`String`](/pt-BR/reference/data-types/string) * `s` — A string a ser dividida. [`String`](/pt-BR/reference/data-types/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`](/pt-BR/reference/data-types/int-uint) **Valor retornado** Retorna um array com as substrings selecionadas de `s` [`Array(String)`](/pt-BR/reference/data-types/array) **Exemplos** **Exemplo de uso** ```sql title=Query theme={null} SELECT splitByString(', ', '1, 2 3, 4,5, abcde'); ``` ```response title=Response theme={null} ┌─splitByStrin⋯4,5, abcde')─┐ │ ['1','2 3','4,5','abcde'] │ └───────────────────────────┘ ``` **Separador vazio** ```sql title=Query theme={null} SELECT splitByString('', 'abcde'); ``` ```response title=Response theme={null} ┌─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`](/pt-BR/reference/settings/session-settings#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** ```sql theme={null} splitByWhitespace(s[, max_substrings]) ``` **Argumentos** * `s` — A string a ser dividida. [`String`](/pt-BR/reference/data-types/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`](/pt-BR/reference/data-types/int-uint) **Valor retornado** Retorna um array com as substrings selecionadas de `s`. [`Array(String)`](/pt-BR/reference/data-types/array) **Exemplos** **Exemplo de uso** ```sql title=Query theme={null} SELECT splitByWhitespace(' 1! a, b. '); ``` ```response title=Response theme={null} ['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](/pt-BR/reference/functions/regular-functions/splitting-merging-functions#splitByNonAlpha)). * `splitByString(S)` divide strings usando determinadas strings separadoras `S` definidas pelo usuário (veja também a função [splitByString](/pt-BR/reference/functions/regular-functions/splitting-merging-functions#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](/pt-BR/reference/functions/regular-functions/splitting-merging-functions#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](/pt-BR/reference/functions/regular-functions/string-functions#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](/pt-BR/reference/functions/regular-functions/array-functions#array)). No caso do tokenizador `splitByString`, se os tokens não formarem um [código de prefixo](https://en.wikipedia.org/wiki/Prefix_code), 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** ```sql theme={null} 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`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/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`](/pt-BR/reference/data-types/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`](/pt-BR/reference/data-types/int-uint) * `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)`](/pt-BR/reference/data-types/array) * `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`](/pt-BR/reference/data-types/int-uint) * `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`](/pt-BR/reference/data-types/int-uint) * `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`](/pt-BR/reference/data-types/int-uint) **Valor retornado** Retorna o array resultante de tokens da string de entrada. [`Array`](/pt-BR/reference/data-types/array) **Exemplos** **Tokenizador padrão** ```sql title=Query theme={null} SELECT tokens('test1,;\\\\ test2,;\\\\ test3,;\\\\ test4') AS tokens; ``` ```response title=Response theme={null} ['test1','test2','test3','test4'] ``` **Tokenizador de n-gramas** ```sql title=Query theme={null} SELECT tokens('abc def', 'ngrams', 3) AS tokens; ``` ```response title=Response theme={null} ['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** ```sql theme={null} tokensForLikePattern(value[, tokenizer[, tokenizer_specific_arguments...]]) ``` **Argumentos** * `value` — A string de entrada. [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/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`](/pt-BR/reference/data-types/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`](/pt-BR/reference/data-types/int-uint) * `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)`](/pt-BR/reference/data-types/array) * `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`](/pt-BR/reference/data-types/int-uint) * `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`](/pt-BR/reference/data-types/int-uint) * `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`](/pt-BR/reference/data-types/int-uint) **Valor retornado** Retorna o array resultante de tokens da string de entrada. [`Array`](/pt-BR/reference/data-types/array) **Exemplos** **Tokenizador padrão** ```sql title=Query theme={null} SELECT tokensForLikePattern('%test1,test2,test3%') AS tokens; ``` ```response title=Response theme={null} ['test2'] ```