> ## 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 das funções de String
# Funções para trabalhar com String
export const VersionBadge = ({minVersion}) =>
Available in version {minVersion} and later
;
As funções para [buscar](/pt-BR/reference/functions/regular-functions/string-search-functions) em strings e para [substituir](/pt-BR/reference/functions/regular-functions/string-replace-functions) em strings são descritas separadamente.
A documentação abaixo é gerada a partir da tabela de sistema `system.functions`.
{/*AUTOGENERATED_START*/}
## CRC32
Introduzido em: v20.1.0
Calcula o checksum CRC32 de uma string usando o polinômio CRC-32-IEEE 802.3 e o valor inicial `0xffffffff` (implementação do zlib).
**Sintaxe**
```sql theme={null}
CRC32(s)
```
**Argumentos**
* `s` — String para a qual calcular o CRC32. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna o checksum CRC32 da string. [`UInt32`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT CRC32('ClickHouse')
```
```response title=Response theme={null}
┌─CRC32('ClickHouse')─┐
│ 1538217360 │
└─────────────────────┘
```
## CRC32IEEE
Introduzido em: v20.1.0
Calcula o checksum CRC32 de uma string usando o polinômio CRC-32-IEEE 802.3.
**Sintaxe**
```sql theme={null}
CRC32IEEE(s)
```
**Argumentos**
* `s` — String para a qual calcular o CRC32. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna o checksum CRC32 da string. [`UInt32`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT CRC32IEEE('ClickHouse');
```
```response title=Response theme={null}
┌─CRC32IEEE('ClickHouse')─┐
│ 3089448422 │
└─────────────────────────┘
```
## CRC64
Introduzido em: v20.1.0
Calcula o checksum CRC64 de uma string usando o polinômio CRC-64-ECMA.
**Sintaxe**
```sql theme={null}
CRC64(s)
```
**Argumentos**
* `s` — String para a qual calcular o CRC64. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna o checksum CRC64 da string. [`UInt64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT CRC64('ClickHouse');
```
```response title=Response theme={null}
┌──CRC64('ClickHouse')─┐
│ 12126588151325169346 │
└──────────────────────┘
```
## appendTrailingCharIfAbsent
Introduzido em: v1.1.0
Adiciona o caractere `c` à string `s` se `s` não estiver vazia e não terminar com o caractere `c`.
**Sintaxe**
```sql theme={null}
appendTrailingCharIfAbsent(s, c)
```
**Argumentos**
* `s` — String de entrada. [`String`](/pt-BR/reference/data-types/string)
* `c` — Caractere a ser acrescentado, caso esteja ausente. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna a string `s` com o caractere `c` acrescentado, caso `s` não termine com `c`. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT appendTrailingCharIfAbsent('https://example.com', '/');
```
```response title=Response theme={null}
┌─appendTraili⋯.com', '/')─┐
│ https://example.com/ │
└──────────────────────────┘
```
## ascii
Introduzido em: v22.11.0
Retorna o código ASCII do primeiro caractere da string `s` como um `Int32`.
**Sintaxe**
```sql theme={null}
ascii(s)
```
**Argumentos**
* `s` — Entrada do tipo `String`. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna o ponto de código ASCII do primeiro caractere. Se `s` estiver vazio, o resultado será `0`. Se o primeiro caractere não for um caractere ASCII ou não fizer parte do intervalo suplementar Latin-1 do UTF-16, o resultado será indefinido. [`Int32`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT ascii('234')
```
```response title=Response theme={null}
┌─ascii('234')─┐
│ 50 │
└──────────────┘
```
## base32Decode
Introduzido em: v25.6.0
Decodifica uma string em [Base32](https://datatracker.ietf.org/doc/html/rfc4648#section-6) (RFC 4648).
Se a string não estiver codificada em Base32 de forma válida, uma exceção será gerada.
**Sintaxe**
```sql theme={null}
base32Decode(encoded)
```
**Argumentos**
* `encoded` — coluna ou constante do tipo String. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna uma string contendo o valor decodificado do argumento. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT base32Decode('IVXGG33EMVSA====');
```
```response title=Response theme={null}
┌─base32Decode('IVXGG33EMVSA====')─┐
│ Encoded │
└──────────────────────────────────┘
```
## base32Encode
Introduzido em: v25.6.0
Codifica uma cadeia de caracteres usando [Base32](https://datatracker.ietf.org/doc/html/rfc4648#section-6).
**Sintaxe**
```sql theme={null}
base32Encode(plaintext)
```
**Argumentos**
* `plaintext` — texto simples a ser codificado. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna uma string contendo o valor codificado do argumento. [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT base32Encode('Encoded')
```
```response title=Response theme={null}
┌─base32Encode('Encoded')─┐
│ IVXGG33EMVSA==== │
└─────────────────────────┘
```
## base58Decode
Introduzido em: v22.7.0
Decodifica uma string em [Base58](https://datatracker.ietf.org/doc/html/draft-msporny-base58-03#section-3).
Se a string não for uma codificação Base58 válida, uma exceção será lançada.
Um segundo argumento opcional, `expected_size`, pode ser fornecido para selecionar um decodificador otimizado de tamanho fixo.
No momento, os valores compatíveis são 32 e 64. Para outros valores, o decodificador genérico é usado.
Quando o decodificador otimizado é selecionado, mas a entrada não pode ser decodificada em exatamente essa quantidade de bytes,
a função lança uma exceção (ou retorna uma string vazia para `tryBase58Decode`).
**Sintaxe**
```sql theme={null}
base58Decode(encoded[, expected_size])
```
**Argumentos**
* `encoded` — coluna String ou constante a ser decodificada. [`String`](/pt-BR/reference/data-types/string)
* `expected_size` — Opcional. Tamanho esperado após a decodificação, em bytes. Quando o valor for 32 ou 64, será usado um decodificador otimizado; para outros valores, será usado o decodificador genérico. [`UInt8, UInt16, UInt32 ou UInt64`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna uma string que contém o valor decodificado do argumento. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT base58Decode('JxF12TrwUP45BMd');
```
```response title=Response theme={null}
┌─base58Decode⋯rwUP45BMd')─┐
│ Hello World │
└──────────────────────────┘
```
## base58Encode
Introduzido em: v22.7.0
Codifica uma string usando a codificação [Base58](https://tools.ietf.org/id/draft-msporny-base58-01.html).
**Sintaxe**
```sql theme={null}
base58Encode(plaintext)
```
**Argumentos**
* `plaintext` — texto simples a ser codificado. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna uma string contendo o valor codificado do argumento. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT base58Encode('ClickHouse');
```
```response title=Response theme={null}
┌─base58Encode('ClickHouse')─┐
│ 4nhk8K7GHXf6zx │
└────────────────────────────┘
```
## base64Decode
Introduzido em: v18.16.0
Decodifica uma string em representação [Base64](https://en.wikipedia.org/wiki/Base64), de acordo com a RFC 4648.
Lança uma exceção em caso de erro.
**Sintaxe**
```sql theme={null}
base64Decode(encoded)
```
**Aliases**: `FROM_BASE64`
**Argumentos**
* `encoded` — coluna do tipo String ou constante a ser decodificada. Se a string não for uma codificação Base64 válida, uma exceção será lançada. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna a string decodificada. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT base64Decode('Y2xpY2tob3VzZQ==')
```
```response title=Response theme={null}
┌─base64Decode('Y2xpY2tob3VzZQ==')─┐
│ clickhouse │
└──────────────────────────────────┘
```
## base64Encode
Introduzido em: v18.16.0
Codifica uma string na representação [Base64](https://en.wikipedia.org/wiki/Base64), de acordo com a RFC 4648.
**Sintaxe**
```sql theme={null}
base64Encode(plaintext)
```
**Aliases**: `TO_BASE64`
**Argumentos**
* `plaintext` — Coluna ou constante de texto simples a ser decodificada. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna uma string com o valor codificado do argumento. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT base64Encode('clickhouse')
```
```response title=Response theme={null}
┌─base64Encode('clickhouse')─┐
│ Y2xpY2tob3VzZQ== │
└────────────────────────────┘
```
## base64URLDecode
Introduzido em: v24.6.0
Decodifica uma string a partir da representação [Base64](https://en.wikipedia.org/wiki/Base64), usando um alfabeto seguro para URL, de acordo com a RFC 4648.
Lança uma exceção em caso de erro.
**Sintaxe**
```sql theme={null}
base64URLDecode(encoded)
```
**Argumentos**
* `encoded` — coluna ou constante do tipo `String` a ser codificada. Se a string não estiver codificada em Base64 de forma válida, uma exceção será lançada. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna uma string que contém o valor decodificado do argumento. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT base64URLDecode('aHR0cHM6Ly9jbGlja2hvdXNlLmNvbQ')
```
```response title=Response theme={null}
┌─base64URLDecode('aHR0cHM6Ly9jbGlja2hvdXNlLmNvbQ')─┐
│ https://clickhouse.com │
└───────────────────────────────────────────────────┘
```
## base64URLEncode
Introduzido na versão: v18.16.0
Codifica uma string usando a representação [Base64](https://datatracker.ietf.org/doc/html/rfc4648#section-4) (RFC 4648) com um alfabeto seguro para URL.
**Sintaxe**
```sql theme={null}
base64URLEncode(plaintext)
```
**Argumentos**
* `plaintext` — Coluna ou constante de texto simples a ser codificada. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna uma string contendo o valor codificado do argumento. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT base64URLEncode('https://clickhouse.com')
```
```response title=Response theme={null}
┌─base64URLEncode('https://clickhouse.com')─┐
│ aHR0cHM6Ly9jbGlja2hvdXNlLmNvbQ │
└───────────────────────────────────────────┘
```
## basename
Introduzido em: v20.1.0
Extrai a parte final de uma string após a última barra ou barra invertida.
Essa função é frequentemente usada para extrair o nome do arquivo de um caminho.
**Sintaxe**
```sql theme={null}
basename(expr)
```
**Argumentos**
* `expr` — Uma expressão de string. As barras invertidas devem ser escapadas. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna a parte final da string de entrada após a última barra ou barra invertida. Se a string de entrada terminar com uma barra ou barra invertida, a função retornará uma string vazia. Retorna a string original se não houver barras nem barras invertidas. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Extrair o nome do arquivo de um caminho Unix**
```sql title=Query theme={null}
SELECT 'some/long/path/to/file' AS a, basename(a)
```
```response title=Response theme={null}
┌─a──────────────────────┬─basename('some/long/path/to/file')─┐
│ some/long/path/to/file │ file │
└────────────────────────┴────────────────────────────────────┘
```
**Extrair o nome do arquivo de um caminho do Windows**
```sql title=Query theme={null}
SELECT 'some\\long\\path\\to\\file' AS a, basename(a)
```
```response title=Response theme={null}
┌─a──────────────────────┬─basename('some\\long\\path\\to\\file')─┐
│ some\long\path\to\file │ file │
└────────────────────────┴────────────────────────────────────────┘
```
**String sem separadores de caminho**
```sql title=Query theme={null}
SELECT 'some-file-name' AS a, basename(a)
```
```response title=Response theme={null}
┌─a──────────────┬─basename('some-file-name')─┐
│ some-file-name │ some-file-name │
└────────────────┴────────────────────────────┘
```
## byteHammingDistance
Introduzido em: v23.9.0
Calcula a [distância de Hamming](https://en.wikipedia.org/wiki/Hamming_distance) entre duas sequências de bytes.
**Sintaxe**
```sql theme={null}
byteHammingDistance(s1, s2)
```
**Aliases**: `mismatches`
**Argumentos**
* `s1` — Primeira string de entrada. [`String`](/pt-BR/reference/data-types/string)
* `s2` — Segunda string de entrada. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna a distância de Hamming entre as duas strings. [`UInt64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT byteHammingDistance('karolin', 'kathrin')
```
```response title=Response theme={null}
┌─byteHammingDistance('karolin', 'kathrin')─┐
│ 3 │
└───────────────────────────────────────────┘
```
## caseFoldUTF8
Introduzido em: v26.3.0
Aplica o case folding do Unicode a uma string UTF-8, convertendo-a em uma forma normalizada semelhante a minúsculas, adequada para comparações sem diferenciar maiúsculas de minúsculas.
Aplica o case folding padrão do Unicode. Preserva caracteres de compatibilidade que não são afetados pelo case folding
(por exemplo, algarismos romanos, números circundados), mas observe que algumas ligaturas, como `ffi`, ainda são decompostas porque o próprio case folding do Unicode as expande.
**Sintaxe**
```sql theme={null}
caseFoldUTF8(str)
```
**Argumentos**
* `str` — string de entrada codificada em UTF-8. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
String UTF-8 com case folding aplicado. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Case folding básico**
```sql title=Query theme={null}
SELECT caseFoldUTF8('Straße')
```
```response title=Response theme={null}
┌─caseFoldUTF8('Straße')─┐
│ strasse │
└─────────────────────────┘
```
## compareSubstrings
Introduzido em: v25.2.0
Compara duas strings em ordem lexicográfica.
**Sintaxe**
```sql theme={null}
compareSubstrings(s1, s2, s1_offset, s2_offset, num_bytes)
```
**Argumentos**
* `s1` — A primeira string a ser comparada. [`String`](/pt-BR/reference/data-types/string)
* `s2` — A segunda string a ser comparada. [`String`](/pt-BR/reference/data-types/string)
* `s1_offset` — A posição em `s1` (baseada em zero) a partir da qual a comparação começa. [`UInt*`](/pt-BR/reference/data-types/int-uint)
* `s2_offset` — A posição em `s2` (índice baseado em zero) a partir da qual a comparação começa. [`UInt*`](/pt-BR/reference/data-types/int-uint)
* `num_bytes` — O número máximo de bytes a serem comparados em ambas as strings. Se `s1_offset` (ou `s2_offset`) + `num_bytes` ultrapassar o fim de uma string de entrada, `num_bytes` será reduzido adequadamente. [`UInt*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna:
* `-1` se `s1`\[`s1_offset` : `s1_offset` + `num_bytes`] \< `s2`\[`s2_offset` : `s2_offset` + `num_bytes`].
* `0` se `s1`\[`s1_offset` : `s1_offset` + `num_bytes`] = `s2`\[`s2_offset` : `s2_offset` + `num_bytes`].
* `1` se `s1`\[`s1_offset` : `s1_offset` + `num_bytes`] > `s2`\[`s2_offset` : `s2_offset` + `num_bytes`].
[`Int8`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT compareSubstrings('Saxony', 'Anglo-Saxon', 0, 6, 5) AS result
```
```response title=Response theme={null}
┌─result─┐
│ 0 │
└────────┘
```
## concat
Introduzido em: v1.1.0
Concatena os argumentos especificados.
Argumentos que não são dos tipos [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring) são convertidos em strings usando a serialização padrão.
Como isso reduz o desempenho, não é recomendável usar argumentos diferentes de String/FixedString.
**Sintaxe**
```sql theme={null}
concat([s1, s2, ...])
```
**Argumentos**
* `s1, s2, ...` — Qualquer número de valores de tipo arbitrário. [`Any`](/pt-BR/reference/data-types)
**Valor retornado**
Retorna a String resultante da concatenação dos argumentos. Se algum dos argumentos for `NULL`, a função retorna `NULL`. Se não houver argumentos, retorna uma string vazia. [`Nullable(String)`](/pt-BR/reference/data-types/nullable)
**Exemplos**
**Concatenação de strings**
```sql title=Query theme={null}
SELECT concat('Hello, ', 'World!')
```
```response title=Response theme={null}
┌─concat('Hello, ', 'World!')─┐
│ Hello, World! │
└─────────────────────────────┘
```
**Concatenação de números**
```sql title=Query theme={null}
SELECT concat(42, 144)
```
```response title=Response theme={null}
┌─concat(42, 144)─┐
│ 42144 │
└─────────────────┘
```
## concatAssumeInjective
Introduzido em: v1.1.0
Semelhante a [`concat`](#concat), mas assume que `concat(s1, s2, ...) → sn` é injetiva,
ou seja, retorna resultados diferentes para argumentos distintos.
Pode ser usado para otimizar `GROUP BY`.
**Sintaxe**
```sql theme={null}
concatAssumeInjective([s1, s2, ...])
```
**Argumentos**
* `s1, s2, ...` — Qualquer quantidade de valores de tipo arbitrário. [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring)
**Valor retornado**
Retorna a string criada pela concatenação dos argumentos. Se qualquer um dos valores dos argumentos for `NULL`, a função retorna `NULL`. Se nenhum argumento for passado, retorna uma string vazia. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Otimização de agrupamento**
```sql title=Query theme={null}
SELECT concat(key1, key2), sum(value) FROM key_val GROUP BY concatAssumeInjective(key1, key2)
```
```response title=Response theme={null}
┌─concat(key1, key2)─┬─sum(value)─┐
│ Hello, World! │ 3 │
│ Hello, World! │ 2 │
│ Hello, World │ 3 │
└────────────────────┴────────────┘
```
## concatWithSeparator
Introduzido em: v22.12.0
Concatena as strings fornecidas, separando-as com o separador especificado.
**Sintaxe**
```sql theme={null}
concatWithSeparator(sep[, exp1, exp2, ...])
```
**Aliases**: `concat_ws`
**Argumentos**
* `sep` — O separador a ser usado. [`const String`](/pt-BR/reference/data-types/string) ou [`const FixedString`](/pt-BR/reference/data-types/fixedstring)
* `exp1, exp2, ...` — Expressão a ser concatenada. Argumentos que não são do tipo `String` ou `FixedString` são convertidos em strings usando a serialização padrão. Como isso reduz o desempenho, não é recomendado usar argumentos diferentes de `String`/`FixedString`. [`Any`](/pt-BR/reference/data-types)
**Valor retornado**
Retorna a `String` criada pela concatenação dos argumentos. Se qualquer um dos valores dos argumentos for `NULL`, a função retorna `NULL`. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT concatWithSeparator('a', '1', '2', '3', '4')
```
```response title=Response theme={null}
┌─concatWithSeparator('a', '1', '2', '3', '4')─┐
│ 1a2a3a4 │
└──────────────────────────────────────────────┘
```
## concatWithSeparatorAssumeInjective
Introduzido em: v22.12.0
Como [`concatWithSeparator`](#concatWithSeparator), mas assume que `concatWithSeparator(sep[,exp1, exp2, ... ]) → result` seja injetiva.
Uma função é considerada injetiva se retornar resultados distintos para argumentos distintos.
Pode ser usada para otimizar `GROUP BY`.
**Sintaxe**
```sql theme={null}
concatWithSeparatorAssumeInjective(sep[, exp1, exp2, ... ])
```
**Argumentos**
* `sep` — O separador a ser usado. [`const String`](/pt-BR/reference/data-types/string) ou [`const FixedString`](/pt-BR/reference/data-types/fixedstring)
* `exp1, exp2, ...` — Expressão a ser concatenada. Argumentos que não são do tipo `String` ou `FixedString` são convertidos em strings usando a serialização padrão. Como isso reduz o desempenho, não é recomendável usar argumentos diferentes de `String`/`FixedString`. [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring)
**Valor retornado**
Retorna a `String` criada pela concatenação dos argumentos. Se qualquer um dos valores dos argumentos for `NULL`, a função retorna `NULL`. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
CREATE TABLE user_data (
user_id UInt32,
first_name String,
last_name String,
score UInt32
)
ENGINE = MergeTree
ORDER BY tuple();
INSERT INTO user_data VALUES
(1, 'John', 'Doe', 100),
(2, 'Jane', 'Smith', 150),
(3, 'John', 'Wilson', 120),
(4, 'Jane', 'Smith', 90);
SELECT
concatWithSeparatorAssumeInjective('-', first_name, last_name) as full_name,
sum(score) as total_score
FROM user_data
GROUP BY concatWithSeparatorAssumeInjective('-', first_name, last_name);
```
```response title=Response theme={null}
┌─full_name───┬─total_score─┐
│ Jane-Smith │ 240 │
│ John-Doe │ 100 │
│ John-Wilson │ 120 │
└─────────────┴─────────────┘
```
## conv
Introduzido em: v25.10.0
Converte números entre diferentes bases numéricas.
A função converte um número de uma base numérica para outra. Ela oferece suporte a bases de 2 a 36.
Para bases maiores que 10, as letras A-Z (sem diferenciar maiúsculas de minúsculas) são usadas para representar os dígitos de 10 a 35.
Esta função é compatível com a função CONV() do MySQL.
**Sintaxe**
```sql theme={null}
conv(number, from_base, to_base)
```
**Argumentos**
* `number` — O número a ser convertido. Pode ser uma string ou um tipo numérico. - `from_base` — A base de origem (2-36). Deve ser um número inteiro. - `to_base` — A base de destino (2-36). Deve ser um número inteiro.
**Valor retornado**
Representação em string do número na base de destino.
**Exemplos**
**Converter decimal em binário**
```sql title=Query theme={null}
SELECT conv('10', 10, 2)
```
```response title=Response theme={null}
1010
```
**Converter hexadecimal para decimal**
```sql title=Query theme={null}
SELECT conv('FF', 16, 10)
```
```response title=Response theme={null}
255
```
**Conversão com número negativo**
```sql title=Query theme={null}
SELECT conv('-1', 10, 16)
```
```response title=Response theme={null}
FFFFFFFFFFFFFFFF
```
**Converter binário para octal**
```sql title=Query theme={null}
SELECT conv('1010', 2, 8)
```
```response title=Response theme={null}
12
```
## convertCharset
Introduzido em: v1.1.0
Retorna a string `s` convertida da codificação `from` para a codificação `to`.
**Sintaxe**
```sql theme={null}
convertCharset(s, from, to)
```
**Argumentos**
* `s` — String de entrada. [`String`](/pt-BR/reference/data-types/string)
* `from` — Codificação de caracteres de origem. [`String`](/pt-BR/reference/data-types/string)
* `to` — Codificação de caracteres de destino. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna a string `s`, convertida da codificação `from` para a codificação `to`. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT convertCharset('Café', 'UTF-8', 'ISO-8859-1');
```
```response title=Response theme={null}
┌─convertChars⋯SO-8859-1')─┐
│ Caf� │
└──────────────────────────┘
```
## damerauLevenshteinDistance
Introduzido em: v24.1.0
Calcula a [distância de Damerau-Levenshtein](https://en.wikipedia.org/wiki/Damerau%E2%80%93Levenshtein_distance) entre duas strings de bytes.
**Sintaxe**
```sql theme={null}
damerauLevenshteinDistance(s1, s2)
```
**Argumentos**
* `s1` — Primeira string de entrada. [`String`](/pt-BR/reference/data-types/string)
* `s2` — Segunda string de entrada. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna a distância de Damerau-Levenshtein entre as duas strings. [`UInt64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT damerauLevenshteinDistance('clickhouse', 'mouse')
```
```response title=Response theme={null}
┌─damerauLevenshteinDistance('clickhouse', 'mouse')─┐
│ 6 │
└───────────────────────────────────────────────────┘
```
## decodeHTMLComponent
Introduzido em: v23.9.0
Decodifica entidades HTML em uma string, convertendo-as nos caracteres correspondentes.
**Sintaxe**
```sql theme={null}
decodeHTMLComponent(s)
```
**Argumentos**
* `s` — String que contém entidades HTML a serem decodificadas. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna a string com as entidades HTML decodificadas. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT decodeHTMLComponent('<div>Hello & "World"</div>')
```
```response title=Response theme={null}
┌─decodeHTMLComponent('<div>Hello & "World"</div>')─┐
│ Hello & "World"
│
└─────────────────────────────────────────────────────────────────────────────┘
```
## decodeXMLComponent
Introduzido em: v21.2.0
Decodifica entidades XML em uma string, convertendo-as em seus caracteres correspondentes.
**Sintaxe**
```sql theme={null}
decodeXMLComponent(s)
```
**Argumentos**
* `s` — String com entidades XML a serem decodificadas. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna a string fornecida com as entidades XML decodificadas. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT decodeXMLComponent('<tag>Hello & World</tag>')
```
```response title=Response theme={null}
┌─decodeXMLCom⋯;/tag>')─┐
│ Hello & World │
└──────────────────────────┘
```
## editDistance
Introduzido em: v23.9.0
Calcula a [distância de edição](https://en.wikipedia.org/wiki/Edit_distance) entre duas sequências de bytes.
**Sintaxe**
```sql theme={null}
editDistance(s1, s2)
```
**Aliases**: `levenshteinDistance`
**Argumentos**
* `s1` — Primeira string de entrada. [`String`](/pt-BR/reference/data-types/string)
* `s2` — Segunda string de entrada. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna a distância de edição entre as duas strings. [`UInt64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT editDistance('clickhouse', 'mouse')
```
```response title=Response theme={null}
┌─editDistance('clickhouse', 'mouse')─┐
│ 6 │
└─────────────────────────────────────┘
```
## editDistanceUTF8
Introduzido em: v24.6.0
Calcula a [distância de edição](https://en.wikipedia.org/wiki/Edit_distance) entre duas strings UTF-8.
**Sintaxe**
```sql theme={null}
editDistanceUTF8(s1, s2)
```
**Aliases**: `levenshteinDistanceUTF8`
**Argumentos**
* `s1` — Primeira string de entrada. [`String`](/pt-BR/reference/data-types/string)
* `s2` — Segunda string de entrada. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna a distância de edição entre as duas strings UTF-8. [`UInt64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT editDistanceUTF8('我是谁', '我是我')
```
```response title=Response theme={null}
┌─editDistanceUTF8('我是谁', '我是我')──┐
│ 1 │
└─────────────────────────────────────┘
```
## encodeXMLComponent
Introduzido em: v21.1.0
Escapa caracteres para inserir uma string em um nó de texto ou em um atributo XML.
**Sintaxe**
```sql theme={null}
encodeXMLComponent(s)
```
**Argumentos**
* `s` — String a ser escapada. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna a string escapada. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
'Hello & "World"' AS original,
encodeXMLComponent('Hello & "World"') AS xml_encoded;
```
```response title=Response theme={null}
┌─original───────────────────┬─xml_encoded──────────────────────────────────────────┐
│ Hello & "World" │ <tag>Hello & "World"</tag> │
└────────────────────────────┴──────────────────────────────────────────────────────┘
```
## endsWith
Introduzido em: v1.1.0
Verifica se uma string termina com o sufixo informado.
**Sintaxe**
```sql theme={null}
endsWith(s, suffix)
```
**Argumentos**
* `s` — String a ser verificada. [`String`](/pt-BR/reference/data-types/string)
* `suffix` — Sufixo a ser verificado. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna `1` se `s` terminar com `suffix`; caso contrário, `0`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT endsWith('ClickHouse', 'House');
```
```response title=Response theme={null}
┌─endsWith('Cl⋯', 'House')─┐
│ 1 │
└──────────────────────────┘
```
## endsWithCaseInsensitive
Introduzido em: v25.10.0
Verifica se uma string termina com o sufixo fornecido sem diferenciar maiúsculas de minúsculas.
**Sintaxe**
```sql theme={null}
endsWithCaseInsensitive(s, suffix)
```
**Argumentos**
* `s` — String a ser verificada. [`String`](/pt-BR/reference/data-types/string)
* `suffix` — Sufixo sem distinção entre maiúsculas e minúsculas a ser verificado. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna `1` se `s` terminar com o `suffix` sem distinção entre maiúsculas e minúsculas; caso contrário, `0`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT endsWithCaseInsensitive('ClickHouse', 'HOUSE');
```
```response title=Response theme={null}
┌─endsWithCaseInsensitive('Cl⋯', 'HOUSE')─┐
│ 1 │
└─────────────────────────────────────────┘
```
## endsWithCaseInsensitiveUTF8
Introduzido na versão: v25.10.0
Retorna se a string `s` termina com o `suffix`, sem diferenciar maiúsculas de minúsculas.
Pressupõe que a string contenha texto válido codificado em UTF-8.
Se essa suposição for violada, nenhuma exceção é lançada e o resultado é indefinido.
**Sintaxe**
```sql theme={null}
endsWithCaseInsensitiveUTF8(s, suffix)
```
**Argumentos**
* `s` — String a ser verificada. [`String`](/pt-BR/reference/data-types/string)
* `suffix` — Sufixo, sem distinção entre maiúsculas e minúsculas, a ser verificado. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna `1` se `s` terminar com `suffix` sem distinção entre maiúsculas e minúsculas; caso contrário, `0`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT endsWithCaseInsensitiveUTF8('данных', 'ых');
```
```response title=Response theme={null}
┌─endsWithCaseInsensitiveUTF8('данных', 'ых')─┐
│ 1 │
└─────────────────────────────────────────────┘
```
## endsWithUTF8
Introduzido em: v23.8.0
Retorna se a string `s` termina com `suffix`.
Pressupõe que a string contenha texto válido codificado em UTF-8.
Se essa suposição for violada, nenhuma exceção é lançada e o resultado é indefinido.
**Sintaxe**
```sql theme={null}
endsWithUTF8(s, suffix)
```
**Argumentos**
* `s` — String a ser verificada. [`String`](/pt-BR/reference/data-types/string)
* `suffix` — Sufixo a ser verificado. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna `1` se `s` terminar com `suffix`; caso contrário, `0`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT endsWithUTF8('данных', 'ых');
```
```response title=Response theme={null}
┌─endsWithUTF8('данных', 'ых')─┐
│ 1 │
└──────────────────────────────┘
```
Introduzido em: v21.3.0
Extrai conteúdo textual de HTML ou XHTML.
Esta função remove tags HTML, comentários e elementos `script`/`style`, deixando apenas o conteúdo textual. Ela faz o seguinte:
* Remove todas as tags HTML/XML
* Remove comentários (`{/* */}`)
* Remove elementos `script` e `style` com seu conteúdo
* Processa seções CDATA (copiadas literalmente)
* Trata e normaliza adequadamente os espaços em branco
Observação: entidades HTML não são decodificadas e devem ser processadas com uma função separada, se necessário.
**Sintaxe**
```sql theme={null}
extractTextFromHTML(html)
```
**Argumentos**
* `html` — `String` que contém o conteúdo HTML do qual o texto será extraído. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna o conteúdo de texto extraído com os espaços em branco normalizados. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT extractTextFromHTML('
Page Title
Hello World!
');
```
```response title=Response theme={null}
┌─extractTextFromHTML('...')─┐
│ Page Title Hello World! │
└────────────────────────────────────────┘
```
## firstLine
Introduzido em: v23.7.0
Retorna a primeira linha de uma string multilinha.
**Sintaxe**
```sql theme={null}
firstLine(s)
```
**Argumentos**
* `s` — String de entrada. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna a primeira linha da string de entrada ou a string inteira, se não houver separadores de linha. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT firstLine('foo\\nbar\\nbaz')
```
```response title=Response theme={null}
┌─firstLine('foo\nbar\nbaz')─┐
│ foo │
└────────────────────────────┘
```
## idnaDecode
Introduzido em: v24.1.0
Retorna a representação Unicode (UTF-8) (algoritmo ToUnicode) de um nome de domínio de acordo com o mecanismo [Internationalized Domain Names in Applications](https://en.wikipedia.org/wiki/Internationalized_domain_name#Internationalizing_Domain_Names_in_Applications) (IDNA).
Em caso de erro (por exemplo, se a entrada for inválida), a string de entrada é retornada.
Observe que aplicar [`idnaEncode()`](#idnaEncode) e [`idnaDecode()`](#idnaDecode) repetidamente não necessariamente retorna a string original devido à normalização de maiúsculas e minúsculas.
**Sintaxe**
```sql theme={null}
idnaDecode(s)
```
**Argumentos**
* `s` — String de entrada. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna uma representação Unicode (UTF-8) da string de entrada, de acordo com o mecanismo IDNA do valor de entrada. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT idnaDecode('xn--strae-oqa.xn--mnchen-3ya.de')
```
```response title=Response theme={null}
┌─idnaDecode('xn--strae-oqa.xn--mnchen-3ya.de')─┐
│ straße.münchen.de │
└───────────────────────────────────────────────┘
```
## idnaEncode
Introduzido em: v24.1.0
Retorna a representação ASCII (algoritmo ToASCII) de um nome de domínio de acordo com o mecanismo [Internationalized Domain Names in Applications](https://en.wikipedia.org/wiki/Internationalized_domain_name#Internationalizing_Domain_Names_in_Applications) (IDNA).
A string de entrada deve estar codificada em UTF e ser convertível em uma string ASCII; caso contrário, uma exceção é gerada.
Nenhuma decodificação de porcentagem nem remoção de tabulações, espaços ou caracteres de controle é realizada.
**Sintaxe**
```sql theme={null}
idnaEncode(s)
```
**Argumentos**
* `s` — String de entrada. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna uma representação ASCII da string de entrada de acordo com o mecanismo IDNA do valor de entrada. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT idnaEncode('straße.münchen.de')
```
```response title=Response theme={null}
┌─idnaEncode('straße.münchen.de')─────┐
│ xn--strae-oqa.xn--mnchen-3ya.de │
└─────────────────────────────────────┘
```
## initcap
Introduzido na versão: v23.7.0
Converte a primeira letra de cada palavra em maiúscula e o restante em minúsculas.
As palavras são sequências de caracteres alfanuméricos separadas por caracteres não alfanuméricos.
Como `initcap` converte apenas a primeira letra de cada palavra em maiúscula, você pode observar um comportamento inesperado em palavras que contêm apóstrofos ou letras maiúsculas.
Esse comportamento é conhecido e, no momento, não há planos para corrigi-lo.
**Sintaxe**
```sql theme={null}
initcap(s)
```
**Argumentos**
* `s` — String de entrada. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna `s` com a primeira letra de cada palavra convertida em maiúscula. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT initcap('building for fast')
```
```response title=Response theme={null}
┌─initcap('building for fast')─┐
│ Building For Fast │
└──────────────────────────────┘
```
**Exemplo de comportamento conhecido para palavras com apóstrofos ou letras maiúsculas**
```sql title=Query theme={null}
SELECT initcap('John''s cat won''t eat.');
```
```response title=Response theme={null}
┌─initcap('Joh⋯n\'t eat.')─┐
│ John'S Cat Won'T Eat. │
└──────────────────────────┘
```
## initcapUTF8
Introduzido em: v23.7.0
Assim como [`initcap`](#initcap), `initcapUTF8` converte a primeira letra de cada palavra em maiúscula e as demais em minúscula.
Pressupõe que a string contenha texto válido codificado em UTF-8.
Se essa suposição for violada, nenhuma exceção é lançada e o resultado é indefinido.
Esta função não detecta o idioma; por exemplo, no turco, o resultado pode não estar exatamente correto (i/İ vs. i/I).
Se o comprimento da sequência de bytes em UTF-8 for diferente entre as versões em maiúsculas e minúsculas de um ponto de código, o resultado poderá estar incorreto para esse ponto de código.
**Sintaxe**
```sql theme={null}
initcapUTF8(s)
```
**Argumentos**
* `s` — Texto de entrada. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna `s` com a primeira letra de cada palavra convertida em maiúscula. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT initcapUTF8('не тормозит')
```
```response title=Response theme={null}
┌─initcapUTF8('не тормозит')─┐
│ Не Тормозит │
└────────────────────────────┘
```
## isValidASCII
Introduzido em: v25.9.0
Retorna 1 se a String ou FixedString de entrada contiver apenas bytes ASCII (0x00–0x7F); caso contrário, retorna 0. Otimizado para o caso positivo (a entrada *é* ASCII válido).
**Sintaxe**
```sql theme={null}
isValidASCII(str)
```
**Aliases**: `isASCII`
**Argumentos**
* Nenhum.
**Valor retornado**
**Exemplos**
**isValidASCII**
```sql title=Query theme={null}
SELECT isValidASCII('hello') AS is_ascii, isValidASCII('你好') AS is_not_ascii
```
```response title=Response theme={null}
```
## isValidUTF8
Introduzido em: v20.1.0
Verifica se o conjunto de bytes forma um texto válido codificado em UTF-8.
**Sintaxe**
```sql theme={null}
isValidUTF8(s)
```
**Argumentos**
* `s` — A string cuja validade da codificação UTF-8 será verificada. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna `1` se o conjunto de bytes constituir um texto válido codificado em UTF-8; caso contrário, `0`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT isValidUTF8('\\xc3\\xb1') AS valid, isValidUTF8('\\xc3\\x28') AS invalid
```
```response title=Response theme={null}
┌─valid─┬─invalid─┐
│ 1 │ 0 │
└───────┴─────────┘
```
## jaroSimilarity
Introduzido em: v24.1.0
Calcula a [similaridade de Jaro](https://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance#Jaro_similarity) entre duas sequências de bytes.
**Sintaxe**
```sql theme={null}
jaroSimilarity(s1, s2)
```
**Argumentos**
* `s1` — Primeira string de entrada. [`String`](/pt-BR/reference/data-types/string)
* `s2` — Segunda string de entrada. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna a similaridade de Jaro entre as duas strings. [`Float64`](/pt-BR/reference/data-types/float)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT jaroSimilarity('clickhouse', 'click')
```
```response title=Response theme={null}
┌─jaroSimilarity('clickhouse', 'click')─┐
│ 0.8333333333333333 │
└───────────────────────────────────────┘
```
## jaroWinklerSimilarity
Introduzido em: v24.1.0
Calcula a [similaridade de Jaro-Winkler](https://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance) entre duas sequências de bytes.
**Sintaxe**
```sql theme={null}
jaroWinklerSimilarity(s1, s2)
```
**Argumentos**
* `s1` — Primeira string de entrada. [`String`](/pt-BR/reference/data-types/string)
* `s2` — Segunda string de entrada. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna a similaridade de Jaro-Winkler entre as duas strings. [`Float64`](/pt-BR/reference/data-types/float)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT jaroWinklerSimilarity('clickhouse', 'click')
```
```response title=Response theme={null}
┌─jaroWinklerSimilarity('clickhouse', 'click')─┐
│ 0.8999999999999999 │
└──────────────────────────────────────────────┘
```
## left
Introduzido em: v22.1.0
Retorna uma substring da string `s` com um `offset` especificado a partir da esquerda.
**Sintaxe**
```sql theme={null}
left(s, offset)
```
**Argumentos**
* `s` — A string da qual será calculada uma substring. [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring)
* `offset` — O número de bytes do deslocamento. [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna:
* Para `offset` positivo, uma substring de `s` com `offset` bytes, começando à esquerda da string.
* Para `offset` negativo, uma substring de `s` com `length(s) - |offset|` bytes, começando à esquerda da string.
* Uma string vazia se `length` for `0`.
[`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Deslocamento positivo**
```sql title=Query theme={null}
SELECT left('Hello World', 5)
```
```response title=Response theme={null}
Hello
```
**Offset negativo**
```sql title=Query theme={null}
SELECT left('Hello World', -6)
```
```response title=Response theme={null}
Hello
```
## leftPad
Introduzido na versão: v21.8.0
Preenche uma string à esquerda com espaços ou com uma string especificada (repetida várias vezes, se necessário) até que a string resultante atinja o `length` especificado.
**Sintaxe**
```sql theme={null}
leftPad(string, length[, pad_string])
```
**Aliases**: `lpad`
**Argumentos**
* `string` — String de entrada a ser preenchida. [`String`](/pt-BR/reference/data-types/string)
* `length` — O comprimento da string resultante. Se o valor for menor que o comprimento da string de entrada, a string de entrada será truncada para `length` caracteres. [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
* `pad_string` — Opcional. A string usada para preencher a string de entrada. Se não for especificada, a string de entrada será preenchida com espaços. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna uma string preenchida à esquerda com o comprimento especificado. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT leftPad('abc', 7, '*'), leftPad('def', 7)
```
```response title=Response theme={null}
┌─leftPad('abc', 7, '*')─┬─leftPad('def', 7)─┐
│ ****abc │ def │
└────────────────────────┴───────────────────┘
```
## leftPadUTF8
Introduzido na: v21.8.0
Preenche uma string UTF-8 à esquerda com espaços ou com uma string especificada (repetida várias vezes, se necessário) até que a string resultante atinja o comprimento especificado.
Ao contrário de [`leftPad`](#leftPad), que mede o comprimento da string em bytes, aqui o comprimento da string é medido em pontos de código.
**Sintaxe**
```sql theme={null}
leftPadUTF8(string, length[, pad_string])
```
**Argumentos**
* `string` — String de entrada que deve ser preenchida. [`String`](/pt-BR/reference/data-types/string)
* `length` — O comprimento da string resultante. Se o valor for menor que o comprimento da string de entrada, a string de entrada será truncada para `length` caracteres. [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
* `pad_string` — Opcional. A string usada para preencher a string de entrada. Se não for especificada, a string de entrada será preenchida com espaços. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna uma string preenchida à esquerda com o comprimento especificado. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT leftPadUTF8('абвг', 7, '*'), leftPadUTF8('дежз', 7)
```
```response title=Response theme={null}
┌─leftPadUTF8('абвг', 7, '*')─┬─leftPadUTF8('дежз', 7)─┐
│ ***абвг │ дежз │
└─────────────────────────────┴────────────────────────┘
```
## leftUTF8
Introduzido em: v22.1.0
Retorna uma substring da string `s` codificada em UTF-8, com um `offset` especificado, a partir da esquerda.
**Sintaxe**
```sql theme={null}
leftUTF8(s, offset)
```
**Argumentos**
* `s` — A string codificada em UTF-8 da qual será extraída uma substring. [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring)
* `offset` — O deslocamento em bytes. [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna:
* Para `offset` positivo, uma substring de `s` com `offset` bytes, começando a partir da esquerda da string.\n"
* Para `offset` negativo, uma substring de `s` com `length(s) - |offset|` bytes, começando a partir da esquerda da string.\n"
* Uma string vazia se `length` for 0.
[`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Offset positivo**
```sql title=Query theme={null}
SELECT leftUTF8('Привет', 4)
```
```response title=Response theme={null}
Прив
```
**OFFSET negativo**
```sql title=Query theme={null}
SELECT leftUTF8('Привет', -4)
```
```response title=Response theme={null}
Пр
```
## lengthUTF8
Introduzido em: v1.1.0
Retorna o tamanho de uma string em pontos de código Unicode, em vez de em bytes ou caracteres.
Supõe que a string contenha texto válido codificado em UTF-8.
Se essa suposição for violada, nenhuma exceção é gerada, e o resultado é indefinido.
**Sintaxe**
```sql theme={null}
lengthUTF8(s)
```
**Aliases**: `CHARACTER_LENGTH`, `CHAR_LENGTH`
**Argumentos**
* `s` — String que contém texto válido codificado em UTF-8. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Comprimento da string `s` em pontos de código Unicode. [`UInt64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT lengthUTF8('Здравствуй, мир!')
```
```response title=Response theme={null}
┌─lengthUTF8('Здравствуй, мир!')─┐
│ 16 │
└────────────────────────────────┘
```
## lower
Introduzido em: v1.1.0
Converte uma cadeia de caracteres ASCII em minúsculas.
**Sintaxe**
```sql theme={null}
lower(s)
```
**Aliases**: `lcase`
**Argumentos**
* `s` — Uma string a ser convertida para minúsculas. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna `s` em minúsculas. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT lower('CLICKHOUSE')
```
```response title=Response theme={null}
┌─lower('CLICKHOUSE')─┐
│ clickhouse │
└─────────────────────┘
```
## lowerUTF8
Introduzido em: v1.1.0
Converte uma string para minúsculas, assumindo que ela contém texto válido codificado em UTF-8. Se essa suposição for violada, nenhuma exceção será lançada e o resultado será indefinido.
**Sintaxe**
```sql theme={null}
lowerUTF8(input)
```
**Argumentos**
* `input` — String de entrada a ser convertida em minúsculas. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna uma string em minúsculas. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**primeiro**
```sql title=Query theme={null}
SELECT lowerUTF8('München') as Lowerutf8;
```
```response title=Response theme={null}
münchen
```
## naturalSortKey
Introduzido em: v26.3.0
A função é usada para ordenação natural.
**Sintaxe**
```sql theme={null}
naturalSortKey(s)
```
**Aliases**: `NATURAL_SORT_KEY`
**Argumentos**
* `s` — Uma string a ser convertida em uma chave de ordenação natural. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna uma string de chave de ordenação natural a partir de `s`. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT s FROM t ORDER BY naturalSortKey(s)
```
```response title=Response theme={null}
┌─s───┐
│ a1 │
| a02 │
└─────┘
```
## normalizeUTF8NFC
Introduzido em: v21.11.0
Normaliza uma string UTF-8 de acordo com a [forma de normalização NFC](https://en.wikipedia.org/wiki/Unicode_equivalence#Normal_forms).
**Sintaxe**
```sql theme={null}
normalizeUTF8NFC(str)
```
**Argumentos**
* `str` — string de entrada codificada em UTF-8. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna a forma normalizada NFC da string UTF-8. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
'é' AS original, -- e + acento agudo combinado (U+0065 + U+0301)
length(original),
normalizeUTF8NFC('é') AS nfc_normalized, -- é (U+00E9)
length(nfc_normalized);
```
```response title=Response theme={null}
┌─original─┬─length(original)─┬─nfc_normalized─┬─length(nfc_normalized)─┐
│ é │ 2 │ é │ 2 │
└──────────┴──────────────────┴────────────────┴────────────────────────┘
```
## normalizeUTF8NFD
Introduzido em: v21.11.0
Normaliza uma string UTF-8 de acordo com a [forma de normalização NFD](https://en.wikipedia.org/wiki/Unicode_equivalence#Normal_forms).
**Sintaxe**
```sql theme={null}
normalizeUTF8NFD(str)
```
**Argumentos**
* `str` — string de entrada codificada em UTF-8. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna a forma normalizada em NFD da string UTF-8. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
'é' AS original, -- é (U+00E9)
length(original),
normalizeUTF8NFD('é') AS nfd_normalized, -- e + acento agudo combinante (U+0065 + U+0301)
length(nfd_normalized);
```
```response title=Response theme={null}
┌─original─┬─length(original)─┬─nfd_normalized─┬─length(nfd_normalized)─┐
│ é │ 2 │ é │ 3 │
└──────────┴──────────────────┴────────────────┴────────────────────────┘
```
## normalizeUTF8NFKC
Introduzido em: v21.11.0
Normaliza uma string UTF-8 segundo a [forma de normalização NFKC](https://en.wikipedia.org/wiki/Unicode_equivalence#Normal_forms).
**Sintaxe**
```sql theme={null}
normalizeUTF8NFKC(str)
```
**Argumentos**
* `str` — string de entrada codificada em UTF-8. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna a forma normalizada em NFKC da string UTF-8. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
'① ② ③' AS original, -- Caracteres de números em círculo
normalizeUTF8NFKC('① ② ③') AS nfkc_normalized; -- Converte para 1 2 3
```
```response title=Response theme={null}
┌─original─┬─nfkc_normalized─┐
│ ① ② ③ │ 1 2 3 │
└──────────┴─────────────────┘
```
## normalizeUTF8NFKCCasefold
Introduzido em: v26.3.0
Normaliza uma string UTF-8 de acordo com a [forma de normalização NFKC\_Casefold](https://unicode.org/reports/tr44/#NFKC_Casefold), que aplica a normalização NFKC e, em seguida, o case folding.
Isso é útil para comparação sem distinção entre maiúsculas e minúsculas de identificadores.
**Sintaxe**
```sql theme={null}
normalizeUTF8NFKCCasefold(str)
```
**Argumentos**
* `str` — string de entrada codificada em UTF-8. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna a forma normalizada NFKC\_Casefold da string em UTF-8. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
'Ä ① Hello' AS original,
normalizeUTF8NFKCCasefold('Ä ① Hello') AS nfkc_cf_normalized;
```
```response title=Response theme={null}
┌─original───┬─nfkc_cf_normalized─┐
│ Ä ① Hello │ ä 1 hello │
└────────────┴────────────────────┘
```
## normalizeUTF8NFKD
Introduzido em: v21.11.0
Normaliza uma string UTF-8 de acordo com a [forma de normalização NFKD](https://en.wikipedia.org/wiki/Unicode_equivalence#Normal_forms).
**Sintaxe**
```sql theme={null}
normalizeUTF8NFKD(str)
```
**Argumentos**
* `str` — String de entrada codificada em UTF-8. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna a forma normalizada em NFKD da string UTF-8. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
'H₂O²' AS original, -- H + subscrito 2 + O + sobrescrito 2
normalizeUTF8NFKD('H₂O²') AS nfkd_normalized; -- Converte para H 2 O 2
```
```response title=Response theme={null}
┌─original─┬─nfkd_normalized─┐
│ H₂O² │ H2O2 │
└──────────┴─────────────────┘
```
## punycodeDecode
Introduzido em: v24.1.0
Retorna o plaintext codificado em UTF-8 de uma string codificada em [Punycode](https://en.wikipedia.org/wiki/Punycode).
Se nenhuma string codificada em Punycode válida for fornecida, uma exceção será lançada.
**Sintaxe**
```sql theme={null}
punycodeDecode(s)
```
**Argumentos**
* `s` — String codificada em Punycode. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna o texto em claro do valor de entrada. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT punycodeDecode('Mnchen-3ya')
```
```response title=Response theme={null}
┌─punycodeDecode('Mnchen-3ya')─┐
│ München │
└──────────────────────────────┘
```
## punycodeEncode
Introduzido em: v24.1.0
Retorna a representação em [Punycode](https://en.wikipedia.org/wiki/Punycode) de uma string.
A string deve estar codificada em UTF8; caso contrário, o comportamento é indefinido.
**Sintaxe**
```sql theme={null}
punycodeEncode(s)
```
**Argumentos**
* `s` — Valor de entrada. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna uma representação em Punycode do valor de entrada. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT punycodeEncode('München')
```
```response title=Response theme={null}
┌─punycodeEncode('München')─┐
│ Mnchen-3ya │
└───────────────────────────┘
```
Introduzido em: v23.2.0
Extrai a primeira string de `haystack` que corresponde ao padrão da expressão regular e ao índice do grupo da regex.
**Sintaxe**
```sql theme={null}
regexpExtract(haystack, pattern[, index])
```
**Aliases**: `REGEXP_EXTRACT`
**Argumentos**
* `haystack` — String na qual será feita a correspondência com o padrão regexp. [`String`](/pt-BR/reference/data-types/string)
* `pattern` — String, expressão regexp. `pattern` pode conter vários grupos regexp; `index` indica qual grupo regex extrair. Um índice de 0 significa corresponder à expressão regular inteira. [`const String`](/pt-BR/reference/data-types/string)
* `index` — Opcional. Um número inteiro maior ou igual a 0, com valor padrão 1. Representa qual grupo regex extrair. [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna a correspondência como uma string [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
regexpExtract('100-200', '(\\d+)-(\\d+)', 1),
regexpExtract('100-200', '(\\d+)-(\\d+)', 2),
regexpExtract('100-200', '(\\d+)-(\\d+)', 0),
regexpExtract('100-200', '(\\d+)-(\\d+)');
```
```response title=Response theme={null}
┌─regexpExtract('100-200', '(\\d+)-(\\d+)', 1)─┬─regexpExtract('100-200', '(\\d+)-(\\d+)', 2)─┬─regexpExtract('100-200', '(\\d+)-(\\d+)', 0)─┬─regexpExtract('100-200', '(\\d+)-(\\d+)')─┐
│ 100 │ 200 │ 100-200 │ 100 │
└──────────────────────────────────────────────┴──────────────────────────────────────────────┴──────────────────────────────────────────────┴───────────────────────────────────────────┘
```
## regexpPosition
Introduzido em: v26.5.0
Retorna a posição em bytes (indexada em 1) da `occurrence`-ésima correspondência de `pattern` em `haystack`, iniciando a busca na posição de byte `position`.
Se `return_option` for 0 (padrão), retorna a posição do primeiro byte da correspondência. Se for 1, retorna a posição do primeiro byte *após* a correspondência.
Se `subexpression` for maior que 0, retorna a posição do grupo de captura correspondente em vez da correspondência completa.
Retorna 0 se nenhuma correspondência for encontrada ou se o grupo de captura solicitado não tiver participado da correspondência.
Fornecido para compatibilidade com o `regexp_instr` do PostgreSQL (também exposto com esse alias). Observe que as posições são baseadas em bytes, em linha com outras funções de regex do ClickHouse; o `regexp_instr` do PostgreSQL é baseado em caracteres.
**Sintaxe**
```sql theme={null}
regexpPosition(haystack, pattern[, position[, occurrence[, return_option[, flags[, subexpression]]]]])
```
**Aliases**: `regexpInstr`, `regexp_instr`
**Argumentos**
* `haystack` — String na qual pesquisar. [`String`](/pt-BR/reference/data-types/string)
* `pattern` — Padrão da expressão regular. [`const String`](/pt-BR/reference/data-types/string)
* `position` — Opcional. Posição em bytes, baseada em 1, para iniciar a busca. Padrão: 1. [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
* `occurrence` — Opcional. Qual ocorrência retornar. Padrão: 1. [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
* `return_option` — Opcional. 0 retorna a posição do início da correspondência; 1 retorna a posição logo após a correspondência. Padrão: 0. [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
* `flags` — Opcional. Flags de regex. Suportadas: `i` (sem diferenciar maiúsculas de minúsculas), `c` (diferenciando maiúsculas de minúsculas), `m`/`n` (âncoras multilinha), `s` (o ponto corresponde a nova linha). Padrão: string vazia. [`const String`](/pt-BR/reference/data-types/string)
* `subexpression` — Opcional. Índice do grupo de captura cuja posição deve ser retornada. 0 significa a correspondência inteira. Padrão: 0. [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna a posição em bytes da correspondência ou 0, se não for encontrada. [`UInt64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Uso básico**
```sql title=Query theme={null}
SELECT
regexpPosition('hello world', 'world'),
regexpPosition('aXbXcXd', 'X', 1, 2),
regexpPosition('aXbXcXd', 'X', 1, 2, 1),
regexpPosition('Hello WORLD', 'world', 1, 1, 0, 'i'),
regexpPosition('foo123bar456', '([a-z]+)([0-9]+)', 1, 2, 0, '', 2);
```
```response title=Response theme={null}
┌─...─┬─...─┬─...─┬─...─┬─...─┐
│ 7 │ 4 │ 5 │ 7 │ 10 │
└─────┴─────┴─────┴─────┴─────┘
```
## removeDiacriticsUTF8
Introduzido em: v26.3.0
Remove marcas diacríticas (acentos) de uma string UTF-8 ao decompor caracteres via NFD,
remover marcas de combinação (categoria Unicode Mn) e, em seguida, recompô-los via NFC.
**Sintaxe**
```sql theme={null}
removeDiacriticsUTF8(str)
```
**Aliases**: `removeAccentsUTF8`
**Argumentos**
* `str` — string de entrada codificada em UTF-8. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
String em UTF-8 sem diacríticos. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Remoção básica de acentos**
```sql title=Query theme={null}
SELECT removeDiacriticsUTF8('café résumé naïve')
```
```response title=Response theme={null}
┌─removeDiacriticsUTF8('café résumé naïve')─┐
│ cafe resume naive │
└────────────────────────────────────────────┘
```
## repeat
Introduzido em: v20.1.0
Concatena uma string a ela mesma o número de vezes especificado.
**Sintaxe**
```sql theme={null}
repeat(s, n)
```
**Argumentos**
* `s` — A string a ser repetida. [`String`](/pt-BR/reference/data-types/string)
* `n` — O número de vezes que a string será repetida. [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Uma string que contém `s` repetida `n` vezes. Se `n` for negativo, a função retorna uma string vazia. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT repeat('abc', 10)
```
```response title=Response theme={null}
┌─repeat('abc', 10)──────────────┐
│ abcabcabcabcabcabcabcabcabcabc │
└────────────────────────────────┘
```
## reverseUTF8
Introduzido em: v1.1.0
Inverte uma sequência de pontos de código Unicode em uma string.
Pressupõe que a string contenha texto válido codificado em UTF-8.
Se essa suposição for violada, não é lançada nenhuma exceção e o resultado é indefinido.
**Sintaxe**
```sql theme={null}
reverseUTF8(s)
```
**Argumentos**
* `s` — String que contém texto codificado em UTF-8 válido. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna uma string com a sequência de pontos de código Unicode invertida. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT reverseUTF8('ClickHouse')
```
```response title=Response theme={null}
esuoHkcilC
```
## right
Introduzido em: v22.1.0
Retorna uma substring da string `s`, com o `offset` especificado, a partir da direita.
**Sintaxe**
```sql theme={null}
right(s, offset)
```
**Argumentos**
* `s` — A string da qual será extraída uma `substring`. [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring)
* `offset` — A quantidade de bytes do deslocamento. [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna:
* Para `offset` positivo, uma `substring` de `s` com `offset` bytes, a partir da direita da string.
* Para `offset` negativo, uma `substring` de `s` com `length(s) - |offset|` bytes, a partir da direita da string.
* Uma string vazia se `length` for `0`.
[`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Deslocamento positivo**
```sql title=Query theme={null}
SELECT right('Hello', 3)
```
```response title=Response theme={null}
llo
```
**Offset negativo**
```sql title=Query theme={null}
SELECT right('Hello', -3)
```
```response title=Response theme={null}
lo
```
## rightPad
Introduzido em: v21.8.0
Preenche uma string à direita com espaços ou com uma string especificada (repetida várias vezes, se necessário) até que a string resultante atinja o `length` especificado.
**Sintaxe**
```sql theme={null}
rightPad(string, length[, pad_string])
```
**Aliases**: `rpad`
**Argumentos**
* `string` — String de entrada que deve ser preenchida. [`String`](/pt-BR/reference/data-types/string)
* `length` — O comprimento da string resultante. Se o valor for menor que o comprimento da string de entrada, a string de entrada será truncada para `length` caracteres. [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
* `pad_string` — Opcional. A string usada para preencher a string de entrada. Se não for especificada, a string de entrada será preenchida com espaços. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna uma string preenchida à direita com o comprimento especificado. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT rightPad('abc', 7, '*'), rightPad('abc', 7)
```
```response title=Response theme={null}
┌─rightPad('abc', 7, '*')─┬─rightPad('abc', 7)─┐
│ abc**** │ abc │
└─────────────────────────┴────────────────────┘
```
## rightPadUTF8
Introduzido na versão: v21.8.0
Preenche a string à direita com espaços ou com uma string especificada (repetida várias vezes, se necessário) até que a string resultante atinja o comprimento informado.
Diferentemente de [`rightPad`](#rightPad), que mede o comprimento da string em bytes, aqui o comprimento da string é medido em pontos de código.
**Sintaxe**
```sql theme={null}
rightPadUTF8(string, length[, pad_string])
```
**Argumentos**
* `string` — String de entrada que deve ser preenchida. [`String`](/pt-BR/reference/data-types/string)
* `length` — O comprimento da string resultante. Se o valor for menor que o comprimento da string de entrada, a string de entrada será truncada para `length` caracteres. [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
* `pad_string` — Opcional. A string usada para preencher a string de entrada. Se não for especificada, a string de entrada será preenchida com espaços. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna uma string preenchida à direita com o comprimento informado. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT rightPadUTF8('абвг', 7, '*'), rightPadUTF8('абвг', 7)
```
```response title=Response theme={null}
┌─rightPadUTF8('абвг', 7, '*')─┬─rightPadUTF8('абвг', 7)─┐
│ абвг*** │ абвг │
└──────────────────────────────┴─────────────────────────┘
```
## rightUTF8
Introduzido na versão: v22.1.0
Retorna uma substring da string codificada em UTF-8 `s`, com um `offset` especificado a partir da direita.
**Sintaxe**
```sql theme={null}
rightUTF8(s, offset)
```
**Argumentos**
* `s` — A string codificada em UTF-8 da qual uma substring será calculada. [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring)
* `offset` — O número de bytes do deslocamento. [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna:
* Para `offset` positivo, uma substring de `s` com `offset` bytes, começando pela direita da string.
* Para `offset` negativo, uma substring de `s` com `length(s) - |offset|` bytes, começando pela direita da string.
* Uma string vazia se `length` for `0`.
[`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Deslocamento positivo**
```sql title=Query theme={null}
SELECT rightUTF8('Привет', 4)
```
```response title=Response theme={null}
ивет
```
**OFFSET negativo**
```sql title=Query theme={null}
SELECT rightUTF8('Привет', -4)
```
```response title=Response theme={null}
ет
```
## soundex
Introduzido em: v23.4.0
Retorna o [código Soundex](https://en.wikipedia.org/wiki/Soundex) de uma cadeia de caracteres.
**Sintaxe**
```sql theme={null}
soundex(s)
```
**Argumentos**
* `s` — Cadeia de caracteres de entrada. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna o código Soundex da cadeia de caracteres de entrada. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT soundex('aksel')
```
```response title=Response theme={null}
┌─soundex('aksel')─┐
│ A240 │
└──────────────────┘
```
## space
Introduzido em: v23.5.0
Concatena um espaço (` `) consigo mesmo o número de vezes especificado.
**Sintaxe**
```sql theme={null}
space(n)
```
**Argumentos**
* `n` — O número de vezes que o espaço deve ser repetido. [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna uma string contendo um espaço repetido `n` vezes. Se `n <= 0`, a função retorna uma string vazia. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT space(3) AS res, length(res);
```
```response title=Response theme={null}
┌─res─┬─length(res)─┐
│ │ 3 │
└─────┴─────────────┘
```
## sparseGrams
Introduzido em: v25.5.0
Encontra todas as substrings de uma string com comprimento de pelo menos `n`,
em que os hashes dos (n-1)-gramas nas extremidades da substring
são estritamente maiores do que os de qualquer (n-1)-grama dentro da substring.
Usa `CRC32` como função de hash.
**Sintaxe**
```sql theme={null}
sparseGrams(s[, min_ngram_length[, max_ngram_length[, min_cutoff_length]]])
```
**Argumentos**
* `s` — Uma string de entrada. [`String`](/pt-BR/reference/data-types/string)
* `min_ngram_length` — Opcional. O comprimento mínimo do n-grama extraído. O valor padrão e mínimo é 3. [`UInt*`](/pt-BR/reference/data-types/int-uint)
* `max_ngram_length` — Opcional. O comprimento máximo do n-grama extraído. O valor padrão é 100. Não deve ser menor que `min_ngram_length`. [`UInt*`](/pt-BR/reference/data-types/int-uint)
* `min_cutoff_length` — Opcional. Se especificado, apenas n-gramas com comprimento maior ou igual a `min_cutoff_length` são retornados. O valor padrão é o mesmo de `min_ngram_length`. Não deve ser menor que `min_ngram_length` nem maior que `max_ngram_length`. [`UInt*`](/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 sparseGrams('alice', 3)
```
```response title=Response theme={null}
┌─sparseGrams('alice', 3)────────────┐
│ ['ali','lic','lice','ice'] │
└────────────────────────────────────┘
```
## sparseGramsHashes
Introduzido em: v25.5.0
Retorna os hashes de todas as substrings de uma determinada string com comprimento de pelo menos `n`,
em que os hashes dos (n-1)-gramas nas bordas da substring
são estritamente maiores do que os de qualquer (n-1)-grama dentro da substring.
Usa `CRC32` como função de hash.
**Sintaxe**
```sql theme={null}
sparseGramsHashes(s[, min_ngram_length, max_ngram_length])
```
**Argumentos**
* `s` — Uma string de entrada. [`String`](/pt-BR/reference/data-types/string)
* `min_ngram_length` — Opcional. O comprimento mínimo do n-grama extraído. O valor padrão e mínimo é 3. [`UInt*`](/pt-BR/reference/data-types/int-uint)
* `max_ngram_length` — Opcional. O comprimento máximo do n-grama extraído. O valor padrão é 100. Não deve ser menor que `min_ngram_length`. [`UInt*`](/pt-BR/reference/data-types/int-uint)
* `min_cutoff_length` — Opcional. Se especificado, apenas n-gramas com comprimento maior ou igual a `min_cutoff_length` são retornados. O valor padrão é o mesmo de `min_ngram_length`. Não deve ser menor que `min_ngram_length` nem maior que `max_ngram_length`. [`UInt*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um array de hashes CRC32 das substrings selecionadas. [`Array(UInt32)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT sparseGramsHashes('alice', 3)
```
```response title=Response theme={null}
┌─sparseGramsHashes('alice', 3)──────────────────────┐
│ [1481062250,2450405249,4012725991,1918774096] │
└────────────────────────────────────────────────────┘
```
## sparseGramsHashesUTF8
Introduzido em: v25.5.0
Encontra os hashes de todas as substrings de uma determinada string UTF-8 com comprimento de pelo menos `n`, em que os hashes dos (n-1)-gramas nas bordas da substring são estritamente maiores do que os de qualquer (n-1)-grama no interior da substring.
Espera uma string UTF-8 e lança uma exceção em caso de sequência UTF-8 inválida.
Usa `CRC32` como função de hash.
**Sintaxe**
```sql theme={null}
sparseGramsHashesUTF8(s[, min_ngram_length, max_ngram_length])
```
**Argumentos**
* `s` — Uma string de entrada. [`String`](/pt-BR/reference/data-types/string)
* `min_ngram_length` — Opcional. O comprimento mínimo do n-grama extraído. O valor padrão e mínimo é 3. [`UInt*`](/pt-BR/reference/data-types/int-uint)
* `max_ngram_length` — Opcional. O comprimento máximo do n-grama extraído. O valor padrão é 100. Não deve ser menor que `min_ngram_length`. [`UInt*`](/pt-BR/reference/data-types/int-uint)
* `min_cutoff_length` — Opcional. Se especificado, retorna apenas n-gramas com comprimento maior ou igual a `min_cutoff_length`. O valor padrão é o mesmo de `min_ngram_length`. Não deve ser menor que `min_ngram_length` nem maior que `max_ngram_length`. [`UInt*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um array com os hashes CRC32 das substrings UTF-8 selecionadas. [`Array(UInt32)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT sparseGramsHashesUTF8('алиса', 3)
```
```response title=Response theme={null}
┌─sparseGramsHashesUTF8('алиса', 3)─┐
│ [4178533925,3855635300,561830861] │
└───────────────────────────────────┘
```
## sparseGramsUTF8
Introduzido em: v25.5.0
Encontra todas as substrings de uma determinada string UTF-8 com comprimento de pelo menos `n`, em que os hashes dos (n-1)-gramas nas bordas da substring são estritamente maiores do que os de qualquer (n-1)-grama dentro dela.
Aceita uma string UTF-8 e lança uma exceção em caso de sequência UTF-8 inválida.
Usa `CRC32` como função de hash.
**Sintaxe**
```sql theme={null}
sparseGramsUTF8(s[, min_ngram_length[, max_ngram_length[, min_cutoff_length]]])
```
**Argumentos**
* `s` — Uma string de entrada. [`String`](/pt-BR/reference/data-types/string)
* `min_ngram_length` — Opcional. O comprimento mínimo do ngrama extraído. O valor padrão e mínimo é 3. [`UInt*`](/pt-BR/reference/data-types/int-uint)
* `max_ngram_length` — Opcional. O comprimento máximo do ngrama extraído. O valor padrão é 100. Não deve ser menor que `min_ngram_length`. [`UInt*`](/pt-BR/reference/data-types/int-uint)
* `min_cutoff_length` — Opcional. Se especificado, somente n-gramas com comprimento maior ou igual a `min_cutoff_length` são retornados. O valor padrão é o mesmo de `min_ngram_length`. Não deve ser menor que `min_ngram_length` nem maior que `max_ngram_length`. [`UInt*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um array das substrings em UTF-8 selecionadas. [`Array(String)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT sparseGramsUTF8('алиса', 3)
```
```response title=Response theme={null}
┌─sparseGramsUTF8('алиса', 3)─┐
│ ['али','лис','иса'] │
└─────────────────────────────┘
```
## startsWith
Introduzido em: v1.1.0
Verifica se uma string começa com a sequência de caracteres fornecida.
**Sintaxe**
```sql theme={null}
startsWith(s, prefix)
```
**Argumentos**
* `s` — String a ser verificada. [`String`](/pt-BR/reference/data-types/string)
* `prefix` — Prefixo a ser verificado. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna `1` se `s` começar com `prefix`; caso contrário, `0`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT startsWith('ClickHouse', 'Click');
```
```response title=Response theme={null}
┌─startsWith('⋯', 'Click')─┐
│ 1 │
└──────────────────────────┘
```
## startsWithCaseInsensitive
Introduzido em: v25.10.0
Verifica se uma string começa com a string fornecida, sem diferenciar maiúsculas de minúsculas.
**Sintaxe**
```sql theme={null}
startsWithCaseInsensitive(s, prefix)
```
**Argumentos**
* `s` — String a ser verificada. [`String`](/pt-BR/reference/data-types/string)
* `prefix` — prefixo sem distinção entre maiúsculas e minúsculas a ser verificado. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna `1` se `s` começar com o `prefix` sem distinção entre maiúsculas e minúsculas; caso contrário, `0`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT startsWithCaseInsensitive('ClickHouse', 'CLICK');
```
```response title=Response theme={null}
┌─startsWithCaseInsensitive('⋯', 'CLICK')─┐
│ 1 │
└─────────────────────────────────────────┘
```
## startsWithCaseInsensitiveUTF8
Introduzido em: v25.10.0
Verifica se uma string começa com o prefixo fornecido sem diferenciar maiúsculas de minúsculas.
Pressupõe que a string contenha texto válido codificado em UTF-8.
Se essa suposição for violada, nenhuma exceção é lançada e o resultado é indefinido.
**Sintaxe**
```sql theme={null}
startsWithCaseInsensitiveUTF8(s, prefix)
```
**Argumentos**
* `s` — String a ser verificada. [`String`](/pt-BR/reference/data-types/string)
* `prefix` — Prefixo sem distinção entre maiúsculas e minúsculas a ser verificado. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna `1` se `s` começar com o `prefix` sem distinção entre maiúsculas e minúsculas; caso contrário, `0`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT startsWithCaseInsensitiveUTF8('приставка', 'при')
```
```response title=Response theme={null}
┌─startsWithUT⋯ка', 'при')─┐
│ 1 │
└──────────────────────────┘
```
## startsWithUTF8
Introduzido em: v23.8.0
Verifica se uma string começa com o prefixo informado.
Pressupõe que a string contenha texto válido codificado em UTF-8.
Se essa suposição for violada, nenhuma exceção é lançada e o resultado é indefinido.
**Sintaxe**
```sql theme={null}
startsWithUTF8(s, prefix)
```
**Argumentos**
* `s` — String a ser verificada. [`String`](/pt-BR/reference/data-types/string)
* `prefix` — Prefixo a ser verificado. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna `1` se `s` começar com `prefix`; caso contrário, `0`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT startsWithUTF8('приставка', 'при')
```
```response title=Response theme={null}
┌─startsWithUT⋯ка', 'при')─┐
│ 1 │
└──────────────────────────┘
```
## stringBytesEntropy
Introduzido em: v25.6.0
Calcula a entropia de Shannon da distribuição de bytes em uma string.
**Sintaxe**
```sql theme={null}
stringBytesEntropy(s)
```
**Argumentos**
* `s` — A string a ser analisada. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna a entropia de Shannon da distribuição dos bytes na string. [`Float64`](/pt-BR/reference/data-types/float)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT stringBytesEntropy('Hello, world!')
```
```response title=Response theme={null}
┌─stringBytesEntropy('Hello, world!')─┐
│ 3.07049960 │
└─────────────────────────────────────┘
```
## stringBytesUniq
Introduzido em: v25.6.0
Conta o número de bytes distintos em uma string.
**Sintaxe**
```sql theme={null}
stringBytesUniq(s)
```
**Argumentos**
* `s` — A string a ser analisada. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna o número de bytes distintos na string. [`UInt16`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT stringBytesUniq('Hello')
```
```response title=Response theme={null}
┌─stringBytesUniq('Hello')─┐
│ 4 │
└──────────────────────────┘
```
## stringJaccardIndex
Introduzido em: v23.11.0
Calcula o [índice de similaridade de Jaccard](https://en.wikipedia.org/wiki/Jaccard_index) entre duas sequências de bytes.
**Sintaxe**
```sql theme={null}
stringJaccardIndex(s1, s2)
```
**Argumentos**
* `s1` — Primeira string de entrada. [`String`](/pt-BR/reference/data-types/string)
* `s2` — Segunda string de entrada. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna o índice de similaridade de Jaccard entre as duas strings. [`Float64`](/pt-BR/reference/data-types/float)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT stringJaccardIndex('clickhouse', 'mouse')
```
```response title=Response theme={null}
┌─stringJaccardIndex('clickhouse', 'mouse')─┐
│ 0.4 │
└───────────────────────────────────────────┘
```
## stringJaccardIndexUTF8
Introduzido em: v23.11.0
Semelhante a [`stringJaccardIndex`](#stringJaccardIndex), mas para strings codificadas em UTF8.
**Sintaxe**
```sql theme={null}
stringJaccardIndexUTF8(s1, s2)
```
**Argumentos**
* `s1` — Primeira string UTF-8 de entrada. [`String`](/pt-BR/reference/data-types/string)
* `s2` — Segunda string UTF-8 de entrada. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna o índice de similaridade Jaccard entre as duas strings UTF-8. [`Float64`](/pt-BR/reference/data-types/float)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT stringJaccardIndexUTF8('我爱你', '我也爱你')
```
```response title=Response theme={null}
┌─stringJaccardIndexUTF8('我爱你', '我也爱你')─┐
│ 0.75 │
└─────────────────────────────────────────────┘
```
## substring
Introduzido em: v1.1.0
Retorna a substring de uma string `s` que começa no índice de byte `offset` especificado.
A contagem de bytes começa em 1, com a seguinte lógica:
* Se `offset` for `0`, retorna uma string vazia.
* Se `offset` for negativo, a substring começa a `offset` caracteres do fim da string, em vez do início.
Um argumento opcional, `length`, especifica o número máximo de bytes que a substring retornada pode ter.
**Sintaxe**
```sql theme={null}
substring(s, offset[, length])
```
**Aliases**: `byteSlice`, `mid`, `substr`
**Argumentos**
* `s` — A string a partir da qual a substring será calculada. [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring) ou [`Enum`](/pt-BR/reference/data-types/enum)
* `offset` — A posição inicial da substring em `s`. [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
* `length` — Opcional. O comprimento máximo da substring. [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna uma substring de `s` com `length` bytes, começando no índice `offset`. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Uso básico**
```sql title=Query theme={null}
SELECT 'database' AS db, substr(db, 5), substr(db, 5, 1)
```
```response title=Response theme={null}
┌─db───────┬─substring('database', 5)─┬─substring('database', 5, 1)─┐
│ database │ base │ b │
└──────────┴──────────────────────────┴─────────────────────────────┘
```
## substringIndex
Introduzido em: v23.7.0
Retorna a substring de `s` anterior a `count` ocorrências do delimitador `delim`, como no Spark ou no MySQL.
**Sintaxe**
```sql theme={null}
substringIndex(s, delim, count)
```
**Aliases**: `SUBSTRING_INDEX`
**Argumentos**
* `s` — A string da qual a substring será extraída. [`String`](/pt-BR/reference/data-types/string)
* `delim` — O caractere usado para separar. [`String`](/pt-BR/reference/data-types/string)
* `count` — O número de ocorrências do delimitador a contar antes de extrair a substring. Se `count` for positivo, tudo à esquerda do delimitador final (contando da esquerda) será retornado. Se `count` for negativo, tudo à direita do delimitador final (contando da direita) será retornado. [`UInt`](/pt-BR/reference/data-types/int-uint) ou [`Int`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna uma substring de `s` antes de `count` ocorrências de `delim`. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT substringIndex('www.clickhouse.com', '.', 2)
```
```response title=Response theme={null}
┌─substringIndex('www.clickhouse.com', '.', 2)─┐
│ www.clickhouse │
└──────────────────────────────────────────────┘
```
## substringIndexUTF8
Introduzido em: v23.7.0
Retorna a substring de `s` que precede `count` ocorrências do delimitador `delim`, especificamente para pontos de código Unicode.
Pressupõe que a string contenha texto válido codificado em UTF-8.
Se essa suposição for violada, não é lançada nenhuma exceção e o resultado é indefinido.
**Sintaxe**
```sql theme={null}
substringIndexUTF8(s, delim, count)
```
**Argumentos**
* `s` — A string da qual a substring será extraída. [`String`](/pt-BR/reference/data-types/string)
* `delim` — O caractere delimitador. [`String`](/pt-BR/reference/data-types/string)
* `count` — O número de ocorrências do delimitador a serem contadas antes de extrair a substring. Se `count` for positivo, tudo à esquerda do delimitador final (contando da esquerda) será retornado. Se `count` for negativo, tudo à direita do delimitador final (contando da direita) será retornado. [`UInt`](/pt-BR/reference/data-types/int-uint) ou [`Int`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna uma substring de `s` antes de `count` ocorrências de `delim`. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo em UTF8**
```sql title=Query theme={null}
SELECT substringIndexUTF8('www.straßen-in-europa.de', '.', 2)
```
```response title=Response theme={null}
www.straßen-in-europa
```
## substringUTF8
Introduzido em: v1.1.0
Retorna a substring de uma string `s` que começa no índice de ponto de código `offset` especificado.
A contagem de pontos de código começa em `1`, de acordo com a seguinte lógica:
* Se `offset` for `0`, será retornada uma string vazia.
* Se `offset` for negativo, a substring começa a `offset` pontos de código do final da string, em vez de começar no início.
Um argumento opcional, `length`, especifica o número máximo de pontos de código que a substring retornada pode ter.
Esta função pressupõe que a string contém texto válido codificado em UTF-8.
Se essa suposição for violada, nenhuma exceção será lançada, e o resultado será indefinido.
**Sintaxe**
```sql theme={null}
substringUTF8(s, offset[, length])
```
**Argumentos**
* `s` — A string da qual extrair uma substring. [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring) ou [`Enum`](/pt-BR/reference/data-types/enum)
* `offset` — A posição inicial da substring em `s`. [`Int`](/pt-BR/reference/data-types/int-uint) ou [`UInt`](/pt-BR/reference/data-types/int-uint)
* `length` — O comprimento máximo da substring. Opcional. [`Int`](/pt-BR/reference/data-types/int-uint) ou [`UInt`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna uma substring de `s` com `length` pontos de código, começando no índice de ponto de código `offset`. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT 'Täglich grüßt das Murmeltier.' AS str, substringUTF8(str, 9), substringUTF8(str, 9, 5)
```
```response title=Response theme={null}
Täglich grüßt das Murmeltier. grüßt das Murmeltier. grüßt
```
## toValidUTF8
Introduzido em: v20.1.0
Converte uma string para uma codificação UTF-8 válida, substituindo quaisquer caracteres UTF-8 inválidos pelo caractere de substituição `�` (U+FFFD).
Quando vários caracteres inválidos consecutivos são encontrados, eles são condensados em um único caractere de substituição.
**Sintaxe**
```sql theme={null}
toValidUTF8(s)
```
**Argumentos**
* `s` — Qualquer conjunto de bytes representado como um objeto do tipo de dado String. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna uma string UTF-8 válida. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT toValidUTF8('\\x61\\xF0\\x80\\x80\\x80b')
```
```response title=Response theme={null}
c
┌─toValidUTF8('a����b')─┐
│ a�b │
└───────────────────────┘
```
## trimBoth
Introduzido em: v20.1.0
Remove os caracteres especificados do início e do fim de uma string.
Por padrão, remove caracteres ASCII de espaço em branco comuns.
**Sintaxe**
```sql theme={null}
trimBoth(s[, trim_characters])
```
**Aliases**: `trim`
**Argumentos**
* `s` — String a ser processada. [`String`](/pt-BR/reference/data-types/string)
* `trim_characters` — Opcional. Caracteres a serem removidos das extremidades. Se não for especificado, caracteres comuns de espaço em branco serão removidos. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna a string com os caracteres especificados removidos de ambas as extremidades. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT trimBoth('$$ClickHouse$$', '$')
```
```response title=Response theme={null}
┌─trimBoth('$$⋯se$$', '$')─┐
│ ClickHouse │
└──────────────────────────┘
```
## trimLeft
Introduzido em: v20.1.0
Remove os caracteres especificados do início de uma string.
Por padrão, remove caracteres de espaço em branco (ASCII) comuns.
**Sintaxe**
```sql theme={null}
trimLeft(input[, trim_characters])
```
**Aliases**: `ltrim`
**Argumentos**
* `input` — String da qual os caracteres serão removidos. [`String`](/pt-BR/reference/data-types/string)
* `trim_characters` — Opcional. Caracteres a serem removidos. Se não for especificado, caracteres de espaço em branco comuns serão removidos. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna a string com os caracteres especificados removidos à esquerda. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT trimLeft('ClickHouse', 'Click');
```
```response title=Response theme={null}
┌─trimLeft('Cl⋯', 'Click')─┐
│ House │
└──────────────────────────┘
```
## trimRight
Introduzido na versão: v20.1.0
Remove os caracteres especificados do fim de uma string.
Por padrão, remove caracteres de espaço em branco (ASCII) comuns.
**Sintaxe**
```sql theme={null}
trimRight(s[, trim_characters])
```
**Aliases**: `rtrim`
**Argumentos**
* `s` — String da qual remover caracteres. [`String`](/pt-BR/reference/data-types/string)
* `trim_characters` — Caracteres opcionais a serem removidos. Se não forem especificados, caracteres de espaço em branco comuns serão removidos. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna a string com os caracteres especificados removidos à direita. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT trimRight('ClickHouse','House');
```
```response title=Response theme={null}
┌─trimRight('C⋯', 'House')─┐
│ Click │
└──────────────────────────┘
```
## tryBase32Decode
Introduzido em: v25.6.0
Aceita uma string e a decodifica usando a codificação [Base32](https://datatracker.ietf.org/doc/html/rfc4648#section-6).
**Sintaxe**
```sql theme={null}
tryBase32Decode(encoded)
```
**Argumentos**
* `encoded` — coluna String ou constante a ser decodificada. Se a string não estiver codificada em Base32 válida, retorna uma string vazia em caso de erro. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna uma string contendo o valor decodificado do argumento. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT tryBase32Decode('IVXGG33EMVSA====');
```
```response title=Response theme={null}
┌─tryBase32Decode('IVXGG33EMVSA====')─┐
│ Encoded │
└─────────────────────────────────────┘
```
## tryBase58Decode
Introduzido em: v22.10.0
Semelhante a [`base58Decode`](#base58Decode), mas retorna uma string vazia em caso de erro.
**Sintaxe**
```sql theme={null}
tryBase58Decode(encoded[, expected_size])
```
**Argumentos**
* `encoded` — coluna String ou constante. Se a string não for codificada em Base58 válida, retorna uma string vazia em caso de erro. [`String`](/pt-BR/reference/data-types/string)
* `expected_size` — Opcional. Tamanho esperado após a decodificação, em bytes. Quando for 32 ou 64, será usado um decodificador otimizado; para outros valores, será usado o decodificador genérico. [`UInt8, UInt16, UInt32 ou UInt64`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna uma string contendo o valor decodificado do argumento. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT tryBase58Decode('3dc8KtHrwM') AS res, tryBase58Decode('invalid') AS res_invalid;
```
```response title=Response theme={null}
┌─res─────┬─res_invalid─┐
│ Encoded │ │
└─────────┴─────────────┘
```
## tryBase64Decode
Introduzido em: v18.16.0
Assim como [`base64Decode`](#base64Decode), mas retorna uma string vazia em caso de erro.
**Sintaxe**
```sql theme={null}
tryBase64Decode(encoded)
```
**Argumentos**
* `encoded` — coluna `String` ou constante a ser decodificada. Se a string não for uma Base64 válida, retorna uma string vazia em caso de erro. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna uma string contendo o valor decodificado do argumento. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT tryBase64Decode('Y2xpY2tob3VzZQ==')
```
```response title=Response theme={null}
┌─tryBase64Decode('Y2xpY2tob3VzZQ==')─┐
│ clickhouse │
└─────────────────────────────────────┘
```
## tryBase64URLDecode
Introduzido na versão: v18.16.0
Assim como [`base64URLDecode`](#base64URLDecode), mas retorna uma string vazia em caso de erro.
**Sintaxe**
```sql theme={null}
tryBase64URLDecode(encoded)
```
**Argumentos**
* `encoded` — coluna String ou constante a ser decodificada. Se a string não for uma string codificada em Base64 válida, retorna uma string vazia em caso de erro. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna uma string que contém o valor decodificado do argumento. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT tryBase64URLDecode('aHR0cHM6Ly9jbGlja2hvdXNlLmNvbQ')
```
```response title=Response theme={null}
┌─tryBase64URLDecode('aHR0cHM6Ly9jbGlja2hvdXNlLmNvbQ')─┐
│ https://clickhouse.com │
└──────────────────────────────────────────────────────┘
```
## tryIdnaEncode
Introduzido na versão: v24.1.0
Retorna a representação em Unicode (UTF-8) (algoritmo ToUnicode) de um nome de domínio de acordo com o mecanismo [Internationalized Domain Names in Applications](https://en.wikipedia.org/wiki/Internationalized_domain_name#Internationalizing_Domain_Names_in_Applications) (IDNA).
Em caso de erro, retorna uma string vazia em vez de gerar uma exceção.
**Sintaxe**
```sql theme={null}
tryIdnaEncode(s)
```
**Argumentos**
* `s` — String de entrada. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna uma representação ASCII da string de entrada de acordo com o mecanismo IDNA do valor de entrada, ou uma string vazia se a entrada for inválida. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT tryIdnaEncode('straße.münchen.de')
```
```response title=Response theme={null}
┌─tryIdnaEncode('straße.münchen.de')──┐
│ xn--strae-oqa.xn--mnchen-3ya.de │
└─────────────────────────────────────┘
```
## tryPunycodeDecode
Introduzido em: v24.1.0
Como `punycodeDecode`, mas retorna uma string vazia se não for fornecida uma string codificada em Punycode válida.
**Sintaxe**
```sql theme={null}
tryPunycodeDecode(s)
```
**Argumentos**
* `s` — String codificada em Punycode. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna o valor de entrada em texto simples ou uma string vazia se a entrada for inválida. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT tryPunycodeDecode('Mnchen-3ya')
```
```response title=Response theme={null}
┌─tryPunycodeDecode('Mnchen-3ya')─┐
│ München │
└─────────────────────────────────┘
```
## upper
Introduzido na versão: v1.1.0
Converte os caracteres latinos ASCII de uma string em maiúsculas.
**Sintaxe**
```sql theme={null}
upper(s)
```
**Aliases**: `ucase`
**Argumentos**
* `s` — A string a ser convertida para letras maiúsculas. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna `s` em letras maiúsculas. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT upper('clickhouse')
```
```response title=Response theme={null}
┌─upper('clickhouse')─┐
│ CLICKHOUSE │
└─────────────────────┘
```
## upperUTF8
Introduzido em: v1.1.0
Converte uma string em maiúsculas, assumindo que a string contém texto válido codificado em UTF-8.
Se essa suposição não for atendida, nenhuma exceção será lançada e o resultado será indefinido.
Esta função não detecta o idioma; por exemplo, para o turco, o resultado pode não estar exatamente correto (i/İ vs. i/I).
Se o comprimento da sequência de bytes UTF-8 for diferente entre as formas maiúscula e minúscula de um ponto de código (como `ẞ` e `ß`), o resultado pode estar incorreto para esse ponto de código.
**Sintaxe**
```sql theme={null}
upperUTF8(s)
```
**Argumentos**
* `s` — Um valor do tipo String. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Um valor do tipo de dados String. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT upperUTF8('München') AS Upperutf8
```
```response title=Response theme={null}
┌─Upperutf8─┐
│ MÜNCHEN │
└───────────┘
```