`](/pt-BR/reference/settings/server-settings/settings#macros) do arquivo de configuração e podem ser usadas para diferenciar servidores por nomes convenientes, mesmo que tenham hostname complexos.
Se a função for executada no contexto de uma tabela distribuída, ela gerará uma coluna normal com valores correspondentes a cada shard.
**Sintaxe**
```sql theme={null}
getMacro(name)
```
**Argumentos**
* `name` — O nome da macro a ser obtida. [`const String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna o valor da macro especificada. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Uso básico**
```sql title=Query theme={null}
SELECT getMacro('test');
```
```response title=Response theme={null}
┌─getMacro('test')─┐
│ Value │
└──────────────────┘
```
## getMaxTableNameLengthForDatabase
Introduzido na versão: v25.1.0
Retorna o comprimento máximo do nome da tabela no banco de dados especificado.
**Sintaxe**
```sql theme={null}
getMaxTableNameLengthForDatabase(database_name)
```
**Argumentos**
* `database_name` — O nome do banco de dados especificado. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna o comprimento do maior nome de tabela, um Integer
**Exemplos**
**típico**
```sql title=Query theme={null}
SELECT getMaxTableNameLengthForDatabase('default');
```
```response title=Response theme={null}
┌─getMaxTableNameLengthForDatabase('default')─┐
│ 206 │
└─────────────────────────────────────────────┘
```
## getMergeTreeSetting
Introduzido em: v25.6.0
Retorna o valor atual de uma configuração do MergeTree.
**Sintaxe**
```sql theme={null}
getMergeTreeSetting(setting_name)
```
**Argumentos**
* `setting_name` — O nome da configuração. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna o valor atual da configuração do MergeTree.
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT getMergeTreeSetting('index_granularity');
```
```response title=Response theme={null}
┌─getMergeTreeSetting('index_granularity')─┐
│ 8192 │
└──────────────────────────────────────────┘
```
## getOSKernelVersion
Introduzido em: v21.11.0
Retorna uma string com a versão do kernel do sistema operacional.
**Sintaxe**
```sql theme={null}
getOSKernelVersion()
```
**Argumentos**
* Nenhum.
**Valor retornado**
Retorna a versão atual do kernel do sistema operacional. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT getOSKernelVersion();
```
```response title=Response theme={null}
┌─getOSKernelVersion()────┐
│ Linux 4.15.0-55-generic │
└─────────────────────────┘
```
## getServerPort
Introduzido em: v21.10.0
Retorna o número da porta do servidor para um determinado protocolo.
**Sintaxe**
```sql theme={null}
getServerPort(port_name)
```
**Argumentos**
* `port_name` — Nome da porta. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna o número da porta do servidor. [`UInt16`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT getServerPort('tcp_port');
```
```response title=Response theme={null}
┌─getServerPort('tcp_port')─┐
│ 9000 │
└───────────────────────────┘
```
## getServerSetting
Introduzido em: v25.6.0
Retorna o valor definido no momento para a configuração do servidor informada.
**Sintaxe**
```sql theme={null}
getServerSetting(setting_name')
```
**Argumentos**
* `setting_name` — O nome da configuração do servidor. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna o valor atual da configuração do servidor. [`Any`](/pt-BR/reference/data-types)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT getServerSetting('allow_use_jemalloc_memory');
```
```response title=Response theme={null}
┌─getServerSetting('allow_use_jemalloc_memory')─┐
│ true │
└───────────────────────────────────────────────┘
```
## getSetting
Introduzido em: v20.7.0
Retorna o valor atual de uma configuração.
**Sintaxe**
```sql theme={null}
getSetting(setting_name)
```
**Argumentos**
* `setting_Name` — O nome da configuração. [`const String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna o valor atual da configuração. [`Any`](/pt-BR/reference/data-types)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT getSetting('enable_analyzer');
SET enable_analyzer = false;
SELECT getSetting('enable_analyzer');
```
```response title=Response theme={null}
┌─getSetting('⋯_analyzer')─┐
│ true │
└──────────────────────────┘
┌─getSetting('⋯_analyzer')─┐
│ false │
└──────────────────────────┘
```
## getSettingOrDefault
Introduzido em: v24.10.0
Retorna o valor atual de uma configuração ou, caso ela não esteja definida no perfil atual, o valor padrão especificado no segundo argumento.
**Sintaxe**
```sql theme={null}
getSettingOrDefault(setting_name, default_value)
```
**Argumentos**
* `setting_name` — O nome da configuração. [`String`](/pt-BR/reference/data-types/string)
* `default_value` — Valor a ser retornado caso custom\_setting não esteja definida. O valor pode ser de qualquer tipo de dado ou Null.
**Valor retornado**
Retorna o valor atual da configuração especificada ou `default_value` caso a configuração não esteja definida.
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT getSettingOrDefault('custom_undef1', 'my_value');
SELECT getSettingOrDefault('custom_undef2', 100);
SELECT getSettingOrDefault('custom_undef3', NULL);
```
```response title=Response theme={null}
my_value
100
NULL
```
## getSizeOfEnumType
Introduzido em: v1.1.0
Retorna o número de campos no [`Enum`](/pt-BR/reference/data-types/enum) fornecido.
**Sintaxe**
```sql theme={null}
getSizeOfEnumType(x)
```
**Argumentos**
* `x` — Valor do tipo `Enum`. [`Enum`](/pt-BR/reference/data-types/enum)
**Valor retornado**
Retorna o número de campos cujos valores de entrada são do tipo `Enum`. [`UInt8/16`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT getSizeOfEnumType(CAST('a' AS Enum8('a' = 1, 'b' = 2))) AS x;
```
```response title=Response theme={null}
┌─x─┐
│ 2 │
└───┘
```
## getSubcolumn
Introduzido em: v23.3.0
Recebe uma expressão ou identificador e uma string constante com o nome da subcoluna.
Retorna a subcoluna solicitada, extraída da expressão.
**Sintaxe**
```sql theme={null}
getSubcolumn(nested_value, subcolumn_name)
```
**Argumentos**
* Nenhum.
**Valor retornado**
**Exemplos**
**getSubcolumn**
```sql title=Query theme={null}
SELECT getSubcolumn(array_col, 'size0'), getSubcolumn(tuple_col, 'elem_name')
```
```response title=Response theme={null}
```
## getTypeSerializationStreams
Introduzido em: v22.6.0
Enumera os caminhos de stream de um tipo de dado.
Esta função se destina a uso em desenvolvimento.
**Sintaxe**
```sql theme={null}
getTypeSerializationStreams(col)
```
**Argumentos**
* `col` — Coluna ou representação textual de um tipo de dado a partir do qual o tipo de dado será detectado. [`Any`](/pt-BR/reference/data-types)
**Valor retornado**
Retorna um array com todos os caminhos dos substreams de serialização. [`Array(String)`](/pt-BR/reference/data-types/array)
**Exemplos**
**tuple**
```sql title=Query theme={null}
SELECT getTypeSerializationStreams(tuple('a', 1, 'b', 2))
```
```response title=Response theme={null}
['{TupleElement(1), Regular}','{TupleElement(2), Regular}','{TupleElement(3), Regular}','{TupleElement(4), Regular}']
```
**map**
```sql title=Query theme={null}
SELECT getTypeSerializationStreams('Map(String, Int64)')
```
```response title=Response theme={null}
['{ArraySizes}','{ArrayElements, TupleElement(keys), Regular}','{ArrayElements, TupleElement(values), Regular}']
```
## globalVariable
Introduzido em: v20.5.0
Recebe um argumento String constante e retorna o valor da variável global com esse nome. Esta função é destinada à compatibilidade com o MySQL e não é necessária nem útil para a operação normal do ClickHouse. Apenas algumas variáveis globais fictícias estão definidas.
**Sintaxe**
```sql theme={null}
globalVariable(name)
```
**Argumentos**
* `name` — Nome da variável global. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna o valor da variável `name`. [`Any`](/pt-BR/reference/data-types)
**Exemplos**
**globalVariable**
```sql title=Query theme={null}
SELECT globalVariable('max_allowed_packet')
```
```response title=Response theme={null}
67108864
```
## hasColumnInTable
Introduzido em: v1.1.0
Verifica se uma coluna específica existe em uma tabela de um banco de dados.
Para elementos em uma estrutura de dados aninhada, a função verifica a existência de uma coluna.
Para a própria estrutura de dados aninhada, a função retorna `0`.
**Sintaxe**
```sql theme={null}
hasColumnInTable([hostname[, username[, password]],]database, table, column)
```
**Argumentos**
* `database` — Nome do banco de dados. [`const String`](/pt-BR/reference/data-types/string)
* `table` — Nome da tabela. [`const String`](/pt-BR/reference/data-types/string)
* `column` — Nome da coluna. [`const String`](/pt-BR/reference/data-types/string)
* `hostname` — Opcional. Nome do servidor remoto em que a verificação será realizada. [`const String`](/pt-BR/reference/data-types/string)
* `username` — Opcional. Nome de usuário do servidor remoto. [`const String`](/pt-BR/reference/data-types/string)
* `password` — Opcional. Senha do servidor remoto. [`const String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna `1` se a coluna informada existir, `0` caso contrário. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Verificar uma coluna existente**
```sql title=Query theme={null}
SELECT hasColumnInTable('system','metrics','metric')
```
```response title=Response theme={null}
1
```
**Verifique uma coluna inexistente**
```sql title=Query theme={null}
SELECT hasColumnInTable('system','metrics','non-existing_column')
```
```response title=Response theme={null}
0
```
## hasThreadFuzzer
Introduzido em: v20.6.0
Retorna se o thread fuzzer está habilitado.
Esta função só é útil para testes e depuração.
**Sintaxe**
```sql theme={null}
hasThreadFuzzer()
```
**Argumentos**
* Nenhum.
**Valor retornado**
Indica se o Thread Fuzzer está ativo. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Verificar o status do Thread Fuzzer**
```sql title=Query theme={null}
SELECT hasThreadFuzzer()
```
```response title=Response theme={null}
┌─hasThreadFuzzer()─┐
│ 0 │
└───────────────────┘
```
## highlightQuery
Introduzido em: v26.5.0
Analisa uma string de consulta em ClickHouse SQL e retorna um array de faixas destacadas para realce de sintaxe.
Cada faixa é uma tupla nomeada com a posição inicial (em bytes), a posição final e o tipo de destaque.
Os tipos de destaque descrevem o papel sintático do fragmento (palavra-chave, identificador, função etc.)
e podem ser usados para atribuir cores na UI. Em padrões de string de LIKE e REGEXP, metacaracteres
e caracteres de escape são destacados separadamente.
**Sintaxe**
```sql theme={null}
highlightQuery(query)
```
**Argumentos**
* `query` — Uma string de consulta em ClickHouse SQL. String.
**Valor retornado**
Um array de tuplas nomeadas `(begin UInt64, end UInt64, type Enum8(...))` que representa intervalos destacados. [`Array(Tuple(begin UInt64, end UInt64, type Enum8(...)))`](/pt-BR/reference/data-types/array)
**Exemplos**
**simples**
```sql title=Query theme={null}
SELECT highlightQuery('SELECT 1')
```
```response title=Response theme={null}
[(0,6,'keyword'),(7,8,'number')]
```
## hostName
Introduzido em: v20.5.0
Retorna o nome do host em que esta função foi executada.
Se a função for executada em um servidor remoto (processamento distribuído), o nome desse servidor remoto será retornado.
Se a função for executada no contexto de uma tabela distribuída, ela gera uma coluna normal com valores correspondentes a cada shard.
Caso contrário, produz um valor constante.
**Sintaxe**
```sql theme={null}
hostName()
```
**Aliases**: `hostname`
**Argumentos**
* Nenhum.
**Valor retornado**
Retorna o nome do host. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT hostName()
```
```response title=Response theme={null}
┌─hostName()─┐
│ clickhouse │
└────────────┘
```
## icebergBucket
Introduzido em: v25.5.0
Implementa a lógica da [transformação de bucket do Iceberg](https://iceberg.apache.org/spec/#bucket-transform-details.)
**Sintaxe**
```sql theme={null}
icebergBucket(N, value)
```
**Argumentos**
* `N` — O número de buckets, módulo. [`const (U)Int*`](/pt-BR/reference/data-types/int-uint)
* `value` — O valor de entrada a ser transformado. [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Bool`](/pt-BR/reference/data-types/boolean) ou [`Decimal`](/pt-BR/reference/data-types/decimal) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring) ou [`UUID`](/pt-BR/reference/data-types/uuid) ou [`Date`](/pt-BR/reference/data-types/date) ou [`Time`](/pt-BR/reference/data-types/time) ou [`DateTime`](/pt-BR/reference/data-types/datetime)
**Valor retornado**
Retorna um hash de 32 bits do valor de entrada. [`Int32`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo**
```sql title=Query theme={null}
SELECT icebergBucket(5, 1.0 :: Float32)
```
```response title=Response theme={null}
4
```
## icebergTruncate
Introduzido em: v25.3.0
Implementa a lógica da transformação truncate do Iceberg: [https://iceberg.apache.org/spec/#truncate-transform-details](https://iceberg.apache.org/spec/#truncate-transform-details).
**Sintaxe**
```sql theme={null}
icebergTruncate(N, value)
```
**Argumentos**
* `value` — O valor a ser transformado. [`String`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Decimal`](/pt-BR/reference/data-types/decimal)
**Valor retornado**
O mesmo tipo que o argumento
**Exemplos**
**Exemplo**
```sql title=Query theme={null}
SELECT icebergTruncate(3, 'iceberg')
```
```response title=Response theme={null}
ice
```
## identity
Introduzido em: v1.1.0
Esta função retorna o argumento que você passa a ela, o que é útil para depuração e testes. Ela permite evitar o uso de índices para observar o desempenho de uma varredura completa. O analisador de consultas ignora tudo o que estiver dentro de funções `identity` ao procurar índices para usar e também desabilita a dobra de constantes.
**Sintaxe**
```sql theme={null}
identity(x)
```
**Argumentos**
* `x` — Valor de entrada. [`Any`](/pt-BR/reference/data-types)
**Valor retornado**
Retorna o valor de entrada inalterado. [`Any`](/pt-BR/reference/data-types)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT identity(42)
```
```response title=Response theme={null}
42
```
## ignore
Introduzido em: v1.1.0
Aceita argumentos arbitrários e retorna `0` incondicionalmente.
**Sintaxe**
```sql theme={null}
ignore(x)
```
**Argumentos**
* `x` — Um valor de entrada que não é usado e é passado apenas para evitar um erro de sintaxe. [`Any`](/pt-BR/reference/data-types)
**Valor retornado**
Sempre retorna `0`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT ignore(0, 'ClickHouse', NULL)
```
```response title=Response theme={null}
┌─ignore(0, 'ClickHouse', NULL)─┐
│ 0 │
└───────────────────────────────┘
```
## indexHint
Introduzido em: v1.1.0
Esta função se destina à depuração e à introspecção.
Ela ignora o argumento e sempre retorna 1.
Os argumentos não são avaliados.
Durante a análise do índice, considera-se que o argumento desta função não esteja encapsulado em `indexHint`.
Isso permite selecionar dados em intervalos do índice pela condição correspondente, mas sem aplicar filtragem adicional por essa condição.
O índice no ClickHouse é esparso, e usar `indexHint` retornará mais dados do que especificar a mesma condição diretamente.
Quando você executa:
```sql theme={null}
SELECT * FROM test WHERE key = 123;
```
O ClickHouse faz duas coisas:
1. Usa o índice para encontrar quais grânulos (blocos de \~8192 linhas) podem conter `key = 123`
2. Lê esses grânulos e filtra suas linhas para retornar apenas aquelas em que `key = 123`
Assim, mesmo que ele leia 8.192 linhas do disco, retorna apenas a 1 linha que realmente corresponde.
Com `indexHint`, quando você executa:
```sql theme={null}
SELECT * FROM test WHERE indexHint(key = 123);
```
O ClickHouse faz apenas uma coisa:
1. Usa o índice para encontrar quais grânulos podem conter `key = 123` e retorna todas as linhas desses grânulos **sem** filtrá-las.
Ele retorna todas as 8.192 linhas, incluindo linhas em que `key = 456`, `key = 789` etc. (Tudo o que, por acaso, estava armazenado no mesmo grânulo.)
`indexHint()` não serve para melhorar o desempenho. Ele serve para depuração e para entender como o índice do ClickHouse funciona:
* Quais grânulos a minha condição seleciona?
* Quantas linhas há nesses grânulos?
* Meu índice está sendo usado de forma eficaz?
Observação: não é possível otimizar uma consulta com a função `indexHint`. A função `indexHint` não otimiza a consulta, pois não fornece nenhuma informação adicional para a análise da consulta. Ter uma expressão dentro da função `indexHint` não é, de forma alguma, melhor do que não usar a função `indexHint`. A função `indexHint` pode ser usada apenas para fins de introspecção e depuração e não melhora o desempenho. Se você vir o uso de `indexHint` por alguém que não seja um colaborador do ClickHouse, provavelmente é um erro, e você deve removê-lo.
**Sintaxe**
```sql theme={null}
indexHint(expression)
```
**Argumentos**
* `expression` — Qualquer expressão para seleção de intervalo de índice. [`Expression`](/pt-BR/reference/data-types/special-data-types/expression)
**Valor retornado**
Retorna `1` em todos os casos. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso com filtro por data**
```sql title=Query theme={null}
SELECT FlightDate AS k, count() FROM ontime WHERE indexHint(k = '2025-09-15') GROUP BY k ORDER BY k ASC;
```
```response title=Response theme={null}
┌──────────k─┬─count()─┐
│ 2025-09-14 │ 7071 │
│ 2025-09-15 │ 16428 │
│ 2025-09-16 │ 1077 │
│ 2025-09-30 │ 8167 │
└────────────┴─────────┘
```
## initialQueryID
Introduzido em: v1.1.0
Retorna o ID da consulta inicial atual.
Outros parâmetros de uma consulta podem ser extraídos do campo `initial_query_id` em [`system.query_log`](/pt-BR/reference/system-tables/query_log).
Ao contrário da função [`queryID`](/pt-BR/reference/functions/regular-functions/other-functions#queryID), `initialQueryID` retorna os mesmos resultados em diferentes shards.
**Sintaxe**
```sql theme={null}
initialQueryID()
```
**Aliases**: `initial_query_id`
**Argumentos**
* Nenhum.
**Valor retornado**
Retorna o ID da consulta inicial da consulta atual. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
CREATE TABLE tmp (str String) ENGINE = Log;
INSERT INTO tmp (*) VALUES ('a');
SELECT count(DISTINCT t) FROM (SELECT initialQueryID() AS t FROM remote('127.0.0.{1..3}', currentDatabase(), 'tmp') GROUP BY queryID());
```
```response title=Response theme={null}
┌─count(DISTINCT t)─┐
│ 1 │
└───────────────────┘
```
## initialQueryStartTime
Introduzido em: v25.4.0
Retorna o horário de início da consulta inicial atual.
`initialQueryStartTime` retorna os mesmos resultados em diferentes shards.
**Sintaxe**
```sql theme={null}
initialQueryStartTime()
```
**Aliases**: `initial_query_start_time`
**Argumentos**
* Nenhum.
**Valor retornado**
Retorna o horário de início da consulta inicial atual. [`DateTime`](/pt-BR/reference/data-types/datetime)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
CREATE TABLE tmp (str String) ENGINE = Log;
INSERT INTO tmp (*) VALUES ('a');
SELECT count(DISTINCT t) FROM (SELECT initialQueryStartTime() AS t FROM remote('127.0.0.{1..3}', currentDatabase(), 'tmp') GROUP BY queryID());
```
```response title=Response theme={null}
┌─count(DISTINCT t)─┐
│ 1 │
└───────────────────┘
```
## initializeAggregation
Introduzido em: v20.6.0
Calcula o resultado de uma função de agregação com base em um único valor.
Esta função pode ser usada para inicializar funções de agregação com o combinador [-State](/pt-BR/reference/functions/aggregate-functions/combinators#-state).
Você pode criar estados de funções de agregação e inseri-los em colunas do tipo [`AggregateFunction`](/pt-BR/reference/data-types/aggregatefunction) ou usar agregados inicializados como valores padrão.
**Sintaxe**
```sql theme={null}
initializeAggregation(aggregate_function, arg1[, arg2, ...])
```
**Argumentos**
* `aggregate_function` — Nome da função de agregação a ser inicializada. [`String`](/pt-BR/reference/data-types/string)
* `arg1[, arg2, ...]` — Argumentos da função de agregação. [`Any`](/pt-BR/reference/data-types)
**Valor retornado**
Retorna o resultado da agregação para cada linha passada à função. O tipo de retorno é o mesmo da função que `initializeAggregation` recebe como primeiro argumento. [`Any`](/pt-BR/reference/data-types)
**Exemplos**
**Uso básico com uniqState**
```sql title=Query theme={null}
SELECT uniqMerge(state) FROM (SELECT initializeAggregation('uniqState', number % 3) AS state FROM numbers(10000));
```
```response title=Response theme={null}
┌─uniqMerge(state)─┐
│ 3 │
└──────────────────┘
```
**Uso de sumState e finalizeAggregation**
```sql title=Query theme={null}
SELECT finalizeAggregation(state), toTypeName(state) FROM (SELECT initializeAggregation('sumState', number % 3) AS state FROM numbers(5));
```
```response title=Response theme={null}
┌─finalizeAggregation(state)─┬─toTypeName(state)─────────────┐
│ 0 │ AggregateFunction(sum, UInt8) │
│ 1 │ AggregateFunction(sum, UInt8) │
│ 2 │ AggregateFunction(sum, UInt8) │
│ 0 │ AggregateFunction(sum, UInt8) │
│ 1 │ AggregateFunction(sum, UInt8) │
└────────────────────────────┴───────────────────────────────┘
```
## isConstant
Introduzido em: v20.3.0
Retorna se o argumento é uma expressão constante.
Uma expressão constante é uma expressão cujo resultado é conhecido durante a análise da consulta, isto é, antes da execução.
Por exemplo, expressões com [literais](/pt-BR/reference/syntax#literals) são expressões constantes.
Esta função se destina principalmente a desenvolvimento, depuração e demonstração.
**Sintaxe**
```sql theme={null}
isConstant(x)
```
**Argumentos**
* `x` — Uma expressão a ser verificada. [`Any`](/pt-BR/reference/data-types)
**Valor retornado**
Retorna `1` se `x` for constante e `0` se `x` não for constante. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Expressão constante**
```sql title=Query theme={null}
SELECT isConstant(x + 1)
FROM (SELECT 43 AS x)
```
```response title=Response theme={null}
┌─isConstant(plus(x, 1))─┐
│ 1 │
└────────────────────────┘
```
**Constante com função**
```sql title=Query theme={null}
WITH 3.14 AS pi
SELECT isConstant(cos(pi))
```
```response title=Response theme={null}
┌─isConstant(cos(pi))─┐
│ 1 │
└─────────────────────┘
```
**Expressão não constante**
```sql title=Query theme={null}
SELECT isConstant(number)
FROM numbers(1)
```
```response title=Response theme={null}
┌─isConstant(number)─┐
│ 0 │
└────────────────────┘
```
**Comportamento da função now()**
```sql title=Query theme={null}
SELECT isConstant(now())
```
```response title=Response theme={null}
┌─isConstant(now())─┐
│ 1 │
└───────────────────┘
```
## isDecimalOverflow
Introduzido em: v20.8.0
Verifica se um número decimal tem dígitos demais para caber corretamente em um tipo de dado Decimal com a precisão especificada.
**Sintaxe**
```sql theme={null}
isDecimalOverflow(value[, precision])
```
**Argumentos**
* `value` — Valor do tipo Decimal a ser verificado. [`Decimal`](/pt-BR/reference/data-types/decimal)
* `precision` — Opcional. A precisão do tipo Decimal. Se omitida, será usada a precisão inicial do primeiro argumento. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna `1` se o valor decimal tiver mais dígitos do que o permitido pela sua precisão e `0` se o valor decimal atender à precisão especificada. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT isDecimalOverflow(toDecimal32(1000000000, 0), 9),
isDecimalOverflow(toDecimal32(1000000000, 0)),
isDecimalOverflow(toDecimal32(-1000000000, 0), 9),
isDecimalOverflow(toDecimal32(-1000000000, 0));
```
```response title=Response theme={null}
┌─isDecimalOverflow(toDecimal32(1000000000, 0), 9)─┬─isDecimalOverflow(toDecimal32(1000000000, 0))─┬─isDecimalOverflow(toDecimal32(-1000000000, 0), 9)─┬─isDecimalOverflow(toDecimal32(-1000000000, 0))─┐
│ 1 │ 1 │ 1 │ 1 │
└──────────────────────────────────────────────────┴───────────────────────────────────────────────┴───────────────────────────────────────────────────┴────────────────────────────────────────────────┘
```
## joinGet
Introduzido em: v18.16.0
Permite extrair dados de uma tabela da mesma forma que de um Dicionário.
Obtém dados de tabelas Join usando a chave de junção especificada.
Compatível apenas com tabelas criadas com a instrução `ENGINE = Join(ANY, LEFT, )` [instrução](/pt-BR/reference/engines/table-engines/special/join).
**Sintaxe**
```sql theme={null}
joinGet(join_storage_table_name, value_column, join_keys)
```
**Argumentos**
* `join_storage_table_name` — Um identificador que indica onde realizar a busca. O identificador é procurado no banco de dados padrão (consulte o parâmetro `default_database` no arquivo de configuração). Para substituir o banco de dados padrão, use a consulta `USE database_name` ou especifique o banco de dados e a tabela com um ponto, como em `database_name.table_name`. [`String`](/pt-BR/reference/data-types/string)
* `value_column` — O nome da coluna da tabela que contém os dados necessários. [`const String`](/pt-BR/reference/data-types/string)
* `join_keys` — Uma lista de chaves de junção. [`Any`](/pt-BR/reference/data-types)
**Valor retornado**
Retorna uma lista de valores correspondente à lista de chaves. [`Any`](/pt-BR/reference/data-types)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
CREATE TABLE db_test.id_val(`id` UInt32, `val` UInt32) ENGINE = Join(ANY, LEFT, id);
INSERT INTO db_test.id_val VALUES (1,11)(2,12)(4,13);
SELECT joinGet(db_test.id_val, 'val', toUInt32(1));
```
```response title=Response theme={null}
┌─joinGet(db_test.id_val, 'val', toUInt32(1))─┐
│ 11 │
└─────────────────────────────────────────────┘
```
**Uso com tabela do banco de dados atual**
```sql title=Query theme={null}
USE db_test;
SELECT joinGet(id_val, 'val', toUInt32(2));
```
```response title=Response theme={null}
┌─joinGet(id_val, 'val', toUInt32(2))─┐
│ 12 │
└─────────────────────────────────────┘
```
**Usar arrays como chaves de junção**
```sql title=Query theme={null}
CREATE TABLE some_table (id1 UInt32, id2 UInt32, name String) ENGINE = Join(ANY, LEFT, id1, id2);
INSERT INTO some_table VALUES (1, 11, 'a') (2, 12, 'b') (3, 13, 'c');
SELECT joinGet(some_table, 'name', 1, 11);
```
```response title=Response theme={null}
┌─joinGet(some_table, 'name', 1, 11)─┐
│ a │
└────────────────────────────────────┘
```
## joinGetOrNull
Introduzido em: v20.4.0
Permite extrair dados de uma tabela da mesma forma que de um Dicionário.
Obtém dados de tabelas Join usando a chave de junção especificada.
Ao contrário de [`joinGet`](#joinGet), retorna `NULL` quando a chave não existe.
Suporta apenas tabelas criadas com a [instrução](/pt-BR/reference/engines/table-engines/special/join) `ENGINE = Join(ANY, LEFT, )`.
**Sintaxe**
```sql theme={null}
joinGetOrNull(join_storage_table_name, value_column, join_keys)
```
**Argumentos**
* `join_storage_table_name` — Um identificador que indica onde realizar a busca. O identificador é procurado no banco de dados padrão (consulte o parâmetro default\_database no arquivo de configuração). Para substituir o banco de dados padrão, use a consulta `USE database_name` ou especifique o banco de dados e a tabela separados por um ponto, como em `database_name.table_name`. [`String`](/pt-BR/reference/data-types/string)
* `value_column` — O nome da coluna da tabela que contém os dados necessários. [`const String`](/pt-BR/reference/data-types/string)
* `join_keys` — Uma lista de chaves de junção. [`Any`](/pt-BR/reference/data-types)
**Valor retornado**
Retorna uma lista de valores correspondente à lista de chaves, ou `NULL` se uma chave não for encontrada. [`Any`](/pt-BR/reference/data-types)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
CREATE TABLE db_test.id_val(`id` UInt32, `val` UInt32) ENGINE = Join(ANY, LEFT, id);
INSERT INTO db_test.id_val VALUES (1,11)(2,12)(4,13);
SELECT joinGetOrNull(db_test.id_val, 'val', toUInt32(1)), joinGetOrNull(db_test.id_val, 'val', toUInt32(999));
```
```response title=Response theme={null}
┌─joinGetOrNull(db_test.id_val, 'val', toUInt32(1))─┬─joinGetOrNull(db_test.id_val, 'val', toUInt32(999))─┐
│ 11 │ ᴺᵁᴸᴸ │
└───────────────────────────────────────────────────┴─────────────────────────────────────────────────────┘
```
## lowCardinalityIndices
Introduzido em: v18.12.0
Retorna a posição de um valor no dicionário de uma coluna [LowCardinality](/pt-BR/reference/data-types/lowcardinality). As posições começam em 1. Como LowCardinality tem dicionários por parte, esta função pode retornar posições diferentes para o mesmo valor em partes diferentes.
**Sintaxe**
```sql theme={null}
lowCardinalityIndices(col)
```
**Argumentos**
* `col` — Uma coluna de baixa cardinalidade. [`LowCardinality`](/pt-BR/reference/data-types/lowcardinality)
**Valor retornado**
A posição do valor no dicionário da parte atual. [`UInt64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplos de uso**
```sql title=Query theme={null}
DROP TABLE IF EXISTS test;
CREATE TABLE test (s LowCardinality(String)) ENGINE = Memory;
-- criar duas partes:
INSERT INTO test VALUES ('ab'), ('cd'), ('ab'), ('ab'), ('df');
INSERT INTO test VALUES ('ef'), ('cd'), ('ab'), ('cd'), ('ef');
SELECT s, lowCardinalityIndices(s) FROM test;
```
```response title=Response theme={null}
┌─s──┬─lowCardinalityIndices(s)─┐
│ ab │ 1 │
│ cd │ 2 │
│ ab │ 1 │
│ ab │ 1 │
│ df │ 3 │
└────┴──────────────────────────┘
┌─s──┬─lowCardinalityIndices(s)─┐
│ ef │ 1 │
│ cd │ 2 │
│ ab │ 3 │
│ cd │ 2 │
│ ef │ 1 │
└────┴──────────────────────────┘
```
## lowCardinalityKeys
Introduzido em: v18.12.0
Retorna os valores do dicionário de uma coluna [LowCardinality](/pt-BR/reference/data-types/lowcardinality).
Se o bloco for menor ou maior que o tamanho do dicionário, o resultado será truncado ou preenchido com valores padrão.
Como o LowCardinality tem dicionários por parte, esta função pode retornar valores de dicionário diferentes em partes diferentes.
**Sintaxe**
```sql theme={null}
lowCardinalityKeys(col)
```
**Argumentos**
* `col` — Uma coluna de baixa cardinalidade. [`LowCardinality`](/pt-BR/reference/data-types/lowcardinality)
**Valor retornado**
Retorna as chaves do dicionário. [`UInt64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**lowCardinalityKeys**
```sql title=Query theme={null}
DROP TABLE IF EXISTS test;
CREATE TABLE test (s LowCardinality(String)) ENGINE = Memory;
-- criar duas partes:
INSERT INTO test VALUES ('ab'), ('cd'), ('ab'), ('ab'), ('df');
INSERT INTO test VALUES ('ef'), ('cd'), ('ab'), ('cd'), ('ef');
SELECT s, lowCardinalityKeys(s) FROM test;
```
```response title=Response theme={null}
┌─s──┬─lowCardinalityKeys(s)─┐
│ ef │ │
│ cd │ ef │
│ ab │ cd │
│ cd │ ab │
│ ef │ │
└────┴───────────────────────┘
┌─s──┬─lowCardinalityKeys(s)─┐
│ ab │ │
│ cd │ ab │
│ ab │ cd │
│ ab │ df │
│ df │ │
└────┴───────────────────────┘
```
## materialize
Introduzido em: v1.1.0
Transforma uma constante em uma coluna completa que contém um único valor.
Colunas completas e constantes são representadas de forma diferente na memória.
As funções geralmente executam código diferente para argumentos normais e constantes, embora o resultado normalmente deva ser o mesmo.
Esta função pode ser usada para depurar esse comportamento.
**Sintaxe**
```sql theme={null}
materialize(x)
```
**Argumentos**
* `x` — Uma constante. [`Any`](/pt-BR/reference/data-types)
**Valor retornado**
Retorna uma coluna completa que contém o valor constante. [`Any`](/pt-BR/reference/data-types)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
-- No exemplo abaixo, a função `countMatches` espera que o segundo argumento seja constante.
-- Esse comportamento pode ser depurado usando a função `materialize` para transformar uma constante em uma coluna completa,
-- verificando que a função gera um erro quando o argumento não é constante.
SELECT countMatches('foobarfoo', 'foo');
SELECT countMatches('foobarfoo', materialize('foo'));
```
```response title=Response theme={null}
2
Code: 44. DB::Exception: Received from localhost:9000. DB::Exception: Illegal type of argument #2 'pattern' of function countMatches, expected constant String, got String
```
## minSampleSizeContinuous
Introduzido na versão: v23.10.0
Calcula o tamanho mínimo de amostra necessário para um teste A/B que compara as médias de uma métrica contínua em duas amostras.
Usa a fórmula descrita [neste artigo](https://towardsdatascience.com/required-sample-size-for-a-b-testing-6f6608dd330a).
Pressupõe tamanhos iguais para os grupos de tratamento e de controle.
Retorna o tamanho de amostra necessário para um grupo (ou seja, o tamanho de amostra necessário para todo o experimento é o dobro do valor retornado).
Também pressupõe variância igual da métrica de teste nos grupos de tratamento e de controle.
**Sintaxe**
```sql theme={null}
minSampleSizeContinuous(baseline, sigma, mde, power, alpha)
```
**Aliases**: `minSampleSizeContinous`
**Argumentos**
* `baseline` — Valor de referência de uma métrica. [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float)
* `sigma` — Desvio padrão de referência de uma métrica. [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float)
* `mde` — Efeito mínimo detectável (MDE) como porcentagem do valor de referência (por exemplo, para um valor de referência de 112.25, MDE 0.03 significa uma variação esperada para 112.25 ± 112.25\*0.03). [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float)
* `power` — Poder estatístico necessário de um teste (1 - probabilidade de erro do Tipo II). [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float)
* `alpha` — Nível de significância necessário de um teste (probabilidade de erro do Tipo I). [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float)
**Valor retornado**
Retorna uma Tuple nomeada com 3 elementos: `minimum_sample_size`, `detect_range_lower` e `detect_range_upper`. Eles correspondem, respectivamente, a: o tamanho de amostra necessário, o limite inferior do intervalo de valores que não podem ser detectados com o tamanho de amostra necessário retornado, calculado como `baseline * (1 - mde)`, e o limite superior do intervalo de valores que não podem ser detectados com o tamanho de amostra necessário retornado, calculado como `baseline * (1 + mde)` (Float64). [`Tuple(Float64, Float64, Float64)`](/pt-BR/reference/data-types/tuple)
**Exemplos**
**minSampleSizeContinuous**
```sql title=Query theme={null}
SELECT minSampleSizeContinuous(112.25, 21.1, 0.03, 0.80, 0.05) AS sample_size
```
```response title=Response theme={null}
(616.2931945826209,108.8825,115.6175)
```
## minSampleSizeConversion
Introduzido em: v22.6.0
Calcula o tamanho mínimo de amostra necessário para um teste A/B que compara conversões (proporções) entre duas amostras.
Usa a fórmula descrita [neste artigo](https://towardsdatascience.com/required-sample-size-for-a-b-testing-6f6608dd330a). Pressupõe tamanhos iguais para os grupos de tratamento e controle. Retorna o tamanho de amostra necessário para um grupo (ou seja, o tamanho de amostra necessário para todo o experimento é o dobro do valor retornado).
**Sintaxe**
```sql theme={null}
minSampleSizeConversion(baseline, mde, power, alpha)
```
**Argumentos**
* `baseline` — Conversão de base. [`Float*`](/pt-BR/reference/data-types/float)
* `mde` — Efeito mínimo detectável (MDE), em pontos percentuais (por exemplo, para uma conversão de base de 0.25, um MDE de 0.03 significa uma mudança esperada para 0.25 ± 0.03). [`Float*`](/pt-BR/reference/data-types/float)
* `power` — Poder estatístico exigido para um teste (1 - probabilidade de erro Tipo II). [`Float*`](/pt-BR/reference/data-types/float)
* `alpha` — Nível de significância exigido para um teste (probabilidade de erro Tipo I). [`Float*`](/pt-BR/reference/data-types/float)
**Valor retornado**
Retorna uma Tuple nomeada com 3 elementos: `minimum_sample_size`, `detect_range_lower`, `detect_range_upper`. Eles são, respectivamente: o tamanho de amostra exigido, o limite inferior do intervalo de valores que não podem ser detectados com o tamanho de amostra exigido retornado, calculado como `baseline - mde`, e o limite superior do intervalo de valores que não podem ser detectados com o tamanho de amostra exigido retornado, calculado como `baseline + mde`. [`Tuple(Float64, Float64, Float64)`](/pt-BR/reference/data-types/tuple)
**Exemplos**
**minSampleSizeConversion**
```sql title=Query theme={null}
SELECT minSampleSizeConversion(0.25, 0.03, 0.80, 0.05) AS sample_size
```
```response title=Response theme={null}
(3396.077603219163,0.22,0.28)
```
## neighbor
Introduzido em: v20.1.0
Retorna um valor de uma coluna em um deslocamento especificado em relação à linha atual.
Esta função está obsoleta e é propensa a erros porque opera na ordem física dos blocos de dados, que pode não corresponder à ordem lógica esperada pelos usuários.
Considere usar funções de janela adequadas em vez dela.
A função pode ser habilitada definindo `allow_deprecated_error_prone_window_functions = 1`.
**Sintaxe**
```sql theme={null}
neighbor(column, offset[, default_value])
```
**Argumentos**
* `column` — A coluna de origem. [`Any`](/pt-BR/reference/data-types)
* `offset` — O deslocamento em relação à linha atual. Valores positivos avançam, e valores negativos retrocedem. [`Integer`](/pt-BR/reference/data-types/int-uint)
* `default_value` — Opcional. O valor retornado se o deslocamento ultrapassar os limites dos dados. Se não for especificado, usa o valor padrão do tipo da coluna. [`Any`](/pt-BR/reference/data-types)
**Valor retornado**
Retorna um valor no deslocamento especificado ou o valor padrão, se estiver fora dos limites. [`Any`](/pt-BR/reference/data-types)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT number, neighbor(number, 2) FROM system.numbers LIMIT 10;
```
```response title=Response theme={null}
┌─number─┬─neighbor(number, 2)─┐
│ 0 │ 2 │
│ 1 │ 3 │
│ 2 │ 4 │
│ 3 │ 5 │
│ 4 │ 6 │
│ 5 │ 7 │
│ 6 │ 8 │
│ 7 │ 9 │
│ 8 │ 0 │
│ 9 │ 0 │
└────────┴─────────────────────┘
```
**Com valor padrão**
```sql title=Query theme={null}
SELECT number, neighbor(number, 2, 999) FROM system.numbers LIMIT 10;
```
```response title=Response theme={null}
┌─number─┬─neighbor(number, 2, 999)─┐
│ 0 │ 2 │
│ 1 │ 3 │
│ 2 │ 4 │
│ 3 │ 5 │
│ 4 │ 6 │
│ 5 │ 7 │
│ 6 │ 8 │
│ 7 │ 9 │
│ 8 │ 999 │
│ 9 │ 999 │
└────────┴──────────────────────────┘
```
## normalizeQuery
Introduzido em: v20.8.0
Substitui literais, sequências de literais e aliases complexos (contendo espaços em branco, mais de dois dígitos ou com pelo menos 36 bytes, como UUIDs) por um placeholder `?`.
**Sintaxe**
```sql theme={null}
normalizeQuery(x)
```
**Argumentos**
* `x` — Sequência de caracteres. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna a sequência de caracteres informada com placeholders. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT normalizeQuery('[1, 2, 3, x]') AS query
```
```response title=Response theme={null}
┌─query────┐
│ [?.., x] │
└──────────┘
```
## normalizeQueryKeepNames
Introduzido em: v21.2.0
Substitui literais e sequências de literais pelo placeholder `?`, mas não substitui aliases complexos (que contêm espaços em branco, mais de dois dígitos ou têm pelo menos 36 bytes de comprimento, como UUIDs).
Isso ajuda a analisar melhor logs de consultas complexas.
**Sintaxe**
```sql theme={null}
normalizeQueryKeepNames(x)
```
**Argumentos**
* `x` — Sequência de caracteres. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna a sequência de caracteres informada com placeholders. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT normalizeQuery('SELECT 1 AS aComplexName123'), normalizeQueryKeepNames('SELECT 1 AS aComplexName123')
```
```response title=Response theme={null}
┌─normalizeQuery('SELECT 1 AS aComplexName123')─┬─normalizeQueryKeepNames('SELECT 1 AS aComplexName123')─┐
│ SELECT ? AS `?` │ SELECT ? AS aComplexName123 │
└───────────────────────────────────────────────┴────────────────────────────────────────────────────────┘
```
## normalizedQueryHash
Introduzido na versão: v20.8.0
Retorna valores de hash de 64 bits idênticos para consultas semelhantes, sem considerar os valores dos literais.
Pode ser útil para analisar logs de consultas.
**Sintaxe**
```sql theme={null}
normalizedQueryHash(x)
```
**Argumentos**
* `x` — Sequência de caracteres. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor de hash de 64 bits. [`UInt64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT normalizedQueryHash('SELECT 1 AS `xyz`') != normalizedQueryHash('SELECT 1 AS `abc`') AS res
```
```response title=Response theme={null}
┌─res─┐
│ 1 │
└─────┘
```
## normalizedQueryHashKeepNames
Introduzido em: v21.2.0
Assim como [`normalizedQueryHash`](#normalizedQueryHash), retorna valores de hash de 64 bits idênticos para consultas semelhantes, sem os valores dos literais, mas não substitui aliases complexos (que contêm espaços em branco, mais de dois dígitos ou têm pelo menos 36 bytes de comprimento, como UUIDs) por um placeholder antes de calcular o hash.
Pode ser útil para analisar logs de consulta.
**Sintaxe**
```sql theme={null}
normalizedQueryHashKeepNames(x)
```
**Argumentos**
* `x` — Sequência de caracteres. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um valor de hash de 64 bits. [`UInt64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT normalizedQueryHash('SELECT 1 AS `xyz123`') != normalizedQueryHash('SELECT 1 AS `abc123`') AS normalizedQueryHash;
SELECT normalizedQueryHashKeepNames('SELECT 1 AS `xyz123`') != normalizedQueryHashKeepNames('SELECT 1 AS `abc123`') AS normalizedQueryHashKeepNames;
```
```response title=Response theme={null}
┌─normalizedQueryHash─┐
│ 0 │
└─────────────────────┘
┌─normalizedQueryHashKeepNames─┐
│ 1 │
└──────────────────────────────┘
```
## obfuscateQuery
Introduzido em: v26.4.0
Ofusca uma consulta SQL substituindo identificadores por palavras aleatórias e literais por valores aleatórios, preservando a estrutura da consulta.
Esta função é útil para anonimizar consultas antes de registrá-las em logs ou compartilhá-las para fins de depuração.
Linhas diferentes produzirão resultados ofuscados distintos, mesmo para a mesma consulta de entrada, o que ajuda
a preservar a privacidade ao trabalhar com várias consultas.
O parâmetro opcional `tag` evita a eliminação de subexpressões comuns quando a mesma chamada de função
é usada várias vezes em uma consulta. Isso garante que cada invocação produza um resultado ofuscado diferente.
Recursos:
* Substitui nomes de tabelas, nomes de colunas e aliases por palavras aleatórias
* Substitui literais numéricos e de string por valores aleatórios
* Preserva a estrutura geral da consulta e a sintaxe SQL
* Produz resultados diferentes para linhas diferentes
**Sintaxe**
```sql theme={null}
obfuscateQuery(query[, tag])
```
**Argumentos**
* `query` — A consulta SQL a ser ofuscada. [`String`](/pt-BR/reference/data-types/string)
* `tag` — Opcional. Um valor para evitar a eliminação de subexpressões comuns quando a mesma chamada de função é usada várias vezes.
**Valor retornado**
A consulta ofuscada, com identificadores e literais substituídos, preservando a estrutura original da consulta. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Uso básico**
```sql title=Query theme={null}
SELECT obfuscateQuery('SELECT name, age FROM users WHERE age > 30')
```
```response title=Response theme={null}
SELECT fruit, number FROM table WHERE number > 12
```
**Com tag para evitar a eliminação de subexpressões comuns**
```sql title=Query theme={null}
SELECT obfuscateQuery('SELECT * FROM t', 1), obfuscateQuery('SELECT * FROM t', 2)
```
```response title=Response theme={null}
SELECT a FROM b, SELECT c FROM d
```
**Linhas diferentes geram resultados diferentes**
```sql title=Query theme={null}
SELECT obfuscateQuery('SELECT 1') AS a, obfuscateQuery('SELECT 1') AS b
```
```response title=Response theme={null}
A B
```
## obfuscateQueryWithSeed
Introduzido em: v26.4.0
Ofusca uma consulta SQL usando uma seed especificada para gerar resultados determinísticos.
Diferentemente de `obfuscateQuery()`, esta função produz resultados determinísticos quando recebe a mesma seed.
Isso é útil quando você precisa de ofuscação consistente em várias execuções ou quando quer
reproduzir a mesma consulta ofuscada para fins de teste ou depuração.
Características:
* Ofuscação determinística com base na seed fornecida
* A mesma seed sempre produz o mesmo resultado ofuscado
* Seeds diferentes produzem resultados diferentes
* Preserva a estrutura da consulta, assim como `obfuscateQuery()`
Casos de uso:
* Casos de teste reproduzíveis
* Anonimização consistente em várias execuções
* Depuração com consultas ofuscadas consistentes
**Sintaxe**
```sql theme={null}
obfuscateQueryWithSeed(query, seed)
```
**Argumentos**
* `query` — A consulta SQL a ser ofuscada. [`String`](/pt-BR/reference/data-types/string)
* `seed` — A seed usada na ofuscação. A mesma seed produz resultados determinísticos. [`Integer`](/pt-BR/reference/data-types/int-uint) ou [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
A consulta ofuscada, gerada de forma determinística com base na seed fornecida. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Ofuscação determinística com seed inteira**
```sql title=Query theme={null}
SELECT obfuscateQueryWithSeed('SELECT name FROM users', 42)
```
```response title=Response theme={null}
SELECT fruit FROM table
```
**Ofuscação determinística com seed textual**
```sql title=Query theme={null}
SELECT obfuscateQueryWithSeed('SELECT id, value FROM data', 'myseed')
```
```response title=Response theme={null}
SELECT a, b FROM c
```
**A mesma seed gera o mesmo resultado**
```sql title=Query theme={null}
SELECT obfuscateQueryWithSeed('SELECT 1', 100) = obfuscateQueryWithSeed('SELECT 1', 100)
```
```response title=Response theme={null}
true
```
## parseReadableSize
Introduzido em: v24.6.0
Dada uma string que contém um tamanho em bytes e `B`, `KiB`, `KB`, `MiB`, `MB` etc. como unidade (isto é, [ISO/IEC 80000-13](https://en.wikipedia.org/wiki/ISO/IEC_80000) ou unidade decimal de byte), esta função retorna o número correspondente de bytes.
Se a função não conseguir interpretar o valor de entrada, ela gera uma exceção.
As operações inversas desta função são [`formatReadableSize`](#formatReadableSize) e [`formatReadableDecimalSize`](#formatReadableDecimalSize).
**Sintaxe**
```sql theme={null}
parseReadableSize(x)
```
**Argumentos**
* `x` — Tamanho em formato legível com unidade de byte decimal ou ISO/IEC 80000-13. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna o número de bytes, arredondado para cima para o inteiro mais próximo. [`UInt64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayJoin(['1 B', '1 KiB', '3 MB', '5.314 KiB']) AS readable_sizes, parseReadableSize(readable_sizes) AS sizes;
```
```response title=Response theme={null}
┌─readable_sizes─┬───sizes─┐
│ 1 B │ 1 │
│ 1 KiB │ 1024 │
│ 3 MB │ 3000000 │
│ 5.314 KiB │ 5442 │
└────────────────┴─────────┘
```
## parseReadableSizeOrNull
Introduzido em: v24.6.0
Dada uma string que contém um tamanho em bytes e `B`, `KiB`, `KB`, `MiB`, `MB` etc. como unidade (isto é, [ISO/IEC 80000-13](https://en.wikipedia.org/wiki/ISO/IEC_80000) ou unidade decimal de byte), esta função retorna o número de bytes correspondente.
Se a função não conseguir interpretar o valor de entrada, retornará `NULL`.
As operações inversas desta função são [`formatReadableSize`](#formatReadableSize) e [`formatReadableDecimalSize`](#formatReadableDecimalSize).
**Sintaxe**
```sql theme={null}
parseReadableSizeOrNull(x)
```
**Argumentos**
* `x` — Tamanho legível com unidade de byte decimal ou no padrão ISO/IEC 80000-13. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna o número de bytes, arredondado para cima para o inteiro mais próximo, ou `NULL` se não for possível interpretar a entrada [`Nullable(UInt64)`](/pt-BR/reference/data-types/nullable)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayJoin(['1 B', '1 KiB', '3 MB', '5.314 KiB', 'invalid']) AS readable_sizes, parseReadableSizeOrNull(readable_sizes) AS sizes;
```
```response title=Response theme={null}
┌─readable_sizes─┬───sizes─┐
│ 1 B │ 1 │
│ 1 KiB │ 1024 │
│ 3 MB │ 3000000 │
│ 5.314 KiB │ 5442 │
│ invalid │ ᴺᵁᴸᴸ │
└────────────────┴─────────┘
```
## parseReadableSizeOrZero
Introduzido em: v24.6.0
Dada uma string contendo um tamanho em bytes e `B`, `KiB`, `KB`, `MiB`, `MB` etc. como unidade (isto é, [ISO/IEC 80000-13](https://en.wikipedia.org/wiki/ISO/IEC_80000) ou unidade decimal de bytes), esta função retorna o número correspondente de bytes.
Se a função não conseguir analisar o valor de entrada, ela retornará `0`.
As operações inversas desta função são [`formatReadableSize`](#formatReadableSize) e [`formatReadableDecimalSize`](#formatReadableDecimalSize).
**Sintaxe**
```sql theme={null}
parseReadableSizeOrZero(x)
```
**Argumentos**
* `x` — Tamanho em formato legível com ISO/IEC 80000-13 ou unidade decimal de bytes. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna o número de bytes, arredondado para cima até o inteiro mais próximo, ou `0` se não for possível analisar a entrada. [`UInt64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayJoin(['1 B', '1 KiB', '3 MB', '5.314 KiB', 'invalid']) AS readable_sizes, parseReadableSizeOrZero(readable_sizes) AS sizes;
```
```response title=Response theme={null}
┌─readable_sizes─┬───sizes─┐
│ 1 B │ 1 │
│ 1 KiB │ 1024 │
│ 3 MB │ 3000000 │
│ 5.314 KiB │ 5442 │
│ invalid │ 0 │
└────────────────┴─────────┘
```
## parseTimeDelta
Introduzido em: v22.7.0
Analisa uma sequência de números seguida de algo semelhante a uma unidade de tempo.
A string de intervalo de tempo usa as seguintes especificações de unidade de tempo:
* `years`, `year`, `yr`, `y`
* `months`, `month`, `mo`
* `weeks`, `week`, `w`
* `days`, `day`, `d`
* `hours`, `hour`, `hr`, `h`
* `minutes`, `minute`, `min`, `m`
* `seconds`, `second`, `sec`, `s`
* `milliseconds`, `millisecond`, `millisec`, `ms`
* `microseconds`, `microsecond`, `microsec`, `μs`, `µs`, `us`
* `nanoseconds`, `nanosecond`, `nanosec`, `ns`
Várias unidades de tempo podem ser combinadas com separadores (espaço, `;`, `-`, `+`, `,`, `:`).
A duração de anos e meses é aproximada: um ano tem 365 dias, e um mês tem 30,5 dias.
**Sintaxe**
```sql theme={null}
parseTimeDelta(timestr)
```
**Argumentos**
* `timestr` — Uma sequência de números seguida de algo semelhante a uma unidade de tempo. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
O número de segundos. [`Float64`](/pt-BR/reference/data-types/float)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT parseTimeDelta('11s+22min')
```
```response title=Response theme={null}
┌─parseTimeDelta('11s+22min')─┐
│ 1331 │
└─────────────────────────────┘
```
**Unidades de tempo complexas**
```sql title=Query theme={null}
SELECT parseTimeDelta('1yr2mo')
```
```response title=Response theme={null}
┌─parseTimeDelta('1yr2mo')─┐
│ 36806400 │
└──────────────────────────┘
```
## partitionId
Introduzido em: v21.4.0
Calcula o [ID da partição](/pt-BR/reference/engines/table-engines/mergetree-family/custom-partitioning-key).
Esta função é lenta e não deve ser usada com um grande número de linhas.
**Sintaxe**
```sql theme={null}
partitionId(column1[, column2, ...])
```
**Aliases**: `partitionID`
**Argumentos**
* `column1, column2, ...` — Coluna cujo ID da partição deve ser retornado.
**Valor retornado**
Retorna o ID da partição à qual a linha pertence. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
DROP TABLE IF EXISTS tab;
CREATE TABLE tab
(
i int,
j int
)
ENGINE = MergeTree
PARTITION BY i
ORDER BY tuple();
INSERT INTO tab VALUES (1, 1), (1, 2), (1, 3), (2, 4), (2, 5), (2, 6);
SELECT i, j, partitionId(i), _partition_id FROM tab ORDER BY i, j;
```
```response title=Response theme={null}
┌─i─┬─j─┬─partitionId(i)─┬─_partition_id─┐
│ 1 │ 1 │ 1 │ 1 │
│ 1 │ 2 │ 1 │ 1 │
│ 1 │ 3 │ 1 │ 1 │
│ 2 │ 4 │ 2 │ 2 │
│ 2 │ 5 │ 2 │ 2 │
│ 2 │ 6 │ 2 │ 2 │
└───┴───┴────────────────┴───────────────┘
```
## queryID
Introduzido em: v21.9.0
Retorna o ID da consulta atual.
Outros parâmetros da consulta podem ser extraídos do campo `query_id` na tabela [`system.query_log`](/pt-BR/reference/system-tables/query_log).
Em contraste com a função [`initialQueryID`](#initialQueryID), `queryID` pode retornar resultados diferentes em shards distintos.
**Sintaxe**
```sql theme={null}
queryID()
```
**Aliases**: `query_id`
**Argumentos**
* Nenhum.
**Valor retornado**
Retorna o ID da consulta atual. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
CREATE TABLE tmp (str String) ENGINE = Log;
INSERT INTO tmp (*) VALUES ('a');
SELECT count(DISTINCT t) FROM (SELECT queryID() AS t FROM remote('127.0.0.{1..3}', currentDatabase(), 'tmp') GROUP BY queryID());
```
```response title=Response theme={null}
┌─count(DISTINCT t)─┐
│ 3 │
└───────────────────┘
```
## revision
Introduzido em: v22.7.0
Retorna a revisão atual do servidor ClickHouse.
**Sintaxe**
```sql theme={null}
revision()
```
**Argumentos**
* Nenhum.
**Valor retornado**
Retorna a revisão atual do servidor ClickHouse. [`UInt32`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT revision()
```
```response title=Response theme={null}
┌─revision()─┐
│ 54485 │
└────────────┘
```
## rowNumberInAllBlocks
Introduzido em: v1.1.0
Retorna um número de linha único para cada linha processada.
**Sintaxe**
```sql theme={null}
rowNumberInAllBlocks()
```
**Argumentos**
* Nenhum.
**Valor retornado**
Retorna o número ordinal da linha no bloco de dados, a partir de `0`. [`UInt64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT rowNumberInAllBlocks()
FROM
(
SELECT *
FROM system.numbers_mt
LIMIT 10
)
SETTINGS max_block_size = 2
```
```response title=Response theme={null}
┌─rowNumberInAllBlocks()─┐
│ 0 │
│ 1 │
└────────────────────────┘
┌─rowNumberInAllBlocks()─┐
│ 4 │
│ 5 │
└────────────────────────┘
┌─rowNumberInAllBlocks()─┐
│ 2 │
│ 3 │
└────────────────────────┘
┌─rowNumberInAllBlocks()─┐
│ 6 │
│ 7 │
└────────────────────────┘
┌─rowNumberInAllBlocks()─┐
│ 8 │
│ 9 │
└────────────────────────┘
```
## rowNumberInBlock
Introduzido em: v1.1.0
Para cada [block](/pt-BR/resources/develop-contribute/introduction/architecture#block) processado por `rowNumberInBlock`, retorna o número da linha atual.
O número retornado começa em 0 para cada [block](/pt-BR/resources/develop-contribute/introduction/architecture#block).
**Sintaxe**
```sql theme={null}
rowNumberInBlock()
```
**Argumentos**
* Nenhum.
**Valor retornado**
Retorna o número ordinal da linha no bloco de dados, a partir de `0`. [`UInt64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT rowNumberInBlock()
FROM
(
SELECT *
FROM system.numbers_mt
LIMIT 10
) SETTINGS max_block_size = 2
```
```response title=Response theme={null}
┌─rowNumberInBlock()─┐
│ 0 │
│ 1 │
└────────────────────┘
┌─rowNumberInBlock()─┐
│ 0 │
│ 1 │
└────────────────────┘
┌─rowNumberInBlock()─┐
│ 0 │
│ 1 │
└────────────────────┘
┌─rowNumberInBlock()─┐
│ 0 │
│ 1 │
└────────────────────┘
┌─rowNumberInBlock()─┐
│ 0 │
│ 1 │
└────────────────────┘
```
## runningAccumulate
Introduzido em: v1.1.0
Acumula os estados de uma função de agregação para cada linha de um bloco de dados.
**Descontinuado**
O estado é redefinido a cada novo bloco de dados.
Devido a esse comportamento propenso a erros, a função foi descontinuada, e recomenda-se usar [funções de janela](/pt-BR/reference/functions/window-functions) em vez dela.
Você pode usar a configuração [`allow_deprecated_error_prone_window_functions`](/pt-BR/reference/settings/session-settings#allow_deprecated_error_prone_window_functions) para permitir o uso desta função.
**Sintaxe**
```sql theme={null}
runningAccumulate(agg_state[, grouping])
```
**Argumentos**
* `agg_state` — Estado da função de agregação. [`AggregateFunction`](/pt-BR/reference/data-types/aggregatefunction)
* `grouping` — Opcional. Chave de agrupamento. O estado da função é redefinido se o valor de `grouping` for alterado. Pode ser qualquer um dos tipos de dados suportados para os quais o operador de igualdade esteja definido. [`Any`](/pt-BR/reference/data-types)
**Valor retornado**
Retorna o resultado acumulado para cada linha. [`Any`](/pt-BR/reference/data-types)
**Exemplos**
**Exemplo de uso com initializeAggregation**
```sql title=Query theme={null}
WITH initializeAggregation('sumState', number) AS one_row_sum_state
SELECT
number,
finalizeAggregation(one_row_sum_state) AS one_row_sum,
runningAccumulate(one_row_sum_state) AS cumulative_sum
FROM numbers(5);
```
```response title=Response theme={null}
┌─number─┬─one_row_sum─┬─cumulative_sum─┐
│ 0 │ 0 │ 0 │
│ 1 │ 1 │ 1 │
│ 2 │ 2 │ 3 │
│ 3 │ 3 │ 6 │
│ 4 │ 4 │ 10 │
└────────┴─────────────┴────────────────┘
```
## runningConcurrency
Introduzido em: v21.3.0
Calcula o número de eventos concorrentes.
Cada evento tem um horário de início e um horário de término.
O horário de início é incluído no evento, enquanto o horário de término é excluído.
As colunas com horário de início e horário de término devem ser do mesmo tipo de dado.
A função calcula o número total de eventos ativos (concorrentes) para cada horário de início do evento.
**Requisitos**
Os eventos devem ser ordenados pelo horário de início em ordem crescente.
Se esse requisito for violado, a função gera uma exceção.
Cada bloco de dados é processado separadamente.
Se eventos de blocos de dados diferentes se sobrepuserem, eles não poderão ser processados corretamente.
**Descontinuado**
É recomendável usar [funções de janela](/pt-BR/reference/functions/window-functions).
**Sintaxe**
```sql theme={null}
runningConcurrency(start, end)
```
**Argumentos**
* `start` — Uma coluna com o horário de início dos eventos. [`Date`](/pt-BR/reference/data-types/date) ou [`DateTime`](/pt-BR/reference/data-types/datetime) ou [`DateTime64`](/pt-BR/reference/data-types/datetime64)
* `end` — Uma coluna com o horário de término dos eventos. [`Date`](/pt-BR/reference/data-types/date) ou [`DateTime`](/pt-BR/reference/data-types/datetime) ou [`DateTime64`](/pt-BR/reference/data-types/datetime64)
**Valor retornado**
Retorna o número de eventos simultâneos em cada horário de início dos eventos. [`UInt32`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT start, runningConcurrency(start, end) FROM example_table;
```
```response title=Response theme={null}
┌──────start─┬─runningConcurrency(start, end)─┐
│ 2025-03-03 │ 1 │
│ 2025-03-06 │ 2 │
│ 2025-03-07 │ 3 │
│ 2025-03-11 │ 2 │
└────────────┴────────────────────────────────┘
```
## runningDifference
Introduzido em: v1.1.0
Calcula a diferença entre os valores de duas linhas consecutivas no bloco de dados.
Retorna `0` para a primeira linha e, para as linhas subsequentes, a diferença em relação à linha anterior.
**Descontinuado**
Retorna diferenças apenas dentro do bloco de dados que está sendo processado no momento.
Por causa desse comportamento propenso a erros, a função está descontinuada.
Recomenda-se usar [funções de janela](/pt-BR/reference/functions/window-functions) em vez dela.
Você pode usar a configuração [`allow_deprecated_error_prone_window_functions`](/pt-BR/reference/settings/session-settings#allow_deprecated_error_prone_window_functions) para permitir o uso desta função.
O resultado da função depende dos blocos de dados envolvidos e da ordem dos dados no bloco.
A ordem das linhas durante o cálculo de `runningDifference()` pode ser diferente da ordem das linhas retornadas ao usuário.
Para evitar isso, você pode criar uma subconsulta com [`ORDER BY`](/pt-BR/reference/statements/select/order-by) e chamar a função fora da subconsulta.
Observe que o tamanho do bloco afeta o resultado.
O estado interno de `runningDifference` é reiniciado a cada novo bloco.
**Sintaxe**
```sql theme={null}
runningDifference(x)
```
**Argumentos**
* `x` — Coluna para a qual calcular a diferença entre valores consecutivos. [`Any`](/pt-BR/reference/data-types)
**Valor retornado**
Retorna a diferença entre valores consecutivos, com 0 para a primeira linha.
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
EventID,
EventTime,
runningDifference(EventTime) AS delta
FROM
(
SELECT
EventID,
EventTime
FROM events
WHERE EventDate = '2025-11-24'
ORDER BY EventTime ASC
LIMIT 5
);
```
```response title=Response theme={null}
┌─EventID─┬───────────EventTime─┬─delta─┐
│ 1106 │ 2025-11-24 00:00:04 │ 0 │
│ 1107 │ 2025-11-24 00:00:05 │ 1 │
│ 1108 │ 2025-11-24 00:00:05 │ 0 │
│ 1109 │ 2025-11-24 00:00:09 │ 4 │
│ 1110 │ 2025-11-24 00:00:10 │ 1 │
└─────────┴─────────────────────┴───────┘
```
**Exemplo do impacto do tamanho do bloco**
```sql title=Query theme={null}
SELECT
number,
runningDifference(number + 1) AS diff
FROM numbers(100000)
WHERE diff != 1;
```
```response title=Response theme={null}
┌─number─┬─diff─┐
│ 0 │ 0 │
└────────┴──────┘
┌─number─┬─diff─┐
│ 65536 │ 0 │
└────────┴──────┘
```
## runningDifferenceStartingWithFirstValue
Introduzido em: v1.1.0
Calcula a diferença entre os valores de linhas consecutivas em um bloco de dados, mas, ao contrário de [`runningDifference`](#runningDifference), retorna o valor real da primeira linha em vez de `0`.
**Descontinuado**
Retorna diferenças apenas dentro do bloco de dados que está sendo processado no momento.
Devido a esse comportamento sujeito a erros, a função foi descontinuada.
Recomenda-se usar [funções de janela](/pt-BR/reference/functions/window-functions) em vez disso.
Você pode usar a configuração `allow_deprecated_error_prone_window_functions` para permitir o uso desta função.
**Sintaxe**
```sql theme={null}
runningDifferenceStartingWithFirstValue(x)
```
**Argumentos**
* `x` — Coluna para a qual calcular a diferença acumulada. [`Any`](/pt-BR/reference/data-types)
**Valor retornado**
Retorna a diferença entre valores consecutivos, sendo que, para a primeira linha, retorna o valor da própria primeira linha. [`Any`](/pt-BR/reference/data-types)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
number,
runningDifferenceStartingWithFirstValue(number) AS diff
FROM numbers(5);
```
```response title=Response theme={null}
┌─number─┬─diff─┐
│ 0 │ 0 │
│ 1 │ 1 │
│ 2 │ 1 │
│ 3 │ 1 │
│ 4 │ 1 │
└────────┴──────┘
```
## serverUUID
Introduzido em: v20.1.0
Retorna o UUID (v4) aleatório e exclusivo gerado quando o servidor é iniciado pela primeira vez.
O UUID é persistido, ou seja, a segunda, a terceira etc. inicialização do servidor retorna o mesmo UUID.
**Sintaxe**
```sql theme={null}
serverUUID()
```
**Argumentos**
* Nenhum.
**Valor retornado**
Retorna o UUID aleatório do servidor. [`UUID`](/pt-BR/reference/data-types/uuid)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT serverUUID();
```
```response title=Response theme={null}
┌─serverUUID()─────────────────────────────┐
│ 7ccc9260-000d-4d5c-a843-5459abaabb5f │
└──────────────────────────────────────────┘
```
## shardCount
Introduzido em: v21.9.0
Retorna o número total de shards de uma consulta distribuída.
Se uma consulta não for distribuída, retorna o valor constante `0`.
**Sintaxe**
```sql theme={null}
shardCount()
```
**Argumentos**
* Nenhum.
**Valor retornado**
Retorna o número total de shards ou `0`. [`UInt32`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
-- Veja o exemplo de shardNum() acima, que também ilustra shardCount()
CREATE TABLE shard_count_example (dummy UInt8)
ENGINE=Distributed(test_cluster_two_shards_localhost, system, one, dummy);
SELECT shardCount() FROM shard_count_example;
```
```response title=Response theme={null}
┌─shardCount()─┐
│ 2 │
│ 2 │
└──────────────┘
```
## shardNum
Introduzido em: v21.9.0
Retorna o índice do shard que processa parte dos dados em uma consulta distribuída.
Os índices começam em `1`.
Se uma consulta não for distribuída, será retornado o valor constante `0`.
**Sintaxe**
```sql theme={null}
shardNum()
```
**Argumentos**
* Nenhum.
**Valor retornado**
Retorna o índice do shard ou uma constante `0`. [`UInt32`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
CREATE TABLE shard_num_example (dummy UInt8)
ENGINE=Distributed(test_cluster_two_shards_localhost, system, one, dummy);
SELECT dummy, shardNum(), shardCount() FROM shard_num_example;
```
```response title=Response theme={null}
┌─dummy─┬─shardNum()─┬─shardCount()─┐
│ 0 │ 1 │ 2 │
│ 0 │ 2 │ 2 │
└───────┴────────────┴──────────────┘
```
## showCertificate
Introduzido em: v22.6.0
Exibe informações sobre o certificado Secure Sockets Layer (SSL) atual do servidor, se ele estiver configurado.
Consulte [Configurando TLS](/pt-BR/concepts/features/security/tls/configuring-tls) para mais informações sobre como configurar o ClickHouse para usar certificados OpenSSL para validar conexões.
**Sintaxe**
```sql theme={null}
showCertificate()
```
**Argumentos**
* Nenhum.
**Valor retornado**
Retorna um map de pares chave-valor referentes ao certificado SSL configurado. [`Map(String, String)`](/pt-BR/reference/data-types/map)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT showCertificate() FORMAT LineAsString;
```
```response title=Response theme={null}
{'version':'1','serial_number':'2D9071D64530052D48308473922C7ADAFA85D6C5','signature_algo':'sha256WithRSAEncryption','issuer':'/CN=marsnet.local CA','not_before':'May 7 17:01:21 2024 GMT','not_after':'May 7 17:01:21 2025 GMT','subject':'/CN=chnode1','pkey_algo':'rsaEncryption'}
```
## sleep
Introduzido em: v1.1.0
Pausa a execução de uma consulta pelo número especificado de segundos.
A função é usada principalmente para fins de teste e depuração.
Em geral, a função `sleep()` não deve ser usada em ambientes de produção, pois pode afetar negativamente o desempenho das consultas e a capacidade de resposta do sistema.
No entanto, ela pode ser útil nos seguintes cenários:
1. **Teste**: Ao testar ou fazer benchmarking do ClickHouse, talvez você queira simular atrasos ou introduzir pausas para observar como o sistema se comporta em determinadas condições.
2. **Depuração**: Se você precisar examinar o estado do sistema ou a execução de uma consulta em um momento específico, poderá usar `sleep()` para introduzir uma pausa, permitindo inspecionar ou coletar informações relevantes.
3. **Simulação**: Em alguns casos, talvez você queira simular cenários do mundo real em que ocorram atrasos ou pausas, como latência de rede ou dependências de sistemas externos.
É importante usar a função `sleep()` com critério e somente quando necessário, pois ela pode afetar o desempenho geral e a capacidade de resposta do seu sistema ClickHouse.
Por motivos de segurança, a função só pode ser executada no perfil do usuário `default` (com `allow_sleep` habilitado).
**Sintaxe**
```sql theme={null}
sleep(seconds)
```
**Argumentos**
* `seconds` — O número de segundos para pausar a execução da consulta, com um máximo de 3 segundos. Pode ser um valor de ponto flutuante para especificar frações de segundo. [`const UInt*`](/pt-BR/reference/data-types/int-uint) ou [`const Float*`](/pt-BR/reference/data-types/float)
**Valor retornado**
Retorna `0`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
-- Esta consulta fará uma pausa de 2 segundos antes de ser concluída.
-- Durante esse tempo, nenhum resultado será retornado, e a consulta parecerá travada ou sem resposta.
SELECT sleep(2);
```
```response title=Response theme={null}
┌─sleep(2)─┐
│ 0 │
└──────────┘
1 row in set. Elapsed: 2.012 sec.
```
## sleepEachRow
Introduzido em: v1.1.0
Pausa a execução de uma consulta por um número específico de segundos para cada linha no conjunto de resultados.
A função `sleepEachRow()` é usada principalmente para testes e depuração, de forma semelhante à função [`sleep()`](#sleep).
Ela permite simular atrasos ou inserir pausas no processamento de cada linha, o que pode ser útil em cenários como:
1. **Testes**: Ao testar ou fazer benchmarking do desempenho do ClickHouse em condições específicas, você pode usar `sleepEachRow()` para simular atrasos ou inserir pausas em cada linha processada.
2. **Depuração**: Se você precisar examinar o estado do sistema ou a execução de uma consulta para cada linha processada, poderá usar `sleepEachRow()` para inserir pausas, permitindo inspecionar ou coletar informações relevantes.
3. **Simulação**: Em alguns casos, você pode querer simular cenários reais em que ocorram atrasos ou pausas para cada linha processada, como ao lidar com sistemas externos ou latência de rede.
Assim como a função `sleep()`, é importante usar `sleepEachRow()` com critério e somente quando necessário, pois ela pode afetar significativamente o desempenho geral e a capacidade de resposta do seu sistema ClickHouse, especialmente ao lidar com grandes conjuntos de resultados.
**Sintaxe**
```sql theme={null}
sleepEachRow(seconds)
```
**Argumentos**
* `seconds` — O número de segundos para pausar a execução da consulta para cada linha do conjunto de resultados, com um máximo de 3 segundos. Pode ser um valor de ponto flutuante para especificar frações de segundo. [`const UInt*`](/pt-BR/reference/data-types/int-uint) ou [`const Float*`](/pt-BR/reference/data-types/float)
**Valor retornado**
Retorna `0` para cada linha. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
-- A saída terá um atraso, com uma pausa de 0,5 segundo entre cada linha.
SELECT number, sleepEachRow(0.5) FROM system.numbers LIMIT 5;
```
```response title=Response theme={null}
┌─number─┬─sleepEachRow(0.5)─┐
│ 0 │ 0 │
│ 1 │ 0 │
│ 2 │ 0 │
│ 3 │ 0 │
│ 4 │ 0 │
└────────┴───────────────────┘
```
## structureToCapnProtoSchema
Introduzido em: v23.8.0
Função que converte a estrutura de uma tabela do ClickHouse para um schema no formato CapnProto
**Sintaxe**
```sql theme={null}
structureToCapnProtoSchema(table_structure, message)
```
**Argumentos**
* Nenhum.
**Valor retornado**
**Exemplos**
**random**
```sql title=Query theme={null}
SELECT structureToCapnProtoSchema('s String, x UInt32', 'MessageName') format TSVRaw
```
```response title=Response theme={null}
struct MessageName
{
s @0 : Data;
x @1 : UInt32;
}
```
## structureToProtobufSchema
Introduzido em: v23.8.0
Converte a estrutura de uma tabela do ClickHouse em um schema no formato Protobuf.
Esta função recebe a definição da estrutura de uma tabela do ClickHouse e a converte em uma
definição de schema em Protocol Buffers (Protobuf) na sintaxe proto3. Isso é útil para gerar
schemas Protobuf que correspondam às estruturas das suas tabelas do ClickHouse para intercâmbio de dados.
**Sintaxe**
```sql theme={null}
structureToProtobufSchema(structure, message_name)
```
**Argumentos**
* `structure` — Definição da estrutura da tabela do ClickHouse como uma string (por exemplo, 'column1 Type1, column2 Type2'). [`String`](/pt-BR/reference/data-types/string)
* `message_name` — Nome do tipo de mensagem Protobuf no schema gerado. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna uma definição de schema Protobuf na sintaxe proto3 que corresponde à estrutura de entrada do ClickHouse. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Conversão da estrutura do ClickHouse para schema Protobuf**
```sql title=Query theme={null}
SELECT structureToProtobufSchema('s String, x UInt32', 'MessageName') FORMAT TSVRaw;
```
```response title=Response theme={null}
syntax = "proto3";
message MessageName
{
bytes s = 1;
uint32 x = 2;
}
```
## tcpPort
Introduzido em: v20.12.0
Retorna o número da porta TCP da [interface nativa](/pt-BR/concepts/features/interfaces/tcp) em que o servidor escuta.
Se executada no contexto de uma tabela distribuída, esta função gera uma coluna comum com valores relevantes para cada shard.
Caso contrário, gera um valor constante.
**Sintaxe**
```sql theme={null}
tcpPort()
```
**Argumentos**
* Nenhum.
**Valor retornado**
Retorna o número da porta TCP. [`UInt16`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT tcpPort()
```
```response title=Response theme={null}
┌─tcpPort()─┐
│ 9000 │
└───────────┘
```
## throwIf
Introduzido em: v1.1.0
Lança uma exceção se o argumento x for true.
Para usar o argumento `error_code`, o parâmetro de configuração `allow_custom_error_code_in_throw` deve estar habilitado.
**Sintaxe**
```sql theme={null}
throwIf(x[, message[, error_code]])
```
**Argumentos**
* `x` — Condição a ser verificada. [`Any`](/pt-BR/reference/data-types)
* `message` — Opcional. Mensagem de erro personalizada. [`const String`](/pt-BR/reference/data-types/string)
* `error_code` — Opcional. Código de erro personalizado. [`const Int8/16/32`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna `0` se a condição for `false` e lança uma exceção se a condição for `true`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT throwIf(number = 3, 'Too many') FROM numbers(10);
```
```response title=Response theme={null}
↙ Progress: 0.00 linhas, 0.00 B (0.00 linhas/s., 0.00 B/s.) Exceção recebida do servidor (versão 19.14.1):
Código: 395. DB::Exception: Recebido de localhost:9000. DB::Exception: Too many.
```
## toColumnTypeName
Introduzido em: v1.1.0
Retorna o nome interno do tipo de dados do valor fornecido.
Diferentemente da função [`toTypeName`](#toTypeName), o tipo de dados retornado pode incluir colunas internas de encapsulamento, como `Const` e `LowCardinality`.
**Sintaxe**
```sql theme={null}
toColumnTypeName(value)
```
**Argumentos**
* `value` — Valor cujo tipo de dado interno deve ser retornado. [`Any`](/pt-BR/reference/data-types)
**Valor retornado**
Retorna o tipo de dado interno usado para representar o valor. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT toColumnTypeName(CAST('2025-01-01 01:02:03' AS DateTime));
```
```response title=Response theme={null}
┌─toColumnTypeName(CAST('2025-01-01 01:02:03', 'DateTime'))─┐
│ Const(UInt32) │
└───────────────────────────────────────────────────────────┘
```
## toTypeName
Introduzido em: v1.1.0
Retorna o nome do tipo do argumento informado.
Se `NULL` for informado, a função retorna o tipo `Nullable(Nothing)`, que corresponde à representação interna de `NULL` no ClickHouse.
**Sintaxe**
```sql theme={null}
toTypeName(x)
```
**Argumentos**
* `x` — Um valor de tipo arbitrário. [`Any`](/pt-BR/reference/data-types)
**Valor retornado**
Retorna o nome do tipo de dado do valor fornecido. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT toTypeName(123)
```
```response title=Response theme={null}
┌─toTypeName(123)─┐
│ UInt8 │
└─────────────────┘
```
## tokenizeQuery
Introduzido em: v26.5.0
Tokeniza uma string de consulta em ClickHouse SQL e retorna um array de tokens.
Cada token é uma tupla nomeada com a posição inicial (em bytes), a posição final e o tipo do token.
**Sintaxe**
```sql theme={null}
tokenizeQuery(query)
```
**Argumentos**
* `query` — Uma string de consulta em ClickHouse SQL. String.
**Valor retornado**
Um array de tuplas nomeadas `(begin UInt64, end UInt64, type Enum8(...))` representando os tokens da consulta. [`Array(Tuple(begin UInt64, end UInt64, type Enum8(...)))`](/pt-BR/reference/data-types/array)
**Exemplos**
**simples**
```sql title=Query theme={null}
SELECT tokenizeQuery('SELECT 1')
```
```response title=Response theme={null}
[(0,6,'BareWord'),(6,7,'Whitespace'),(7,8,'Number')]
```
## transactionID
Introduzido em: v22.6.0
Retorna o ID de uma transação.
Esta função faz parte de um conjunto de funcionalidades experimentais.
Ative o suporte experimental a transações adicionando esta configuração aos seus [arquivos de configuração](/pt-BR/concepts/features/configuration/server-config/configuration-files):
```xml theme={null}
1
```
Para mais informações, consulte a página [Suporte transacional (ACID)](/pt-BR/concepts/features/operations/insert/transactions#transactions-commit-and-rollback).
**Sintaxe**
```sql theme={null}
transactionID()
```
**Argumentos**
* Nenhum.
**Valor retornado**
Retorna uma tupla composta por `start_csn`, `local_tid` e `host_id`.
* `start_csn`: Número sequencial global; o timestamp de commit mais recente observado quando esta transação foi iniciada.
* `local_tid`: Número sequencial local, exclusivo para cada transação iniciada por este host dentro de um `start_csn` específico.
* `host_id`: UUID do host que iniciou esta transação.
[`Tuple(UInt64, UInt64, UUID)`](/pt-BR/reference/data-types/tuple)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
BEGIN TRANSACTION;
SELECT transactionID();
ROLLBACK;
```
```response title=Response theme={null}
┌─transactionID()────────────────────────────────┐
│ (32,34,'0ee8b069-f2bb-4748-9eae-069c85b5252b') │
└────────────────────────────────────────────────┘
```
## transactionLatestSnapshot
Introduzido em: v22.6.0
Retorna o snapshot mais recente (Commit Sequence Number) de uma [transação](/pt-BR/concepts/features/operations/insert/transactions#transactions-commit-and-rollback) disponível para leitura.
Esta função faz parte de um conjunto de recursos experimentais. Ative o suporte experimental a transações adicionando esta configuração às suas configurações:
```xml theme={null}
1
```
Para mais informações, consulte a página [Suporte transacional (ACID)](/pt-BR/concepts/features/operations/insert/transactions#transactions-commit-and-rollback).
**Sintaxe**
```sql theme={null}
transactionLatestSnapshot()
```
**Argumentos**
* Nenhum.
**Valor retornado**
Retorna o snapshot (CSN) mais recente da transação. [`UInt64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
BEGIN TRANSACTION;
SELECT transactionLatestSnapshot();
ROLLBACK;
```
```response title=Response theme={null}
┌─transactionLatestSnapshot()─┐
│ 32 │
└─────────────────────────────┘
```
## transactionOldestSnapshot
Introduzido em: v22.6.0
Retorna o snapshot mais antigo (Commit Sequence Number) visível para alguma [transação](/pt-BR/concepts/features/operations/insert/transactions#transactions-commit-and-rollback) em execução.
Esta função faz parte de um conjunto de recursos experimentais. Ative o suporte experimental a transações adicionando esta opção à sua configuração:
```xml theme={null}
1
```
Para mais informações, consulte a página [suporte transacional (ACID)](/pt-BR/concepts/features/operations/insert/transactions#transactions-commit-and-rollback).
**Sintaxe**
```sql theme={null}
transactionOldestSnapshot()
```
**Argumentos**
* Nenhum.
**Valor retornado**
Retorna o snapshot (CSN) mais antigo de uma transação. [`UInt64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
BEGIN TRANSACTION;
SELECT transactionOldestSnapshot();
ROLLBACK;
```
```response title=Response theme={null}
┌─transactionOldestSnapshot()─┐
│ 32 │
└─────────────────────────────┘
```
## transform
Introduzido em: v1.1.0
Transforma um valor de acordo com um mapeamento explicitamente definido entre determinados elementos e outros elementos.
Há duas variações desta função:
* `transform(x, array_from, array_to, default)` - transforma `x` usando arrays de mapeamento, com um valor padrão para elementos sem correspondência
* `transform(x, array_from, array_to)` - faz a mesma transformação, mas retorna o `x` original se nenhuma correspondência for encontrada
A função procura `x` em `array_from` e retorna o elemento correspondente de `array_to` no mesmo índice.
Se `x` não for encontrado em `array_from`, ela retorna o valor `default` (versão com 4 parâmetros) ou o `x` original (versão com 3 parâmetros).
Se houver vários elementos correspondentes em `array_from`, ela retorna o elemento correspondente à primeira correspondência.
Requisitos:
* `array_from` e `array_to` devem ter o mesmo número de elementos
* Para a versão com 4 parâmetros: `transform(T, Array(T), Array(U), U) -> U`, em que `T` e `U` podem ser tipos compatíveis diferentes
* Para a versão com 3 parâmetros: `transform(T, Array(T), Array(T)) -> T`, em que todos os tipos devem ser iguais
**Sintaxe**
```sql theme={null}
transform(x, array_from, array_to[, default])
```
**Argumentos**
* `x` — Valor a ser transformado. [`(U)Int*`](/pt-BR/reference/data-types/int-uint) or [`Decimal`](/pt-BR/reference/data-types/decimal) or [`Float*`](/pt-BR/reference/data-types/float) or [`String`](/pt-BR/reference/data-types/string) or [`Date`](/pt-BR/reference/data-types/date) or [`DateTime`](/pt-BR/reference/data-types/datetime)
* `array_from` — Array constante de valores para buscar correspondências. [`Array((U)Int*)`](/pt-BR/reference/data-types/array) or [`Array(Decimal)`](/pt-BR/reference/data-types/array) or [`Array(Float*)`](/pt-BR/reference/data-types/array) or [`Array(String)`](/pt-BR/reference/data-types/array) or [`Array(Date)`](/pt-BR/reference/data-types/array) or [`Array(DateTime)`](/pt-BR/reference/data-types/array)
* `array_to` — Array constante de valores a serem retornados para as correspondências encontradas em `array_from`. [`Array((U)Int*)`](/pt-BR/reference/data-types/array) or [`Array(Decimal)`](/pt-BR/reference/data-types/array) or [`Array(Float*)`](/pt-BR/reference/data-types/array) or [`Array(String)`](/pt-BR/reference/data-types/array) or [`Array(Date)`](/pt-BR/reference/data-types/array) or [`Array(DateTime)`](/pt-BR/reference/data-types/array)
* `default` — Opcional. Valor a ser retornado se `x` não for encontrado em `array_from`. Se omitido, retorna `x` sem alterações. [`(U)Int*`](/pt-BR/reference/data-types/int-uint) or [`Decimal`](/pt-BR/reference/data-types/decimal) or [`Float*`](/pt-BR/reference/data-types/float) or [`String`](/pt-BR/reference/data-types/string) or [`Date`](/pt-BR/reference/data-types/date) or [`DateTime`](/pt-BR/reference/data-types/datetime)
**Valor retornado**
Retorna o valor correspondente de `array_to` se x corresponder a um elemento de `array_from`; caso contrário, retorna default (se fornecido) ou x (se default não for fornecido). [`Any`](/pt-BR/reference/data-types)
**Exemplos**
**transform(T, Array(T), Array(U), U) -> U**
```sql title=Query theme={null}
SELECT
transform(SearchEngineID, [2, 3], ['Yandex', 'Google'], 'Other') AS title,
count() AS c
FROM test.hits
WHERE SearchEngineID != 0
GROUP BY title
ORDER BY c DESC
```
```response title=Response theme={null}
┌─title─────┬──────c─┐
│ Yandex │ 498635 │
│ Google │ 229872 │
│ Other │ 104472 │
└───────────┴────────┘
```
**transform(T, Array(T), Array(T)) -> T**
```sql title=Query theme={null}
SELECT
transform(domain(Referer), ['yandex.ru', 'google.ru', 'vkontakte.ru'], ['www.yandex', 'example.com', 'vk.com']) AS s, count() AS c
FROM test.hits
GROUP BY domain(Referer)
ORDER BY count() DESC
LIMIT 10
```
```response title=Response theme={null}
┌─s──────────────┬───────c─┐
│ │ 2906259 │
│ www.yandex │ 867767 │
│ ███████.ru │ 313599 │
│ mail.yandex.ru │ 107147 │
│ ██████.ru │ 100355 │
│ █████████.ru │ 65040 │
│ news.yandex.ru │ 64515 │
│ ██████.net │ 59141 │
│ example.com │ 57316 │
└────────────────┴─────────┘
```
## uniqThetaIntersect
Introduzido em: v22.9.0
Dois objetos `uniqThetaSketch` são usados para calcular a interseção (operação de conjunto ∩); o resultado é um novo `uniqThetaSketch`.
**Sintaxe**
```sql theme={null}
uniqThetaIntersect(uniqThetaSketch,uniqThetaSketch)
```
**Argumentos**
* `uniqThetaSketch` — objeto uniqThetaSketch. [`Tuple`](/pt-BR/reference/data-types/tuple) ou [`Array`](/pt-BR/reference/data-types/array) ou [`Date`](/pt-BR/reference/data-types/date) ou [`DateTime`](/pt-BR/reference/data-types/datetime) ou [`String`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`Decimal`](/pt-BR/reference/data-types/decimal)
**Valor retornado**
Um novo uniqThetaSketch contendo o resultado da interseção. [`UInt64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT finalizeAggregation(uniqThetaIntersect(a, b)) AS a_intersect_b, finalizeAggregation(a) AS a_cardinality, finalizeAggregation(b) AS b_cardinality
FROM
(SELECT arrayReduce('uniqThetaState', [1, 2]) AS a, arrayReduce('uniqThetaState', [2, 3, 4]) AS b);
```
```response title=Response theme={null}
┌─a_intersect_b─┬─a_cardinality─┬─b_cardinality─┐
│ 1 │ 2 │ 3 │
└───────────────┴───────────────┴───────────────┘
```
## uniqThetaNot
Introduzido em: v22.9.0
Dois objetos `uniqThetaSketch` para realizar o cálculo a\_not\_b (operação de conjunto ×); o resultado é um novo `uniqThetaSketch`.
**Sintaxe**
```sql theme={null}
uniqThetaNot(uniqThetaSketch,uniqThetaSketch)
```
**Argumentos**
* `uniqThetaSketch` — objeto do tipo uniqThetaSketch. [`Tuple`](/pt-BR/reference/data-types/tuple) ou [`Array`](/pt-BR/reference/data-types/array) ou [`Date`](/pt-BR/reference/data-types/date) ou [`DateTime`](/pt-BR/reference/data-types/datetime) ou [`String`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`Decimal`](/pt-BR/reference/data-types/decimal)
**Valor retornado**
Retorna um novo uniqThetaSketch contendo o resultado de a\_not\_b. [`UInt64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT finalizeAggregation(uniqThetaNot(a, b)) AS a_not_b, finalizeAggregation(a) AS a_cardinality, finalizeAggregation(b) AS b_cardinality
FROM
(SELECT arrayReduce('uniqThetaState', [2, 3, 4]) AS a, arrayReduce('uniqThetaState', [1, 2]) AS b);
```
```response title=Response theme={null}
┌─a_not_b─┬─a_cardinality─┬─b_cardinality─┐
│ 2 │ 3 │ 2 │
└─────────┴───────────────┴───────────────┘
```
## uniqThetaUnion
Introduzido em: v22.9.0
Usa dois objetos `uniqThetaSketch` para calcular a união (operação de conjunto ∪); o resultado é um novo `uniqThetaSketch`.
**Sintaxe**
```sql theme={null}
uniqThetaUnion(uniqThetaSketch,uniqThetaSketch)
```
**Argumentos**
* `uniqThetaSketch` — objeto uniqThetaSketch. [`Tuple`](/pt-BR/reference/data-types/tuple) ou [`Array`](/pt-BR/reference/data-types/array) ou [`Date`](/pt-BR/reference/data-types/date) ou [`DateTime`](/pt-BR/reference/data-types/datetime) ou [`String`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`Decimal`](/pt-BR/reference/data-types/decimal)
**Valor retornado**
Retorna um novo uniqThetaSketch com o resultado da união. [`UInt64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT finalizeAggregation(uniqThetaUnion(a, b)) AS a_union_b, finalizeAggregation(a) AS a_cardinality, finalizeAggregation(b) AS b_cardinality
FROM
(SELECT arrayReduce('uniqThetaState', [1, 2]) AS a, arrayReduce('uniqThetaState', [2, 3, 4]) AS b);
```
```response title=Response theme={null}
┌─a_union_b─┬─a_cardinality─┬─b_cardinality─┐
│ 4 │ 2 │ 3 │
└───────────┴───────────────┴───────────────┘
```
## uptime
Introduzido em: v1.1.0
Retorna o uptime do servidor em segundos.
Se for executada no contexto de uma tabela distribuída, essa função gera uma coluna comum com valores correspondentes a cada shard.
Caso contrário, produz um valor constante.
**Sintaxe**
```sql theme={null}
uptime()
```
**Argumentos**
* Nenhum.
**Valor retornado**
Retorna o uptime do servidor em segundos. [`UInt32`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT uptime() AS Uptime
```
```response title=Response theme={null}
┌─Uptime─┐
│ 55867 │
└────────┘
```
## variantElement
Introduzido em: v25.2.0
Extrai, de uma coluna `Variant`, uma coluna do tipo especificado.
**Sintaxe**
```sql theme={null}
variantElement(variant, type_name[, default_value])
```
**Argumentos**
* `variant` — Coluna Variant. [`Variant`](/pt-BR/reference/data-types/variant)
* `type_name` — O nome do tipo de variante a ser extraído. [`String`](/pt-BR/reference/data-types/string)
* `default_value` — O valor padrão que será usado se `variant` não tiver uma variante do tipo especificado. Pode ser de qualquer tipo. Opcional. [`Any`](/pt-BR/reference/data-types)
**Valor retornado**
Retorna uma coluna com o tipo de variante especificado extraído da coluna Variant. [`Any`](/pt-BR/reference/data-types)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
CREATE TABLE test (v Variant(UInt64, String, Array(UInt64))) ENGINE = Memory;
INSERT INTO test VALUES (NULL), (42), ('Hello, World!'), ([1, 2, 3]);
SELECT v, variantElement(v, 'String'), variantElement(v, 'UInt64'), variantElement(v, 'Array(UInt64)') FROM test;
```
```response title=Response theme={null}
┌─v─────────────┬─variantElement(v, 'String')─┬─variantElement(v, 'UInt64')─┬─variantElement(v, 'Array(UInt64)')─┐
│ ᴺᵁᴸᴸ │ ᴺᵁᴸᴸ │ ᴺᵁᴸᴸ │ [] │
│ 42 │ ᴺᵁᴸᴸ │ 42 │ [] │
│ Hello, World! │ Hello, World! │ ᴺᵁᴸᴸ │ [] │
│ [1,2,3] │ ᴺᵁᴸᴸ │ ᴺᵁᴸᴸ │ [1,2,3] │
└───────────────┴─────────────────────────────┴─────────────────────────────┴────────────────────────────────────┘
```
## variantType
Introduzido em: v24.2.0
Retorna o nome do tipo de variante de cada linha da coluna `Variant`. Se a linha contiver NULL, retorna 'None'.
**Sintaxe**
```sql theme={null}
variantType(variant)
```
**Argumentos**
* `variant` — coluna Variant. [`Variant`](/pt-BR/reference/data-types/variant)
**Valor retornado**
Retorna uma coluna Enum com o nome do tipo da variante para cada linha. [`Enum`](/pt-BR/reference/data-types/enum)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
CREATE TABLE test (v Variant(UInt64, String, Array(UInt64))) ENGINE = Memory;
INSERT INTO test VALUES (NULL), (42), ('Hello, World!'), ([1, 2, 3]);
SELECT variantType(v) FROM test;
```
```response title=Response theme={null}
┌─variantType(v)─┐
│ None │
│ UInt64 │
│ String │
│ Array(UInt64) │
└────────────────┘
```
## version
Introduzido na versão: v1.1.0
Retorna a versão atual do ClickHouse como uma string no formato: `major_version.minor_version.patch_version.number_of_commits_since_the_previous_stable_release`.
Se for executada no contexto de uma tabela distribuída, esta função gera uma coluna comum com valores específicos de cada shard.
Caso contrário, produz um valor constante.
**Sintaxe**
```sql theme={null}
version()
```
**Argumentos**
* Nenhum.
**Valor retornado**
Retorna a versão atual do ClickHouse. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT version()
```
```response title=Response theme={null}
┌─version()─┐
│ 24.2.1.1 │
└───────────┘
```
## visibleWidth
Introduzido em: v1.1.0
Calcula a largura aproximada ao gerar valores no console em formato de texto (separado por tabulação).
Esta função é usada pelo sistema para implementar os formatos Pretty.
`NULL` é representado como uma string correspondente a `NULL` nos formatos Pretty.
**Sintaxe**
```sql theme={null}
visibleWidth(x)
```
**Argumentos**
* `x` — Um valor de qualquer tipo de dado. [`Any`](/pt-BR/reference/data-types)
**Valor retornado**
Retorna a largura aproximada do valor quando ele é exibido em formato de texto. [`UInt64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Calcular a largura visível de NULL**
```sql title=Query theme={null}
SELECT visibleWidth(NULL)
```
```response title=Response theme={null}
┌─visibleWidth(NULL)─┐
│ 4 │
└────────────────────┘
```
## zookeeperSessionUptime
Introduzido em: v21.11.0
Retorna o uptime da sessão atual do ZooKeeper, em segundos.
**Sintaxe**
```sql theme={null}
zookeeperSessionUptime()
```
**Argumentos**
* Nenhum.
**Valor retornado**
Retorna o uptime da sessão atual do ZooKeeper em segundos. [`UInt32`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT zookeeperSessionUptime();
```
```response title=Response theme={null}
┌─zookeeperSessionUptime()─┐
│ 286 │
└──────────────────────────┘
```