const)` antes da análise de índices, para que a chave primária por coluna e os skip indexes em cada `a_i` possam ser usados. Formas parcialmente constantes, como `coalesce(a, 42, b)` e `coalesce(a, b, 42)`, são tratadas: a lista de argumentos é normalizada como o próprio `coalesce` faz (literais `NULL` são descartados, e argumentos após o primeiro não-`Nullable` são descartados), e uma constante final não `NULL`, se houver, é incluída como o ramo final. A reescrita é estritamente aditiva para a poda de índices; a filtragem em tempo de execução ainda usa o predicado original.
## allow\_materialized\_view\_with\_bad\_select
Permite CREATE MATERIALIZED VIEW com uma consulta SELECT que referencie tabelas ou colunas inexistentes. Ela ainda precisa ser sintaticamente válida. Não se aplica a MVs atualizáveis. Não se aplica se o esquema da MV precisar ser inferido a partir da consulta SELECT (isto é, se o CREATE não tiver lista de colunas nem uma tabela TO). Pode ser usado para criar uma MV antes da tabela de origem.
## allow\_named\_collection\_override\_by\_default
Permite, por padrão, substituir os campos das coleções nomeadas.
## allow\_non\_metadata\_alters
Permite executar alters que afetam não apenas os metadados das tabelas, mas também os dados no disco
## allow\_nonconst\_timezone\_arguments
Permite argumentos de fuso horário não constantes em determinadas funções relacionadas a tempo, como toTimeZone(), fromUnixTimestamp\*() e snowflakeToDateTime\*().
Essa configuração existe apenas por motivos de compatibilidade. No ClickHouse, o fuso horário é uma propriedade do tipo de dado e, consequentemente, da coluna.
Ativar essa configuração dá a impressão equivocada de que valores diferentes dentro de uma coluna podem ter fusos horários distintos.
Portanto, não ative essa configuração.
## allow\_nondeterministic\_mutations
Configuração no nível do usuário que permite que mutações em tabelas replicadas usem funções não determinísticas, como `dictGet`.
Como, por exemplo, os dicionários podem ficar dessincronizados entre os nós, mutações que extraem valores deles não são permitidas por padrão em tabelas replicadas. Ativar essa configuração permite esse comportamento, mas passa a ser responsabilidade do usuário garantir que os dados usados estejam sincronizados em todos os nós.
**Exemplo**
```xml theme={null}
1
```
## allow\_nondeterministic\_optimize\_skip\_unused\_shards
Permite usar funções não determinísticas (como `rand` ou `dictGet`, já que esta última tem algumas ressalvas em relação a atualizações) na chave de sharding.
Valores possíveis:
* 0 — Não permitido.
* 1 — Permitido.
## allow\_nullable\_tuple\_in\_extracted\_subcolumns
Controla se subcolunas extraídas do tipo `Tuple(...)` podem ser tipadas como `Nullable(Tuple(...))`.
* `false`: Retorna `Tuple(...)` e usa valores padrão da tupla para linhas em que a subcoluna está ausente.
* `true`: Retorna `Nullable(Tuple(...))` e usa `NULL` para linhas em que a subcoluna está ausente.
Essa configuração controla apenas o comportamento das subcolunas extraídas.
Ela não controla se colunas `Nullable(Tuple(...))` podem ser criadas em tabelas; isso é controlado por `allow_experimental_nullable_tuple_type`.
O ClickHouse usa o valor dessa configuração carregado na inicialização do servidor.
Alterações feitas com `SET` ou `SETTINGS` no nível da consulta não alteram o comportamento das subcolunas extraídas.
Para alterar o comportamento das subcolunas extraídas, atualize `allow_nullable_tuple_in_extracted_subcolumns` na configuração do perfil de inicialização (por exemplo, em users.xml) e reinicie o servidor.
## allow\_prefetched\_read\_pool\_for\_local\_filesystem
Prefere o pool de threads de prefetch se todas as partes estiverem no sistema de arquivos local
## allow\_prefetched\_read\_pool\_for\_remote\_filesystem
Prefere o pool de threads de pré-busca se todas as partes estiverem em um sistema de arquivos remoto
## allow\_push\_predicate\_ast\_for\_distributed\_subqueries
Permite o push predicate no nível da AST para subconsultas distribuídas com o analisador habilitado
## allow\_push\_predicate\_when\_subquery\_contains\_with
Permite push predicate em subconsultas que contêm a cláusula WITH
## allow\_rank\_dense\_rank\_arguments
Permite passar argumentos para as funções de janela `RANK` e `DENSE_RANK` para fins de retrocompatibilidade.
De acordo com o padrão SQL, `RANK` e `DENSE_RANK` não recebem argumentos — elas classificam as linhas com base
apenas na janela `OVER (ORDER BY ...)`. Em versões do ClickHouse anteriores à 26.5, consultas como
`RANK(x) OVER (...)` aceitavam e ignoravam silenciosamente o argumento, o que gerava confusão para os usuários
(o argumento visível sugeria que influenciava a classificação, mas não influenciava).
Quando essa configuração é `false` (o padrão), `RANK` e `DENSE_RANK` rejeitam quaisquer argumentos e
lançam `NUMBER_OF_ARGUMENTS_DOESNT_MATCH`. Quando definida como `true`, o comportamento permissivo legado é
restaurado — os argumentos são ignorados silenciosamente, em linha com o comportamento anterior à 26.5.
## allow\_reorder\_prewhere\_conditions
Ao mover condições de WHERE para PREWHERE, permite reordená-las para otimizar a filtragem
## allow\_settings\_after\_format\_in\_insert
Controla se `SETTINGS` após `FORMAT` em consultas `INSERT` é permitido ou não. Não é recomendável usar isso, pois parte de `SETTINGS` pode ser interpretada como valores.
Exemplo:
```sql theme={null}
INSERT INTO FUNCTION null('foo String') SETTINGS max_threads=1 VALUES ('bar');
```
Mas a consulta a seguir só funcionará com `allow_settings_after_format_in_insert`:
```sql theme={null}
SET allow_settings_after_format_in_insert=1;
INSERT INTO FUNCTION null('foo String') VALUES ('bar') SETTINGS max_threads=1;
```
Valores possíveis:
* 0 — Não permitir.
* 1 — Permitir.
Use esta configuração apenas por compatibilidade com versões anteriores, se seus casos de uso dependerem da sintaxe antiga.
## allow\_simdjson
Permite o uso da biblioteca simdjson em funções 'JSON\*' se as instruções AVX2 estiverem disponíveis. Se desabilitada, a rapidjson será usada.
## allow\_special\_serialization\_kinds\_in\_output\_formats
Permite a saída de colunas com tipos especiais de serialização, como Sparse e Replicated, sem convertê-las para a representação completa da coluna.
Isso ajuda a evitar cópias desnecessárias de dados durante a formatação.
## allow\_statistics
**Aliases**: `allow_experimental_statistics`
Permite definir colunas com [estatísticas](/pt-BR/reference/engines/table-engines/mergetree-family/mergetree#table_engine-mergetree-creating-a-table) e [manipular essas estatísticas](/pt-BR/reference/engines/table-engines/mergetree-family/mergetree#column-statistics).
## allow\_statistics\_optimize
**Aliases**: `allow_statistic_optimize`
Permite usar estatísticas para otimizar consultas.
## allow\_suspicious\_codecs
Se estiver definido como true, permite especificar codecs de compressão sem utilidade.
## allow\_suspicious\_fixed\_string\_types
Na instrução CREATE TABLE, permite criar colunas do tipo FixedString(n) com n > 256. FixedString com comprimento >= 256 é suspeita e muito provavelmente indica uso incorreto
## allow\_suspicious\_indices
Rejeita índices primários/secundários e chaves de ordenação com expressões idênticas
## allow\_suspicious\_low\_cardinality\_types
Permite ou restringe o uso de [LowCardinality](/pt-BR/reference/data-types/lowcardinality) com tipos de dados de tamanho fixo de 8 bytes ou menos: tipos de dados numéricos e `FixedString(8_bytes_or_less)`.
Para valores fixos pequenos, o uso de `LowCardinality` geralmente é ineficiente, porque o ClickHouse armazena um índice numérico para cada linha. Como resultado:
* O uso de espaço em disco pode aumentar.
* O consumo de RAM pode ser maior, dependendo do tamanho do dicionário.
* Algumas funções podem ficar mais lentas devido a operações adicionais de codificação/decodificação.
Os tempos de merge em tabelas com o motor [MergeTree](/pt-BR/reference/engines/table-engines/mergetree-family/mergetree) podem aumentar por todos os motivos descritos acima.
Valores possíveis:
* 1 — O uso de `LowCardinality` não é restrito.
* 0 — O uso de `LowCardinality` é restrito.
## allow\_suspicious\_primary\_key
Permite `PRIMARY KEY`/`ORDER BY` considerados suspeitos para MergeTree (isto é, SimpleAggregateFunction).
## allow\_suspicious\_ttl\_expressions
Rejeita expressões TTL que não dependem de nenhuma coluna da tabela. Isso indica, na maioria das vezes, um erro do usuário.
## allow\_suspicious\_types\_in\_group\_by
Permite ou restringe o uso dos tipos [Variant](/pt-BR/reference/data-types/variant) e [Dynamic](/pt-BR/reference/data-types/dynamic) nas chaves de GROUP BY.
## allow\_suspicious\_types\_in\_order\_by
Permite ou restringe o uso dos tipos [Variant](/pt-BR/reference/data-types/variant) e [Dynamic](/pt-BR/reference/data-types/dynamic) nas chaves `ORDER BY`.
## allow\_suspicious\_variant\_types
Na instrução CREATE TABLE, esta configuração permite especificar o tipo Variant com tipos de variante semelhantes (por exemplo, com diferentes tipos numéricos ou de data). Habilitar essa configuração pode introduzir alguma ambiguidade ao trabalhar com valores de tipos semelhantes.
## allow\_unrestricted\_reads\_from\_keeper
Permite leituras irrestritas (sem condição no path) da tabela system.zookeeper; pode ser útil, mas não é seguro para o ZooKeeper
## alter\_move\_to\_space\_execute\_async
Executa ALTER TABLE MOVE ... TO \[DISK|VOLUME] de modo assíncrono
## alter\_partition\_verbose\_result
Habilita ou desabilita a exibição de informações sobre as partes às quais as operações de manipulação de partições e partes foram aplicadas com sucesso.
Aplicável a [ATTACH PARTITION|PART](/pt-BR/reference/statements/alter/partition#attach-partitionpart) e [FREEZE PARTITION](/pt-BR/reference/statements/alter/partition#freeze-partition).
Valores possíveis:
* 0 — desabilita a verbosidade.
* 1 — habilita a verbosidade.
**Exemplo**
```sql theme={null}
CREATE TABLE test(a Int64, d Date, s String) ENGINE = MergeTree PARTITION BY toYYYYMDECLARE(d) ORDER BY a;
INSERT INTO test VALUES(1, '2021-01-01', '');
INSERT INTO test VALUES(1, '2021-01-01', '');
ALTER TABLE test DETACH PARTITION ID '202101';
ALTER TABLE test ATTACH PARTITION ID '202101' SETTINGS alter_partition_verbose_result = 1;
┌─command_type─────┬─partition_id─┬─part_name────┬─old_part_name─┐
│ ATTACH PARTITION │ 202101 │ 202101_7_7_0 │ 202101_5_5_0 │
│ ATTACH PARTITION │ 202101 │ 202101_8_8_0 │ 202101_6_6_0 │
└──────────────────┴──────────────┴──────────────┴───────────────┘
ALTER TABLE test FREEZE SETTINGS alter_partition_verbose_result = 1;
┌─command_type─┬─partition_id─┬─part_name────┬─backup_name─┬─backup_path───────────────────┬─part_backup_path────────────────────────────────────────────┐
│ FREEZE ALL │ 202101 │ 202101_7_7_0 │ 8 │ /var/lib/clickhouse/shadow/8/ │ /var/lib/clickhouse/shadow/8/data/default/test/202101_7_7_0 │
│ FREEZE ALL │ 202101 │ 202101_8_8_0 │ 8 │ /var/lib/clickhouse/shadow/8/ │ /var/lib/clickhouse/shadow/8/data/default/test/202101_8_8_0 │
└──────────────┴──────────────┴──────────────┴─────────────┴───────────────────────────────┴─────────────────────────────────────────────────────────────┘
```
## alter\_sync
**Aliases**: `replication_alter_partitions_sync`
Permite especificar o comportamento de espera para ações executadas em réplicas por consultas [`ALTER`](/pt-BR/reference/statements/alter), [`OPTIMIZE`](/pt-BR/reference/statements/optimize) ou [`TRUNCATE`](/pt-BR/reference/statements/truncate).
Valores possíveis:
* `0` — Não esperar.
* `1` — Aguardar a própria execução.
* `2` — Aguardar todos.
* `3` - Aguardar apenas as réplicas ativas.
Valor padrão no Cloud: `0`.
`alter_sync` se aplica apenas a tabelas `Replicated` e `SharedMergeTree`; não tem efeito ao alterar tabelas que não sejam `Replicated` nem `Shared`.
## alter\_update\_mode
Um modo para consultas `ALTER` que contêm comandos `UPDATE`.
Valores possíveis:
* `heavy` - executa uma mutação normal.
* `lightweight` - executa uma atualização leve, se possível; caso contrário, executa uma mutação normal.
* `lightweight_force` - executa uma atualização leve, se possível; caso contrário, gera uma exceção.
## analyze\_index\_with\_space\_filling\_curves
Se uma tabela tiver uma curva de preenchimento espacial em seu índice, por exemplo, `ORDER BY mortonEncode(x, y)` ou `ORDER BY hilbertEncode(x, y)`, e a consulta tiver condições sobre seus argumentos, por exemplo, `x >= 10 AND x <= 20 AND y >= 20 AND y <= 30`, use a curva de preenchimento espacial para a análise do índice.
## analyzer\_compatibility\_allow\_compound\_identifiers\_in\_unflatten\_nested
Permite adicionar identificadores compostos ao nested. Esta é uma configuração de compatibilidade porque altera o resultado da consulta. Quando desativada, `SELECT a.b.c FROM table ARRAY JOIN a` não funciona, e `SELECT a FROM table` não inclui a coluna `a.b.c` no resultado de `Nested a`.
## analyzer\_compatibility\_join\_using\_top\_level\_identifier
Força a resolução do identificador em JOIN USING a partir da projeção (por exemplo, em `SELECT a + 1 AS b FROM t1 JOIN t2 USING (b)`, o join será realizado por `t1.a + 1 = t2.b`, em vez de `t1.b = t2.b`).
## analyzer\_inline\_views
Quando habilitado, o analisador substitui views comuns (não materializadas, não parametrizadas) pelas subconsultas que as definem, permitindo otimizações entre camadas, como o pushdown de predicados e o pruning de colunas.
## any\_join\_distinct\_right\_table\_keys
Habilita o comportamento legado do servidor ClickHouse em operações `ANY INNER|LEFT JOIN`.
Use esta configuração apenas para compatibilidade com versões anteriores, se seus casos de uso dependerem do comportamento legado de `JOIN`.
Quando o comportamento legado está habilitado:
* Os resultados das operações `t1 ANY LEFT JOIN t2` e `t2 ANY RIGHT JOIN t1` não são iguais, porque o ClickHouse usa a lógica de mapeamento de chaves entre tabelas da esquerda para a direita, de muitos para um.
* Os resultados das operações `ANY INNER JOIN` contêm todas as linhas da tabela à esquerda, assim como nas operações `SEMI LEFT JOIN`.
Quando o comportamento legado está desabilitado:
* Os resultados das operações `t1 ANY LEFT JOIN t2` e `t2 ANY RIGHT JOIN t1` são iguais, porque o ClickHouse usa a lógica que fornece mapeamento de chaves de um para muitos em operações `ANY RIGHT JOIN`.
* Os resultados das operações `ANY INNER JOIN` contêm uma linha por chave de ambas as tabelas, a da esquerda e a da direita.
Valores possíveis:
* 0 — O comportamento legado está desabilitado.
* 1 — O comportamento legado está habilitado.
Veja também:
* [Strictness de JOIN](/pt-BR/reference/statements/select/join#settings)
## apply\_deleted\_mask
Habilita a filtragem de linhas excluídas com exclusão leve. Se estiver desabilitado, uma consulta poderá ler essas linhas. Isso é útil para cenários de depuração e de "recuperação" de exclusões
## apply\_mutations\_on\_fly
Se true, mutações (UPDATEs e DELETEs) que não estiverem materializadas na data part serão aplicadas durante SELECTs.
## apply\_patch\_parts
Se true, patch parts (que representam atualizações leves) são aplicadas nas consultas SELECT.
## apply\_patch\_parts\_join\_cache\_buckets
Número de buckets no cache temporário para aplicar patch parts no modo Join.
## apply\_prewhere\_after\_final
Quando habilitada, as condições PREWHERE são aplicadas após o processamento FINAL em ReplacingMergeTree e motores semelhantes.
Isso pode ser útil quando o PREWHERE faz referência a colunas que podem ter valores diferentes entre linhas duplicadas
e você quer que o FINAL selecione a linha que prevalece antes da filtragem. Quando desabilitada, o PREWHERE é aplicado durante a leitura.
Observação: se apply\_row\_level\_security\_after\_final estiver habilitada e a política de linha usar colunas fora da chave de ordenação, o PREWHERE também
será adiado para manter a ordem de execução correta (a política de linha deve ser aplicada antes do PREWHERE).
## apply\_row\_policy\_after\_final
Quando habilitado, as políticas de linha e PREWHERE são aplicados após o processamento de FINAL para tabelas \*MergeTree. (Especialmente para ReplacingMergeTree)
Quando desabilitado, as políticas de linha são aplicadas antes de FINAL, o que pode causar resultados diferentes quando a política
filtra linhas que deveriam ser usadas para desduplicação no ReplacingMergeTree ou em motores semelhantes.
Se a expressão da política de linha depender apenas de colunas em ORDER BY, ela ainda será aplicada antes de FINAL como uma otimização,
pois essa filtragem não pode afetar o resultado da desduplicação.
Valores possíveis:
* 0 — A política de linha e PREWHERE são aplicados antes de FINAL (padrão).
* 1 — A política de linha e PREWHERE são aplicados após FINAL.
## apply\_settings\_from\_server
Define se o cliente deve aceitar configurações do servidor.
Isso afeta apenas as operações realizadas no lado do cliente, em particular a análise dos dados de entrada de INSERT e a formatação do resultado da consulta. A maior parte da execução da consulta acontece no servidor e não é afetada por essa configuração.
Normalmente, essa configuração deve ser definida no profile do usuário (`users.xml` ou consultas como `ALTER USER`), não por meio do cliente (argumentos de linha de comando do cliente, consulta `SET` ou seção `SETTINGS` da consulta `SELECT`). Pelo cliente, ela pode ser alterada para false, mas não pode ser alterada para true (porque o servidor não enviará as configurações se o profile do usuário tiver `apply_settings_from_server = false`).
Observe que, inicialmente (24.12), havia uma configuração do servidor (`send_settings_to_client`), mas depois ela foi substituída por essa configuração do cliente, para facilitar o uso.
## archive\_adaptive\_buffer\_max\_size\_bytes
Limita o tamanho máximo do buffer adaptativo usado ao gravar em arquivos de arquivamento (por exemplo, arquivos tar
## arrow\_flight\_request\_descriptor\_type
Tipo de descritor a ser usado nas solicitações do Arrow Flight. 'path' envia o nome do conjunto de dados como um descritor de caminho. 'command' envia uma consulta SQL como um descritor de comando (obrigatório para o Dremio).
Valores possíveis:
* 'path' — Use FlightDescriptor::Path (padrão, funciona com a maioria dos servidores Arrow Flight)
* 'command' — Use FlightDescriptor::Command com uma consulta SELECT (obrigatório para o Dremio)
## ast\_fuzzer\_any\_query
Quando false (padrão), o fuzzer de AST do lado do servidor (controlado por `ast_fuzzer_runs`) aplica fuzzing apenas a consultas somente leitura (SELECT, EXPLAIN, SHOW, DESCRIBE, EXISTS). Quando true, o fuzzing é aplicado a todos os tipos de consulta, incluindo DDL e INSERT.
## ast\_fuzzer\_runs
Habilita o AST fuzzer no lado do servidor, que executa consultas aleatórias após cada consulta normal, descartando os resultados.
* 0: desabilitado (padrão).
* Um valor entre 0 e 1 (sem incluir os extremos): probabilidade de executar uma única consulta com fuzzing.
* Um valor >= 1: número de consultas com fuzzing a executar por consulta normal.
O fuzzer acumula fragmentos de AST de todas as consultas em todas as sessões, produzindo mutações cada vez mais interessantes ao longo do tempo. As consultas com fuzzing que falham são descartadas silenciosamente; os resultados nunca são retornados ao cliente.
## asterisk\_include\_alias\_columns
Inclui colunas [ALIAS](/pt-BR/reference/statements/create/table#alias) em consultas com curinga (`SELECT *`).
Valores possíveis:
* 0 - desabilitado
* 1 - habilitado
## asterisk\_include\_materialized\_columns
Inclui colunas [MATERIALIZED](/pt-BR/reference/statements/create/view#materialized-view) em consultas com curinga (`SELECT *`).
Valores possíveis:
* 0 - desabilitado
* 1 - habilitado
## asterisk\_include\_virtual\_columns
Inclui colunas virtuais em consultas com curinga (`SELECT *`).
Valores possíveis:
* 0 - desabilitado
* 1 - habilitado
## async\_insert
Se true, os dados da consulta INSERT são armazenados em uma fila e depois gravados na tabela em segundo plano. Se wait\_for\_async\_insert for false, a consulta INSERT será processada quase instantaneamente; caso contrário, o cliente aguardará até que os dados sejam gravados na tabela
## async\_insert\_busy\_timeout\_decrease\_rate
A taxa de crescimento exponencial com que o timeout adaptativo de inserção assíncrona diminui
## async\_insert\_busy\_timeout\_increase\_rate
A taxa de crescimento exponencial com que o tempo limite adaptativo de inserção assíncrona aumenta
## async\_insert\_busy\_timeout\_max\_ms
**Aliases**: `async_insert_busy_timeout_ms`
Tempo máximo de espera, a partir do recebimento dos primeiros dados, antes de descarregar os dados coletados por consulta.
Valor padrão no Cloud: `1000` (1s).
## async\_insert\_busy\_timeout\_min\_ms
Se o ajuste automático estiver habilitado por meio de async\_insert\_use\_adaptive\_busy\_timeout, é o tempo mínimo de espera antes de descarregar os dados coletados por consulta, desde o aparecimento dos primeiros dados. Também serve como valor inicial para o algoritmo adaptativo
## async\_insert\_deduplicate
Para consultas INSERT assíncronas em tabela replicada, especifica que deve ser realizada a desduplicação dos blocos inseridos
## async\_insert\_max\_data\_size
Tamanho máximo, em bytes, dos dados ainda não analisados acumulados por consulta antes de serem inseridos
Valor padrão no Cloud: `104857600` (100 MiB).
## async\_insert\_max\_query\_number
Número máximo de consultas de inserção antes da inserção.
Só tem efeito se a configuração [`async_insert_deduplicate`](#async_insert_deduplicate) for 1.
## async\_insert\_poll\_timeout\_ms
Tempo limite para consultar dados da fila de insert assíncrono
## async\_insert\_use\_adaptive\_busy\_timeout
Se estiver definido como true, usa o timeout adaptativo de espera para inserts assíncronos
## async\_query\_sending\_for\_remote
Habilita a criação assíncrona de conexões e o envio de consultas ao executar uma consulta remota.
Habilitado por padrão.
## async\_socket\_for\_remote
Habilita a leitura assíncrona no socket durante a execução de uma consulta remota.
Habilitado por padrão.
## automatic\_parallel\_replicas\_min\_bytes\_per\_replica
Limiar de bytes a serem lidos por réplica para ativar automaticamente as réplicas paralelas (aplica-se somente quando `automatic_parallel_replicas_mode`=1). 0 significa sem limiar.
O número total de bytes a serem lidos é estimado com base nas estatísticas coletadas.
## automatic\_parallel\_replicas\_mode
Habilita a alternância automática para a execução com réplicas paralelas com base nas estatísticas coletadas. Requer `enable_analyzer = 1`, `enable_parallel_replicas != 0`, `parallel_replicas_local_plan = 1` e que `cluster_for_parallel_replicas` seja fornecido.
0 - desativado, 1 - ativado, 2 - somente a coleta de estatísticas está ativada (a alternância para a execução com réplicas paralelas está desativada).
## azure\_allow\_parallel\_part\_upload
Usa várias threads para upload multipart no Azure.
## azure\_check\_objects\_after\_upload
Verifica cada objeto enviado ao Azure Blob Storage para garantir que o envio foi concluído com sucesso
## azure\_connect\_timeout\_ms
Tempo limite de conexão com o host dos discos do Azure.
## azure\_create\_new\_file\_on\_insert
Ativa ou desativa a criação de um novo arquivo a cada insert nas tabelas do engine Azure
## azure\_ignore\_file\_doesnt\_exist
Ignora a ausência do arquivo ao ler determinadas chaves, caso ele não exista.
Valores possíveis:
* 1 — `SELECT` retorna resultado vazio.
* 0 — `SELECT` gera uma exceção.
## azure\_list\_object\_keys\_size
Número máximo de arquivos que podem ser retornados em lote na requisição ListObject
## azure\_max\_blocks\_in\_multipart\_upload
Número máximo de blocos no upload multipart para o Azure.
## azure\_max\_get\_burst
Número máximo de requisições que podem ser emitidas simultaneamente antes de atingir o limite de requisições por segundo. Por padrão (0), é igual a `azure_max_get_rps`
## azure\_max\_get\_rps
Limite para a taxa de solicitações GET ao Azure por segundo antes que o throttling seja aplicado. Zero significa ilimitado.
## azure\_max\_inflight\_parts\_for\_one\_file
O número máximo de partes carregadas simultaneamente em uma solicitação de upload em múltiplas partes. 0 significa ilimitado.
## azure\_max\_put\_burst
Número máximo de solicitações que podem ser feitas simultaneamente antes de atingir o limite de solicitações por segundo. Por padrão (0), é igual a `azure_max_put_rps`
## azure\_max\_put\_rps
Limite da taxa de requisições PUT no Azure por segundo antes da aplicação de throttling. Zero significa sem limite.
## azure\_max\_redirects
Número máximo permitido de saltos de redirecionamento do Azure.
## azure\_max\_single\_part\_copy\_size
O tamanho máximo do objeto a ser copiado por meio de uma cópia de parte única para o Azure blob storage.
## azure\_max\_single\_part\_upload\_size
O tamanho máximo de um objeto para upload em uma única parte no Azure blob storage.
## azure\_max\_single\_read\_retries
O número máximo de tentativas em uma única leitura do Azure Blob Storage.
## azure\_max\_unexpected\_write\_error\_retries
O número máximo de tentativas em caso de erros inesperados durante a gravação no armazenamento de blobs do Azure
## azure\_max\_upload\_part\_size
O tamanho máximo da parte a ser enviada durante o upload multipart para o Azure blob storage.
## azure\_min\_upload\_part\_size
O tamanho mínimo da parte a ser enviada durante um upload em várias partes para o Azure blob storage.
## azure\_request\_timeout\_ms
Tempo limite de inatividade para enviar e receber dados de/para o Azure. A operação falhará se uma única chamada TCP de leitura ou gravação ficar bloqueada por esse período.
## azure\_sdk\_max\_retries
Número máximo de novas tentativas no SDK do Azure
## azure\_sdk\_retry\_initial\_backoff\_ms
Backoff mínimo entre tentativas no Azure SDK
## azure\_sdk\_retry\_max\_backoff\_ms
Backoff máximo entre tentativas no SDK do Azure
## azure\_skip\_empty\_files
Ativa ou desativa a opção de ignorar arquivos vazios no mecanismo S3.
Valores possíveis:
* 0 — `SELECT` gera uma exceção se o arquivo vazio não for compatível com o formato solicitado.
* 1 — `SELECT` retorna um resultado vazio para um arquivo vazio.
## azure\_strict\_upload\_part\_size
O tamanho exato da parte a ser enviada durante o upload em múltiplas partes para o Azure blob storage.
## azure\_throw\_on\_zero\_files\_match
Lança um erro se nenhum arquivo corresponder, de acordo com as regras de expansão de glob.
Valores possíveis:
* 1 — `SELECT` lança uma exceção.
* 0 — `SELECT` retorna um resultado vazio.
## azure\_truncate\_on\_insert
Ativa ou desativa o TRUNCATE antes do insert em tabelas do engine Azure.
## azure\_upload\_part\_size\_multiply\_factor
Multiplica azure\_min\_upload\_part\_size por esse fator sempre que azure\_multiply\_parts\_count\_threshold partes forem enviadas em uma única gravação para o Azure blob storage.
## azure\_upload\_part\_size\_multiply\_parts\_count\_threshold
Sempre que esse número de partes é enviado para o Azure blob storage, azure\_min\_upload\_part\_size é multiplicado por azure\_upload\_part\_size\_multiply\_factor.
## azure\_use\_adaptive\_timeouts
Quando definido como `true`, as duas primeiras tentativas de todas as solicitações ao Azure são feitas com timeouts baixos de envio e recebimento.
Quando definido como `false`, todas as tentativas são feitas com os mesmos timeouts.
## backup\_restore\_batch\_size\_for\_keeper\_multi
Tamanho máximo do lote para solicitações múltiplas ao \[Zoo]Keeper durante o backup ou a restauração
## backup\_restore\_batch\_size\_for\_keeper\_multiread
Tamanho máximo do lote para a solicitação de multileitura ao \[Zoo]Keeper durante backup ou restauração
## backup\_restore\_failure\_after\_host\_disconnected\_for\_seconds
Se um host, durante uma operação BACKUP ON CLUSTER ou RESTORE ON CLUSTER, não recriar seu nó efêmero 'alive' no ZooKeeper dentro desse intervalo de tempo, todo o backup ou a restauração será considerado com falha.
Esse valor deve ser maior do que qualquer tempo razoável para um host se reconectar ao ZooKeeper após uma falha.
Zero significa ilimitado.
## backup\_restore\_finish\_timeout\_after\_error\_sec
Por quanto tempo o iniciador deve aguardar até que outro host reaja ao nó 'error' e interrompa seu trabalho na operação atual de BACKUP ON CLUSTER ou RESTORE ON CLUSTER.
## backup\_restore\_keeper\_fault\_injection\_probability
Probabilidade aproximada de falha de uma solicitação ao Keeper durante o backup ou a restauração. O valor válido está no intervalo \[0.0f, 1.0f]
## backup\_restore\_keeper\_fault\_injection\_seed
0 - semente aleatória; caso contrário, usa o valor da configuração
## backup\_restore\_keeper\_max\_retries
Número máximo de tentativas para operações do \[Zoo]Keeper durante uma operação de BACKUP ou RESTORE.
Deve ser alto o suficiente para que toda a operação não falhe devido a uma falha temporária do \[Zoo]Keeper.
## backup\_restore\_keeper\_max\_retries\_while\_handling\_error
Número máximo de tentativas para operações do \[Zoo]Keeper ao tratar um erro em uma operação BACKUP ON CLUSTER ou RESTORE ON CLUSTER.
## backup\_restore\_keeper\_max\_retries\_while\_initializing
Número máximo de tentativas para operações no \[Zoo]Keeper durante a inicialização de uma operação BACKUP ON CLUSTER ou RESTORE ON CLUSTER.
## backup\_restore\_keeper\_retry\_initial\_backoff\_ms
Tempo limite do backoff inicial para operações do \[Zoo]Keeper durante backup ou restauração
## backup\_restore\_keeper\_retry\_max\_backoff\_ms
Tempo máximo de backoff para operações do \[Zoo]Keeper durante backup ou restauração
Valor padrão no Cloud: `60000`.
## backup\_restore\_keeper\_value\_max\_size
Tamanho máximo dos dados de um nó do \[Zoo]Keeper durante o processo de backup
## backup\_restore\_s3\_retry\_attempts
Configuração para Aws::Client::RetryStrategy; o Aws::Client faz novas tentativas automaticamente. 0 significa nenhuma tentativa. Aplica-se apenas a backup/restauração.
## backup\_restore\_s3\_retry\_initial\_backoff\_ms
Atraso inicial de backoff, em milissegundos, antes da primeira nova tentativa durante o backup e a restauração. Cada nova tentativa subsequente aumenta o atraso exponencialmente, até o máximo especificado por `backup_restore_s3_retry_max_backoff_ms`
## backup\_restore\_s3\_retry\_jitter\_factor
Fator de jitter aplicado ao atraso de backoff de nova tentativa em Aws::Client::RetryStrategy durante operações de backup e restauração. O atraso de backoff calculado é multiplicado por um fator aleatório no intervalo \[1.0, 1.0 + jitter], até o máximo de `backup_restore_s3_retry_max_backoff_ms`. Deve estar no intervalo \[0.0, 1.0]
## backup\_restore\_s3\_retry\_max\_backoff\_ms
Atraso máximo, em milissegundos, entre novas tentativas durante operações de backup e restauração.
## backup\_slow\_all\_threads\_after\_retryable\_s3\_error
Quando definido como `true`, todas as threads que executam requisições ao S3 para o mesmo endpoint de backup ficam mais lentas
depois que qualquer requisição individual ao S3 encontrar um erro do S3 passível de nova tentativa, como 'Slow Down'.
Quando definido como `false`, cada thread lida com o backoff das requisições ao S3 independentemente das demais.
## cache\_warmer\_threads
Só tem efeito no ClickHouse Cloud. Número de threads em segundo plano para baixar especulativamente novas partes de dados para o cache do sistema de arquivos quando [cache\_populated\_by\_fetch](/pt-BR/reference/settings/merge-tree-settings#cache_populated_by_fetch) estiver habilitado. Zero para desabilitar.
## calculate\_text\_stack\_trace
Calcula o stack trace em texto em caso de exceções durante a execução de consultas. Esse é o padrão. Isso exige a busca de símbolos, o que pode tornar os testes de fuzzing mais lentos quando um grande número de consultas incorretas é executado. Em condições normais, você não deve desativar esta opção.
## cancel\_http\_readonly\_queries\_on\_client\_close
Cancela consultas HTTP de somente leitura (por exemplo, `SELECT`) quando um cliente fecha a conexão sem aguardar a resposta.
Valor padrão no Cloud: `1`.
## cast\_ipv4\_ipv6\_default\_on\_conversion\_error
O operador CAST para IPv4, o operador CAST para o tipo IPv6 e as funções toIPv4 e toIPv6 retornarão o valor padrão em vez de gerar uma exceção em caso de erro de conversão.
## cast\_keep\_nullable
Habilita ou desabilita a manutenção do tipo de dado `Nullable` em operações [CAST](/pt-BR/reference/functions/regular-functions/type-conversion-functions#CAST).
Quando a configuração está habilitada e o argumento da função `CAST` é `Nullable`, o resultado também é convertido para o tipo `Nullable`. Quando a configuração está desabilitada, o resultado sempre tem exatamente o tipo de destino.
Valores possíveis:
* 0 — O resultado de `CAST` tem exatamente o tipo de destino especificado.
* 1 — Se o tipo do argumento for `Nullable`, o resultado de `CAST` será convertido em `Nullable(DestinationDataType)`.
**Exemplos**
A consulta a seguir resulta exatamente no tipo de dado de destino:
```sql theme={null}
SET cast_keep_nullable = 0;
SELECT CAST(toNullable(toInt32(0)) AS Int32) as x, toTypeName(x);
```
Resultado:
```text theme={null}
┌─x─┬─toTypeName(CAST(toNullable(toInt32(0)), 'Int32'))─┐
│ 0 │ Int32 │
└───┴───────────────────────────────────────────────────┘
```
A consulta a seguir faz com que o tipo de dados de destino receba a modificação `Nullable`:
```sql theme={null}
SET cast_keep_nullable = 1;
SELECT CAST(toNullable(toInt32(0)) AS Int32) as x, toTypeName(x);
```
Resultado:
```text theme={null}
┌─x─┬─toTypeName(CAST(toNullable(toInt32(0)), 'Int32'))─┐
│ 0 │ Nullable(Int32) │
└───┴───────────────────────────────────────────────────┘
```
**Veja também**
* [CAST](/pt-BR/reference/functions/regular-functions/type-conversion-functions#CAST) função
## cast\_string\_to\_date\_time\_mode
Permite escolher o parser da representação textual de data e hora durante a conversão de String.
Valores possíveis:
* `'best_effort'` — Ativa o parsing estendido.
O ClickHouse pode analisar o formato básico `YYYY-MM-DD HH:MM:SS` e todos os formatos de data e hora [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601). Por exemplo, `'2018-06-08T01:02:03.000Z'`.
* `'best_effort_us'` — Semelhante a `best_effort` (veja a diferença em [parseDateTimeBestEffortUS](/pt-BR/reference/functions/regular-functions/type-conversion-functions#parseDateTimeBestEffortUS)
* `'basic'` — Usa o parser básico.
O ClickHouse pode analisar apenas o formato básico `YYYY-MM-DD HH:MM:SS` ou `YYYY-MM-DD`. Por exemplo, `2019-08-20 10:18:56` ou `2019-08-20`.
Veja também:
* [Tipo de dado DateTime.](/pt-BR/reference/data-types/datetime)
* [Funções para trabalhar com datas e horas.](/pt-BR/reference/functions/regular-functions/date-time-functions)
## cast\_string\_to\_dynamic\_use\_inference
Usar inferência de tipos durante a conversão de String para Dynamic
## cast\_string\_to\_variant\_use\_inference
Usa a inferência de tipos durante a conversão de String para Variant.
## check\_named\_collection\_dependencies
Verifica se DROP NAMED COLLECTION não quebrará as tabelas que dependem dela
## check\_query\_single\_value\_result
Define o nível de detalhamento do resultado da consulta [CHECK TABLE](/pt-BR/reference/statements/check-table) para os motores da família `MergeTree` .
Valores possíveis:
* 0 — a consulta mostra o status de verificação de cada data part individual da tabela.
* 1 — a consulta mostra o status geral de verificação da tabela.
## check\_referential\_table\_dependencies
Verifica se uma consulta DDL (como DROP TABLE ou RENAME) não quebrará dependências referenciais
## check\_table\_dependencies
Verifica se a consulta DDL (como DROP TABLE ou RENAME) não causará a quebra de dependências
## checksum\_on\_read
Valide os checksum durante a leitura. Ela vem habilitada por padrão e deve permanecer sempre habilitada em produção. Não espere obter nenhum benefício ao desabilitar essa configuração. Ela deve ser usada apenas para experimentos e benchmarks. A configuração se aplica apenas a tabelas da família MergeTree. Os checksum são sempre validados para outros motores de tabela e ao receber dados pela rede.
## cloud\_mode
Modo Cloud
Valor padrão na Cloud: `1`.
## cloud\_mode\_database\_engine
O engine de banco de dados permitido no Cloud. 1 - reescreve DDLs para usar o banco de dados Replicated, 2 - reescreve DDLs para usar o banco de dados Shared
Valor padrão no Cloud: `2`.
## cloud\_mode\_engine
A família de engines permitida no Cloud.
* 0 - permite tudo
* 1 - reescreve DDLs para usar \*ReplicatedMergeTree
* 2 - reescreve DDLs para usar SharedMergeTree
* 3 - reescreve DDLs para usar SharedMergeTree, exceto quando um disco remoto é especificado explicitamente
* 4 - igual a 3, mas também usa Alias em vez de Distributed (a tabela Alias apontará para a tabela de destino da tabela Distributed, portanto usará a tabela local correspondente)
UInt64 para minimizar a parte pública
Valor padrão no Cloud: `2`.
## cluster\_for\_parallel\_replicas
Cluster do shard em que o servidor atual está localizado
Valor padrão do Cloud: `default`.
## cluster\_function\_process\_archive\_on\_multiple\_nodes
Se definido como `true`, aumenta o desempenho do processamento de arquivos compactados em funções de cluster. Deve ser definido como `false` para garantir compatibilidade e evitar erros durante a atualização para 25.7+ ao usar funções de cluster com arquivos compactados em versões anteriores.
## cluster\_table\_function\_buckets\_batch\_size
Define o tamanho aproximado de um lote (em bytes) usado no processamento distribuído de tarefas em funções de tabela de cluster com granularidade de divisão `bucket`. O sistema acumula os dados até que pelo menos essa quantidade seja atingida. O tamanho real pode ser ligeiramente maior para se alinhar aos limites dos dados.
## cluster\_table\_function\_split\_granularity
Controla como os dados são divididos em tarefas ao executar uma CLUSTER TABLE FUNCTION.
Esta configuração define a granularidade da distribuição do trabalho no cluster:
* `file` — cada tarefa processa um arquivo inteiro.
* `bucket` — as tarefas são criadas por bloco de dados interno dentro de um arquivo (por exemplo, row groups de Parquet).
Escolher uma granularidade mais fina (como `bucket`) pode melhorar o paralelismo ao trabalhar com um número pequeno de arquivos grandes.
Por exemplo, se um arquivo Parquet contiver vários row groups, habilitar a granularidade `bucket` permite que cada grupo seja processado de forma independente por diferentes workers.
## collect\_hash\_table\_stats\_during\_aggregation
Habilita a coleta de estatísticas da tabela hash para otimizar a alocação de memória
## collect\_hash\_table\_stats\_during\_joins
Habilita a coleta de estatísticas da tabela hash para otimizar a alocação de memóri
## compatibility
A configuração `compatibility` faz com que o ClickHouse use as configurações padrão de uma versão anterior do ClickHouse, informada no próprio valor da configuração.
Se algumas configurações estiverem definidas com valores diferentes do padrão, esses valores serão respeitados (apenas as configurações que não tiverem sido modificadas serão afetadas pela configuração `compatibility`).
Essa configuração aceita um número de versão do ClickHouse como string, como `22.3` ou `22.8`. Um valor vazio significa que essa configuração está desabilitada.
Desabilitada por padrão.
No ClickHouse Cloud, a configuração de compatibilidade padrão no nível do serviço precisa ser definida pelo suporte do ClickHouse Cloud. Abra [um chamado](https://clickhouse.cloud/support) para solicitar essa definição.
No entanto, a configuração `compatibility` pode ser substituída nos níveis de usuário, função, perfil, consulta ou sessão usando os mecanismos padrão de configuração do ClickHouse, como `SET compatibility = '22.3'` em uma sessão ou `SETTINGS compatibility = '22.3'` em uma consulta.
## compatibility\_ignore\_auto\_increment\_in\_create\_table
Ignora a palavra-chave AUTO\_INCREMENT na declaração da coluna se true; caso contrário, retorna um erro. Isso simplifica a migração do MySQL
## compatibility\_ignore\_collation\_in\_create\_table
Compatibilidade: ignorar collation no CREATE TABLE
## compatibility\_s3\_presigned\_url\_query\_in\_path
Compatibilidade: quando ativada, incorpora os parâmetros de consulta da URL pré-assinada (por exemplo, X-Amz-\*) à chave do S3 (comportamento legado),
de modo que '?' funcione como um curinga no caminho. Quando desativada (padrão), os parâmetros de consulta da URL pré-assinada são mantidos na string de consulta da URL
para evitar que '?' seja interpretado como um curinga.
## compile\_aggregate\_expressions
Ativa ou desativa a compilação JIT de funções de agregação em código nativo. Ativar essa configuração pode melhorar o desempenho.
Valores possíveis:
* 0 — A agregação é feita sem compilação JIT.
* 1 — A agregação é feita com compilação JIT.
**Veja também**
* [min\_count\_to\_compile\_aggregate\_expression](#min_count_to_compile_aggregate_expression)
## compile\_expressions
Compila algumas funções escalares e operadores em código nativo.
## compile\_sort\_description
Compila a descrição da ordenação em código nativo.
## connect\_timeout
Tempo limite da conexão se não houver réplicas.
## connect\_timeout\_with\_failover\_ms
O tempo limite, em milissegundos, para se conectar a um servidor remoto com o engine de tabela Distributed, se as seções 'shard' e 'réplica' forem usadas na definição do cluster.
Se não for bem-sucedido, serão feitas várias tentativas de conexão com diferentes réplicas.
## connect\_timeout\_with\_failover\_secure\_ms
Tempo limite de conexão para selecionar a primeira réplica saudável (para conexões seguras).
## connection\_pool\_max\_wait\_ms
O tempo de espera, em milissegundos, por uma conexão quando o pool de conexões está cheio.
Valores possíveis:
* Inteiro positivo.
* 0 — Sem timeout.
## connections\_with\_failover\_max\_tries
O número máximo de tentativas de conexão com cada réplica do mecanismo de tabela Distributed.
## convert\_query\_to\_cnf
Quando definido como `true`, uma consulta `SELECT` será convertida para a forma normal conjuntiva (CNF). Em alguns casos, reescrever uma consulta em CNF pode resultar em uma execução mais rápida (veja esta [issue no GitHub](https://github.com/ClickHouse/ClickHouse/issues/11749) para mais detalhes).
Por exemplo, observe como a consulta `SELECT` abaixo não é modificada (comportamento padrão):
```sql theme={null}
EXPLAIN SYNTAX
SELECT *
FROM
(
SELECT number AS x
FROM numbers(20)
) AS a
WHERE ((x >= 1) AND (x <= 5)) OR ((x >= 10) AND (x <= 15))
SETTINGS convert_query_to_cnf = false;
```
O resultado é:
```response theme={null}
┌─explain────────────────────────────────────────────────────────┐
│ SELECT x │
│ FROM │
│ ( │
│ SELECT number AS x │
│ FROM numbers(20) │
│ WHERE ((x >= 1) AND (x <= 5)) OR ((x >= 10) AND (x <= 15)) │
│ ) AS a │
│ WHERE ((x >= 1) AND (x <= 5)) OR ((x >= 10) AND (x <= 15)) │
│ SETTINGS convert_query_to_cnf = 0 │
└────────────────────────────────────────────────────────────────┘
```
Vamos definir `convert_query_to_cnf` como `true` e ver o que muda:
```sql theme={null}
EXPLAIN SYNTAX
SELECT *
FROM
(
SELECT number AS x
FROM numbers(20)
) AS a
WHERE ((x >= 1) AND (x <= 5)) OR ((x >= 10) AND (x <= 15))
SETTINGS convert_query_to_cnf = true;
```
Observe que a cláusula `WHERE` foi reescrita em CNF, mas o conjunto de resultados permanece idêntico — a lógica booleana não muda:
```response theme={null}
┌─explain───────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│ SELECT x │
│ FROM │
│ ( │
│ SELECT number AS x │
│ FROM numbers(20) │
│ WHERE ((x <= 15) OR (x <= 5)) AND ((x <= 15) OR (x >= 1)) AND ((x >= 10) OR (x <= 5)) AND ((x >= 10) OR (x >= 1)) │
│ ) AS a │
│ WHERE ((x >= 10) OR (x >= 1)) AND ((x >= 10) OR (x <= 5)) AND ((x <= 15) OR (x >= 1)) AND ((x <= 15) OR (x <= 5)) │
│ SETTINGS convert_query_to_cnf = 1 │
└───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
```
Valores possíveis: true, false
## correlated\_subqueries\_default\_join\_kind
Controla o tipo de junções usadas no plano de consulta descorrelacionado. O valor padrão é `right`, o que significa que o plano descorrelacionado conterá RIGHT JOINs com a entrada da subconsulta no lado direito.
Valores possíveis:
* `left` - O processo de descorrelação produzirá LEFT JOINs, e a tabela de entrada aparecerá no lado esquerdo.
* `right` - O processo de descorrelação produzirá RIGHT JOINs, e a tabela de entrada aparecerá no lado direito.
## correlated\_subqueries\_substitute\_equivalent\_expressions
Usa expressões de filtro para inferir expressões equivalentes e substituí-las em vez de criar um CROSS JOIN.
## correlated\_subqueries\_use\_in\_memory\_buffer
Usa buffer na memória para a entrada de subconsultas correlacionadas para evitar sua reavaliação.
## count\_distinct\_implementation
Especifica qual das funções `uniq*` deve ser usada para executar a construção [COUNT(DISTINCT ...)](/pt-BR/reference/functions/aggregate-functions/count).
Valores possíveis:
* [uniq](/pt-BR/reference/functions/aggregate-functions/uniq)
* [uniqCombined](/pt-BR/reference/functions/aggregate-functions/uniqCombined)
* [uniqCombined64](/pt-BR/reference/functions/aggregate-functions/uniqCombined64)
* [uniqHLL12](/pt-BR/reference/functions/aggregate-functions/uniqHLL12)
* [uniqExact](/pt-BR/reference/functions/aggregate-functions/uniqExact)
## count\_distinct\_optimization
Reescreve count distinct em uma subconsulta de group by
## count\_matches\_stop\_at\_empty\_match
Interrompe a contagem assim que um padrão corresponder a zero caracteres na função `countMatches`.
## create\_if\_not\_exists
Ativa `IF NOT EXISTS` para a instrução `CREATE` por padrão. Se esta configuração ou `IF NOT EXISTS` estiver especificado e uma tabela com o nome informado já existir, nenhuma exceção será lançada.
## create\_index\_ignore\_unique
Ignora a palavra-chave UNIQUE em CREATE UNIQUE INDEX. Criado para testes de compatibilidade com SQL.
## create\_replicated\_merge\_tree\_fault\_injection\_probability
A probabilidade de ocorrer uma injeção de falha durante a criação da tabela, após a criação dos metadados no ZooKeeper
## create\_table\_empty\_primary\_key\_by\_default
Permite criar tabelas \*MergeTree com chave primária vazia quando ORDER BY e PRIMARY KEY não são especificados
## cross\_join\_min\_bytes\_to\_compress
Tamanho mínimo do bloco a ser comprimido em CROSS JOIN. O valor zero significa desativar esse limite. Esse bloco é comprimido quando qualquer um dos dois limites (por linhas ou por bytes) é atingido.
## cross\_join\_min\_rows\_to\_compress
Número mínimo de linhas para comprimir o bloco em CROSS JOIN. O valor zero significa desabilitar esse limite. O bloco é comprimido quando qualquer um dos dois limites (por linhas ou por bytes) é atingido.
## cross\_to\_inner\_join\_rewrite
Usa inner join em vez de comma/cross join se houver expressões de junção na cláusula WHERE. Valores: 0 - sem reescrita, 1 - aplicar se possível para comma/cross, 2 - forçar a reescrita de todas as junções por vírgula, cross - se possível
## data\_type\_default\_nullable
Faz com que os tipos de dados sem modificadores explícitos [NULL or NOT NULL](/pt-BR/reference/statements/create/table#null-or-not-null-modifiers) na definição da coluna sejam [Nullable](/pt-BR/reference/data-types/nullable).
Valores possíveis:
* 1 — Os tipos de dados nas definições de coluna são definidos como `Nullable` por padrão.
* 0 — Os tipos de dados nas definições de coluna são definidos, por padrão, como não `Nullable`.
## database\_atomic\_wait\_for\_drop\_and\_detach\_synchronously
Adiciona um modificador `SYNC` a todas as consultas `DROP` e `DETACH`.
Valores possíveis:
* 0 — A execução das consultas será adiada.
* 1 — As consultas serão executadas sem atraso.
## database\_datalake\_require\_metadata\_access
Define se deve gerar erro ou não caso não haja permissões para obter os metadados da tabela no mecanismo de banco de dados DataLakeCatalog.
## database\_replicated\_allow\_explicit\_uuid
0 - Não permite especificar explicitamente UUIDs para tabelas em bancos de dados Replicated. 1 - Permite. 2 - Permite, mas ignora o UUID especificado e gera um UUID aleatório.
## database\_replicated\_allow\_heavy\_create
Permite consultas DDL de longa execução (CREATE AS SELECT e POPULATE) no database engine Replicated. Observe que isso pode bloquear a DDL queue por muito tempo.
## database\_replicated\_allow\_only\_replicated\_engine
Permite criar apenas tabelas Replicated em bancos de dados com engine Replicated
Valor padrão no Cloud: `1`.
## database\_replicated\_allow\_replicated\_engine\_arguments
0 - Não permitir especificar explicitamente o caminho do ZooKeeper e o nome da réplica para tabelas \*MergeTree em bancos de dados Replicated. 1 - Permitir. 2 - Permitir, mas ignorar o caminho especificado e usar o caminho padrão. 3 - Permitir e não registrar aviso.
## database\_replicated\_always\_detach\_permanently
Executa DETACH TABLE como DETACH TABLE PERMANENTLY se o engine do banco de dados for Replicated
## database\_replicated\_enforce\_synchronous\_settings
Exige espera síncrona para algumas consultas (veja também database\_atomic\_wait\_for\_drop\_and\_detach\_synchronously, mutations\_sync, alter\_sync). Não é recomendável habilitar essas configurações.
## database\_replicated\_initial\_query\_timeout\_sec
Define por quanto tempo a consulta DDL inicial deve aguardar que o banco de dados Replicated processe as entradas anteriores da fila DDL, em segundos.
Valores possíveis:
* Inteiro positivo.
* 0 — Ilimitado.
## database\_shared\_drop\_table\_delay\_seconds
O atraso, em segundos, antes que uma tabela excluída seja efetivamente removida de um banco de dados Shared. Isso permite recuperar a tabela dentro desse período usando a instrução `UNDROP TABLE`.
## decimal\_check\_overflow
Verifica overflow em operações aritméticas e de comparação com decimais
## deduplicate\_blocks\_in\_dependent\_materialized\_views
Ativa ou desativa a verificação de desduplicação para visões materializadas que recebem dados de tabelas Replicated\*.
Valores possíveis:
0 — Desativado.
1 — Ativado.
Quando ativada, o ClickHouse realiza a desduplicação de blocos em visões materializadas que dependem de tabelas Replicated\*.
Essa configuração é útil para garantir que as visões materializadas não contenham dados duplicados quando a operação de inserção estiver sendo repetida devido a uma falha.
**Veja também**
* [Processamento de NULL em operadores IN](/pt-BR/concepts/features/operations/insert/deduplicating-inserts-on-retries#insert-deduplication-with-materialized-views)
## deduplicate\_insert
Habilita ou desabilita a desduplicação de blocos de `INSERT INTO` (para tabelas Replicated\*).
Essa configuração substitui `insert_deduplicate` e `async_insert_deduplicate`.
Essa configuração tem três valores possíveis:
* disable — A desduplicação é desabilitada para a consulta `INSERT INTO`.
* enable — A desduplicação é habilitada para a consulta `INSERT INTO`.
* backward\_compatible\_choice — A desduplicação é habilitada se `insert_deduplicate` ou `async_insert_deduplicate` estiverem habilitados para o tipo específico de insert.
## deduplicate\_insert\_select
Habilita ou desabilita a desduplicação de blocos de `INSERT SELECT` (para tabelas Replicated\*).
Essa configuração substitui `insert_deduplicate` e `deduplicate_insert` em consultas `INSERT SELECT`.
Essa configuração tem quatro valores possíveis:
* disable — A desduplicação fica desabilitada para a consulta `INSERT SELECT`.
* force\_enable — A desduplicação é habilitada para a consulta `INSERT SELECT`. Se o resultado do `SELECT` não for estável, uma exceção é gerada.
* enable\_when\_possible — A desduplicação é habilitada se `insert_deduplicate` estiver habilitado e o resultado do `SELECT` for estável; caso contrário, fica desabilitada.
* enable\_even\_for\_bad\_queries - A desduplicação é habilitada se `insert_deduplicate` estiver habilitado. Se o resultado do `SELECT` não for estável, um aviso é registrado no log, mas a consulta é executada com desduplicação. Esta opção existe para compatibilidade com versões anteriores. Considere usar outras opções, pois ela pode levar a resultados inesperados.
## default\_materialized\_view\_sql\_security
Permite definir o valor padrão da opção SQL SECURITY ao criar uma visão materializada. [Mais sobre SQL security](/pt-BR/reference/statements/create/view#sql_security).
O valor padrão é `DEFINER`.
## default\_max\_bytes\_in\_join
Tamanho máximo da tabela do lado direito quando um limite é necessário, mas `max_bytes_in_join` não está definido.
## default\_normal\_view\_sql\_security
Permite definir a opção padrão de `SQL SECURITY` ao criar uma view normal. [Mais sobre SQL security](/pt-BR/reference/statements/create/view#sql_security).
O valor padrão é `INVOKER`.
## default\_table\_engine
Mecanismo de tabela padrão usado quando `ENGINE` não é definido em uma instrução `CREATE`.
Valores possíveis:
* uma string que representa qualquer nome válido de mecanismo de tabela
Valor padrão no Cloud: `SharedMergeTree`.
**Exemplo**
Consulta:
```sql theme={null}
SET default_table_engine = 'Log';
SELECT name, value, changed FROM system.settings WHERE name = 'default_table_engine';
```
Resultado:
```response theme={null}
┌─name─────────────────┬─value─┬─changed─┐
│ default_table_engine │ Log │ 1 │
└──────────────────────┴───────┴─────────┘
```
Neste exemplo, qualquer nova tabela que não especificar um `Engine` usará o mecanismo de tabela `Log`:
Consulta:
```sql theme={null}
CREATE TABLE my_table (
x UInt32,
y UInt32
);
SHOW CREATE TABLE my_table;
```
Resultado:
```response theme={null}
┌─statement────────────────────────────────────────────────────────────────┐
│ CREATE TABLE default.my_table
(
`x` UInt32,
`y` UInt32
)
ENGINE = Log
└──────────────────────────────────────────────────────────────────────────┘
```
## default\_temporary\_table\_engine
O mesmo que [default\_table\_engine](#default_table_engine), mas para tabelas temporárias.
Neste exemplo, qualquer nova tabela temporária que não especifique `Engine` usará o mecanismo de tabela `Log`:
Consulta:
```sql theme={null}
SET default_temporary_table_engine = 'Log';
CREATE TEMPORARY TABLE my_table (
x UInt32,
y UInt32
);
SHOW CREATE TEMPORARY TABLE my_table;
```
Resultado:
```response theme={null}
┌─statement────────────────────────────────────────────────────────────────┐
│ CREATE TEMPORARY TABLE default.my_table
(
`x` UInt32,
`y` UInt32
)
ENGINE = Log
└──────────────────────────────────────────────────────────────────────────┘
```
## default\_view\_definer
Permite definir a opção `DEFINER` padrão ao criar uma VIEW. [Mais sobre SQL security](/pt-BR/reference/statements/create/view#sql_security).
O valor padrão é `CURRENT_USER`.
## defer\_partition\_pruning\_after\_final
Quando ativada (padrão), a poda de partições é ignorada em consultas `FINAL` em tabelas cujas
colunas da chave de partição não fazem parte da chave de ordenação. Esse é o comportamento seguro em termos de corretude
introduzido na 26.3: `FINAL` pode precisar desduplicar linhas que compartilham uma chave primária, mas estão
em partições diferentes, e a poda de partições excluiria silenciosamente essas linhas da
entrada da desduplicação.
Quando desativada, a poda de partições é aplicada mesmo com `FINAL`, restaurando o comportamento
anterior à 26.3. Isso pode ser substancialmente mais rápido para consultas com predicados `WHERE` na
coluna de partição, mas só é correto quando linhas com a mesma chave primária não podem existir
em partições diferentes — por exemplo, tabelas de log de eventos cuja coluna de partição é definida no momento da inserção
e nunca muda.
Essa configuração afeta apenas tabelas particionadas cujas colunas da chave de partição não estão contidas
na chave de ordenação; para outras tabelas, a poda de partições é sempre aplicada.
Valores possíveis:
* 0 — Aplicar a poda de partições antes de `FINAL` (comportamento anterior à 26.3, mais rápido, mas inseguro no caso geral).
* 1 — Adiar a poda de partições para depois de `FINAL` (padrão, seguro em termos de corretude).
## delta\_lake\_enable\_engine\_predicate
Habilita a poda interna de dados no delta-kernel.
## delta\_lake\_enable\_expression\_visitor\_logging
Habilita logs no nível Test do visitor de expressões do DeltaLake. Esses logs podem ser detalhados demais, até mesmo para logs de teste.
## delta\_lake\_insert\_max\_bytes\_in\_data\_file
Define o limite, em bytes, para um único arquivo de dados inserido no delta lake.
## delta\_lake\_insert\_max\_rows\_in\_data\_file
Define um limite de linhas para um único arquivo de dados inserido no Delta Lake.
## delta\_lake\_log\_metadata
Habilita o registro em log dos arquivos de metadados do delta lake na tabela do sistema.
## delta\_lake\_reload\_schema\_for\_consistency
Se habilitado, o schema é recarregado dos metadados do DeltaLake antes da execução de cada consulta para garantir
a consistência entre o schema usado durante a análise da consulta e o schema usado durante a execução.
## delta\_lake\_snapshot\_end\_version
Versão final do snapshot do delta lake a ser lida. O valor -1 significa ler a versão mais recente (o valor 0 é uma versão de snapshot válida).
## delta\_lake\_snapshot\_start\_version
Versão inicial do snapshot do Delta Lake a ser lida. O valor -1 significa ler a versão mais recente (o valor 0 é uma versão de snapshot válida).
## delta\_lake\_snapshot\_version
Versão do snapshot do Delta Lake a ser lida. O valor -1 significa ler a versão mais recente (o valor 0 é uma versão de snapshot válida).
## delta\_lake\_throw\_on\_engine\_predicate\_error
Ativa o lançamento de uma exceção caso ocorra um erro ao analisar o predicado de varredura no delta-kernel.
## describe\_compact\_output
Se true, inclui apenas os nomes e os tipos das colunas no resultado da consulta DESCRIBE
## describe\_include\_subcolumns
Habilita a descrição de subcolunas em uma consulta [DESCRIBE](/pt-BR/reference/statements/describe-table). Por exemplo, membros de um [Tuple](/pt-BR/reference/data-types/tuple) ou subcolunas de um tipo de dado [Map](/pt-BR/reference/data-types/map#reading-subcolumns-of-map), [Nullable](/pt-BR/reference/data-types/nullable#finding-null) ou [Array](/pt-BR/reference/data-types/array#array-size).
Valores possíveis:
* 0 — As subcolunas não são incluídas em consultas `DESCRIBE`.
* 1 — As subcolunas são incluídas em consultas `DESCRIBE`.
**Exemplo**
Veja um exemplo da instrução [DESCRIBE](/pt-BR/reference/statements/describe-table).
## describe\_include\_virtual\_columns
Se true, as colunas virtuais da tabela serão incluídas no resultado da consulta DESCRIBE.
## dialeto
Qual dialeto será usado para processar a consulta
## dictionary\_use\_async\_executor
Executa um pipeline para ler a fonte do dicionário em várias threads. Compatível apenas com dicionários que usam fonte CLICKHOUSE local.
## dictionary\_validate\_primary\_key\_type
Valida o tipo da chave primária de dicionários. Por padrão, o tipo `id` de layouts simples será convertido implicitamente para UInt64.
## distinct\_overflow\_mode
Define o que acontece quando a quantidade de dados excede um dos limites.
Valores possíveis:
* `throw`: lançar uma exceção (padrão).
* `break`: interromper a execução da consulta e retornar o resultado parcial, como se os
dados de origem tivessem se esgotado.
## distributed\_aggregation\_memory\_efficient
Indica se o modo de economia de memória da agregação distribuída está habilitado.
## distributed\_background\_insert\_batch
**Aliases**: `distributed_directory_monitor_batch_inserts`
Ativa/desativa o envio em lote dos dados inseridos.
Quando o envio em lote está ativado, o motor de tabela [Distributed](/pt-BR/reference/engines/table-engines/special/distributed) tenta enviar vários arquivos de dados inseridos em uma única operação, em vez de enviá-los separadamente. O envio em lote melhora o desempenho do cluster ao aproveitar melhor os recursos do servidor e da rede.
Possible values:
* 1 — Ativado.
* 0 — Desativado.
## distributed\_background\_insert\_max\_sleep\_time\_ms
**Aliases**: `distributed_directory_monitor_max_sleep_time_ms`
Intervalo máximo para que o motor de tabela [Distributed](/pt-BR/reference/engines/table-engines/special/distributed) envie dados. Limita o crescimento exponencial do intervalo definido na configuração [distributed\_background\_insert\_sleep\_time\_ms](#distributed_background_insert_sleep_time_ms).
Valores possíveis:
* Um número inteiro positivo de milissegundos.
## distributed\_background\_insert\_sleep\_time\_ms
**Aliases**: `distributed_directory_monitor_sleep_time_ms`
Intervalo base para o motor de tabela [Distributed](/pt-BR/reference/engines/table-engines/special/distributed) enviar dados. O intervalo real aumenta exponencialmente em caso de erro.
Valores possíveis:
* Um número inteiro positivo de milissegundos.
## distributed\_background\_insert\_split\_batch\_on\_failure
**Aliases**: `distributed_directory_monitor_split_batch_on_failure`
Habilita/desabilita a divisão de batches em caso de falha.
Às vezes, o envio de um batch específico para o shard remoto pode falhar por causa de algum pipeline posterior complexo (ou seja, `MATERIALIZED VIEW` com `GROUP BY`), devido a `Memory limit exceeded` ou erros semelhantes. Nesse caso, tentar novamente não ajudará (e isso deixará os envios distribuídos da tabela travados), mas enviar os arquivos desse batch um a um pode fazer com que o `INSERT` seja bem-sucedido.
Portanto, definir essa configuração como `1` desabilitará o batching para esses batches (ou seja, desabilita temporariamente `distributed_background_insert_batch` para batches com falha).
Valores possíveis:
* 1 — Habilitado.
* 0 — Desabilitado.
Essa configuração também afeta batches corrompidos (que podem aparecer devido ao encerramento anormal do servidor (máquina) e à ausência de `fsync_after_insert`/`fsync_directories` para o motor de tabela [Distributed](/pt-BR/reference/engines/table-engines/special/distributed)).
Você não deve depender da divisão automática de batches, pois isso pode prejudicar o desempenho.
## distributed\_background\_insert\_timeout
**Aliases**: `insert_distributed_timeout`
Tempo limite para a consulta INSERT em distributed. Essa configuração é usada apenas com insert\_distributed\_sync habilitado. O valor 0 significa que não há tempo limite.
## distributed\_cache\_alignment
Tem efeito apenas no ClickHouse Cloud. Uma configuração para fins de teste; não a altere
## distributed\_cache\_bypass\_connection\_pool
Só tem efeito no ClickHouse Cloud. Permite contornar o pool de conexões do cache distribuído
## distributed\_cache\_connect\_backoff\_max\_ms
Só tem efeito no ClickHouse Cloud. Número máximo de milissegundos de backoff para criar conexões com o distributed cache.
## distributed\_cache\_connect\_backoff\_min\_ms
Só tem efeito no ClickHouse Cloud. Tempo mínimo de backoff, em milissegundos, para criar conexões com o distributed cache.
## distributed\_cache\_connect\_max\_tries
Tem efeito apenas no ClickHouse Cloud. Número de tentativas de conexão ao cache distribuído em caso de falha
## distributed\_cache\_connect\_timeout\_ms
Só tem efeito no ClickHouse Cloud. Tempo limite de conexão ao estabelecer conexão com o servidor de cache distribuído.
## distributed\_cache\_credentials\_refresh\_period\_seconds
Só tem efeito no ClickHouse Cloud. Período de atualização das credenciais.
## distributed\_cache\_data\_packet\_ack\_window
Só tem efeito no ClickHouse Cloud. Janela para envio de ACK da sequência de DataPacket em uma única solicitação de leitura do cache distribuído
## distributed\_cache\_discard\_connection\_if\_unread\_data
Só tem efeito no ClickHouse Cloud. Descarta a conexão se houver dados não lidos.
## distributed\_cache\_fetch\_metrics\_only\_from\_current\_az
Só tem efeito no ClickHouse Cloud. Busca métricas apenas da zona de disponibilidade atual em system.distributed\_cache\_metrics, system.distributed\_cache\_events
## distributed\_cache\_file\_cache\_name
Tem efeito apenas no ClickHouse Cloud. Uma configuração usada apenas em testes de CI — nome do cache do sistema de arquivos a ser usado no distributed cache.
## distributed\_cache\_log\_mode
Só tem efeito no ClickHouse Cloud. Modo de gravação no system.distributed\_cache\_log
## distributed\_cache\_max\_unacked\_inflight\_packets
Só tem efeito no ClickHouse Cloud. Número máximo de pacotes em trânsito sem confirmação em uma única solicitação de leitura do distributed cache
## distributed\_cache\_min\_bytes\_for\_seek
Só tem efeito no ClickHouse Cloud. Número mínimo de bytes para executar seek no distributed cache.
## distributed\_cache\_pool\_behaviour\_on\_limit
Só tem efeito no ClickHouse Cloud. Define o comportamento da conexão do distributed cache quando o limite do pool é atingido
## distributed\_cache\_prefer\_bigger\_buffer\_size
Só tem efeito no ClickHouse Cloud. É o mesmo que filesystem\_cache\_prefer\_bigger\_buffer\_size, mas para o cache distribuído.
## distributed\_cache\_read\_only\_from\_current\_az
Só tem efeito no ClickHouse Cloud. Permite ler apenas da zona de disponibilidade atual. Se desabilitado, fará leituras de todos os servidores de cache em todas as zonas de disponibilidade.
## distributed\_cache\_read\_request\_max\_tries
Só tem efeito no ClickHouse Cloud. Número de tentativas para fazer uma solicitação de leitura do distributed cache em caso de falha
## distributed\_cache\_receive\_response\_wait\_milliseconds
Só tem efeito no ClickHouse Cloud. Tempo de espera, em milissegundos, para receber os dados de uma solicitação do distributed cache
## distributed\_cache\_receive\_timeout\_milliseconds
Só tem efeito no ClickHouse Cloud. Tempo de espera, em milissegundos, para receber qualquer resposta do distributed cache
Valor padrão do Cloud: `20000`.
## distributed\_cache\_receive\_timeout\_ms
Tem efeito apenas no ClickHouse Cloud. Tempo limite para receber dados do servidor do distributed cache, em milissegundos. Se nenhum byte for recebido nesse intervalo, uma exceção é lançada.
## distributed\_cache\_send\_timeout\_ms
Só tem efeito no ClickHouse Cloud. Tempo limite para enviar dados ao servidor de cache distribuído, em milissegundos. Se um cliente precisar enviar dados, mas não conseguir enviar nenhum byte dentro desse intervalo, será gerada uma exceção.
## distributed\_cache\_tcp\_keep\_alive\_timeout\_ms
Só tem efeito no ClickHouse Cloud. O tempo, em milissegundos, que a conexão com o servidor de cache distribuído precisa permanecer inativa antes de o TCP começar a enviar sondas de keepalive.
## distributed\_cache\_throw\_on\_error
Só tem efeito no ClickHouse Cloud. Relança a exceção ocorrida durante a comunicação com o distributed cache ou a exceção recebida do distributed cache. Caso contrário, em caso de erro, recorre a ignorar o distributed cache.
## distributed\_cache\_use\_clients\_cache\_for\_read
Só tem efeito no ClickHouse Cloud. Usa o cache dos clientes para solicitações de leitura.
## distributed\_cache\_use\_clients\_cache\_for\_write
Tem efeito apenas no ClickHouse Cloud. Use o cache dos clientes para requisições de gravação.
## distributed\_cache\_wait\_connection\_from\_pool\_milliseconds
Só tem efeito no ClickHouse Cloud. Tempo de espera, em milissegundos, para receber uma conexão do pool de conexões se distributed\_cache\_pool\_behaviour\_on\_limit for wait
## distributed\_cache\_write\_request\_max\_tries
Só tem efeito no ClickHouse Cloud. Número de tentativas para realizar uma solicitação de gravação do distributed cache em caso de falha
## distributed\_connections\_pool\_size
O número máximo de conexões simultâneas com servidores remotos para o processamento distribuído de todas as consultas a uma única tabela Distributed. Recomendamos definir um valor não inferior ao número de servidores no cluster.
## distributed\_ddl\_entry\_format\_version
Versão de compatibilidade das consultas de DDL distribuído (ON CLUSTER)
Valor padrão no Cloud: `6`.
## distributed\_ddl\_output\_mode
Define o formato do resultado da consulta DDL distribuída.
Valores possíveis:
* `throw` — Retorna o conjunto de resultados com o status de execução da consulta para todos os hosts em que a consulta foi concluída. Se a consulta falhar em alguns hosts, a primeira exceção será relançada. Se a consulta ainda não tiver sido concluída em alguns hosts e [distributed\_ddl\_task\_timeout](#distributed_ddl_task_timeout) for excedido, a exceção `TIMEOUT_EXCEEDED` será lançada.
* `none` — É semelhante a `throw`, mas a consulta DDL distribuída não retorna conjunto de resultados.
* `null_status_on_timeout` — Retorna `NULL` como status de execução em algumas linhas do conjunto de resultados, em vez de lançar `TIMEOUT_EXCEEDED`, se a consulta ainda não tiver sido concluída nos hosts correspondentes.
* `never_throw` — Não lança `TIMEOUT_EXCEEDED` nem relança exceções se a consulta falhar em alguns hosts.
* `none_only_active` - semelhante a `none`, mas não espera por réplicas inativas do banco de dados `Replicated`. Observação: com esse modo, é impossível saber que a consulta não foi executada em alguma réplica e será executada em segundo plano.
* `null_status_on_timeout_only_active` — semelhante a `null_status_on_timeout`, mas não espera por réplicas inativas do banco de dados `Replicated`
* `throw_only_active` — semelhante a `throw`, mas não espera por réplicas inativas do banco de dados `Replicated`
Valor padrão no Cloud: `none_only_active`.
## distributed\_ddl\_task\_timeout
Define o tempo limite para respostas a consultas DDL de todos os hosts do cluster. Se uma solicitação DDL não tiver sido executada em todos os hosts, a resposta conterá um erro de timeout e a solicitação será executada em modo assíncrono. Um valor negativo significa infinito.
Valores possíveis:
* Inteiro positivo.
* 0 — Modo assíncrono.
* Inteiro negativo — timeout infinito.
## distributed\_foreground\_insert
**Aliases**: `insert_distributed_sync`
Habilita ou desabilita a inserção síncrona de dados em uma tabela [Distributed](/pt-BR/reference/engines/table-engines/special/distributed).
Por padrão, ao inserir dados em uma tabela `Distributed`, o servidor ClickHouse envia os dados para os nós do cluster em segundo plano. Quando `distributed_foreground_insert=1`, os dados são processados de forma síncrona, e a operação `INSERT` só é concluída depois que todos os dados são salvos em todos os shards (pelo menos uma réplica para cada shard se `internal_replication` for true).
Valores possíveis:
* `0` — Os dados são inseridos em segundo plano.
* `1` — Os dados são inseridos em modo síncrono.
Valor padrão no Cloud: `1`.
**Veja também**
* [Motor de tabela Distributed](/pt-BR/reference/engines/table-engines/special/distributed)
* [Gerenciamento de tabelas distribuídas](/pt-BR/reference/statements/system#managing-distributed-tables)
## distributed\_group\_by\_no\_merge
Não mescla estados de agregação de diferentes servidores no processamento distribuído de consultas; você pode usar essa opção quando tiver certeza de que há chaves diferentes em shards diferentes.
Valores possíveis:
* `0` — Desabilitado (o processamento final da consulta é feito no nó iniciador).
* `1` - Não mescla estados de agregação de diferentes servidores no processamento distribuído de consultas (a consulta é processada completamente no shard, e o iniciador apenas atua como proxy dos dados); pode ser usado quando houver certeza de que há chaves diferentes em shards diferentes.
* `2` - Igual a `1`, mas aplica `ORDER BY` e `LIMIT` no iniciador (isso não é possível quando a consulta é processada completamente no nó remoto, como em `distributed_group_by_no_merge=1`); pode ser usado para consultas com `ORDER BY` e/ou `LIMIT`.
**Exemplo**
```sql theme={null}
SELECT *
FROM remote('127.0.0.{2,3}', system.one)
GROUP BY dummy
LIMIT 1
SETTINGS distributed_group_by_no_merge = 1
FORMAT PrettyCompactMonoBlock
┌─dummy─┐
│ 0 │
│ 0 │
└───────┘
```
```sql theme={null}
SELECT *
FROM remote('127.0.0.{2,3}', system.one)
GROUP BY dummy
LIMIT 1
SETTINGS distributed_group_by_no_merge = 2
FORMAT PrettyCompactMonoBlock
┌─dummy─┐
│ 0 │
└───────┘
```
## distributed\_index\_analysis
A análise de índices será distribuída entre as réplicas.
É benéfico para armazenamento compartilhado e grandes volumes de dados no cluster.
Usa as réplicas de cluster\_for\_parallel\_replicas.
**Veja também**
* [distributed\_index\_analysis\_for\_non\_shared\_merge\_tree](#distributed_index_analysis_for_non_shared_merge_tree)
* [distributed\_index\_analysis\_min\_parts\_to\_activate](/pt-BR/reference/settings/merge-tree-settings#distributed_index_analysis_min_parts_to_activate)
* [distributed\_index\_analysis\_min\_indexes\_bytes\_to\_activate](/pt-BR/reference/settings/merge-tree-settings#distributed_index_analysis_min_indexes_bytes_to_activate)
## distributed\_index\_analysis\_for\_non\_shared\_merge\_tree
Habilita a análise distribuída de índice mesmo para engines que não sejam SharedMergeTree (engine exclusivo do Cloud).
## distributed\_index\_analysis\_only\_on\_coordinator
Se habilitado, a análise distribuída de índices será executada apenas no coordenador.
Isso evita consultas geradas em O(N^2) quando o predicado contém subconsultas (por exemplo, `IN (SELECT ...)`),
porque, caso contrário, cada réplica seguidora acionaria de forma independente sua própria análise distribuída de índices,
mas torna a análise distribuída de índices menos eficiente se tabelas grandes forem usadas nas subconsultas.
## distributed\_insert\_skip\_read\_only\_replicas
Permite ignorar réplicas somente leitura em consultas INSERT na Distributed.
Valores possíveis:
* 0 — INSERT ocorrerá normalmente; se for para uma réplica somente leitura, falhará
* 1 — O iniciador ignorará réplicas somente leitura antes de enviar dados para os shards.
## distributed\_plan\_default\_reader\_bucket\_count
Número padrão de tarefas para leitura paralela em uma consulta distribuída. As tarefas são distribuídas entre as réplicas.
## distributed\_plan\_default\_shuffle\_join\_bucket\_count
Número padrão de buckets do distributed shuffle-hash-join.
## distributed\_plan\_execute\_locally
Executa todas as tarefas de um plano de consulta distribuída localmente. Útil para testes e depuração.
## distributed\_plan\_force\_exchange\_kind
Força o tipo especificado de operadores Exchange entre os estágios de consultas distribuídas.
Possíveis valores:
* '' - não força nenhum tipo de operador Exchange, permite que o otimizador escolha,
* 'Persisted' - usa arquivos temporários no armazenamento de objetos,
* 'Streaming' - transmite os dados de Exchange pela rede.
## distributed\_plan\_force\_shuffle\_aggregation
Usa a estratégia de agregação Shuffle em vez de PartialAggregation + Merge no plano de consulta distribuído.
## distributed\_plan\_max\_rows\_to\_broadcast
Número máximo de linhas para usar broadcast join em vez de shuffle join no plano de consulta distribuída.
## distributed\_plan\_optimize\_exchanges
Remove exchanges desnecessários no plano de consulta distribuída. Desative esta opção para depuração.
## distributed\_plan\_prefer\_replicas\_over\_workers
Serializa o plano distribuído de consulta para execução nas réplicas.
## distributed\_product\_mode
Altera o comportamento das [subconsultas distribuídas](/pt-BR/reference/statements/in).
O ClickHouse aplica essa configuração quando a consulta contém o produto de tabelas distribuídas, isto é, quando a consulta de uma tabela distribuída contém uma subconsulta não `GLOBAL` sobre uma tabela distribuída.
Restrições:
* Aplicado apenas a subconsultas `IN` e `JOIN`.
* Somente se a seção `FROM` usar uma tabela distribuída com mais de um shard.
* Somente se a subconsulta envolver uma tabela distribuída com mais de um shard.
* Não é usado para a função de tabela [remote](/pt-BR/reference/functions/table-functions/remote).
Valores possíveis:
* `deny` — Valor padrão. Proíbe o uso desses tipos de subconsultas (retorna a exceção "Double-distributed in/JOIN subqueries is denied").
* `local` — Substitui o banco de dados e a tabela na subconsulta pelos locais do servidor de destino (shard), mantendo o `IN`/`JOIN` normal.
* `global` — Substitui a consulta `IN`/`JOIN` por `GLOBAL IN`/`GLOBAL JOIN`.
* `allow` — Permite o uso desses tipos de subconsultas.
## distributed\_push\_down\_limit
Habilita ou desabilita a aplicação de [LIMIT](#limit) separadamente em cada shard.
Isso ajuda a evitar:
* O envio de linhas extras pela rede;
* O processamento, no iniciador, de linhas além do limite.
A partir da versão 21.9, não é mais possível obter resultados imprecisos, pois `distributed_push_down_limit` altera a execução da consulta somente se pelo menos uma das condições abaixo for atendida:
* [distributed\_group\_by\_no\_merge](#distributed_group_by_no_merge) > 0.
* A consulta **não tem** `GROUP BY`/`DISTINCT`/`LIMIT BY`, mas tem `ORDER BY`/`LIMIT`.
* A consulta **tem** `GROUP BY`/`DISTINCT`/`LIMIT BY` com `ORDER BY`/`LIMIT` e:
* [optimize\_skip\_unused\_shards](#optimize_skip_unused_shards) está habilitado.
* [optimize\_distributed\_group\_by\_sharding\_key](#optimize_distributed_group_by_sharding_key) está habilitado.
Valores possíveis:
* 0 — Desabilitado.
* 1 — Habilitado.
Veja também:
* [distributed\_group\_by\_no\_merge](#distributed_group_by_no_merge)
* [optimize\_skip\_unused\_shards](#optimize_skip_unused_shards)
* [optimize\_distributed\_group\_by\_sharding\_key](#optimize_distributed_group_by_sharding_key)
## distributed\_replica\_error\_cap
* Tipo: inteiro sem sinal
* Valor padrão: 1000
A contagem de erros de cada réplica é limitada a esse valor, evitando que uma única réplica acumule erros em excesso.
Veja também:
* [load\_balancing](#load_balancing-round_robin)
* [Mecanismo de tabela Distributed](/pt-BR/reference/engines/table-engines/special/distributed)
* [distributed\_replica\_error\_half\_life](#distributed_replica_error_half_life)
* [distributed\_replica\_max\_ignored\_errors](#distributed_replica_max_ignored_errors)
## distributed\_replica\_error\_half\_life
* Tipo: segundos
* Valor padrão: 60 segundos
Controla a rapidez com que os erros em tabelas distribuídas são reduzidos a zero. Se uma réplica ficar indisponível por algum tempo, acumular 5 erros e distributed\_replica\_error\_half\_life estiver definido como 1 segundo, então a réplica será considerada normal 3 segundos após o último erro.
Veja também:
* [load\_balancing](#load_balancing-round_robin)
* [Motor de tabela Distributed](/pt-BR/reference/engines/table-engines/special/distributed)
* [distributed\_replica\_error\_cap](#distributed_replica_error_cap)
* [distributed\_replica\_max\_ignored\_errors](#distributed_replica_max_ignored_errors)
## distributed\_replica\_max\_ignored\_errors
* Tipo: inteiro sem sinal
* Valor padrão: 0
O número de erros que serão ignorados durante a escolha de réplicas (de acordo com o algoritmo `load_balancing`).
Veja também:
* [load\_balancing](#load_balancing-round_robin)
* [mecanismo de tabela Distributed](/pt-BR/reference/engines/table-engines/special/distributed)
* [distributed\_replica\_error\_cap](#distributed_replica_error_cap)
* [distributed\_replica\_error\_half\_life](#distributed_replica_error_half_life)
## do\_not\_merge\_across\_partitions\_select\_final
Melhora as consultas FINAL ao evitar mesclagens entre partições diferentes.
Quando ativado, em consultas SELECT FINAL, as partes de partições diferentes não serão mescladas entre si. Em vez disso, a mesclagem ocorrerá apenas dentro de cada partição. Isso pode melhorar significativamente o desempenho das consultas ao trabalhar com tabelas particionadas.
## dynamic\_disk\_allow\_from\_env
Permite usar substituições `from_env` na configuração dinâmica de disco (ou seja, nos argumentos da função `disk()`).
Desativada por padrão para impedir que usuários leiam variáveis de ambiente arbitrárias ao definir o armazenamento da tabela.
## dynamic\_disk\_allow\_from\_zk
Permite usar substituições `from_zk` na configuração de disco dinâmica (ou seja, nos argumentos da função `disk()`).
Desativada por padrão.
## dynamic\_disk\_allow\_include
Permite usar `include` na configuração de disco dinâmico (ou seja, nos argumentos da função `disk()`).
Desativada por padrão.
## dynamic\_throw\_on\_type\_mismatch
Ao aplicar uma função a uma coluna [Dynamic](/pt-BR/reference/data-types/dynamic) usando a implementação padrão,
controla o que acontece com as linhas cujo tipo real é incompatível com a função:
* `true` (padrão) — gera uma exceção.
* `false` — retorna `NULL` para essas linhas.
## empty\_result\_for\_aggregation\_by\_constant\_keys\_on\_empty\_set
Retorna um resultado vazio ao fazer agregação por chaves constantes em um conjunto vazio.
## empty\_result\_for\_aggregation\_by\_empty\_set
Retorna um resultado vazio ao fazer agregação sem chaves em conjunto vazio.
## enable\_adaptive\_memory\_spill\_scheduler
Aciona o processador para descarregar dados para armazenamento externo de forma adaptativa. No momento, há suporte a grace join.
## enable\_add\_distinct\_to\_in\_subqueries
Habilita `DISTINCT` em subconsultas `IN`. Esta é uma configuração de trade-off: ao habilitá-la, é possível reduzir bastante o tamanho das tabelas temporárias transferidas em subconsultas distribuídas com `IN` e acelerar significativamente a transferência de dados entre shards, garantindo que apenas valores únicos sejam enviados.
No entanto, habilitar essa configuração exige esforço adicional de merging em cada nó, pois a desduplicação (`DISTINCT`) precisa ser realizada. Use essa configuração quando a transferência de rede for um gargalo e o custo adicional de merging for aceitável.
## enable\_automatic\_decision\_for\_merging\_across\_partitions\_for\_final
Se estiver definida, o ClickHouse habilitará automaticamente essa otimização quando a expressão da chave de partição for determinística e todas as colunas usadas nela estiverem incluídas na chave primária.
Essa derivação automática garante que linhas com os mesmos valores de chave primária sempre pertençam à mesma partição, tornando seguro evitar merge entre partições.
## enable\_blob\_storage\_log
Registra informações sobre operações de blob storage na tabela system.blob\_storage\_log
## enable\_blob\_storage\_log\_for\_read\_operations
Grava informações sobre operações de leitura do armazenamento de blobs na tabela system.blob\_storage\_log.
Também requer que `enable_blob_storage_log` esteja habilitado.
## enable\_early\_constant\_folding
Ativa a otimização de consultas na qual analisamos os resultados de funções e subconsultas e reescrevemos a consulta se houver constantes nesses resultados
## enable\_extended\_results\_for\_datetime\_functions
Habilita ou desabilita o retorno de resultados do tipo `Date32` com intervalo ampliado (em comparação com o tipo `Date`)
ou `DateTime64` com intervalo ampliado (em comparação com o tipo `DateTime`).
Valores possíveis:
* `0` — As funções retornam `Date` ou `DateTime` para todos os tipos de argumentos.
* `1` — As funções retornam `Date32` ou `DateTime64` para argumentos `Date32` ou `DateTime64` e `Date` ou `DateTime` nos demais casos.
A tabela abaixo mostra o comportamento dessa configuração para várias funções de data e hora.
| Função | `enable_extended_results_for_datetime_functions = 0` | `enable_extended_results_for_datetime_functions = 1` |
| ------------------------- | --------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------ |
| `toStartOfYear` | Retorna `Date` ou `DateTime` | Retorna `Date`/`DateTime` para entradas `Date`/`DateTime`
Retorna `Date32`/`DateTime64` para entradas `Date32`/`DateTime64` |
| `toStartOfISOYear` | Retorna `Date` ou `DateTime` | Retorna `Date`/`DateTime` para entradas `Date`/`DateTime`
Retorna `Date32`/`DateTime64` para entradas `Date32`/`DateTime64` |
| `toStartOfQuarter` | Retorna `Date` ou `DateTime` | Retorna `Date`/`DateTime` para entradas `Date`/`DateTime`
Retorna `Date32`/`DateTime64` para entradas `Date32`/`DateTime64` |
| `toStartOfMonth` | Retorna `Date` ou `DateTime` | Retorna `Date`/`DateTime` para entradas `Date`/`DateTime`
Retorna `Date32`/`DateTime64` para entradas `Date32`/`DateTime64` |
| `toStartOfWeek` | Retorna `Date` ou `DateTime` | Retorna `Date`/`DateTime` para entradas `Date`/`DateTime`
Retorna `Date32`/`DateTime64` para entradas `Date32`/`DateTime64` |
| `toLastDayOfWeek` | Retorna `Date` ou `DateTime` | Retorna `Date`/`DateTime` para entradas `Date`/`DateTime`
Retorna `Date32`/`DateTime64` para entradas `Date32`/`DateTime64` |
| `toLastDayOfMonth` | Retorna `Date` ou `DateTime` | Retorna `Date`/`DateTime` para entradas `Date`/`DateTime`
Retorna `Date32`/`DateTime64` para entradas `Date32`/`DateTime64` |
| `toMonday` | Retorna `Date` ou `DateTime` | Retorna `Date`/`DateTime` para entradas `Date`/`DateTime`
Retorna `Date32`/`DateTime64` para entradas `Date32`/`DateTime64` |
| `toStartOfDay` | Retorna `DateTime`
*Observação: resultados incorretos para valores fora do intervalo de 1970 a 2149* | Retorna `DateTime` para entradas `Date`/`DateTime`
Retorna `DateTime64` para entradas `Date32`/`DateTime64` |
| `toStartOfHour` | Retorna `DateTime`
*Observação: resultados incorretos para valores fora do intervalo de 1970 a 2149* | Retorna `DateTime` para entradas `Date`/`DateTime`
Retorna `DateTime64` para entradas `Date32`/`DateTime64` |
| `toStartOfFifteenMinutes` | Retorna `DateTime`
*Observação: resultados incorretos para valores fora do intervalo de 1970 a 2149* | Retorna `DateTime` para valores de entrada `Date`/`DateTime`
Retorna `DateTime64` para valores de entrada `Date32`/`DateTime64` |
| `toStartOfTenMinutes` | Retorna `DateTime`
*Observação: resultados incorretos para valores fora do intervalo de 1970-2149* | Retorna `DateTime` para entradas `Date`/`DateTime`
Retorna `DateTime64` para entradas `Date32`/`DateTime64` |
| `toStartOfFiveMinutes` | Retorna `DateTime`
*Observação: resultados incorretos para valores fora do intervalo de 1970 a 2149* | Retorna `DateTime` para valores de entrada `Date`/`DateTime`
Retorna `DateTime64` para valores de entrada `Date32`/`DateTime64` |
| `toStartOfMinute` | Retorna `DateTime`
*Observação: resultados incorretos para valores fora do intervalo de 1970 a 2149* | Retorna `DateTime` para valores de entrada `Date`/`DateTime`
Retorna `DateTime64` para valores de entrada `Date32`/`DateTime64` |
| `timeSlot` | Retorna `DateTime`
*Observação: resultados incorretos para valores fora do intervalo de 1970-2149* | Retorna `DateTime` para entradas `Date`/`DateTime`
Retorna `DateTime64` para entradas `Date32`/`DateTime64` |
## enable\_filesystem\_cache
Usa o cache para filesystem remoto. Esta configuração não ativa/desativa o cache para disks (isso deve ser feito via configuração do disk), mas permite ignorar o cache para algumas queries, se desejado
## enable\_filesystem\_cache\_log
Permite registrar o log do cache do sistema de arquivos para cada consulta
## enable\_filesystem\_cache\_on\_write\_operations
Habilita ou desabilita o cache `write-through`. Se definido como `false`, o cache `write-through` é desabilitado para operações de gravação. Se definido como `true`, o cache `write-through` é habilitado desde que `cache_on_write_operations` esteja ativado na seção de configuração do disco de cache da configuração do servidor.
Consulte ["Usando cache local"](/pt-BR/concepts/features/configuration/server-config/storing-data#using-local-cache) para mais detalhes.
Valor padrão no Cloud: `1`.
## enable\_filesystem\_read\_prefetches\_log
Grava em system.filesystem prefetch\_log durante a consulta. Deve ser usado apenas para testes ou depuração; não é recomendado deixá-lo ativado por padrão
## enable\_full\_text\_index
**Aliases**: `allow_experimental_full_text_index`
Quando definido como true, permite usar o índice de texto.
## enable\_global\_with\_statement
Propagar instruções WITH para consultas UNION e para todas as subconsultas
## enable\_hdfs\_pread
Ativa ou desativa o `pread` para arquivos HDFS. Por padrão, `hdfsPread` é usado. Se estiver desativado, `hdfsRead` e `hdfsSeek` serão usados para ler arquivos HDFS.
## enable\_http\_compression
Habilita ou desabilita a compressão de dados na resposta a uma requisição HTTP.
Para mais informações, consulte a [descrição da interface HTTP](/pt-BR/concepts/features/interfaces/http).
Possible values:
* 0 — Desabilitado.
* 1 — Habilitado.
## enable\_job\_stack\_trace
Exibe o stack trace do criador do job quando o job resulta em uma exceção. Desativada por padrão para evitar sobrecarga de desempenho.
## enable\_join\_fixed\_hash\_table\_conversion
Permite converter a tabela hash em um array simples para junções quando a chave for um único inteiro com um pequeno intervalo de valores.
## enable\_join\_runtime\_filters
Filtra o lado esquerdo usando o conjunto de chaves de JOIN coletadas do lado direito em tempo de execução.
## enable\_join\_transitive\_predicates
Infere predicados transitivos de equi-join a partir de condições de join existentes.
Por exemplo, com `A.x = B.x` e `B.x = C.x`, um predicado sintético `A.x = C.x`
é adicionado para que o otimizador da ordem dos joins possa considerar planos diretos (A JOIN C).
## enable\_lazy\_columns\_replication
Habilita a replicação sob demanda de colunas em JOIN e ARRAY JOIN, permitindo evitar cópias desnecessárias das mesmas linhas várias vezes na memória.
## enable\_lightweight\_delete
**Aliases**: `allow_experimental_lightweight_delete`
Habilita mutações de exclusão leve com DELETE para tabelas MergeTree.
## enable\_lightweight\_update
**Aliases**: `allow_experimental_lightweight_update`
Permite o uso de atualizações leves.
## enable\_materialized\_cte
Ativa expressões de tabela comuns materializadas; essa opção tem precedência sobre enable\_global\_with\_statement
## enable\_memory\_bound\_merging\_of\_aggregation\_results
Habilita a estratégia de mesclagem com limite de memória para agregação.
## enable\_multiple\_prewhere\_read\_steps
Mova mais condições de WHERE para PREWHERE e faça leituras do disco e a filtragem em várias etapas se houver várias condições combinadas com AND
## enable\_named\_columns\_in\_function\_tuple
Gerar tuplas nomeadas na função tuple() quando todos os nomes forem exclusivos e puderem ser tratados como identificadores sem aspas.
## enable\_optimize\_predicate\_expression
Ativa o pushdown de predicados em consultas `SELECT`.
O pushdown de predicados pode reduzir significativamente o tráfego de rede em consultas distribuídas.
Valores possíveis:
* 0 — Desativado.
* 1 — Ativado.
Uso
Considere as seguintes consultas:
1. `SELECT count() FROM test_table WHERE date = '2018-10-10'`
2. `SELECT count() FROM (SELECT * FROM test_table) WHERE date = '2018-10-10'`
Se `enable_optimize_predicate_expression = 1`, o tempo de execução dessas consultas será o mesmo, porque o ClickHouse aplica `WHERE` à subconsulta durante o processamento.
Se `enable_optimize_predicate_expression = 0`, o tempo de execução da segunda consulta será muito maior, porque a cláusula `WHERE` só é aplicada a todos os dados depois que a subconsulta é concluída.
## enable\_optimize\_predicate\_expression\_to\_final\_subquery
Permite fazer push do predicado para a subconsulta FINAL.
## enable\_order\_by\_all
Ativa ou desativa a ordenação com a sintaxe `ORDER BY ALL`; consulte [ORDER BY](/pt-BR/reference/statements/select/order-by).
Valores possíveis:
* 0 — Desativa ORDER BY ALL.
* 1 — Ativa ORDER BY ALL.
**Exemplo**
Consulta:
```sql theme={null}
CREATE TABLE TAB(C1 Int, C2 Int, ALL Int) ENGINE=Memory();
INSERT INTO TAB VALUES (10, 20, 30), (20, 20, 10), (30, 10, 20);
SELECT * FROM TAB ORDER BY ALL; -- retorna um erro informando que ALL é ambíguo
SELECT * FROM TAB ORDER BY ALL SETTINGS enable_order_by_all = 0;
```
Resultado:
```text theme={null}
┌─C1─┬─C2─┬─ALL─┐
│ 20 │ 20 │ 10 │
│ 30 │ 10 │ 20 │
│ 10 │ 20 │ 30 │
└────┴────┴─────┘
```
## enable\_parallel\_blocks\_marshalling
Afeta apenas consultas distribuídas. Se estiver habilitada, os blocos serão (des)serializados e (des)comprimidos nas threads do pipeline (ou seja, com paralelismo maior que o padrão) antes/depois do envio ao iniciador.
## enable\_parsing\_to\_custom\_serialization
Se true, os dados podem ser convertidos diretamente em colunas com serialização personalizada (por exemplo, Sparse), com base nas dicas de serialização obtidas da tabela.
## enable\_positional\_arguments
Habilita ou desabilita o suporte a argumentos posicionais nas instruções [GROUP BY](/pt-BR/reference/statements/select/group-by), [LIMIT BY](/pt-BR/reference/statements/select/limit-by) e [ORDER BY](/pt-BR/reference/statements/select/order-by).
Valores possíveis:
* 0 — Argumentos posicionais não são suportados.
* 1 — Argumentos posicionais são suportados: números de coluna podem ser usados no lugar de nomes de coluna.
**Exemplo**
Consulta:
```sql theme={null}
CREATE TABLE positional_arguments(one Int, two Int, three Int) ENGINE=Memory();
INSERT INTO positional_arguments VALUES (10, 20, 30), (20, 20, 10), (30, 10, 20);
SELECT * FROM positional_arguments ORDER BY 2,3;
```
Resultado:
```text theme={null}
┌─one─┬─two─┬─three─┐
│ 30 │ 10 │ 20 │
│ 20 │ 20 │ 10 │
│ 10 │ 20 │ 30 │
└─────┴─────┴───────┘
```
## enable\_positional\_arguments\_for\_projections
Ativa ou desativa o suporte a argumentos posicionais em definições de PROJECTION. Veja também a configuração [enable\_positional\_arguments](#enable_positional_arguments).
Esta é uma configuração avançada, e você não deve alterá-la se estiver apenas começando a usar o ClickHouse.
Valores possíveis:
* 0 — Argumentos posicionais não têm suporte.
* 1 — Argumentos posicionais têm suporte: números de colunas podem ser usados no lugar de nomes de colunas.
## enable\_producing\_buckets\_out\_of\_order\_in\_aggregation
Permite que a agregação com eficiência de memória (consulte `distributed_aggregation_memory_efficient`) produza buckets fora de ordem.
Isso pode melhorar o desempenho quando os tamanhos dos buckets de agregação são desiguais, permitindo que uma réplica envie buckets com IDs mais altos para o iniciador enquanto ainda processa alguns buckets pesados com IDs mais baixos.
A desvantagem é um uso de memória potencialmente maior.
## enable\_reads\_from\_query\_cache
Quando ativado, os resultados de consultas `SELECT` são obtidos do [cache de consultas](/pt-BR/concepts/features/performance/caches/query-cache).
Valores possíveis:
* 0 - Desabilitado
* 1 - Habilitado
## enable\_s3\_requests\_logging
Ativa um logging bem detalhado das requisições ao S3. Recomendado apenas para depuração.
## enable\_scalar\_subquery\_optimization
Se definido como true, impede que subconsultas escalares (des)serializem valores escalares grandes e possivelmente evita a execução da mesma subconsulta mais de uma vez.
## enable\_scopes\_for\_with\_statement
Se desabilitada, as declarações em cláusulas WITH de nível pai terão o mesmo escopo que teriam se fossem declaradas no escopo atual.
Observe que esta é uma configuração de compatibilidade do analyzer para permitir a execução de algumas consultas inválidas que o analyzer antigo conseguia executar.
## enable\_shared\_storage\_snapshot\_in\_query
Se estiver habilitada, todas as subconsultas em uma única consulta compartilharão o mesmo StorageSnapshot para cada tabela.
Isso garante uma visão consistente dos dados em toda a consulta, mesmo que a mesma tabela seja acessada várias vezes.
Isso é necessário para consultas em que a consistência interna das partes de dados é importante. Exemplo:
```sql theme={null}
SELECT
count()
FROM events
WHERE (_part, _part_offset) IN (
SELECT _part, _part_offset
FROM events
WHERE user_id = 42
)
```
Sem esta configuração, as consultas externa e interna podem operar sobre snapshots de dados diferentes, levando a resultados incorretos.
Ao habilitar esta configuração, a otimização que remove dos snapshots as partes de dados desnecessárias após a conclusão da etapa de planejamento é desativada.
Como resultado, consultas de longa duração podem manter partes obsoletas por toda a sua duração, atrasando a limpeza dessas partes e aumentando a pressão sobre o armazenamento.
Atualmente, esta configuração se aplica apenas a tabelas da família MergeTree.
Valores possíveis:
* 0 - Desabilitado
* 1 - Habilitado
## enable\_sharing\_sets\_for\_mutations
Permite compartilhar objetos Set criados para subconsultas IN entre diferentes tarefas da mesma mutação. Isso reduz o uso de memória e o consumo de CPU
## enable\_software\_prefetch\_in\_aggregation
Habilita o uso de prefetch por software na agregaç
## enable\_software\_prefetch\_in\_join
Ativa o uso de software prefetch na fase de sondagem do hash join para mascarar a latência de acesso à memória em tabelas hash grandes.
## enable\_time\_time64\_type
**Aliases**: `allow_experimental_time_time64_type`
Permite a criação dos tipos de dados [Time](/pt-BR/reference/data-types/time) e [Time64](/pt-BR/reference/data-types/time64).
## enable\_unaligned\_array\_join
Permite ARRAY JOIN com vários arrays de tamanhos diferentes. Quando essa configuração está ativada, os arrays serão redimensionados para o mais longo.
## enable\_url\_encoding
Permite habilitar/desabilitar a decodificação/codificação do caminho na URI em tabelas com o motor [URL](/pt-BR/reference/engines/table-engines/special/url).
Desabilitado por padrão.
## enable\_vertical\_final
Se estiver habilitado, remove linhas duplicadas durante o FINAL marcando as linhas como excluídas e filtrando-as posteriormente, em vez de mesclá-las
## enable\_writes\_to\_query\_cache
Quando ativado, os resultados de consultas `SELECT` são armazenados no [cache de consultas](/pt-BR/concepts/features/performance/caches/query-cache).
Valores possíveis:
* 0 - Desabilitado
* 1 - Habilitado
## enforce\_strict\_identifier\_format
Se habilitada, permite apenas identificadores que contenham caracteres alfanuméricos e underscores.
## engine\_file\_allow\_create\_multiple\_files
Habilita ou desabilita a criação de um novo arquivo a cada insert em tabelas com o engine File se o format tiver o sufixo (`JSON`, `ORC`, `Parquet` etc.). Se estiver habilitado, a cada insert, um novo arquivo será criado com um nome seguindo este padrão:
`data.Parquet` -> `data.1.Parquet` -> `data.2.Parquet` etc.
Possible values:
* 0 — a consulta `INSERT` acrescenta novos dados ao final do arquivo.
* 1 — a consulta `INSERT` cria um novo arquivo.
## engine\_file\_empty\_if\_not\_exists
Permite selecionar dados de uma tabela do engine File sem que o arquivo exista.
Possíveis valores:
* 0 — `SELECT` lança uma exceção.
* 1 — `SELECT` retorna um resultado vazio.
## engine\_file\_skip\_empty\_files
Ativa ou desativa a omissão de arquivos vazios em tabelas com o motor [File](/pt-BR/reference/engines/table-engines/special/file).
Valores possíveis:
* 0 — `SELECT` gera uma exceção se o arquivo vazio não for compatível com o formato solicitado.
* 1 — `SELECT` retorna um resultado vazio para um arquivo vazio.
## engine\_file\_truncate\_on\_insert
Ativa ou desativa o truncamento antes do insert em tabelas com o motor [File](/pt-BR/reference/engines/table-engines/special/file).
Valores possíveis:
* 0 — a consulta `INSERT` acrescenta novos dados ao final do arquivo.
* 1 — a consulta `INSERT` substitui o conteúdo existente do arquivo pelos novos dados.
## engine\_url\_skip\_empty\_files
Ativa ou desativa a opção de ignorar arquivos vazios em tabelas do mecanismo [URL](/pt-BR/reference/engines/table-engines/special/url).
Valores possíveis:
* 0 — `SELECT` gera uma exceção se o arquivo vazio não for compatível com o formato solicitado.
* 1 — `SELECT` retorna um resultado vazio para um arquivo vazio.
## exact\_rows\_before\_limit
Quando habilitada, o ClickHouse fornecerá o valor exato da estatística rows\_before\_limit\_at\_least, mas isso exige que os dados antes do limite sejam lidos por completo
## except\_default\_mode
Configura o modo padrão na consulta EXCEPT. Valores possíveis: string vazia, 'ALL', 'DISTINCT'. Se estiver vazia, uma consulta sem modo gerará uma exceção.
## exclude\_materialize\_skip\_indexes\_on\_insert
Exclui os skip indexes especificados de serem criados e armazenados durante INSERTs. Os skip indexes excluídos ainda serão criados e armazenados [durante mesclagens](/pt-BR/reference/settings/merge-tree-settings#materialize_skip_indexes_on_merge) ou por uma
consulta [MATERIALIZE INDEX](/pt-BR/reference/statements/alter/skipping-index#materialize-index) explícita.
Não tem efeito se [materialize\_skip\_indexes\_on\_insert](#materialize_skip_indexes_on_insert) estiver definido como false.
Exemplo:
```sql theme={null}
CREATE TABLE tab
(
a UInt64,
b UInt64,
INDEX idx_a a TYPE minmax,
INDEX idx_b b TYPE set(3)
)
ENGINE = MergeTree ORDER BY tuple();
SET exclude_materialize_skip_indexes_on_insert='idx_a'; -- idx_a não será atualizado no insert
--SET exclude_materialize_skip_indexes_on_insert='idx_a, idx_b'; -- nenhum índice seria atualizado no insert
INSERT INTO tab SELECT number, number / 50 FROM numbers(100); -- apenas idx_b é atualizado
-- como é uma configuração de sessão, pode ser definida individualmente por consulta
INSERT INTO tab SELECT number, number / 50 FROM numbers(100, 100) SETTINGS exclude_materialize_skip_indexes_on_insert='idx_b';
ALTER TABLE tab MATERIALIZE INDEX idx_a; -- esta consulta pode ser usada para materializar o índice explicitamente
SET exclude_materialize_skip_indexes_on_insert = DEFAULT; -- redefine a configuração para o valor padrão
```
## execute\_exists\_as\_scalar\_subquery
Executa subconsultas EXISTS não correlacionadas como subconsultas escalares. Assim como nas subconsultas escalares, o cache é usado, e o constant folding é aplicado ao resultado.
Valor padrão no Cloud: `0`.
## external\_storage\_connect\_timeout\_sec
Timeout de conexão em segundos. No momento, compatível apenas com MySQL
## external\_storage\_max\_read\_bytes
Limita o número máximo de bytes quando uma tabela com engine externo deve descarregar os dados do histórico. No momento, há suporte apenas para MySQL table engine, database engine e Dicionário. Se for igual a 0, essa configuração é desabilitada
## external\_storage\_max\_read\_rows
Limita o número máximo de linhas quando uma tabela com engine externo deve gravar dados do histórico. No momento, há suporte apenas para MySQL table engine, database engine e Dicionário. Se for igual a 0, esta configuração ficará desabilitada
## external\_storage\_rw\_timeout\_sec
Tempo limite de leitura/gravação em segundos. No momento, compatível apenas com MySQL
## external\_table\_functions\_use\_nulls
Define como as funções de tabela [mysql](/pt-BR/reference/functions/table-functions/mysql), [postgresql](/pt-BR/reference/functions/table-functions/postgresql) e [odbc](/pt-BR/reference/functions/table-functions/odbc) utilizam colunas Nullable.
Possíveis valores:
* 0 — A função de tabela usa explicitamente colunas Nullable.
* 1 — A função de tabela usa implicitamente colunas Nullable.
**Uso**
Se a configuração estiver definida como `0`, a função de tabela não cria colunas Nullable e insere valores padrão em vez de NULL. Isso também se aplica a valores NULL dentro de arrays.
## external\_table\_strict\_query
Se estiver definido como true, a transformação de expression em filter local será proibida para consultas a external tables.
**Aliases**: `extract_kvp_max_pairs_per_row`
Número máximo de pares que podem ser produzidos pela função `extractKeyValuePairs`. Serve como salvaguarda para evitar o consumo excessivo de memória.
## extremes
Define se os valores extremos (os mínimos e máximos nas colunas do resultado de uma consulta) devem ser contabilizados. Aceita 0 ou 1. O padrão é 0 (desabilitado).
Para mais informações, consulte a seção "Valores extremos".
## fallback\_to\_stale\_replicas\_for\_distributed\_queries
Direciona a consulta para uma réplica desatualizada se dados atualizados não estiverem disponíveis. Veja [Replicação](/pt-BR/reference/engines/table-engines/mergetree-family/replication).
O ClickHouse seleciona a réplica mais adequada entre as réplicas desatualizadas da tabela.
Usado ao executar `SELECT` em uma tabela distribuída que aponta para tabelas replicadas.
Por padrão, 1 (habilitado).
## filesystem\_cache\_allow\_background\_download
Permite que o cache do sistema de arquivos enfileire downloads em segundo plano para dados lidos do armazenamento remoto. Desative esta opção para manter os downloads em primeiro plano para a consulta/sessão atual.
## filesystem\_cache\_boundary\_alignment
Alinhamento dos limites do cache do sistema de arquivos. Essa configuração se aplica apenas a leituras que não são de disco (por exemplo, ao cache de motores de tabela remotos / funções de tabela, mas não à configuração de armazenamento de tabelas MergeTree). O valor 0 significa que não há alinhamento.
## filesystem\_cache\_enable\_background\_download\_during\_fetch
Só tem efeito no ClickHouse Cloud. Tempo de espera para adquirir o bloqueio do cache para reservar espaço no cache do sistema de arquivos
## filesystem\_cache\_enable\_background\_download\_for\_metadata\_files\_in\_packed\_storage
Só tem efeito no ClickHouse Cloud. Tempo de espera para obter o bloqueio do cache para reservar espaço no cache do sistema de arquivos
## filesystem\_cache\_max\_download\_size
Tamanho máximo do cache de sistema de arquivos remoto que pode ser baixado por uma única consulta
## filesystem\_cache\_name
Nome do cache do sistema de arquivos a ser usado em motores de tabela sem estado ou lagos de dados
## filesystem\_cache\_prefer\_bigger\_buffer\_size
Prefere um tamanho de buffer maior se o cache do sistema de arquivos estiver habilitado, para evitar a gravação de pequenos segmentos de arquivo, o que prejudica o desempenho do cache. Por outro lado, habilitar essa configuração pode aumentar o uso de memória.
## filesystem\_cache\_reserve\_space\_wait\_lock\_timeout\_milliseconds
Tempo de espera para adquirir o bloqueio do cache para reservar espaço no cache do sistema de arquivos
## filesystem\_cache\_segments\_batch\_size
Limite para o tamanho de um único lote de segmentos de arquivo que um buffer de leitura pode solicitar ao cache. Um valor muito baixo levará a solicitações excessivas ao cache; um valor muito alto pode tornar mais lenta a remoção de entradas do cache
## filesystem\_cache\_skip\_download\_if\_exceeds\_per\_query\_cache\_write\_limit
**Aliases**: `skip_download_if_exceeds_query_cache`
Ignora o download do sistema de arquivos remoto caso exceda o tamanho do cache de consultas
## filesystem\_prefetch\_max\_memory\_usage
Uso máximo de memória para prefetches.
Valor padrão no Cloud: 10% da memória total.
## filesystem\_prefetch\_step\_bytes
Passo de prefetch em bytes. Zero significa `auto` — o melhor passo de prefetch será estimado automaticamente, mas pode não ser o ideal em 100% dos casos. O valor real pode ser diferente por causa da configuração filesystem\_prefetch\_min\_bytes\_for\_single\_read\_task
## filesystem\_prefetch\_step\_marks
Passo de prefetch em marcas. Zero significa `auto` — aproximadamente o melhor passo de prefetch será determinado automaticamente, mas pode não ser 100% o ideal. O valor real pode ser diferente por causa da configuração filesystem\_prefetch\_min\_bytes\_for\_single\_read\_task
## filesystem\_prefetches\_limit
Número máximo de prefetches. Zero significa sem limite. A configuração `filesystem_prefetches_max_memory_usage` é mais recomendada se você quiser limitar o número de prefetches
## final
Aplica automaticamente o modificador [FINAL](/pt-BR/reference/statements/select/from#final-modifier) a todas as tabelas de uma consulta nas quais [FINAL](/pt-BR/reference/statements/select/from#final-modifier) é aplicável, incluindo tabelas em JOIN, tabelas em subconsultas e
tabelas distribuídas.
Valores possíveis:
* 0 - desabilitado
* 1 - habilitado
Exemplo:
```sql theme={null}
CREATE TABLE test
(
key Int64,
some String
)
ENGINE = ReplacingMergeTree
ORDER BY key;
INSERT INTO test FORMAT Values (1, 'first');
INSERT INTO test FORMAT Values (1, 'second');
SELECT * FROM test;
┌─key─┬─some───┐
│ 1 │ second │
└─────┴────────┘
┌─key─┬─some──┐
│ 1 │ first │
└─────┴───────┘
SELECT * FROM test SETTINGS final = 1;
┌─key─┬─some───┐
│ 1 │ second │
└─────┴────────┘
SET final = 1;
SELECT * FROM test;
┌─key─┬─some───┐
│ 1 │ second │
└─────┴────────┘
```
## finalize\_projection\_parts\_synchronously
Quando ativada, as partes de projeção são finalizadas de forma síncrona durante o INSERT, reduzindo o pico de uso de memória, mas com menor paralelismo de upload no S3. Por padrão, o fluxo de saída de cada projeção é mantido ativo até que toda a parte (incluindo todas as projeções) seja finalizada, o que permite sobrepor uploads no S3, mas aumenta o pico de uso de memória proporcionalmente ao número de projeções. Essa configuração afeta apenas o fluxo de INSERT; merge e mutation já finalizam as projeções de forma síncrona.
## flatten\_nested
Define o formato dos dados de colunas [nested](/pt-BR/reference/data-types/nested-data-structures).
Valores possíveis:
* 1 — A coluna nested é desmembrada em arrays separados.
* 0 — A coluna nested permanece como um único array de tuplas.
**Uso**
Se a configuração estiver definida como `0`, é possível usar um nível arbitrário de aninhamento.
**Exemplos**
Consulta:
```sql theme={null}
SET flatten_nested = 1;
CREATE TABLE t_nest (`n` Nested(a UInt32, b UInt32)) ENGINE = MergeTree ORDER BY tuple();
SHOW CREATE TABLE t_nest;
```
Resultado:
```text theme={null}
┌─statement───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│ CREATE TABLE default.t_nest
(
`n.a` Array(UInt32),
`n.b` Array(UInt32)
)
ENGINE = MergeTree
ORDER BY tuple()
SETTINGS index_granularity = 8192 │
└─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
```
Consulta:
```sql theme={null}
SET flatten_nested = 0;
CREATE TABLE t_nest (`n` Nested(a UInt32, b UInt32)) ENGINE = MergeTree ORDER BY tuple();
SHOW CREATE TABLE t_nest;
```
Resultado:
```text theme={null}
┌─statement──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│ CREATE TABLE default.t_nest
(
`n` Nested(a UInt32, b UInt32)
)
ENGINE = MergeTree
ORDER BY tuple()
SETTINGS index_granularity = 8192 │
└────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
```
## force\_aggregate\_partitions\_independently
Força o uso da otimização quando ela for aplicável, mesmo que as heurísticas decidam não utilizá-la
## force\_aggregation\_in\_order
Essa configuração é usada pelo próprio servidor para dar suporte a consultas distribuídas. Não a altere manualmente, pois isso comprometerá o funcionamento normal. (Força o uso de agregação em ordem nos nós remotos durante a agregação distribuída).
## force\_data\_skipping\_indices
Desabilita a execução da consulta se os data skipping indices especificados não forem usados.
Considere o exemplo a seguir:
```sql theme={null}
CREATE TABLE data
(
key Int,
d1 Int,
d1_null Nullable(Int),
INDEX d1_idx d1 TYPE minmax GRANULARITY 1,
INDEX d1_null_idx assumeNotNull(d1_null) TYPE minmax GRANULARITY 1
)
Engine=MergeTree()
ORDER BY key;
SELECT * FROM data_01515;
SELECT * FROM data_01515 SETTINGS force_data_skipping_indices=''; -- a consulta produzirá o erro CANNOT_PARSE_TEXT.
SELECT * FROM data_01515 SETTINGS force_data_skipping_indices='d1_idx'; -- a consulta produzirá o erro INDEX_NOT_USED.
SELECT * FROM data_01515 WHERE d1 = 0 SETTINGS force_data_skipping_indices='d1_idx'; -- Ok.
SELECT * FROM data_01515 WHERE d1 = 0 SETTINGS force_data_skipping_indices='`d1_idx`'; -- Ok (exemplo de parser completo).
SELECT * FROM data_01515 WHERE d1 = 0 SETTINGS force_data_skipping_indices='`d1_idx`, d1_null_idx'; -- a consulta produzirá o erro INDEX_NOT_USED, pois d1_null_idx não é utilizado.
SELECT * FROM data_01515 WHERE d1 = 0 AND assumeNotNull(d1_null) = 0 SETTINGS force_data_skipping_indices='`d1_idx`, d1_null_idx'; -- Ok.
```
## force\_grouping\_standard\_compatibility
Faz a função GROUPING retornar 1 quando o argumento não é usado como chave de agregação
## force\_index\_by\_date
Desativa a execução da consulta se o índice não puder ser usado com base na data.
Funciona com tabelas da família MergeTree.
Se `force_index_by_date=1`, o ClickHouse verifica se a consulta tem uma condição na chave de data que possa ser usada para restringir os intervalos de dados. Se não houver uma condição adequada, ele gera uma exceção. No entanto, ele não verifica se a condição reduz a quantidade de dados a serem lidos. Por exemplo, a condição `Date != ' 2000-01-01 '` é aceitável mesmo quando corresponde a todos os dados da tabela (ou seja, a execução da consulta exige uma varredura completa). Para mais informações sobre intervalos de dados em tabelas da família MergeTree, consulte [MergeTree](/pt-BR/reference/engines/table-engines/mergetree-family/mergetree).
## force\_optimize\_projection
Ativa ou desativa o uso obrigatório de [projeções](/pt-BR/reference/engines/table-engines/mergetree-family/mergetree#projections) em consultas `SELECT`, quando a otimização de projeções estiver ativada (consulte a configuração [optimize\_use\_projections](#optimize_use_projections)).
Valores possíveis:
* 0 — A otimização de projeções não é obrigatória.
* 1 — A otimização de projeções é obrigatória.
## force\_optimize\_projection\_name
Se estiver definido como uma string não vazia, verifique se essa projeção é usada na consulta pelo menos uma vez.
Valores possíveis:
* string: nome da projeção usada em uma consulta
## force\_optimize\_skip\_unused\_shards
Habilita ou desabilita a execução da consulta se [optimize\_skip\_unused\_shards](#optimize_skip_unused_shards) estiver habilitado e não for possível ignorar os shards não utilizados. Se isso não for possível e a configuração estiver habilitada, uma exceção será lançada.
Valores possíveis:
* 0 — Desabilitado. O ClickHouse não lança uma exceção.
* 1 — Habilitado. A execução da consulta é desabilitada somente se a tabela tiver uma chave de sharding.
* 2 — Habilitado. A execução da consulta é desabilitada independentemente de a tabela ter uma chave de sharding definida.
## force\_optimize\_skip\_unused\_shards\_nesting
Controla como [`force_optimize_skip_unused_shards`](#force_optimize_skip_unused_shards) (portanto, ainda requer [`force_optimize_skip_unused_shards`](#force_optimize_skip_unused_shards)) depende do nível de aninhamento da consulta distribuída (caso em que você tenha uma tabela `Distributed` que consulta outra tabela `Distributed`).
Valores possíveis:
* 0 - Desabilitado, `force_optimize_skip_unused_shards` sempre funciona.
* 1 — Habilita `force_optimize_skip_unused_shards` apenas para o primeiro nível.
* 2 — Habilita `force_optimize_skip_unused_shards` até o segundo nível.
## force\_primary\_key
Impede a execução da consulta se não for possível usar a chave primária para indexação.
Funciona com tabelas da família MergeTree.
Se `force_primary_key=1`, o ClickHouse verifica se a consulta tem uma condição na chave primária que possa ser usada para restringir os intervalos de dados. Se não houver uma condição adequada, ele gera uma exceção. No entanto, não verifica se a condição reduz a quantidade de dados a serem lidos. Para mais informações sobre intervalos de dados em tabelas MergeTree, consulte [MergeTree](/pt-BR/reference/engines/table-engines/mergetree-family/mergetree).
## force\_remove\_data\_recursively\_on\_drop
Remove os dados recursivamente na consulta DROP. Evita o erro 'Diretório não está vazio', mas pode remover silenciosamente dados desanexados
## formatdatetime\_e\_with\_space\_padding
O formatador '%e' na função 'formatDateTime' imprime dias de um único dígito com um espaço à esquerda, por exemplo, ' 2' em vez de '2'.
## formatdatetime\_f\_prints\_scale\_number\_of\_digits
O formatador '%f' na função 'formatDateTime' imprime apenas a quantidade de dígitos correspondente à escala de um DateTime64, em vez de 6 dígitos fixos.
## formatdatetime\_f\_prints\_single\_zero
O especificador de formato '%f' na função 'formatDateTime' imprime um único zero em vez de seis zeros se o valor formatado não tiver frações de segundo.
## formatdatetime\_format\_without\_leading\_zeros
Os formatadores '%c', '%l' e '%k' na função 'formatDateTime' exibem meses e horas sem zeros à esquerda.
## formatdatetime\_parsedatetime\_m\_is\_month\_name
O especificador '%M' nas funções 'formatDateTime' e 'parseDateTime' exibe/interpreta o nome do mês em vez dos minutos.
## fsync\_metadata
Habilita ou desabilita o [fsync](http://pubs.opengroup.org/onlinepubs/9699919799/functions/fsync.html) ao gravar arquivos `.sql`. Habilitado por padrão.
Faz sentido desabilitá-lo se o servidor tiver milhões de tabelas pequenas que são constantemente criadas e removidas.
## function\_date\_trunc\_return\_type\_behavior
Permite alterar o comportamento do tipo de retorno da função `dateTrunc`.
Valores possíveis:
* 0 - Quando o segundo argumento é `DateTime64/Date32`, o tipo de retorno será `DateTime64/Date32`, independentemente da unidade de tempo no primeiro argumento.
* 1 - Para `Date32`, o resultado é sempre `Date`. Para `DateTime64`, o resultado é `DateTime` para unidades de tempo `second` e superiores.
## function\_implementation
Escolha a implementação da função para um destino ou uma variante específica (experimental). Se estiver em branco, habilite todas elas.
## function\_json\_value\_return\_type\_allow\_complex
Controla se é permitido retornar tipos complexos (como: struct, array, map) para a função json\_value.
```sql theme={null}
SELECT JSON_VALUE('{"hello":{"world":"!"}}', '$.hello') settings function_json_value_return_type_allow_complex=true
┌─JSON_VALUE('{"hello":{"world":"!"}}', '$.hello')─┐
│ {"world":"!"} │
└──────────────────────────────────────────────────┘
1 row in set. Elapsed: 0.001 sec.
```
Valores possíveis:
* true — Permite.
* false — Não permite.
## function\_json\_value\_return\_type\_allow\_nullable
Controla se é permitido retornar `NULL` quando o valor não existir na função JSON\_VALUE.
```sql theme={null}
SELECT JSON_VALUE('{"hello":"world"}', '$.b') settings function_json_value_return_type_allow_nullable=true;
┌─JSON_VALUE('{"hello":"world"}', '$.b')─┐
│ ᴺᵁᴸᴸ │
└────────────────────────────────────────┘
1 row in set. Elapsed: 0.001 sec.
```
Valores possíveis:
* true — Permite.
* false — Não permite.
## function\_locate\_has\_mysql\_compatible\_argument\_order
Controla a ordem dos argumentos da função [locate](/pt-BR/reference/functions/regular-functions/string-search-functions#locate).
Valores possíveis:
* 0 — A função `locate` aceita os argumentos `(haystack, needle[, start_pos])`.
* 1 — A função `locate` aceita os argumentos `(needle, haystack, [, start_pos])` (comportamento compatível com MySQL)
## function\_range\_max\_elements\_in\_block
Define o limite de segurança para o volume de dados gerado pela função [range](/pt-BR/reference/functions/regular-functions/array-functions#range). Especifica o número máximo de valores gerados pela função por bloco de dados (soma dos tamanhos dos arrays para cada linha em um bloco).
Valores possíveis:
* Inteiro positivo.
**Veja também**
* [`max_block_size`](#max_block_size)
* [`min_insert_block_size_rows`](#min_insert_block_size_rows)
## function\_sleep\_max\_microseconds\_per\_block
Número máximo de microssegundos pelos quais a função `sleep` pode suspender a execução em cada bloco. Se um usuário a chamar com um valor maior, ela lança uma exceção. Este é um limite de segurança.
## function\_visible\_width\_behavior
A versão do comportamento de `visibleWidth`. 0 - conta apenas o número de pontos de código; 1 - conta corretamente caracteres de largura zero e caracteres combináveis, conta caracteres de largura total como dois, estima a largura da tabulação e conta caracteres de exclusão.
## functions\_h3\_default\_if\_invalid
Se false, as funções h3, por exemplo h3CellAreaM2, geram uma exceção se a entrada for inválida. Se true, elas retornam 0 ou o valor padrão.
## geo\_distance\_returns\_float64\_on\_float64\_arguments
Se todos os quatro argumentos das funções `geoDistance`, `greatCircleDistance` e `greatCircleAngle` forem Float64, retorna Float64 e usa precisão dupla nos cálculos internos. Em versões anteriores do ClickHouse, as funções sempre retornavam Float32.
## geotoh3\_argument\_order
A função 'geoToH3' aceita (lon, lat) se estiver configurada como 'lon\_lat' e (lat, lon) se estiver configurada como 'lat\_lon'.
## glob\_expansion\_max\_elements
Número máximo de endereços permitidos (para armazenamentos externos, funções de tabela etc.).
## grace\_hash\_join\_initial\_buckets
Número inicial de buckets para grace hash join
## grace\_hash\_join\_max\_buckets
Limite para o número de buckets do grace hash join
## group\_by\_overflow\_mode
Define o que acontece quando o número de chaves exclusivas para agregação excede o limite:
* `throw`: gera uma exceção
* `break`: interrompe a execução da consulta e retorna o resultado parcial
* `any`: continua a agregação para as chaves que entraram no conjunto, mas não adiciona novas chaves ao conjunto.
Usar o valor 'any' permite executar uma aproximação de GROUP BY. A qualidade dessa
aproximação depende da natureza estatística dos dados.
## group\_by\_two\_level\_threshold
A partir de quantas chaves começa uma agregação em dois níveis. 0 - o limite não está definido.
## group\_by\_two\_level\_threshold\_bytes
A partir de qual tamanho do estado de agregação, em bytes, uma agregação em dois níveis passa a ser usada. 0 — o limite não está definido. A agregação em dois níveis é usada quando pelo menos um dos limites é atingido.
## group\_by\_use\_nulls
Altera a forma como a [cláusula GROUP BY](/pt-BR/reference/statements/select/group-by) trata os tipos das chaves de agregação.
Quando os especificadores `ROLLUP`, `CUBE` ou `GROUPING SETS` são usados, algumas chaves de agregação podem não ser usadas para produzir determinadas linhas de resultado.
As colunas dessas chaves são preenchidas com o valor padrão ou com `NULL` nas linhas correspondentes, dependendo desta configuração.
Valores possíveis:
* 0 — O valor padrão do tipo da chave de agregação é usado para preencher os valores ausentes.
* 1 — O ClickHouse executa `GROUP BY` da mesma forma que o padrão SQL define. Os tipos das chaves de agregação são convertidos para [Nullable](/pt-BR/reference/data-types/nullable). As colunas das chaves de agregação correspondentes são preenchidas com [NULL](/pt-BR/reference/syntax#null) nas linhas em que elas não foram usadas.
Veja também:
* [cláusula GROUP BY](/pt-BR/reference/statements/select/group-by)
## h3togeo\_lon\_lat\_result\_order
A função 'h3ToGeo' retorna (lon, lat) se true; caso contrário, (lat, lon).
## handshake\_timeout\_ms
Tempo limite, em milissegundos, para receber o pacote Hello das réplicas durante o handshake.
## hdfs\_create\_new\_file\_on\_insert
Habilita ou desabilita a criação de um novo arquivo a cada insert em tabelas com o engine HDFS. Se estiver habilitada, a cada insert será criado um novo arquivo HDFS com um nome semelhante a este padrão:
inicial: `data.Parquet.gz` -> `data.1.Parquet.gz` -> `data.2.Parquet.gz`, etc.
Valores possíveis:
* 0 — a consulta `INSERT` acrescenta novos dados ao final do arquivo.
* 1 — a consulta `INSERT` cria um novo arquivo.
## hdfs\_ignore\_file\_doesnt\_exist
Ignora a ausência do arquivo caso ele não exista ao ler determinadas chaves.
Valores possíveis:
* 1 — `SELECT` retorna um resultado vazio.
* 0 — `SELECT` gera uma exceção.
## hdfs\_replication
O número real de réplicas pode ser especificado quando o arquivo HDFS é criado.
## hdfs\_skip\_empty\_files
Habilita ou desabilita ignorar arquivos vazios em tabelas com o mecanismo [HDFS](/pt-BR/reference/engines/table-engines/integrations/hdfs).
Valores possíveis:
* 0 — `SELECT` gera uma exceção se o arquivo vazio não for compatível com o formato solicitado.
* 1 — `SELECT` retorna um resultado vazio para um arquivo vazio.
## hdfs\_throw\_on\_zero\_files\_match
Gera um erro se nenhum arquivo corresponder de acordo com as regras de expansão de glob.
Valores possíveis:
* 1 — `SELECT` gera uma exceção.
* 0 — `SELECT` retorna um resultado vazio.
## hdfs\_truncate\_on\_insert
Ativa ou desativa o truncamento antes de um insert em tabelas com mecanismo HDFS. Se estiver desativado, será gerada uma exceção ao tentar fazer um insert se um arquivo no HDFS já existir.
Valores possíveis:
* 0 — a consulta `INSERT` acrescenta novos dados ao final do arquivo.
* 1 — a consulta `INSERT` substitui o conteúdo existente do arquivo pelos novos dados.
## hedged\_connection\_timeout\_ms
Timeout de conexão para estabelecer uma conexão com a réplica em requisições Hedged
## highlight\_max\_matches\_per\_row
Define o número máximo de correspondências de destaque por linha na função [highlight](/pt-BR/reference/functions/regular-functions/string-search-functions#highlight). Use essa configuração para evitar uso excessivo de memória ao destacar padrões altamente repetitivos em textos extensos.
Valores possíveis:
* Inteiro positivo.
## hnsw\_candidate\_list\_size\_for\_search
O tamanho da lista dinâmica de candidatos durante a pesquisa no índice de similaridade vetorial, também conhecido como 'ef\_search'.
## hsts\_max\_age
Tempo de expiração do HSTS. 0 significa desabilitar o HSTS.
## http\_connection\_timeout
Tempo limite de conexão HTTP (em segundos).
Valores possíveis:
* Qualquer número inteiro positivo.
* 0 - Desabilitado (tempo limite infinito).
Não envie os cabeçalhos HTTP X-ClickHouse-Progress com frequência maior que a do intervalo especificado.
Tempo máximo, em segundos, para ler todos os cabeçalhos da requisição HTTP. Este é um limite total de tempo para toda a fase de processamento dos cabeçalhos, não um timeout por leitura. Protege contra ataques do tipo slowloris, em que um cliente envia dados de cabeçalho lentamente para manter as conexões abertas.
## http\_make\_head\_request
A configuração `http_make_head_request` permite executar uma solicitação `HEAD` ao ler dados via HTTP para obter informações sobre o arquivo a ser lido, como seu tamanho. Como ela é habilitada por padrão, pode ser desejável desabilitar essa configuração nos casos em que o servidor não oferece suporte a solicitações `HEAD`.
## http\_max\_field\_name\_size
Comprimento máximo do nome do campo no cabeçalho HTTP
## http\_max\_field\_value\_size
Tamanho máximo do valor de um campo em um cabeçalho HTTP
## http\_max\_fields
Número máximo de campos no cabeçalho HTTP
## http\_max\_multipart\_form\_data\_size
Limite do tamanho do conteúdo multipart/form-data. Essa configuração não pode ser interpretada a partir de parâmetros de URL e deve ser definida em um profile de usuário. Observe que o conteúdo é interpretado e as tabelas externas são criadas na memória antes do início da execução da consulta. Este é o único limite que tem efeito nessa etapa (os limites de uso máximo de memória e tempo máximo de execução não têm efeito durante a leitura de form data HTTP).
Tamanho total máximo de todos os cabeçalhos da requisição HTTP (nomes e valores combinados), em bytes.
## http\_max\_request\_param\_data\_size
Limite para o tamanho dos dados da requisição usados como parâmetro de consulta em requisições HTTP predefinidas.
## http\_max\_tries
Número máximo de tentativas de leitura via HTTP.
## http\_max\_uri\_size
Define o tamanho máximo da URI de uma requisição HTTP.
Valores possíveis:
* Inteiro positivo.
## http\_native\_compression\_disable\_checksumming\_on\_decompress
Ativa ou desativa a verificação de checksum ao descomprimir os dados de HTTP POST enviados pelo cliente. Usado apenas com o formato de compressão nativo do ClickHouse (não é usado com `gzip` ou `deflate`).
Para mais informações, leia a [descrição da interface HTTP](/pt-BR/concepts/features/interfaces/http).
Valores possíveis:
* 0 — Desativado.
* 1 — Ativado.
## http\_receive\_timeout
Tempo limite para recebimento via HTTP (em segundos).
Valores possíveis:
* Qualquer número inteiro positivo.
* 0 - Desabilitado (tempo limite infinito).
## http\_response\_buffer\_size
Número de bytes armazenados em buffer na memória do servidor antes de enviar uma resposta HTTP ao cliente ou gravar em disco (quando `http_wait_end_of_query` está habilitado).
Permite adicionar ou substituir cabeçalhos HTTP que o servidor retornará na resposta com um resultado de consulta bem-sucedido.
Isso afeta apenas a interface HTTP.
Se o cabeçalho já estiver definido por padrão, o valor fornecido o substituirá.
Se o cabeçalho não estiver definido por padrão, ele será adicionado à lista de cabeçalhos.
Os cabeçalhos definidos pelo servidor por padrão e não substituídos por esta configuração permanecerão.
A configuração permite definir um cabeçalho com um valor constante. Atualmente, não há como definir um cabeçalho com um valor calculado dinamicamente.
Nem os nomes nem os valores podem conter caracteres de controle ASCII.
Se você implementar uma aplicação de UI que permita aos usuários modificar configurações, mas ao mesmo tempo tome decisões com base nos cabeçalhos retornados, recomenda-se restringir esta configuração a readonly.
Exemplo: `SET http_response_headers = '{"Content-Type": "image/png"}'`
## http\_retry\_initial\_backoff\_ms
Milissegundos mínimos de backoff ao tentar ler novamente via http
## http\_retry\_max\_backoff\_ms
Número máximo de milissegundos de backoff ao tentar novamente a leitura via http
## http\_send\_timeout
Tempo limite de envio HTTP (em segundos).
Valores possíveis:
* Qualquer número inteiro positivo.
* 0 - Desabilitado (tempo limite infinito).
Isso se aplica apenas ao perfil padrão. É necessário reiniciar o servidor para que as alterações entrem em vigor.
## http\_skip\_not\_found\_url\_for\_globs
Ignora URLs de globs com erro HTTP\_NOT\_FOUND
## http\_wait\_end\_of\_query
Habilita a bufferização da resposta HTTP no servidor.
## http\_write\_exception\_in\_output\_format
Escreve a exceção no formato de saída para gerar uma saída válida. Funciona com os formatos JSON e XML.
## http\_zlib\_compression\_level
Define o nível de compressão dos dados na resposta a uma requisição HTTP se [enable\_http\_compression = 1](#enable_http_compression).
Valores possíveis: números de 1 a 9.
## iceberg\_compaction\_data\_cleanup
O período após o qual os dados serão excluídos.
## iceberg\_compaction\_delay\_bias
Atraso mínimo entre 2 operações de compactação em segundo plano.
## iceberg\_data\_file\_size\_lower\_threshold\_compaction
Limite para arquivos de dados na compactação no Iceberg.
## iceberg\_data\_file\_size\_upper\_threshold\_compaction
Limite superior para compactação de arquivos de dados no Iceberg.
## iceberg\_delete\_data\_on\_drop
Se todos os arquivos do Iceberg devem ser excluídos ao executar `drop`.
## iceberg\_expire\_default\_max\_ref\_age\_ms
Valor padrão da propriedade da tabela Iceberg `history.expire.max-ref-age-ms`, usada por `expire_snapshots` quando essa propriedade não está presente.
## iceberg\_expire\_default\_max\_snapshot\_age\_ms
Valor padrão da propriedade de tabela Iceberg `history.expire.max-snapshot-age-ms` usado por `expire_snapshots` quando essa propriedade não está presente.
## iceberg\_expire\_default\_min\_snapshots\_to\_keep
Valor padrão da propriedade `history.expire.min-snapshots-to-keep` da tabela Iceberg, usado por `expire_snapshots` quando essa propriedade não está presente.
## iceberg\_insert\_max\_bytes\_in\_data\_file
Máximo de bytes do arquivo de dados Parquet do Iceberg em uma operação de inserção.
## iceberg\_insert\_max\_partitions
Número máximo de partições permitido em uma única operação de inserção para o mecanismo de tabela Iceberg.
## iceberg\_insert\_max\_rows\_in\_data\_file
Número máximo de linhas no arquivo de dados Parquet do Iceberg durante a operação de inserção.
## iceberg\_max\_number\_datafiles\_to\_compact
Limite de arquivos de dados para compactação no Iceberg.
## iceberg\_metadata\_compression\_method
Método de compressão do arquivo `.metadata.json`.
## iceberg\_metadata\_log\_level
Controla o nível de log de metadados para tabelas Iceberg em system.iceberg\_metadata\_log.
Em geral, essa configuração pode ser modificada para fins de depuração.
Valores possíveis:
* none - Sem log de metadados.
* metadata - Arquivo raiz metadata.json.
* manifest\_list\_metadata - Tudo o que está acima + metadados da manifest list avro correspondente a um snapshot.
* manifest\_list\_entry - Tudo o que está acima + entradas da manifest list avro.
* manifest\_file\_metadata - Tudo o que está acima + metadados dos manifest files avro percorridos.
* manifest\_file\_entry - Tudo o que está acima + entradas dos manifest files avro percorridos.
## iceberg\_metadata\_staleness\_ms
Se for diferente de zero, ignora a busca dos metadados do Iceberg no catálogo remoto se houver um snapshot de metadados em cache mais recente do que a janela de desatualização especificada. Zero significa sempre buscar a versão mais recente dos metadados no catálogo remoto. Definir esse valor como diferente de zero troca um pouco de desatualização por menor latência nas operações de leitura.
## iceberg\_orphan\_files\_older\_than\_seconds
Limite padrão de idade, em segundos, para a remoção de arquivos órfãos em tabelas Iceberg. Arquivos mais recentes do que esse limite não são considerados órfãos. É usado quando o argumento `older_than` é omitido da chamada do procedimento `remove_orphan_files()`. O padrão é 259200 (3 dias).
## iceberg\_snapshot\_id
Consulta a tabela Iceberg usando o ID de snapshot especificado.
## iceberg\_timestamp\_ms
Consulte a tabela Iceberg usando o snapshot vigente em um timestamp específico.
## idle\_connection\_timeout
Tempo limite para encerrar conexões TCP ociosas após o número especificado de segundos.
Valores possíveis:
* Inteiro positivo (0 - encerra imediatamente, após 0 segundos).
## ignore\_cold\_parts\_seconds
Só tem efeito no ClickHouse Cloud. Exclui novas partes de dados de consultas SELECT até que sejam pré-aquecidas (consulte [cache\_populated\_by\_fetch](/pt-BR/reference/settings/merge-tree-settings#cache_populated_by_fetch)) ou atinjam essa quantidade de segundos. Somente para Replicated-/SharedMergeTree.
## ignore\_data\_skipping\_indices
Ignora os índices de data skipping especificados, caso sejam usados pela consulta.
Considere o exemplo a seguir:
```sql theme={null}
CREATE TABLE data
(
key Int,
x Int,
y Int,
INDEX x_idx x TYPE minmax GRANULARITY 1,
INDEX y_idx y TYPE minmax GRANULARITY 1,
INDEX xy_idx (x,y) TYPE minmax GRANULARITY 1
)
Engine=MergeTree()
ORDER BY key;
INSERT INTO data VALUES (1, 2, 3);
SELECT * FROM data;
SELECT * FROM data SETTINGS ignore_data_skipping_indices=''; -- a consulta produzirá o erro CANNOT_PARSE_TEXT.
SELECT * FROM data SETTINGS ignore_data_skipping_indices='x_idx'; -- Ok.
SELECT * FROM data SETTINGS ignore_data_skipping_indices='na_idx'; -- Ok.
SELECT * FROM data WHERE x = 1 AND y = 1 SETTINGS ignore_data_skipping_indices='xy_idx',force_data_skipping_indices='xy_idx' ; -- a consulta produzirá o erro INDEX_NOT_USED, pois xy_idx é explicitamente ignorado.
SELECT * FROM data WHERE x = 1 AND y = 2 SETTINGS ignore_data_skipping_indices='xy_idx';
```
A consulta sem ignorar nenhum índice:
```sql theme={null}
EXPLAIN indexes = 1 SELECT * FROM data WHERE x = 1 AND y = 2;
Expression ((Projection + Before ORDER BY))
Filter (WHERE)
ReadFromMergeTree (default.data)
Indexes:
PrimaryKey
Condition: true
Parts: 1/1
Granules: 1/1
Skip
Name: x_idx
Description: minmax GRANULARITY 1
Parts: 0/1
Granules: 0/1
Skip
Name: y_idx
Description: minmax GRANULARITY 1
Parts: 0/0
Granules: 0/0
Skip
Name: xy_idx
Description: minmax GRANULARITY 1
Parts: 0/0
Granules: 0/0
```
Desconsiderando o índice `xy_idx`:
```sql theme={null}
EXPLAIN indexes = 1 SELECT * FROM data WHERE x = 1 AND y = 2 SETTINGS ignore_data_skipping_indices='xy_idx';
Expression ((Projection + Before ORDER BY))
Filter (WHERE)
ReadFromMergeTree (default.data)
Indexes:
PrimaryKey
Condition: true
Parts: 1/1
Granules: 1/1
Skip
Name: x_idx
Description: minmax GRANULARITY 1
Parts: 0/1
Granules: 0/1
Skip
Name: y_idx
Description: minmax GRANULARITY 1
Parts: 0/0
Granules: 0/0
```
Compatível com tabelas da família MergeTree.
## ignore\_drop\_queries\_probability
Se estiver habilitada, o servidor ignorará todas as consultas DROP TABLE com a probabilidade especificada (para os motores Memory e JOIN, substituirá DROP por TRUNCATE). Usado para fins de teste
## ignore\_format\_null\_for\_explain
Se estiver habilitado, `FORMAT Null` será ignorado em consultas `EXPLAIN`, e o formato de saída padrão será usado no lugar dele.
Se estiver desabilitado, consultas `EXPLAIN` com `FORMAT Null` não produzirão saída (comportamento compatível com versões anteriores).
## ignore\_materialized\_views\_with\_dropped\_target\_table
Ignorar MVs com tabela de destino removida ao enviar para views
## ignore\_on\_cluster\_for\_replicated\_access\_entities\_queries
Ignora a cláusula ON CLUSTER em queries de gerenciamento de entidades de acesso replicadas.
## ignore\_on\_cluster\_for\_replicated\_database
Sempre ignora a cláusula ON CLUSTER em consultas DDL com bancos de dados Replicated.
## ignore\_on\_cluster\_for\_replicated\_named\_collections\_queries
Ignorar a cláusula ON CLUSTER em consultas de gerenciamento de coleções nomeadas replicadas.
## ignore\_on\_cluster\_for\_replicated\_udf\_queries
Ignora a cláusula ON CLUSTER em consultas de gerenciamento de UDF replicadas.
## implicit\_select
Permite escrever consultas SELECT simples sem a palavra-chave SELECT no início, o que facilita o uso como calculadora; por exemplo, `1 + 2` se torna uma consulta válida.
No `clickhouse-local`, isso é habilitado por padrão e pode ser desabilitado explicitamente.
## implicit\_table\_at\_top\_level
Se não estiver vazio, consultas sem FROM no nível superior lerão desta tabela em vez de system.one.
Isso é usado no clickhouse-local para processar dados de entrada.
A configuração pode ser definida explicitamente por um usuário, mas não foi concebida para esse tipo de uso.
Subconsultas não são afetadas por essa configuração (nem subconsultas escalares, nem subconsultas em FROM ou IN).
SELECTs no nível superior em cadeias de UNION, INTERSECT e EXCEPT são tratados de maneira uniforme e afetados por essa configuração, independentemente do agrupamento entre parênteses.
Não está definido como essa configuração afeta views e consultas distribuídas.
A configuração aceita um nome de tabela (nesse caso, a tabela é resolvida a partir do banco de dados atual) ou um nome qualificado na forma 'database.table'.
Tanto o nome do banco de dados quanto o da tabela devem estar sem aspas — somente identificadores simples são permitidos.
## implicit\_transaction
Se estiver habilitado e ainda não estiver em uma transação, envolve a consulta em uma transação completa (begin + commit ou rollback)
## inject\_random\_order\_for\_select\_without\_order\_by
Quando habilitada, injeta 'ORDER BY rand()' em consultas SELECT sem cláusula ORDER BY.
Aplica-se apenas à profundidade de subconsulta = 0. Subconsultas e INSERT INTO ... SELECT não são afetados.
Se a construção de nível superior for UNION, 'ORDER BY rand()' é injetado em cada filho de forma independente.
Útil apenas para testes e desenvolvimento (a ausência de ORDER BY é uma fonte de resultados de consulta não determinísticos).
## insert\_allow\_materialized\_columns
Se esta configuração estiver habilitada, permite colunas materializadas em INSERT.
## insert\_deduplicate
Ativa ou desativa a desduplicação de blocos de `INSERT` (para tabelas Replicated\*).
Possíveis valores:
* 0 — Desativado.
* 1 — Ativado.
Por padrão, os blocos inseridos em tabelas replicadas pela instrução `INSERT` são desduplicados (consulte [Replicação de dados](/pt-BR/reference/engines/table-engines/mergetree-family/replication)).
Em tabelas replicadas, por padrão, apenas os 100 blocos mais recentes de cada partição são desduplicados (consulte [replicated\_deduplication\_window](/pt-BR/reference/settings/merge-tree-settings#replicated_deduplication_window), [replicated\_deduplication\_window\_seconds](/pt-BR/reference/settings/merge-tree-settings#replicated_deduplication_window_seconds)).
Para tabelas não replicadas, consulte [non\_replicated\_deduplication\_window](/pt-BR/reference/settings/merge-tree-settings#non_replicated_deduplication_window).
## insert\_deduplication\_token
Essa configuração permite que o usuário defina sua própria semântica de desduplicação em MergeTree/ReplicatedMergeTree.
Por exemplo, ao fornecer um valor único para a configuração em cada instrução INSERT,
o usuário pode evitar que os mesmos dados inseridos sejam desduplicados.
Valores possíveis:
* Qualquer string
`insert_deduplication_token` é usado para desduplicação *apenas* quando não está vazio.
Para tabelas replicadas, por padrão, apenas as 100 inserções mais recentes de cada partição são desduplicadas (consulte [replicated\_deduplication\_window](/pt-BR/reference/settings/merge-tree-settings#replicated_deduplication_window), [replicated\_deduplication\_window\_seconds](/pt-BR/reference/settings/merge-tree-settings#replicated_deduplication_window_seconds)).
Para tabelas não replicadas, consulte [non\_replicated\_deduplication\_window](/pt-BR/reference/settings/merge-tree-settings#non_replicated_deduplication_window).
`insert_deduplication_token` funciona no nível da partição (assim como o checksum `insert_deduplication`). Várias partições podem ter o mesmo `insert_deduplication_token`.
Exemplo:
```sql theme={null}
CREATE TABLE test_table
( A Int64 )
ENGINE = MergeTree
ORDER BY A
SETTINGS non_replicated_deduplication_window = 100;
INSERT INTO test_table SETTINGS insert_deduplication_token = 'test' VALUES (1);
-- o próximo insert não será desduplicado porque insert_deduplication_token é diferente
INSERT INTO test_table SETTINGS insert_deduplication_token = 'test1' VALUES (1);
-- o próximo insert será desduplicado porque insert_deduplication_token
-- é igual a um dos anteriores
INSERT INTO test_table SETTINGS insert_deduplication_token = 'test' VALUES (2);
SELECT * FROM test_table
┌─A─┐
│ 1 │
└───┘
┌─A─┐
│ 1 │
└───┘
```
## insert\_keeper\_fault\_injection\_probability
Probabilidade aproximada de falha de uma solicitação do Keeper durante uma operação de insert. O valor válido está no intervalo \[0.0f, 1.0f]
## insert\_keeper\_fault\_injection\_seed
0 - semente aleatória; caso contrário, o valor da configuração
## insert\_keeper\_max\_retries
Esta configuração define o número máximo de novas tentativas para solicitações ao ClickHouse Keeper (ou ZooKeeper) durante inserções em MergeTree replicado. Só são consideradas para novas tentativas as solicitações ao Keeper que falharem devido a erro de rede, timeout de sessão do Keeper ou timeout da solicitação.
Valores possíveis:
* Inteiro positivo.
* 0 — As novas tentativas ficam desabilitadas
Valor padrão no Cloud: `20`.
As novas tentativas de solicitações ao Keeper são feitas após um determinado timeout. O timeout é controlado pelas seguintes configurações: `insert_keeper_retry_initial_backoff_ms`, `insert_keeper_retry_max_backoff_ms`.
A primeira nova tentativa é feita após o timeout definido por `insert_keeper_retry_initial_backoff_ms`. Os timeouts subsequentes serão calculados da seguinte forma:
```
timeout = min(insert_keeper_retry_max_backoff_ms, latest_timeout * 2)
```
Por exemplo, se `insert_keeper_retry_initial_backoff_ms=100`, `insert_keeper_retry_max_backoff_ms=10000` e `insert_keeper_max_retries=8`, então os timeouts serão `100, 200, 400, 800, 1600, 3200, 6400, 10000`.
Além da tolerância a falhas, as tentativas de repetição visam proporcionar uma melhor experiência ao usuário — elas permitem evitar o retorno de um erro durante a execução de INSERT se o Keeper for reiniciado, por exemplo, devido a uma atualização.
## insert\_keeper\_retry\_initial\_backoff\_ms
Tempo de espera inicial (em milissegundos) para tentar novamente uma solicitação do Keeper com falha durante a execução da consulta INSERT
Valores possíveis:
* Inteiro positivo.
* 0 — Sem tempo limite
## insert\_keeper\_retry\_max\_backoff\_ms
Tempo limite máximo (em milissegundos) para tentar novamente uma solicitação do Keeper com falha durante a execução de uma consulta INSERT
Valores possíveis:
* Inteiro positivo.
* 0 — O tempo limite máximo não é limitado
## insert\_null\_as\_default
Habilita ou desabilita a inserção de [valores padrão](/pt-BR/reference/statements/create/table#default_values) no lugar de [NULL](/pt-BR/reference/syntax#null) em colunas com tipo de dado não [Nullable](/pt-BR/reference/data-types/nullable).
Se o tipo da coluna não for Nullable e essa configuração estiver desabilitada, a inserção de `NULL` causará uma exceção. Se o tipo da coluna for Nullable, os valores `NULL` serão inseridos como estão, independentemente dessa configuração.
Essa configuração se aplica a consultas [INSERT ... SELECT](/pt-BR/reference/statements/insert-into#inserting-the-results-of-select). Observe que subconsultas `SELECT` podem ser concatenadas com a cláusula `UNION ALL`.
Valores possíveis:
* 0 — Inserir `NULL` em uma coluna não Nullable causa uma exceção.
* 1 — O valor padrão da coluna é inserido no lugar de `NULL`.
## insert\_quorum
Esta configuração não se aplica ao SharedMergeTree; consulte [consistência do SharedMergeTree](/pt-BR/products/cloud/features/infrastructure/shared-merge-tree#consistency) para mais informações.
Habilita gravações com quorum.
* Se `insert_quorum < 2`, as gravações com quorum ficam desabilitadas.
* Se `insert_quorum >= 2`, as gravações com quorum ficam habilitadas.
* Se `insert_quorum = 'auto'`, use o número da maioria (`number_of_replicas / 2 + 1`) como quorum.
Gravações com quorum
`INSERT` só é bem-sucedido quando o ClickHouse consegue gravar corretamente os dados em `insert_quorum` réplicas dentro de `insert_quorum_timeout`. Se, por qualquer motivo, o número de réplicas com gravações bem-sucedidas não atingir `insert_quorum`, a gravação será considerada malsucedida, e o ClickHouse excluirá o bloco inserido de todas as réplicas em que os dados já tiverem sido gravados.
Quando `insert_quorum_parallel` está desabilitado, todas as réplicas do quorum são consistentes, ou seja, contêm dados de todas as consultas `INSERT` anteriores (a sequência de `INSERT` é linearizada). Ao ler dados gravados com `insert_quorum` enquanto `insert_quorum_parallel` está desabilitado, você pode ativar a consistência sequencial para consultas `SELECT` usando [select\_sequential\_consistency](#select_sequential_consistency).
O ClickHouse gera uma exceção:
* Se o número de réplicas disponíveis no momento da consulta for menor que `insert_quorum`.
* Quando `insert_quorum_parallel` está desabilitado e é feita uma tentativa de gravar dados enquanto o bloco anterior ainda não foi inserido em `insert_quorum` réplicas. Essa situação pode ocorrer se o usuário tentar executar outra consulta `INSERT` na mesma tabela antes de a anterior com `insert_quorum` ser concluída.
Veja também:
* [insert\_quorum\_timeout](#insert_quorum_timeout)
* [insert\_quorum\_parallel](#insert_quorum_parallel)
* [select\_sequential\_consistency](#select_sequential_consistency)
## insert\_quorum\_parallel
Esta configuração não se aplica ao SharedMergeTree; veja [SharedMergeTree consistency](/pt-BR/products/cloud/features/infrastructure/shared-merge-tree#consistency) para mais informações.
Habilita ou desabilita o paralelismo para consultas `INSERT` com quorum. Se estiver habilitado, consultas `INSERT` adicionais poderão ser enviadas enquanto as consultas anteriores ainda não tiverem terminado. Se estiver desabilitado, gravações adicionais na mesma tabela serão rejeitadas.
Valores possíveis:
* 0 — Desabilitado.
* 1 — Habilitado.
Veja também:
* [insert\_quorum](#insert_quorum)
* [insert\_quorum\_timeout](#insert_quorum_timeout)
* [select\_sequential\_consistency](#select_sequential_consistency)
## insert\_quorum\_timeout
Tempo limite, em milissegundos, para gravação com quorum. Se o tempo limite expirar e nenhuma gravação tiver sido realizada até então, o ClickHouse gerará uma exceção, e o cliente deverá repetir a consulta para gravar o mesmo bloco na mesma ou em qualquer outra réplica.
Veja também:
* [insert\_quorum](#insert_quorum)
* [insert\_quorum\_parallel](#insert_quorum_parallel)
* [select\_sequential\_consistency](#select_sequential_consistency)
## insert\_shard\_id
Se não for `0`, especifica o shard da tabela [Distributed](/pt-BR/reference/engines/table-engines/special/distributed) no qual os dados serão inseridos sincronicamente.
Se o valor de `insert_shard_id` estiver incorreto, o servidor lançará uma exceção.
Para obter o número de shards em `requested_cluster`, você pode verificar a config do servidor ou usar esta consulta:
```sql theme={null}
SELECT uniq(shard_num) FROM system.clusters WHERE cluster = 'requested_cluster';
```
Valores possíveis:
* 0 — Desativado.
* Qualquer número de `1` a `shards_num` da tabela [Distributed](/pt-BR/reference/engines/table-engines/special/distributed) correspondente.
**Exemplo**
Consulta:
```sql theme={null}
CREATE TABLE x AS system.numbers ENGINE = MergeTree ORDER BY number;
CREATE TABLE x_dist AS x ENGINE = Distributed('test_cluster_two_shards_localhost', currentDatabase(), x);
INSERT INTO x_dist SELECT * FROM numbers(5) SETTINGS insert_shard_id = 1;
SELECT * FROM x_dist ORDER BY number ASC;
```
Resultado:
```text theme={null}
┌─number─┐
│ 0 │
│ 0 │
│ 1 │
│ 1 │
│ 2 │
│ 2 │
│ 3 │
│ 3 │
│ 4 │
│ 4 │
└────────┘
```
## interactive\_delay
O intervalo, em microssegundos, para verificar se a execução da requisição foi cancelada e enviar o progresso.
## intersect\_default\_mode
Define o modo padrão da consulta INTERSECT. Valores possíveis: string vazia, 'ALL', 'DISTINCT'. Se estiver vazio, a consulta sem modo lançará uma exceção.
## jemalloc\_collect\_profile\_samples\_in\_trace\_log
Coleta amostras de alocação e desalocação do jemalloc no log de trace.
## jemalloc\_enable\_profiler
Habilita o profiler do jemalloc para a consulta. O jemalloc fará a amostragem das alocações e de todas as desalocações das alocações amostradas.
Os perfis podem ser descarregados com SYSTEM JEMALLOC FLUSH PROFILE, que pode ser usado para análise de alocação.
As amostras também podem ser armazenadas em system.trace\_log usando a configuração jemalloc\_collect\_global\_profile\_samples\_in\_trace\_log ou a configuração da consulta jemalloc\_collect\_profile\_samples\_in\_trace\_log.
Consulte [Profiling de alocação](/pt-BR/concepts/features/performance/allocation-profiling)
## jemalloc\_profile\_text\_collapsed\_use\_count
Ao usar o formato de saída 'collapsed' para o perfil de heap do jemalloc, agregue por número de alocações em vez de bytes. Quando false (padrão), cada pilha é ponderada por bytes ativos; quando true, pela contagem de alocações ativas.
## jemalloc\_profile\_text\_output\_format
Formato de saída do perfil de heap do jemalloc na tabela system.jemalloc\_profile\_text. Pode ser: 'raw' (perfil bruto), 'symbolized' (formato jeprof com símbolos) ou 'collapsed' (formato FlameGraph).
## jemalloc\_profile\_text\_symbolize\_with\_inline
Define se os frames inline devem ser incluídos ao simbolizar o perfil de heap do jemalloc. Quando ativada, os frames inline são incluídos, o que pode tornar o processo de simbolização drasticamente mais lento; quando desativada, eles são ignorados. Afeta apenas os formatos de saída 'symbolized' e 'collapsed'.
## join\_algorithm
Especifica qual algoritmo de [JOIN](/pt-BR/reference/statements/select/join) é usado.
É possível especificar vários algoritmos, e um deles será escolhido para uma consulta específica com base em kind/strictness e no mecanismo da tabela.
Valores possíveis:
* grace\_hash
[Grace hash join](https://en.wikipedia.org/wiki/Hash_join#Grace_hash_join) é usado. O Grace hash oferece uma opção de algoritmo para executar junções complexas com bom desempenho, limitando o uso de memória.
A primeira fase de um grace join lê a tabela da direita e a divide em N buckets, dependendo do valor hash das colunas-chave (inicialmente, N é `grace_hash_join_initial_buckets`). Isso é feito de modo a garantir que cada bucket possa ser processado de forma independente. As linhas do primeiro bucket são adicionadas a uma tabela hash em memória, enquanto as demais são salvas em disco. Se a tabela hash crescer além do limite de memória (por exemplo, conforme definido por [`max_bytes_in_join`](/pt-BR/reference/settings/session-settings#max_bytes_in_join)), o número de buckets será aumentado, assim como o bucket atribuído a cada linha. Quaisquer linhas que não pertençam ao bucket atual são descarregadas e reatribuídas.
Oferece suporte a `INNER/LEFT/RIGHT/FULL ALL/ANY JOIN`.
* hash
[Hash join algorithm](https://en.wikipedia.org/wiki/Hash_join) é usado. É a implementação mais genérica e oferece suporte a todas as combinações de kind e strictness, além de múltiplas chaves de junção combinadas com `OR` na seção `JOIN ON`.
Ao usar o algoritmo `hash`, a parte direita de `JOIN` é carregada na RAM.
* parallel\_hash
Uma variação de `hash` join que divide os dados em buckets e cria várias tabelas hash simultaneamente, em vez de apenas uma, para acelerar esse processo.
Ao usar o algoritmo `parallel_hash`, a parte direita de `JOIN` é carregada na RAM.
* partial\_merge
Uma variação do [algoritmo sort-merge](https://en.wikipedia.org/wiki/Sort-merge_join), em que apenas a tabela da direita é totalmente ordenada.
`RIGHT JOIN` e `FULL JOIN` são compatíveis apenas com strictness `ALL` (`SEMI`, `ANTI`, `ANY` e `ASOF` não são compatíveis).
Ao usar o algoritmo `partial_merge`, o ClickHouse ordena os dados e os grava em disco. O algoritmo `partial_merge` no ClickHouse difere ligeiramente da implementação clássica. Primeiro, o ClickHouse ordena a tabela da direita pelas chaves de junção em blocos e cria um índice min-max para os blocos ordenados. Em seguida, ele ordena partes da tabela da esquerda pela `chave de junção` e faz a junção com a tabela da direita. O índice min-max também é usado para ignorar blocos desnecessários da tabela da direita.
* direct
O algoritmo `direct` (também conhecido como nested loop) faz uma busca na tabela da direita usando as linhas da tabela da esquerda como chaves.
É compatível com armazenamentos especiais, como [Dictionary](/pt-BR/reference/engines/table-engines/special/dictionary), [EmbeddedRocksDB](/pt-BR/reference/engines/table-engines/integrations/embedded-rocksdb) e tabelas [MergeTree](/pt-BR/reference/engines/table-engines/mergetree-family/mergetree).
Para tabelas MergeTree, o algoritmo envia filtros de chave de junção diretamente para a camada de armazenamento. Isso pode ser mais eficiente quando a chave pode usar o índice de chave primária da tabela para buscas; caso contrário, ele executa varreduras completas da tabela da direita para cada bloco da tabela da esquerda.
Oferece suporte a junções `INNER` e `LEFT` e apenas a chaves de junção de igualdade com uma única coluna, sem outras condições.
* auto
Quando definido como `auto`, `hash` join é tentado primeiro, e o algoritmo é alternado dinamicamente para outro algoritmo se o limite de memória for excedido.
* full\_sorting\_merge
[Algoritmo sort-merge](https://en.wikipedia.org/wiki/Sort-merge_join) com ordenação completa das tabelas unidas antes da junção.
* prefer\_partial\_merge
O ClickHouse sempre tenta usar `partial_merge` join, se possível; caso contrário, usa `hash`. *Descontinuado*, igual a `partial_merge,hash`.
* default (descontinuado)
Valor legado; não use mais.
Igual a `direct,hash`, ou seja, tenta usar direct join e hash join (nessa ordem).
## join\_any\_take\_last\_row
Altera o comportamento das operações `JOIN` com strictness `ANY`.
Essa configuração se aplica apenas a operações `JOIN` com tabelas que usam o motor [Join](/pt-BR/reference/engines/table-engines/special/join).
Valores possíveis:
* 0 — Se a tabela da direita tiver mais de uma linha correspondente, apenas a primeira encontrada será associada.
* 1 — Se a tabela da direita tiver mais de uma linha correspondente, apenas a última encontrada será associada.
Veja também:
* [cláusula JOIN](/pt-BR/reference/statements/select/join)
* [motor de tabela Join](/pt-BR/reference/engines/table-engines/special/join)
* [join\_default\_strictness](#join_default_strictness)
## join\_default\_strictness
Define a strictness padrão para [cláusulas JOIN](/pt-BR/reference/statements/select/join).
Valores possíveis:
* `ALL` — Se a tabela da direita tiver várias linhas correspondentes, o ClickHouse cria um [produto cartesiano](https://en.wikipedia.org/wiki/Cartesian_product) com as linhas correspondentes. Esse é o comportamento normal de `JOIN` no SQL padrão.
* `ANY` — Se a tabela da direita tiver várias linhas correspondentes, apenas a primeira encontrada será usada na junção. Se a tabela da direita tiver apenas uma linha correspondente, os resultados de `ANY` e `ALL` serão os mesmos.
* `ASOF` — Para unir sequências com correspondência incerta.
* `Empty string` — Se `ALL` ou `ANY` não for especificado na consulta, o ClickHouse lança uma exceção.
## join\_on\_disk\_max\_files\_to\_merge
Limita o número de arquivos permitidos para ordenação paralela em operações de MergeJoin quando executadas em disco.
Quanto maior o valor da configuração, mais RAM é usada e menos E/S de disco é necessária.
Possíveis valores:
* Qualquer inteiro positivo, a partir de 2.
## join\_output\_by\_rowlist\_perkey\_rows\_threshold
O limite inferior da média de linhas por chave na tabela à direita para determinar se a saída deve usar uma lista de linhas no hash join.
## join\_overflow\_mode
Define qual ação o ClickHouse executa quando qualquer um dos limites de join a seguir é atingido:
* [max\_bytes\_in\_join](/pt-BR/reference/settings/session-settings#max_bytes_in_join)
* [max\_rows\_in\_join](/pt-BR/reference/settings/session-settings#max_rows_in_join)
Valores possíveis:
* `THROW` — o ClickHouse lança uma exceção e interrompe a operação.
* `BREAK` — o ClickHouse interrompe a operação e não lança uma exceção.
Valor padrão: `THROW`.
**Veja também**
* [cláusula JOIN](/pt-BR/reference/statements/select/join)
* [motor de tabela Join](/pt-BR/reference/engines/table-engines/special/join)
## join\_runtime\_bloom\_filter\_bytes
Tamanho, em bytes, de um filtro de Bloom usado como filtro de runtime para JOIN (consulte a configuração enable\_join\_runtime\_filters).
## join\_runtime\_bloom\_filter\_hash\_functions
Número de funções hash em um filtro de Bloom usado como filtro de runtime de JOIN (consulte a configuração enable\_join\_runtime\_filters).
## join\_runtime\_bloom\_filter\_max\_ratio\_of\_set\_bits
Se o número de bits definidos em um filtro de Bloom em tempo de execução exceder essa proporção, o filtro será desativado completamente para reduzir a sobrecarga.
## join\_runtime\_filter\_blocks\_to\_skip\_before\_reenabling
Número de blocos ignorados antes de tentar reativar dinamicamente um runtime filter que havia sido desabilitado anteriormente devido a uma baixa taxa de filtragem.
## join\_runtime\_filter\_exact\_values\_limit
Número máximo de elementos no runtime filter armazenados como estão em um conjunto; quando esse limite é excedido, ele passa a usar um filtro de Bloom.
## join\_runtime\_filter\_pass\_ratio\_threshold\_for\_disabling
Se a razão entre as linhas aprovadas e as linhas verificadas for maior que esse limite, o filtro de runtime será considerado ineficiente e será desativado pelos próximos `join_runtime_filter_blocks_to_skip_before_reenabling` blocos para reduzir a sobrecarga.
## join\_to\_sort\_maximum\_table\_rows
O número máximo de linhas na tabela da direita para determinar se ela deve ser reordenada pela chave em LEFT ou INNER JOIN.
## join\_to\_sort\_minimum\_perkey\_rows
O limite inferior da média de linhas por chave na tabela da direita para determinar se a tabela da direita deve ser reordenada pela chave em left join ou inner join. Essa configuração garante que a otimização não seja aplicada a chaves esparsas da tabela
## join\_use\_nulls
Define como o [JOIN](/pt-BR/reference/statements/select/join) se comporta. Ao combinar tabelas, podem surgir células vazias. O ClickHouse as preenche de maneiras diferentes com base nesta configuração.
Possíveis valores:
* 0 — As células vazias são preenchidas com o valor padrão do tipo do campo correspondente.
* 1 — `JOIN` se comporta da mesma forma que no SQL padrão. O tipo do campo correspondente é convertido para [Nullable](/pt-BR/reference/data-types/nullable), e as células vazias são preenchidas com [NULL](/pt-BR/reference/syntax).
## joined\_block\_split\_single\_row
Permite dividir em fragmentos o resultado do hash join por linhas correspondentes a uma única linha da tabela à esquerda.
Isso pode reduzir o uso de memória no caso de uma linha com muitas correspondências na tabela à direita, mas pode aumentar o uso de CPU.
Observe que `max_joined_block_size_rows != 0` é obrigatório para que essa configuração tenha efeito.
O `max_joined_block_size_bytes`, em combinação com essa configuração, é útil para evitar uso excessivo de memória em caso de dados desbalanceados, com algumas linhas grandes tendo muitas correspondências na tabela à direita.
## joined\_subquery\_requires\_alias
Exige que subconsultas usadas em joins e funções de tabela tenham aliases para a qualificação correta dos nomes.
## kafka\_disable\_num\_consumers\_limit
Desabilita o limite de kafka\_num\_consumers, que depende do número de núcleos de CPU disponíveis.
## kafka\_max\_wait\_ms
O tempo de espera, em milissegundos, para ler mensagens do [Kafka](/pt-BR/reference/engines/table-engines/integrations/kafka) antes de tentar novamente.
Valores possíveis:
* Inteiro positivo.
* 0 — Sem limite de tempo.
Veja também:
* [Apache Kafka](https://kafka.apache.org/)
## keeper\_map\_strict\_mode
Impõe verificações adicionais durante operações no KeeperMap. Ex.: lança uma exceção ao inserir uma chave que já existe
## keeper\_max\_retries
Máximo de tentativas para operações gerais do Keeper
## keeper\_retry\_initial\_backoff\_ms
Tempo limite de backoff inicial para operações gerais do Keeper
## keeper\_retry\_max\_backoff\_ms
Tempo máximo de backoff para operações gerais do Keeper
## least\_greatest\_legacy\_null\_behavior
Se ativada, as funções 'least' e 'greatest' retornam NULL se um de seus argumentos for NULL.
## legacy\_column\_name\_of\_tuple\_literal
Liste todos os nomes dos elementos de literais Tuple grandes nos nomes de coluna, em vez de hash. Esta configuração existe apenas por motivos de compatibilidade. Faz sentido defini-la como 'true' ao fazer um rolling update do cluster de uma versão inferior a 21.7 para uma superior.
## lightweight\_delete\_mode
Modo de consulta de atualização interna executada como parte da exclusão leve.
Valores possíveis:
* `alter_update` - executa a consulta `ALTER UPDATE`, que cria uma mutação pesada.
* `lightweight_update` - executa atualização leve, se possível; caso contrário, executa `ALTER UPDATE`.
* `lightweight_update_force` - executa atualização leve, se possível; caso contrário, gera uma exceção.
## lightweight\_deletes\_sync
O mesmo que [`mutations_sync`](#mutations_sync), mas controla apenas a execução de exclusões leves.
Valores possíveis:
| Valor | Descrição |
| ----- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `0` | As mutações são executadas de forma assíncrona. |
| `1` | A consulta aguarda a conclusão das exclusões leves no servidor atual. |
| `2` | A consulta aguarda a conclusão das exclusões leves em todas as réplicas (se existirem). |
| `3` | A consulta aguarda apenas as réplicas ativas. Compatível apenas com `SharedMergeTree`. Para `ReplicatedMergeTree`, o comportamento é o mesmo de `mutations_sync = 2`. |
**Veja também**
* [Sincronicidade das consultas ALTER](/pt-BR/reference/statements/alter#synchronicity-of-alter-queries)
* [Mutações](/pt-BR/reference/statements/alter#mutations)
Valor padrão no Cloud: `1`.
## limit
Define o número máximo de linhas a retornar no resultado da consulta. Ele ajusta o valor definido pela cláusula [LIMIT](/pt-BR/reference/statements/select/limit), para que o limite especificado na consulta não possa exceder o limite definido por esta configuração.
Valores possíveis:
* 0 — O número de linhas não é limitado.
* Inteiro positivo.
## load\_balancing
Especifica o algoritmo de seleção de réplicas usado para o processamento distribuído de consultas.
O ClickHouse oferece suporte aos seguintes algoritmos de seleção de réplicas:
* [Random](#load_balancing-random) (por padrão)
* [Nearest hostname](#load_balancing-nearest_hostname)
* [Hostname levenshtein distance](#load_balancing-hostname_levenshtein_distance)
* [In order](#load_balancing-in_order)
* [First or random](#load_balancing-first_or_random)
* [Round robin](#load_balancing-round_robin)
Veja também:
* [distributed\_replica\_max\_ignored\_errors](#distributed_replica_max_ignored_errors)
### Random (padrão)
```sql theme={null}
load_balancing = random
```
O número de erros é contabilizado para cada réplica. A consulta é enviada para a réplica com menos erros e, se houver várias nessas condições, para qualquer uma delas.
Desvantagens: a proximidade do servidor não é levada em conta; se as réplicas tiverem dados diferentes, você também obterá dados diferentes.
### Hostname mais semelhante
```sql theme={null}
load_balancing = nearest_hostname
```
O número de erros é contado para cada réplica. A cada 5 minutos, o número de erros é dividido por 2 usando divisão inteira. Assim, o número de erros é calculado com suavização exponencial para um período recente. Se houver uma réplica com o menor número de erros (ou seja, se erros tiverem ocorrido recentemente nas outras réplicas), a consulta será enviada para ela. Se houver várias réplicas com o mesmo número mínimo de erros, a consulta será enviada para a réplica com o hostname mais parecido com o hostname do servidor no arquivo de configuração (com base no número de caracteres diferentes nas mesmas posições, até o comprimento mínimo de ambos os hostnames).
Por exemplo, example01-01-1 e example01-01-2 diferem em uma posição, enquanto example01-01-1 e example01-02-2 diferem em duas posições.
Esse método pode parecer primitivo, mas não requer dados externos sobre a topologia da rede nem compara endereços IP, o que seria complicado no caso dos nossos endereços IPv6.
Assim, se houver réplicas equivalentes, a mais próxima pelo nome será preferida.
Também podemos supor que, ao enviar uma consulta para o mesmo servidor, na ausência de falhas, uma consulta distribuída também irá para os mesmos servidores. Portanto, mesmo que dados diferentes estejam nas réplicas, a consulta retornará, em sua maior parte, os mesmos resultados.
### Distância de Levenshtein entre hostnames
```sql theme={null}
load_balancing = hostname_levenshtein_distance
```
Assim como `nearest_hostname`, mas compara o hostname usando a [distância de Levenshtein](https://en.wikipedia.org/wiki/Levenshtein_distance). Por exemplo:
```text theme={null}
example-clickhouse-0-0 ample-clickhouse-0-0
1
example-clickhouse-0-0 example-clickhouse-1-10
2
example-clickhouse-0-0 example-clickhouse-12-0
3
```
### Em ordem
```sql theme={null}
load_balancing = in_order
```
As réplicas com o mesmo número de erros são acessadas na mesma ordem em que foram especificadas na configuração.
Esse método é adequado quando você sabe exatamente qual réplica é preferível.
### Primeiro ou aleatório
```sql theme={null}
load_balancing = first_or_random
```
Esse algoritmo escolhe a primeira réplica do conjunto ou uma réplica aleatória se a primeira não estiver disponível. Ele é eficaz em topologias de replicação cruzada, mas não é útil em outras configurações.
O algoritmo `first_or_random` resolve o problema do algoritmo `in_order`. Com `in_order`, se uma réplica ficar indisponível, a próxima recebe o dobro da carga, enquanto as demais réplicas continuam lidando com o volume habitual de tráfego. Ao usar o algoritmo `first_or_random`, a carga é distribuída de forma uniforme entre as réplicas que ainda estão disponíveis.
É possível definir explicitamente qual é a primeira réplica usando a configuração `load_balancing_first_offset`. Isso dá mais controle para redistribuir a carga das consultas entre as réplicas.
### Round Robin
```sql theme={null}
load_balancing = round_robin
```
Este algoritmo usa uma política round-robin entre réplicas com o mesmo número de erros (apenas as consultas com a política `round_robin` são levadas em conta).
## load\_balancing\_first\_offset
A qual réplica a consulta deve ser enviada de preferência quando a estratégia de balanceamento de carga FIRST\_OR\_RANDOM é usada.
## load\_marks\_asynchronously
Carrega as marcas do MergeTree de forma assíncrona
Valor padrão no Cloud: `1`.
## local\_filesystem\_read\_method
Método de leitura de dados do sistema de arquivos local, um dos seguintes: read, pread, mmap, io\_uring, pread\_threadpool.
O método 'io\_uring' é experimental e não funciona para Log, TinyLog, StripeLog, File, Set e Join, nem para outras tabelas com arquivos aos quais é possível acrescentar dados quando há leituras e gravações concorrentes.
Se você ler vários artigos sobre 'io\_uring' na Internet, não se deixe impressionar por eles. Ele não é um método melhor de leitura de arquivos, exceto no caso de uma grande quantidade de pequenas solicitações de E/S, o que não ocorre no ClickHouse. Não há motivo para habilitar o 'io\_uring'.
## local\_filesystem\_read\_prefetch
Deve usar pré-carregamento ao ler dados do sistema de arquivos local.
## lock\_acquire\_timeout
Define quantos segundos uma solicitação de bloqueio espera antes de falhar.
O timeout de bloqueio é usado para evitar deadlocks ao executar operações de leitura/gravação em tabelas. Quando o timeout expira e a solicitação de bloqueio falha, o servidor ClickHouse gera uma exceção "Locking attempt timed out! Possible deadlock avoided. Client should retry." com o código de erro `DEADLOCK_AVOIDED`.
Valores possíveis:
* Inteiro positivo (em segundos).
* 0 — Sem timeout de bloqueio.
Especifica o valor do campo `log_comment` da tabela [system.query\_log](/pt-BR/reference/system-tables/query_log) e o texto de comentário do log do servidor.
Pode ser usado para melhorar a legibilidade dos logs do servidor. Além disso, ajuda a selecionar consultas relacionadas ao teste em `system.query_log` após executar [clickhouse-test](/pt-BR/resources/develop-contribute/contribute/tests).
Valores possíveis:
* Qualquer string com comprimento máximo de [max\_query\_size](#max_query_size). Se `max_query_size` for excedido, o servidor gera uma exceção.
**Exemplo**
Consulta:
```sql theme={null}
SET log_comment = 'log_comment test', log_queries = 1;
SELECT 1;
SYSTEM FLUSH LOGS;
SELECT type, query FROM system.query_log WHERE log_comment = 'log_comment test' AND event_date >= yesterday() ORDER BY event_time DESC LIMIT 2;
```
Resultado:
```text theme={null}
┌─type────────┬─query─────┐
│ QueryStart │ SELECT 1; │
│ QueryFinish │ SELECT 1; │
└─────────────┴───────────┘
```
## log\_formatted\_queries
Permite registrar consultas formatadas na tabela de sistema [system.query\_log](/pt-BR/reference/system-tables/query_log) (preenche a coluna `formatted_query` na [system.query\_log](/pt-BR/reference/system-tables/query_log)).
Valores possíveis:
* 0 — As consultas formatadas não são registradas na tabela de sistema.
* 1 — As consultas formatadas são registradas na tabela de sistema.
## log\_processors\_profiles
Grava na tabela `system.processors_profile_log` o tempo que o processador passou em execução/aguardando dados.
Veja também:
* [`system.processors_profile_log`](/pt-BR/reference/system-tables/processors_profile_log)
* [`EXPLAIN PIPELINE`](/pt-BR/reference/statements/explain#explain-pipeline)
## log\_profile\_events
Registra estatísticas de desempenho de consultas em `query_log`, `query_thread_log` e `query_views_log`.
## log\_queries
Configura o registro de consultas.
As consultas enviadas ao ClickHouse com essa configuração são registradas de acordo com as regras do parâmetro de configuração do servidor [query\_log](/pt-BR/reference/settings/server-settings/settings#query_log).
Exemplo:
```text theme={null}
log_queries=1
```
## log\_queries\_cut\_to\_length
Se o comprimento da consulta for maior que um limite especificado (em bytes), a consulta será truncada ao ser gravada no log de consultas. O comprimento da consulta exibida no log de texto comum também será limitado.
## log\_queries\_min\_query\_duration\_ms
Se estiver habilitada (valor diferente de zero), as consultas mais rápidas do que o valor dessa configuração não serão registradas (você pode entendê-la como um `long_query_time` do [MySQL Slow Query Log](https://dev.mysql.com/doc/refman/5.7/slow-query-log.html)); isso basicamente significa que você não as encontrará nas tabelas a seguir:
* `system.query_log`
* `system.query_thread_log`
Somente consultas do seguinte tipo serão registradas no log:
* `QUERY_FINISH`
* `EXCEPTION_WHILE_PROCESSING`
* Tipo: milissegundos
* Valor padrão: 0 (qualquer consulta)
## log\_queries\_min\_type
Tipo mínimo de `query_log` a ser registrado.
Valores possíveis:
* `QUERY_START` (`=1`)
* `QUERY_FINISH` (`=2`)
* `EXCEPTION_BEFORE_START` (`=3`)
* `EXCEPTION_WHILE_PROCESSING` (`=4`)
Pode ser usado para limitar quais registros irão para `query_log`; por exemplo, se você estiver interessado apenas em erros, pode usar `EXCEPTION_WHILE_PROCESSING`:
```text theme={null}
log_queries_min_type='EXCEPTION_WHILE_PROCESSING'
```
## log\_queries\_probability
Permite que um usuário grave nas tabelas de sistema [query\_log](/pt-BR/reference/system-tables/query_log), [query\_thread\_log](/pt-BR/reference/system-tables/query_thread_log) e [query\_views\_log](/pt-BR/reference/system-tables/query_views_log) apenas uma amostra das consultas, selecionadas aleatoriamente com a probabilidade especificada. Isso ajuda a reduzir a carga quando há um grande volume de consultas por segundo.
Valores possíveis:
* 0 — As consultas não são registradas nas tabelas de sistema.
* Número positivo de ponto flutuante no intervalo \[0..1]. Por exemplo, se o valor da configuração for `0.5`, cerca de metade das consultas será registrada nas tabelas de sistema.
* 1 — Todas as consultas são registradas nas tabelas de sistema.
## log\_query\_settings
Registra as configurações da consulta no query\_log e no log de span do OpenTelemetry.
## log\_query\_threads
Configura o registro em log das threads de consulta.
As threads de consulta são registradas na tabela [system.query\_thread\_log](/pt-BR/reference/system-tables/query_thread_log). Essa configuração só tem efeito quando [log\_queries](#log_queries) é true. As threads das consultas executadas pelo ClickHouse com essa configuração são registradas de acordo com as regras definidas no parâmetro de configuração do servidor [query\_thread\_log](/pt-BR/reference/settings/server-settings/settings#query_thread_log).
Valores possíveis:
* 0 — Desabilitado.
* 1 — Habilitado.
**Exemplo**
```text theme={null}
log_query_threads=1
```
## log\_query\_views
Configura o registro de visualizações de consultas.
Quando uma consulta executada pelo ClickHouse com essa configuração habilitada tem visualizações associadas (materializadas ou visualizações em tempo real), elas são registradas no parâmetro de configuração do servidor [query\_views\_log](/pt-BR/reference/settings/server-settings/settings#query_views_log).
Exemplo:
```text theme={null}
log_query_views=1
```
## low\_cardinality\_allow\_in\_native\_format
Permite ou restringe o uso do tipo de dado [LowCardinality](/pt-BR/reference/data-types/lowcardinality) com o formato [Native](/pt-BR/reference/formats/Native).
Se o uso de `LowCardinality` for restringido, o servidor ClickHouse converte colunas `LowCardinality` em colunas comuns em consultas `SELECT` e converte colunas comuns em colunas `LowCardinality` em consultas `INSERT`.
Essa configuração é necessária principalmente para clientes de terceiros que não oferecem suporte ao tipo de dado `LowCardinality`.
Possible values:
* 1 — O uso de `LowCardinality` não é restringido.
* 0 — O uso de `LowCardinality` é restringido.
## low\_cardinality\_max\_dictionary\_size
Define o tamanho máximo, em linhas, de um Dicionário global compartilhado para o tipo de dado [LowCardinality](/pt-BR/reference/data-types/lowcardinality) que pode ser gravado em um sistema de arquivos de armazenamento. Essa configuração evita problemas de RAM em caso de crescimento ilimitado do Dicionário. Todos os dados que não puderem ser codificados devido à limitação do tamanho máximo do Dicionário são gravados pelo ClickHouse usando o método comum.
Valores possíveis:
* Qualquer número inteiro positivo.
## low\_cardinality\_use\_single\_dictionary\_for\_part
Ativa ou desativa o uso de um único Dicionário para a data part.
Por padrão, o servidor ClickHouse monitora o tamanho dos dicionários e, se um dicionário exceder o limite, o servidor começa a gravar o próximo. Para impedir a criação de vários dicionários, defina `low_cardinality_use_single_dictionary_for_part = 1`.
Valores possíveis:
* 1 — A criação de vários dicionários para a data part é proibida.
* 0 — A criação de vários dicionários para a data part não é proibida.
## low\_priority\_query\_wait\_time\_ms
Quando o mecanismo de priorização de consultas é usado (consulte a configuração `priority`), consultas de baixa prioridade aguardam o término das consultas de maior prioridade. Esta configuração define por quanto tempo elas aguardam.
## make\_distributed\_plan
Cria plano de consulta distribuída.
## materialize\_skip\_indexes\_on\_insert
Define se os INSERTs criam e armazenam skip indexes. Se desabilitado, os skip indexes só serão criados e armazenados [durante mesclagens](/pt-BR/reference/settings/merge-tree-settings#materialize_skip_indexes_on_merge) ou por um [MATERIALIZE INDEX](/pt-BR/reference/statements/alter/skipping-index#materialize-index) explícito.
Veja também [exclude\_materialize\_skip\_indexes\_on\_insert](#exclude_materialize_skip_indexes_on_insert).
## materialize\_statistics\_on\_insert
Define se INSERTs criam e inserem estatísticas. Se desabilitado, as estatísticas serão criadas e armazenadas durante as merges ou por MATERIALIZE STATISTICS explícito
## materialize\_ttl\_after\_modify
Aplica o TTL a dados antigos após a consulta ALTER MODIFY TTL
## materialized\_views\_ignore\_errors
Permite ignorar erros em MATERIALIZED VIEW e enviar o bloco original para a tabela, independentemente das MVs
## materialized\_views\_squash\_parallel\_inserts
Agrupa inserts paralelos na tabela de destino de visões materializadas de uma única consulta INSERT para reduzir a quantidade de partes geradas.
Se definido como `false` e `parallel_view_processing` estiver habilitado, a consulta INSERT gerará uma parte na tabela de destino para cada `max_insert_thread`.
## max\_analyze\_depth
Número máximo de análises executadas pelo interpretador.
## max\_ast\_depth
A profundidade máxima de aninhamento da árvore sintática de uma consulta. Se for excedida, uma exceção será lançada.
No momento, isso não é verificado durante o parsing, mas apenas após o parsing da consulta.
Isso significa que uma árvore sintática profunda demais pode ser criada durante o parsing,
mas a consulta falhará.
## max\_ast\_elements
O número máximo de elementos em uma árvore sintática de consulta. Se esse limite for excedido, uma exceção será lançada.
No momento, isso não é verificado durante o parsing, mas apenas após o parsing da consulta.
Isso significa que uma árvore sintática excessivamente profunda pode ser criada durante o parsing,
mas a consulta falhará.
## max\_autoincrement\_series
O limite para o número de séries criadas pela função `generateSerialID`.
Como cada série representa um nó no Keeper, recomenda-se não ter mais do que alguns milhões delas.
## max\_backup\_bandwidth
A velocidade máxima de leitura, em bytes por segundo, para um backup específico no servidor. Zero significa sem limite.
## max\_block\_size
No ClickHouse, os dados são processados em blocos, que são conjuntos de partes de colunas. Os ciclos internos de processamento de um único bloco são eficientes, mas há custos perceptíveis no processamento de cada bloco.
A configuração `max_block_size` indica o número máximo recomendado de linhas a serem incluídas em um único bloco ao carregar dados de tabelas. Blocos com o tamanho de `max_block_size` nem sempre são carregados da tabela: se o ClickHouse determinar que menos dados precisam ser recuperados, um bloco menor será processado.
O tamanho do bloco não deve ser muito pequeno, para evitar custos perceptíveis no processamento de cada bloco. Também não deve ser muito grande, para garantir que consultas com uma cláusula LIMIT sejam executadas rapidamente após o processamento do primeiro bloco. Ao definir `max_block_size`, o objetivo deve ser evitar o consumo excessivo de memória ao extrair um grande número de colunas em múltiplas threads e preservar ao menos alguma localidade de cache.
## max\_bytes\_before\_external\_group\_by
Valor padrão no Cloud: metade da quantidade de memória por réplica.
Habilita ou desabilita a execução de cláusulas `GROUP BY` na memória externa.
(Consulte [GROUP BY na memória externa](/pt-BR/reference/statements/select/group-by#group-by-in-external-memory))
Valores possíveis:
* Volume máximo de RAM (em bytes) que pode ser usado por uma única operação [GROUP BY](/pt-BR/reference/statements/select/group-by).
* `0` — `GROUP BY` na memória externa desabilitado.
Se o uso de memória durante operações de GROUP BY exceder esse limite em bytes,
ative o modo de agregação externa (gravar dados em disco).
O valor recomendado é metade da memória disponível do sistema.
## max\_bytes\_before\_external\_join
Se for definido com um valor diferente de zero e `join_algorithm` for `hash`, `parallel_hash`, `default` ou `auto`, o hash join será convertido automaticamente em grace hash join para permitir o spilling para disco quando os dados do lado direito excederem essa quantidade de bytes. Quando definido como 0 (padrão), esse limite absoluto em bytes é desabilitado, mas o spilling automático ainda pode ocorrer por meio de `max_bytes_ratio_before_external_join` (que, por padrão, é `0.5`); defina ambos como `0` para desabilitar totalmente o spilling automático. Isso impede a otimização de leitura em ordem por meio de join.
## max\_bytes\_before\_external\_sort
Valor padrão no Cloud: metade da quantidade de memória por réplica.
Habilita ou desabilita a execução de cláusulas `ORDER BY` em memória externa. Consulte [Detalhes de implementação de ORDER BY](/pt-BR/reference/statements/select/order-by#implementation-details)
Se o uso de memória durante a operação `ORDER BY` exceder esse limite em bytes, o modo de "ordenação externa" (gravar dados em disco) será ativado.
Valores possíveis:
* Volume máximo de RAM (em bytes) que pode ser usado por uma única operação [ORDER BY](/pt-BR/reference/statements/select/order-by).
O valor recomendado é metade da memória disponível do sistema
* `0` — `ORDER BY` em memória externa desabilitado.
## max\_bytes\_before\_remerge\_sort
No caso de ORDER BY com LIMIT, quando o uso de memória exceder o limite especificado, execute etapas adicionais de mesclagem de blocos antes da mesclagem final para manter apenas as primeiras LIMIT linhas.
## max\_bytes\_for\_lazy\_final
Número máximo de bytes no conjunto para a otimização lazy FINAL. Se esse limite for excedido, usa o FINAL normal.
## max\_bytes\_in\_distinct
O número máximo de bytes do estado (em bytes descomprimidos) na memória,
usado por uma tabela hash ao utilizar DISTINCT.
## max\_bytes\_in\_join
O tamanho máximo, em bytes, da tabela hash usada em junções entre tabelas.
Essa configuração se aplica às operações [SELECT ... JOIN](/pt-BR/reference/statements/select/join)
e ao [motor de tabela Join](/pt-BR/reference/engines/table-engines/special/join).
Se a consulta contiver junções, o ClickHouse verifica essa configuração para cada resultado intermediário.
O ClickHouse pode prosseguir com diferentes ações quando o limite é atingido. Use
a configuração [join\_overflow\_mode](/pt-BR/reference/settings/session-settings#join_overflow_mode) para escolher a ação.
Valores possíveis:
* Inteiro positivo.
* 0 — O controle de memória está desabilitado.
## max\_bytes\_in\_set
O número máximo de bytes (de dados não comprimidos) usado por um conjunto criado a partir de uma subconsulta na cláusula IN.
## max\_bytes\_ratio\_before\_external\_group\_by
A fração da memória disponível que pode ser usada pelo `GROUP BY`. Quando esse limite é atingido,
a agregação passa a usar memória externa.
Por exemplo, se definido como `0.6`, o `GROUP BY` permitirá usar 60% da memória disponível
(para servidor/usuário/mesclagens) no início da execução; depois disso, passará
a usar agregação externa.
## max\_bytes\_ratio\_before\_external\_join
A proporção da memória disponível que pode ser usada para `JOIN`. Quando esse valor é atingido, o hash join será convertido em grace hash join para fazer spill dos dados do lado direito para disco.
Por exemplo, se definido como `0.6`, `JOIN` permitirá usar `60%` da memória disponível (para servidor/usuário/mesclagens) para a tabela hash do lado direito no início da execução; depois disso, começa o spill para disco.
Se `max_bytes_before_external_join` e `max_bytes_ratio_before_external_join` estiverem definidos, será usado o menor limite resultante. Se a proporção for `0`, apenas a configuração absoluta se aplica.
Tem efeito apenas quando `join_algorithm` é `hash`, `parallel_hash`, `default` ou `auto` e um caminho de dados temporários está configurado.
## max\_bytes\_ratio\_before\_external\_sort
A fração da memória disponível que pode ser usada por `ORDER BY`. Quando esse limite é atingido, a ordenação externa é utilizada.
Por exemplo, se definido como `0.6`, `ORDER BY` permitirá usar `60%` da memória disponível (para servidor/usuário/merges) no início da execução; depois disso, começará a usar ordenação externa.
Observe que `max_bytes_before_external_sort` ainda é respeitado; o spilling para disco só será feito se o bloco de ordenação for maior que `max_bytes_before_external_sort`.
## max\_bytes\_to\_read
O número máximo de bytes (de dados não comprimidos) que podem ser lidos de uma tabela ao executar uma consulta.
A restrição é verificada para cada fragmento de dados processado, aplicada apenas à
expressão de tabela mais profunda e, ao ler de um servidor remoto, verificada apenas no
servidor remoto.
## max\_bytes\_to\_read\_leaf
O número máximo de bytes (de dados não comprimidos) que pode ser lido de uma
tabela local em um nó folha ao executar uma consulta distribuída. Embora consultas distribuídas
possam emitir várias subconsultas para cada shard (folha), esse limite
será verificado apenas na etapa de leitura nos nós folha e será ignorado na
etapa de mesclagem dos resultados no nó raiz.
Por exemplo, um cluster consiste em 2 shards, e cada shard contém uma tabela com
100 bytes de dados. Uma consulta distribuída que deveria ler todos os dados
de ambas as tabelas com a configuração `max_bytes_to_read=150` falhará, pois o total
será de 200 bytes. Uma consulta com `max_bytes_to_read_leaf=150` terá êxito, já que
os nós folha lerão no máximo 100 bytes.
A restrição é verificada para cada fragmento de dados processado.
Essa configuração é instável com `prefer_localhost_replica=1`.
## max\_bytes\_to\_sort
O número máximo de bytes antes da ordenação. Se for necessário processar mais do que a quantidade especificada de
bytes não comprimidos para a operação ORDER BY, o comportamento
será determinado por `sort_overflow_mode`, que por padrão está definido como `throw`.
## max\_bytes\_to\_transfer
O número máximo de bytes (dados não comprimidos) que podem ser enviados a um servidor remoto
ou salvos em uma tabela temporária quando a seção GLOBAL IN/JOIN é executada.
## max\_columns\_to\_read
O número máximo de colunas que podem ser lidas de uma tabela em uma única consulta.
Se uma consulta exigir a leitura de mais colunas do que o número especificado, uma exceção
será gerada.
Essa configuração é útil para evitar consultas excessivamente complexas.
O valor `0` significa sem limite.
## max\_compress\_block\_size
O tamanho máximo dos blocos de dados não comprimidos antes da compressão para gravação em uma tabela. O padrão é 1.048.576 (1 MiB). Especificar um tamanho de bloco menor geralmente resulta em uma taxa de compressão ligeiramente menor; a velocidade de compressão e descompressão aumenta um pouco devido à localidade de cache, e o consumo de memória é reduzido.
Esta é uma configuração de nível avançado, e você não deve alterá-la se estiver apenas começando a usar o ClickHouse.
Não confunda blocos usados para compressão (um bloco de memória composto por bytes) com blocos usados no processamento de consultas (um conjunto de linhas de uma tabela).
## max\_concurrent\_queries\_for\_all\_users
Gera uma exceção se o valor dessa configuração for menor ou igual ao número atual de consultas processadas simultaneamente.
Exemplo: `max_concurrent_queries_for_all_users` pode ser definido como 99 para todos os usuários, e o administrador do banco de dados pode defini-lo como 100 para a própria conta para executar consultas de investigação mesmo quando o servidor estiver sobrecarregado.
Modificar a configuração para uma consulta ou um usuário não afeta outras consultas.
Valores possíveis:
* Inteiro positivo.
* 0 — Sem limite.
**Exemplo**
```xml theme={null}
99
```
**Veja também**
* [max\_concurrent\_queries](/pt-BR/reference/settings/server-settings/settings#max_concurrent_queries)
Valor padrão no Cloud: `1000`.
## max\_concurrent\_queries\_for\_user
O número máximo de consultas processadas simultaneamente por usuário.
Valores possíveis:
* Inteiro positivo.
* 0 — Sem limite.
**Exemplo**
```xml theme={null}
5
```
## max\_consume\_snapshots
Número máximo de snapshots do Paimon a consumir por leitura incremental. 0 significa que não há limite.
## max\_distributed\_connections
O número máximo de conexões simultâneas com servidores remotos para o processamento distribuído de uma única consulta em uma única tabela Distributed. Recomendamos definir um valor no mínimo igual ao número de servidores no cluster.
Os parâmetros a seguir são usados apenas ao criar tabelas Distributed (e ao iniciar o servidor), portanto não há motivo para alterá-los em tempo de execução.
## max\_distributed\_depth
Limita a profundidade máxima de consultas recursivas em tabelas [Distributed](/pt-BR/reference/engines/table-engines/special/distributed).
Se esse valor for excedido, o servidor lança uma exceção.
Valores possíveis:
* Inteiro positivo.
* 0 — Profundidade ilimitada.
## max\_download\_buffer\_size
O tamanho máximo do buffer para download em paralelo por thread (por exemplo, para URL engine).
## max\_download\_threads
O número máximo de threads para fazer download de dados (por exemplo, para o URL engine).
## max\_estimated\_execution\_time
Tempo máximo estimado de execução da consulta, em segundos. Verificado em cada bloco de dados
quando [`timeout_before_checking_execution_speed`](/pt-BR/reference/settings/session-settings#timeout_before_checking_execution_speed)
é atingido.
## max\_execution\_speed
O número máximo de linhas processadas por segundo. Verificado em cada bloco de dados quando
[`timeout_before_checking_execution_speed`](/pt-BR/reference/settings/session-settings#timeout_before_checking_execution_speed)
expira. Se a velocidade de execução estiver alta, ela será reduzida.
## max\_execution\_speed\_bytes
O número máximo de bytes processados por segundo. É verificado em cada bloco de dados quando
[`timeout_before_checking_execution_speed`](/pt-BR/reference/settings/session-settings#timeout_before_checking_execution_speed)
expira. Se a velocidade de execução for alta, ela será reduzida.
## max\_execution\_time
O tempo máximo de execução da consulta, em segundos.
O parâmetro `max_execution_time` pode ser um pouco difícil de entender.
Ele funciona com base em interpolação em relação à velocidade atual de execução da consulta
(esse comportamento é controlado por [`timeout_before_checking_execution_speed`](/pt-BR/reference/settings/session-settings#timeout_before_checking_execution_speed)).
O ClickHouse interromperá uma consulta se o tempo de execução projetado exceder o
`max_execution_time` especificado. Por padrão, `timeout_before_checking_execution_speed`
é definido como 10 segundos. Isso significa que, após 10 segundos de execução da consulta, o ClickHouse
começará a estimar o tempo total de execução. Se, por exemplo, `max_execution_time`
for definido como 3600 segundos (1 hora), o ClickHouse encerrará a consulta se o tempo estimado
ultrapassar esse limite de 3600 segundos. Se você definir `timeout_before_checking_execution_speed`
como 0, o ClickHouse usará o tempo de relógio como base para `max_execution_time`.
Se o tempo de execução da consulta exceder o número especificado de segundos, o comportamento será
determinado por 'timeout\_overflow\_mode', que, por padrão, é definido como `throw`.
O timeout é verificado, e a consulta só pode ser interrompida em pontos específicos durante o processamento de dados.
Atualmente, ela não pode ser interrompida durante a mesclagem de estados de agregação nem durante a análise da consulta,
e o tempo real de execução será maior que o valor dessa configuração.
## max\_execution\_time\_leaf
Semanticamente semelhante a [`max_execution_time`](#max_execution_time), mas aplicado apenas
aos nós folha em consultas distribuídas ou remotas.
Por exemplo, se quisermos limitar o tempo de execução em um nó folha a `10s`, mas
não houver limite no nó inicial, em vez de definir `max_execution_time` nas
configurações da subconsulta aninhada:
```sql theme={null}
SELECT count()
FROM cluster(cluster, view(SELECT * FROM t SETTINGS max_execution_time = 10));
```
Podemos usar `max_execution_time_leaf` nas configurações da consulta:
```sql theme={null}
SELECT count()
FROM cluster(cluster, view(SELECT * FROM t)) SETTINGS max_execution_time_leaf = 10;
```
## max\_expanded\_ast\_elements
Tamanho máximo da árvore de sintaxe da consulta, em número de nós, após a expansão de aliases e do asterisco.
## max\_fetch\_partition\_retries\_count
Número de tentativas ao buscar uma partição em outro host.
## max\_final\_threads
Define o número máximo de threads paralelas para a fase de leitura de dados da consulta `SELECT` com o modificador [FINAL](/pt-BR/reference/statements/select/from#final-modifier).
Valores possíveis:
* Inteiro positivo.
* 0 ou 1 — Desativado. As consultas `SELECT` são executadas em uma única thread.
## max\_http\_get\_redirects
Número máximo de saltos de redirecionamento HTTP GET permitidos. Isso garante medidas adicionais de segurança para impedir que um servidor malicioso redirecione suas requisições para serviços inesperados.\n\nIsso pode acontecer quando um servidor externo redireciona para outro endereço, mas esse endereço parece ser interno à infraestrutura da empresa e, ao enviar uma requisição HTTP para um servidor interno, você pode acessar uma API interna pela rede interna, contornando a autenticação, ou até mesmo consultar outros serviços, como Redis ou Memcached. Se você não tem uma infraestrutura interna (incluindo algo em execução no seu localhost) ou confia no servidor, é seguro permitir redirecionamentos. Ainda assim, tenha em mente que, se a URL usar HTTP em vez de HTTPS, você terá de confiar não apenas no servidor remoto, mas também no seu ISP e em todas as redes intermediárias.
Valor padrão no Cloud: `10`.
## max\_hyperscan\_regexp\_length
Define o tamanho máximo de cada expressão regular nas [funções hyperscan multi-match](/pt-BR/reference/functions/regular-functions/string-search-functions#multiMatchAny).
Valores possíveis:
* Inteiro positivo.
* 0 - O tamanho não é limitado.
**Exemplo**
Consulta:
```sql theme={null}
SELECT multiMatchAny('abcd', ['ab','bcd','c','d']) SETTINGS max_hyperscan_regexp_length = 3;
```
Resultado:
```text theme={null}
┌─multiMatchAny('abcd', ['ab', 'bcd', 'c', 'd'])─┐
│ 1 │
└────────────────────────────────────────────────┘
```
Consulta:
```sql theme={null}
SELECT multiMatchAny('abcd', ['ab','bcd','c','d']) SETTINGS max_hyperscan_regexp_length = 2;
```
Resultado:
```text theme={null}
Exception: Regexp length too large.
```
**Veja também**
* [max\_hyperscan\_regexp\_total\_length](#max_hyperscan_regexp_total_length)
## max\_hyperscan\_regexp\_total\_length
Define o comprimento total máximo de todas as expressões regulares em cada [hyperscan multi-match function](/pt-BR/reference/functions/regular-functions/string-search-functions#multiMatchAny).
Valores possíveis:
* Inteiro positivo.
* 0 — O comprimento não é limitado.
**Exemplo**
Consulta:
```sql theme={null}
SELECT multiMatchAny('abcd', ['a','b','c','d']) SETTINGS max_hyperscan_regexp_total_length = 5;
```
Resultado:
```text theme={null}
┌─multiMatchAny('abcd', ['a', 'b', 'c', 'd'])─┐
│ 1 │
└─────────────────────────────────────────────┘
```
Consulta:
```sql theme={null}
SELECT multiMatchAny('abcd', ['ab','bc','c','d']) SETTINGS max_hyperscan_regexp_total_length = 5;
```
Resultado:
```text theme={null}
Exception: Total regexp lengths too large.
```
**Veja também**
* [max\_hyperscan\_regexp\_length](#max_hyperscan_regexp_length)
## max\_insert\_block\_size
**Aliases**: `max_insert_block_size_rows`
O tamanho máximo dos blocos (em número de linhas) a serem formados para inserção em uma tabela.
Essa configuração controla a formação de blocos em dois contextos:
1. Análise de formato: quando o servidor analisa formatos de entrada baseados em linhas (CSV, TSV, JSONEachRow etc.) de qualquer interface (HTTP, clickhouse-client com dados inline, gRPC, PostgreSQL wire protocol), os blocos são emitidos quando:
* min\_insert\_block\_size\_rows AND min\_insert\_block\_size\_bytes são atingidos, OR
* max\_insert\_block\_size\_rows OR max\_insert\_block\_size\_bytes é atingido
Observação: ao usar clickhouse-client ou clickhouse-local para ler de um arquivo, o próprio cliente analisa os dados, e essa configuração se aplica no lado do cliente.
2. Operações de INSERT: durante consultas INSERT e quando os dados passam por visões materializadas, o comportamento dessa configuração depende de `use_strict_insert_block_limits`:
* Quando habilitada: os blocos são emitidos quando:
* Limiares mínimos (AND): min\_insert\_block\_size\_rows AND min\_insert\_block\_size\_bytes são atingidos
* Limiares máximos (OR): max\_insert\_block\_size\_rows OR max\_insert\_block\_size\_bytes é atingido
* Quando desabilitada: os blocos são emitidos quando min\_insert\_block\_size\_rows OR min\_insert\_block\_size\_bytes é atingido. As configurações de max\_insert\_block\_size não são aplicadas.
Valores possíveis:
* Inteiro positivo.
## max\_insert\_block\_size\_bytes
O tamanho máximo dos blocos (em bytes) a serem formados para inserção em uma tabela.
Esta configuração funciona em conjunto com max\_insert\_block\_size\_rows e controla a formação de blocos no mesmo contexto. Consulte max\_insert\_block\_size\_rows para informações detalhadas sobre quando e como essas configurações são aplicadas.
Valores possíveis:
* Inteiro positivo.
* 0 — a configuração não participa da formação de blocos.
## max\_insert\_delayed\_streams\_for\_parallel\_write
O número máximo de streams (colunas) para atrasar o flush final da part. Padrão: automático (100 caso o armazenamento subjacente tenha suporte a gravação paralela, por exemplo, S3, e desativado caso contrário)
Valor padrão no Cloud: `50`.
## max\_insert\_threads
O número máximo de threads para executar a consulta `INSERT SELECT`.
Valores possíveis:
* 0 (ou 1) — `INSERT SELECT` sem execução em paralelo.
* Inteiro positivo, maior que 1.
Valor padrão do Cloud:
* `1` para nós com 8 GiB de memória
* `2` para nós com 16 GiB de memória
* `4` para nós maiores
O `INSERT SELECT` em paralelo só tem efeito se a parte `SELECT` for executada em paralelo. Consulte a configuração [`max_threads`](#max_threads).
Valores mais altos resultarão em maior uso de memória.
## max\_insert\_threads\_min\_free\_memory\_per\_thread
Igual a `max_threads_min_free_memory_per_thread`, mas aplicada a `max_insert_threads` em vez de `max_threads`. O valor padrão é maior porque pipelines de inserção normalmente mantêm buffers por thread maiores (partes do MergeTree, blocos de compressão) do que pipelines de leitura.
Se a quantidade de memória livre for menor que `max_insert_threads` multiplicado por esse valor, `max_insert_threads` será reduzido para se adequar, até um mínimo de `1`.
Defina como `0` para desativar esse limite.
## max\_joined\_block\_size\_bytes
Tamanho máximo, em bytes, do bloco para o resultado do JOIN (se o algoritmo de join oferecer suporte). 0 significa ilimitado.
## max\_joined\_block\_size\_rows
Tamanho máximo do bloco para o resultado do JOIN (se o algoritmo de join oferecer suporte). 0 significa ilimitado.
## max\_limit\_for\_vector\_search\_queries
Consultas SELECT com LIMIT maior do que o definido nessa configuração não podem usar índices de similaridade vetorial. Isso ajuda a evitar estouros de memória nesses índices.
## max\_local\_read\_bandwidth
A velocidade máxima das leituras locais em bytes por segundo.
## max\_local\_write\_bandwidth
A velocidade máxima das gravações locais em bytes por segundo.
## max\_memory\_usage
Valor padrão no Cloud: depende da quantidade de RAM na réplica.
A quantidade máxima de RAM usada para executar uma consulta em um único servidor.
Um valor de `0` significa ilimitado.
Essa configuração não considera o volume de memória disponível nem o volume total
de memória da máquina. A restrição se aplica a uma única consulta em um
único servidor.
Você pode usar `SHOW PROCESSLIST` para ver o consumo de memória atual de cada consulta.
O pico de consumo de memória é rastreado para cada consulta e registrado no log.
O uso de memória não é totalmente rastreado para os estados das seguintes funções de agregação
com argumentos `String` e `Array`:
* `min`
* `max`
* `any`
* `anyLast`
* `argMin`
* `argMax`
O consumo de memória também é limitado pelos parâmetros [`max_memory_usage_for_user`](/pt-BR/reference/settings/session-settings#max_memory_usage_for_user)
e [`max_server_memory_usage`](/pt-BR/reference/settings/server-settings/settings#max_server_memory_usage).
## max\_memory\_usage\_for\_user
A quantidade máxima de RAM usada para executar as consultas de um usuário em um único servidor. Zero significa ilimitado.
Por padrão, essa quantidade não é restrita (`max_memory_usage_for_user = 0`).
Veja também a descrição de [`max_memory_usage`](/pt-BR/reference/settings/session-settings#max_memory_usage).
Por exemplo, se você quiser definir `max_memory_usage_for_user` como 1000 bytes para um usuário chamado `clickhouse_read`, poderá usar a instrução
```sql theme={null}
ALTER USER clickhouse_read SETTINGS max_memory_usage_for_user = 1000;
```
Você pode verificar se funcionou saindo do cliente, entrando novamente e usando a função `getSetting`:
```sql theme={null}
SELECT getSetting('max_memory_usage_for_user');
```
## max\_network\_bandwidth
Limita a velocidade da transferência de dados pela rede em bytes por segundo. Esta configuração se aplica a cada consulta.
Valores possíveis:
* Inteiro positivo.
* 0 — O controle de largura de banda está desativado.
## max\_network\_bandwidth\_for\_all\_users
Limita a velocidade com que os dados são transferidos pela rede, em bytes por segundo. Esta configuração se aplica a todas as consultas executadas simultaneamente no servidor.
Valores possíveis:
* Inteiro positivo.
* 0 — O controle da taxa de transferência de dados está desabilitado.
## max\_network\_bandwidth\_for\_user
Limita a velocidade da transferência de dados pela rede em bytes por segundo. Essa configuração se aplica a todas as consultas executadas simultaneamente por um único usuário.
Valores possíveis:
* Inteiro positivo.
* 0 — O controle da velocidade de transferência de dados está desabilitado.
## max\_network\_bytes
Limita o volume de dados (em bytes) recebido ou transmitido pela rede durante a execução de uma consulta. Essa configuração se aplica a cada consulta individual.
Valores possíveis:
* Inteiro positivo.
* 0 — O controle do volume de dados está desativado.
## max\_number\_of\_partitions\_for\_independent\_aggregation
Número máximo de partições na tabela para aplicar a otimizaçã
## max\_os\_cpu\_wait\_time\_ratio\_to\_throw
Proporção máxima entre os tempos de espera de CPU do SO (métrica OSCPUWaitMicroseconds) e de uso (métrica OSCPUVirtualTimeMicroseconds) para considerar a rejeição de consultas. A interpolação linear entre a proporção mínima e a máxima é usada para calcular a probabilidade; a probabilidade é 1 neste ponto.
## max\_parallel\_replicas
O número máximo de réplicas para cada shard ao executar uma consulta.
Possíveis valores:
* Inteiro positivo.
**Informações adicionais**
Essa opção pode produzir resultados diferentes, dependendo das configurações usadas.
### Processamento em paralelo usando a chave `SAMPLE`
Uma consulta pode ser processada mais rapidamente se for executada em vários servidores em paralelo. Mas o desempenho da consulta pode piorar nos seguintes casos:
* A posição da chave de amostragem na chave de particionamento não permite varreduras por intervalo eficientes.
* Adicionar uma chave de amostragem à tabela torna menos eficiente a filtragem por outras colunas.
* A chave de amostragem é uma expressão cara de calcular.
* A distribuição de latência do cluster tem uma cauda longa, de modo que consultar mais servidores aumenta a latência geral da consulta.
### Processamento paralelo com [parallel\_replicas\_custom\_key](#parallel_replicas_custom_key)
Essa configuração é útil para qualquer tabela replicada.
## max\_parser\_backtracks
Número máximo de retrocessos do analisador sintático (quantas vezes ele tenta alternativas diferentes durante o processo de análise descendente recursiva).
## max\_parser\_depth
Limita a profundidade máxima de recursão no parser recursivo descendente. Permite controlar o tamanho da pilha.
Valores possíveis:
* Inteiro positivo.
* 0 — A profundidade de recursão é ilimitada.
## max\_parsing\_threads
O número máximo de threads para fazer o parsing de dados em formatos de entrada que suportam parsing em paralelo. Por padrão, ele é determinado automaticamente.
## max\_partition\_size\_to\_drop
Restrição para remover partições durante a consulta. O valor `0` significa que você pode remover partições sem restrições.
Valor padrão no Cloud: 1 TB.
Esta configuração de consulta substitui a configuração equivalente no servidor; consulte [max\_partition\_size\_to\_drop](/pt-BR/reference/settings/server-settings/settings#max_partition_size_to_drop)
## max\_partitions\_per\_insert\_block
Limita o número máximo de partições em um único bloco inserido,
e uma exceção é gerada se o bloco contiver partições demais.
* Inteiro positivo.
* `0` — Número ilimitado de partições.
**Detalhes**
Ao inserir dados, o ClickHouse calcula o número de partições no
bloco inserido. Se o número de partições for maior que
`max_partitions_per_insert_block`, o ClickHouse registra um aviso ou gera uma
exceção com base em `throw_on_max_partitions_per_insert_block`. As exceções têm
o seguinte texto:
> "Partições demais em um único bloco INSERT (`partitions_count` partições, o limite é " + toString(max\_partitions) + ").
> O limite é controlado pela configuração 'max\_partitions\_per\_insert\_block'.
> Um grande número de partições é um equívoco comum. Isso causará um grave
> impacto negativo no desempenho, incluindo inicialização lenta do servidor, consultas INSERT lentas
> e consultas SELECT lentas. O número total recomendado de partições para uma tabela é
> abaixo de 1000..10000. Observe que o particionamento não se destina a acelerar
> consultas SELECT (a ORDER BY key é suficiente para tornar consultas de intervalo rápidas).
> As partições se destinam à manipulação de dados (DROP PARTITION, etc)."
Essa configuração é um limite de segurança, porque usar um grande número de partições é um equívoco comum.
## max\_partitions\_to\_read
Limita o número máximo de partições que podem ser acessadas em uma única consulta.
O valor da configuração especificado quando a tabela é criada pode ser substituído por uma configuração no nível da consulta.
Valores possíveis:
* Inteiro positivo
* `-1` - ilimitado (padrão)
Você também pode especificar a configuração do MergeTree [`max_partitions_to_read`](/pt-BR/reference/settings/session-settings#max_partitions_to_read) nas configurações da tabela.
## max\_parts\_to\_move
Limita o número de partes que podem ser movidas em uma consulta. Zero significa sem limite.
## max\_projection\_rows\_to\_use\_projection\_index
Se o número de linhas lidas do índice de projeção for menor ou igual a esse limite, o ClickHouse tentará aplicar o índice de projeção durante a execução da consulta.
## max\_query\_size
O número máximo de bytes de uma string de consulta analisada pelo parser SQL.
Os dados na cláusula VALUES de consultas INSERT são processados por um parser de fluxo separado (que consome O(1) de RAM) e não são afetados por essa restrição.
`max_query_size` não pode ser definido dentro de uma consulta SQL (por exemplo, `SELECT now() SETTINGS max_query_size=10000`) porque o ClickHouse precisa alocar um buffer para analisar a consulta, e o tamanho desse buffer é determinado pela configuração `max_query_size`, que deve ser definida antes da execução da consulta.
## max\_rand\_distribution\_parameter
Valor máximo para os parâmetros de forma da distribuição em funções de distribuição aleatória, como `randChiSquared`, `randStudentT` e `randFisherF`. Isso evita tempos de computação extremamente longos com valores extremos dos parâmetros.
## max\_rand\_distribution\_trials
Número máximo de tentativas permitido para funções de distribuição aleatória, como `randBinomial` e `randNegativeBinomial`. Isso evita tempos de processamento excessivamente longos com um grande número de tentativas.
## max\_read\_buffer\_size
O tamanho máximo do buffer para leitura do filesystem.
## max\_read\_buffer\_size\_local\_fs
O tamanho máximo do buffer para leitura no sistema de arquivos local. Se definido como 0, `max_read_buffer_size` será usado.
## max\_read\_buffer\_size\_remote\_fs
O tamanho máximo do buffer para leitura em um filesystem remoto. Se for definido como 0, `max_read_buffer_size` será usado.
## max\_recursive\_cte\_evaluation\_depth
Limite máximo para a profundidade de avaliação de CTEs recursivas
## max\_remote\_read\_network\_bandwidth
A velocidade máxima de transferência de dados pela rede, em bytes por segundo, para leitura.
## max\_remote\_write\_network\_bandwidth
A velocidade máxima de transferência de dados pela rede, em bytes por segundo, para gravação.
## max\_replica\_delay\_for\_distributed\_queries
Desativa réplicas com defasagem em consultas distribuídas. Veja [Replicação](/pt-BR/reference/engines/table-engines/mergetree-family/replication).
Define o tempo em segundos. Se a defasagem de uma réplica for maior ou igual ao valor definido, essa réplica não será usada.
Valores possíveis:
* Inteiro positivo.
* 0 — A defasagem das réplicas não é verificada.
Para evitar o uso de qualquer réplica com defasagem diferente de zero, defina este parâmetro como 1.
Usado ao executar `SELECT` em uma tabela distribuída que aponta para tabelas replicadas.
## max\_result\_bytes
Limita o tamanho do resultado em bytes (sem compressão). A consulta será interrompida após o processamento de um bloco de dados se o limite for atingido,
mas o último bloco do resultado não será cortado; portanto, o tamanho do resultado pode ser maior que esse limite.
**Observações**
O tamanho do resultado na memória é considerado para esse limite.
Mesmo que o tamanho do resultado seja pequeno, ele pode fazer referência a estruturas de dados maiores na memória,
como dicionários de colunas LowCardinality e Arenas de colunas AggregateFunction,
portanto o limite pode ser excedido apesar do pequeno tamanho do resultado.
Essa configuração é de baixo nível e deve ser usada com cautela
## max\_result\_rows
Valor padrão no Cloud: `0`.
Limita o número de linhas no resultado. Também é verificado para subconsultas e em servidores remotos ao executar partes de uma consulta Distributed.
Nenhum limite é aplicado quando o valor é `0`.
A consulta será interrompida após processar um bloco de dados se o limite for atingido, mas
não cortará o último bloco do resultado; portanto, o tamanho do resultado pode ser
maior que o limite.
## max\_reverse\_dictionary\_lookup\_cache\_size\_bytes
Tamanho máximo, em bytes, do cache por consulta de lookup reverso em dicionário usado pela função `dictGetKeys`. O cache armazena tuplas de chave serializadas por valor de atributo para evitar varrer o dicionário novamente na mesma consulta. Quando o limite é atingido, as entradas são removidas usando LRU. Defina como 0 para desativar o cache.
## max\_rows\_for\_lazy\_final
Número máximo de linhas no conjunto para a otimização lazy FINAL. Se esse limite for excedido, recorre ao FINAL normal.
## max\_rows\_in\_distinct
O número máximo de linhas distintas ao usar DISTINCT.
## max\_rows\_in\_join
Limita o número de linhas na tabela hash usada em junções entre tabelas.
Esta configuração se aplica às operações [SELECT ... JOIN](/pt-BR/reference/statements/select/join)
e ao motor de tabela [Join](/pt-BR/reference/engines/table-engines/special/join).
Se uma consulta contiver várias junções, o ClickHouse verificará essa configuração para cada resultado intermediário.
O ClickHouse pode prosseguir com diferentes ações quando o limite for atingido. Use a
configuração [`join_overflow_mode`](/pt-BR/reference/settings/session-settings#join_overflow_mode) para escolher a ação.
Valores possíveis:
* Inteiro positivo.
* `0` — Número ilimitado de linhas.
## max\_rows\_in\_set
O número máximo de linhas de um conjunto de dados na cláusula IN criado a partir de uma subconsulta.
## max\_rows\_in\_set\_to\_optimize\_join
Tamanho máximo do conjunto usado para filtrar tabelas em join pelos conjuntos de linhas umas das outras antes do join.
Valores possíveis:
* 0 — Desativa.
* Qualquer inteiro positivo.
## max\_rows\_to\_group\_by
O número máximo de chaves únicas geradas pela agregação. Essa configuração permite
limitar o consumo de memória durante a agregação.
Se a agregação durante o GROUP BY gerar mais do que o número especificado de
linhas (chaves únicas de GROUP BY), o comportamento será determinado por
'group\_by\_overflow\_mode', que por padrão é `throw`, mas também pode ser alterado
para um modo aproximado de GROUP BY.
## max\_rows\_to\_read
O número máximo de linhas que podem ser lidas de uma tabela ao executar uma consulta.
A restrição é verificada em cada fragmento de dados processado, aplicada apenas à
expressão de tabela mais interna e, ao ler de um servidor remoto, verificada apenas no
servidor remoto.
## max\_rows\_to\_read\_leaf
O número máximo de linhas que podem ser lidas de uma tabela local em um nó folha ao
executar uma consulta distribuída. Embora as consultas distribuídas possam emitir várias subconsultas
para cada shard (folha), esse limite será verificado apenas na etapa de leitura nos
nós folha e ignorado na etapa de mesclagem de resultados no nó raiz.
Por exemplo, um cluster consiste em 2 shards, e cada shard contém uma tabela com
100 linhas. A consulta distribuída que deve ler todos os dados de ambas as
tabelas com a configuração `max_rows_to_read=150` falhará, pois, no total, haverá
200 linhas. Uma consulta com `max_rows_to_read_leaf=150` terá êxito, já que os nós folha
lerão no máximo 100 linhas.
A restrição é verificada para cada fragmento de dados processado.
Essa configuração é instável com `prefer_localhost_replica=1`.
## max\_rows\_to\_sort
O número máximo de linhas antes da ordenação. Isso permite limitar o consumo de memória durante a ordenação.
Se mais do que a quantidade especificada de registros precisar ser processada para a operação ORDER BY,
o comportamento será determinado por `sort_overflow_mode`, que por padrão é definido como `throw`.
## max\_rows\_to\_transfer
Número máximo de linhas que podem ser enviadas a um servidor remoto ou salvas em uma
tabela temporária quando a seção GLOBAL IN/JOIN é executada.
## max\_sessions\_for\_user
Número máximo de sessões simultâneas por usuário autenticado no servidor ClickHouse.
Exemplo:
```xml theme={null}
1
2
0
single_session_user
two_sessions_profile
unlimited_sessions_profile
```
Valores possíveis:
* Inteiro positivo
* `0` - número infinito de sessões simultâneas (padrão)
## max\_size\_to\_preallocate\_for\_aggregation
Para quantos elementos é permitido pré-alocar espaço, no total, em todas as tabelas hash antes da agregaçã
## max\_size\_to\_preallocate\_for\_joins
Para quantos elementos é permitido pré-alocar, no total, espaço em todas as tabelas hash antes da jun
## max\_skip\_unavailable\_shards\_num
Quando `skip_unavailable_shards` está ativado, limita o número máximo de shards que podem ser ignorados silenciosamente.
Se o número de shards indisponíveis exceder esse valor, uma exceção é lançada em vez de eles serem ignorados silenciosamente.
Um valor de 0 significa que não há limite (comportamento padrão — todos os shards indisponíveis podem ser ignorados).
## max\_skip\_unavailable\_shards\_ratio
Quando `skip_unavailable_shards` está ativado, limita a proporção máxima (de 0 a 1) de shards que podem ser ignorados silenciosamente.
Se a proporção de shards indisponíveis em relação ao total de shards exceder esse valor, uma exceção será lançada em vez de serem ignorados silenciosamente.
Um valor de 0 significa que não há limite (comportamento padrão — todos os shards indisponíveis podem ser ignorados).
## max\_streams\_for\_files\_processing\_in\_cluster\_functions
Se não for zero, limita o número de threads que leem dados de arquivos em *funções de tabela Cluster*.
## max\_streams\_for\_merge\_tree\_reading
Se não for zero, limita o número de streams de leitura ao ler a tabela MergeTree.
## max\_streams\_for\_union\_step
Limita o número de fluxos de dados ativos simultaneamente em uma etapa `UNION` (aplica-se tanto a `UNION ALL` quanto a `UNION DISTINCT`, porque `UNION DISTINCT` é implementado por meio de uma etapa `UNION ALL` seguida de uma etapa `DISTINCT`). Quando uma consulta `UNION` tem muitas subconsultas, todas elas abrem seus buffers de leitura ao mesmo tempo, o que faz com que o uso de memória seja proporcional ao número de subconsultas. Essa configuração insere processadores `Concat` para afunilar o pipeline, de modo que, no máximo, essa quantidade de fluxos fique ativa ao mesmo tempo, reduzindo drasticamente o pico de memória. O limite real é o menor entre este valor e `max_threads * max_streams_for_union_step_to_max_threads_ratio` (se qualquer um dos dois for 0, ele será ignorado). Quando ambos são 0, nenhum afunilamento é aplicado.
## max\_streams\_for\_union\_step\_to\_max\_threads\_ratio
Essa proporção, multiplicada por `max_threads`, determina um limite para a quantidade de fluxos ativos simultaneamente em uma etapa `UNION` (aplica-se tanto a `UNION ALL` quanto a `UNION DISTINCT`). O limite real é o menor entre esse valor calculado e `max_streams_for_union_step` (se qualquer um deles for 0, ele é ignorado). Por exemplo, com `max_threads = 8` e essa proporção definida como 1, no máximo 8 fluxos ficarão ativos. Defina como 0 para desabilitar esse limite baseado nessa proporção.
## max\_streams\_multiplier\_for\_merge\_tables
Solicita mais streams ao ler de uma tabela Merge. As streams serão distribuídas entre as tabelas usadas pela tabela Merge. Isso permite uma distribuição mais uniforme do trabalho entre as threads e é especialmente útil quando as tabelas mescladas têm tamanhos diferentes.
## max\_streams\_to\_max\_threads\_ratio
Permite usar mais fontes do que o número de threads, para distribuir o trabalho de maneira mais uniforme entre elas. Presume-se que esta seja uma solução temporária, já que no futuro será possível fazer com que o número de fontes seja igual ao número de threads, mas com cada fonte selecionando dinamicamente o trabalho disponível para si.
## max\_subquery\_depth
Se uma consulta tiver mais subconsultas aninhadas do que o número especificado, uma
exceção será gerada.
Isso permite fazer uma verificação preventiva para evitar que os usuários do seu
cluster escrevam consultas excessivamente complexas.
## max\_table\_size\_to\_drop
Restrição para excluir tabelas no momento da consulta. O valor `0` significa que você pode excluir todas as tabelas sem nenhuma restrição.
Valor padrão no Cloud: 1 TB.
Esta configuração de consulta substitui a configuração equivalente no servidor; consulte [max\_table\_size\_to\_drop](/pt-BR/reference/settings/server-settings/settings#max_table_size_to_drop)
## max\_temporary\_columns
O número máximo de colunas temporárias que podem ser mantidas na RAM simultaneamente
durante a execução de uma consulta, incluindo colunas constantes. Se uma consulta gerar mais
colunas temporárias na memória do que o número especificado, como resultado de cálculos
intermediários, uma exceção será lançada.
Essa configuração é útil para evitar consultas excessivamente complexas.
O valor `0` significa ilimitado.
## max\_temporary\_data\_on\_disk\_size\_for\_query
A quantidade máxima de dados consumida por arquivos temporários em disco, em bytes, para todas as
consultas em execução simultânea.
Valores possíveis:
* Inteiro positivo.
* `0` — ilimitado (padrão)
## max\_temporary\_data\_on\_disk\_size\_for\_user
A quantidade máxima de dados, em bytes, consumida por arquivos temporários no disco em todas as
consultas do usuário executadas simultaneamente.
Valores possíveis:
* Inteiro positivo.
* `0` — ilimitado (padrão)
## max\_temporary\_non\_const\_columns
Assim como `max_temporary_columns`, o número máximo de colunas temporárias que devem
ser mantidas na RAM simultaneamente durante a execução de uma consulta, sem contar as
colunas constantes.
Colunas constantes são geradas com bastante frequência durante a execução de uma consulta, mas exigem
praticamente zero recursos computacionais.
## max\_threads
O número máximo de threads de processamento de consultas, excluindo as threads usadas para recuperar dados de servidores remotos (consulte o parâmetro ['max\_distributed\_connections'](/pt-BR/reference/settings/session-settings#max_distributed_connections)).
Esse parâmetro se aplica a threads que executam, em paralelo, os mesmos estágios do pipeline de processamento da consulta.
Por exemplo, ao ler uma tabela, se for possível avaliar expressões com funções, filtrar com `WHERE` e pré-agregar para `GROUP BY` em paralelo usando pelo menos o número de threads definido por 'max\_threads', então 'max\_threads' será usado.
Para consultas concluídas rapidamente por causa de um LIMIT, você pode definir um valor menor para 'max\_threads'.
Por exemplo, se a quantidade necessária de registros estiver presente em cada bloco e max\_threads = 8, então 8 blocos serão recuperados, embora bastasse ler apenas um.
Quanto menor o valor de `max_threads`, menor o consumo de memória.
A configuração `max_threads`, por padrão, corresponde ao número de threads de hardware (número de CPU cores) disponíveis para o ClickHouse.
Como caso especial, para processadores x86 com menos de 32 CPU cores e SMT (por exemplo, Intel HyperThreading), o ClickHouse usa por padrão o número de núcleos lógicos (= 2 x número de núcleos físicos).
Sem SMT (por exemplo, Intel HyperThreading), isso corresponde ao número de CPU cores.
Para usuários do ClickHouse Cloud, o valor padrão será exibido como `auto(N)`, em que N corresponde ao tamanho de vCPU do seu serviço, por exemplo, 2vCPU/8GiB, 4vCPU/16GiB etc.
Consulte a aba de configurações no console do Cloud para ver uma lista de todos os tamanhos de serviço.
## max\_threads\_for\_indexes
O número máximo de threads que processam os índices.
## max\_threads\_min\_free\_memory\_per\_thread
Reduz `max_threads` quando o servidor está sob pressão de memória, para evitar iniciar consultas com alto paralelismo que provavelmente atingiriam o limite de memória.
A memória livre é calculada como o `max_server_memory_usage` do servidor menos a memória atualmente rastreada pelo memory tracker global. Se essa memória livre for menor que `max_threads` multiplicado por esse valor, `max_threads` será reduzido ao maior N tal que `N * value <= free_memory`, com mínimo de `1`.
Defina como `0` para desabilitar esse limite.
Por exemplo, com o padrão de 1 GiB e 32 GiB de memória livre, `max_threads` fica limitado a 32; com 1 GiB de memória livre, ele volta para 1.
Essa configuração se aplica ao paralelismo no lado da leitura (`SELECT`, `UNION`, `INTERSECT`/`EXCEPT` e o lado `SELECT` de `INSERT ... SELECT`). Para o lado da escrita, veja `max_insert_threads_min_free_memory_per_thread`.
## max\_untracked\_memory
Pequenas alocações e desalocações são agrupadas em uma variável local da thread e rastreadas ou analisadas pelo profiler apenas quando um valor (em valor absoluto) se torna maior que o valor especificado. Se o valor for maior que 'memory\_profiler\_step', ele será efetivamente reduzido para 'memory\_profiler\_step'.
## max\_wkb\_geometry\_elements
Número máximo de pontos, anéis ou polígonos permitidos em um único elemento de geometria WKB durante a análise por `readWKB` e funções relacionadas. Isso protege contra alocações excessivas de memória causadas por dados WKB malformados. Defina como 0 para usar o limite fixo no código (100 milhões).
## memory\_overcommit\_ratio\_denominator
Ele representa o limite flexível de memória quando o limite rígido é atingido em nível global.
Esse valor é usado para calcular a razão de overcommit da consulta.
Zero significa ignorar a consulta.
Leia mais sobre [memory overcommit](/pt-BR/concepts/features/configuration/settings/memory-overcommit).
## memory\_overcommit\_ratio\_denominator\_for\_user
Representa o limite flexível de memória quando o limite rígido é atingido no nível do usuário.
Esse valor é usado para calcular a razão de overcommit da consulta.
Zero significa ignorar a consulta.
Leia mais sobre [overcommit de memória](/pt-BR/concepts/features/configuration/settings/memory-overcommit).
## memory\_profiler\_sample\_max\_allocation\_size
Coleta alocações aleatórias com tamanho menor ou igual ao valor especificado, com probabilidade igual a `memory_profiler_sample_probability`. 0 significa desabilitado. Talvez você queira definir 'max\_untracked\_memory' como 0 para que esse limite funcione como esperado.
## memory\_profiler\_sample\_min\_allocation\_size
Coleta alocações aleatórias com tamanho maior ou igual ao valor especificado, com probabilidade igual a `memory_profiler_sample_probability`. 0 significa desabilitado. Talvez seja interessante definir 'max\_untracked\_memory' como 0 para que esse limite funcione como esperado.
## memory\_profiler\_sample\_probability
Coleta alocações e desalocações aleatórias e as grava em system.trace\_log com trace\_type 'MemorySample'. A probabilidade se aplica a cada operação de alloc/free, independentemente do tamanho da alocação (isso pode ser alterado com `memory_profiler_sample_min_allocation_size` e `memory_profiler_sample_max_allocation_size`). Observe que a amostragem ocorre apenas quando a quantidade de memória não rastreada excede 'max\_untracked\_memory'. Talvez você queira definir 'max\_untracked\_memory' como 0 para uma amostragem ainda mais granular.
## memory\_profiler\_step
Define o intervalo do profiler de memória. Sempre que o uso de memória da consulta ultrapassar cada próximo intervalo, em número de bytes, o profiler de memória coletará o stacktrace de alocação e o gravará em [trace\_log](/pt-BR/reference/system-tables/trace_log).
Valores possíveis:
* Um número inteiro positivo de bytes.
* 0 para desativar o profiler de memória.
## memory\_tracker\_fault\_probability
Para testar a `exception safety`, lance uma exceção sempre que alocar memória, com a probabilidade especificada.
## memory\_usage\_overcommit\_max\_wait\_microseconds
Tempo máximo que a thread aguardará a liberação de memória em caso de memory overcommit no nível do usuário.
Se o timeout for atingido e a memória não for liberada, uma exceção será lançada.
Leia mais sobre [memory overcommit](/pt-BR/concepts/features/configuration/settings/memory-overcommit).
## merge\_table\_max\_tables\_to\_look\_for\_schema\_inference
Ao criar uma tabela `Merge` sem um esquema explícito ou ao usar a função de tabela `merge`, infira o esquema como a união de, no máximo, o número especificado de tabelas correspondentes.
Se houver mais tabelas do que esse número, o esquema será inferido com base nas primeiras tabelas até o limite especificado.
## merge\_tree\_coarse\_index\_granularity
Ao buscar dados, o ClickHouse verifica as marcas de dados no arquivo de índice. Se o ClickHouse constatar que as chaves necessárias estão em um determinado intervalo, ele divide esse intervalo em `merge_tree_coarse_index_granularity` subintervalos e busca recursivamente as chaves necessárias neles.
Valores possíveis:
* Qualquer número inteiro par positivo.
## merge\_tree\_compact\_parts\_min\_granules\_to\_multibuffer\_read
Só tem efeito no ClickHouse Cloud. Número de grânulos na stripe de uma parte compacta de tabelas MergeTree para usar o leitor multibuffer, que oferece suporte à leitura paralela e ao prefetch. No caso de leitura a partir de um sistema de arquivos remoto, o uso do leitor multibuffer aumenta o número de solicitações de leitura.
## merge\_tree\_determine\_task\_size\_by\_prewhere\_columns
Se deve usar apenas o tamanho das colunas `prewhere` para determinar o tamanho da tarefa de leitura.
## merge\_tree\_max\_bytes\_to\_use\_cache
Se o ClickHouse precisar ler mais de `merge_tree_max_bytes_to_use_cache` bytes em uma consulta, ele não usará o cache de blocos não comprimidos.
O cache de blocos não comprimidos armazena dados extraídos para consultas. O ClickHouse usa esse cache para acelerar as respostas a consultas pequenas e repetidas. Essa configuração protege o cache contra a degradação causada por consultas que leem uma grande quantidade de dados. A configuração do servidor [uncompressed\_cache\_size](/pt-BR/reference/settings/server-settings/settings#uncompressed_cache_size) define o tamanho do cache de blocos não comprimidos.
Valores possíveis:
* Qualquer número inteiro positivo.
## merge\_tree\_max\_rows\_to\_use\_cache
Se o ClickHouse precisar ler mais de `merge_tree_max_rows_to_use_cache` linhas em uma consulta, ele não usará o cache de blocos descomprimidos.
O cache de blocos descomprimidos armazena dados extraídos para consultas. O ClickHouse usa esse cache para acelerar as respostas a consultas pequenas e repetidas. Essa configuração evita que o cache seja prejudicado por consultas que leem uma grande quantidade de dados. A configuração do servidor [uncompressed\_cache\_size](/pt-BR/reference/settings/server-settings/settings#uncompressed_cache_size) define o tamanho do cache de blocos descomprimidos.
Valores possíveis:
* Qualquer número inteiro positivo.
## merge\_tree\_min\_bytes\_for\_concurrent\_read
Se o número de bytes a serem lidos de um arquivo de uma tabela com o motor [MergeTree](/pt-BR/reference/engines/table-engines/mergetree-family/mergetree) exceder `merge_tree_min_bytes_for_concurrent_read`, o ClickHouse tentará ler esse arquivo de forma concorrente usando várias threads.
Valor possível:
* Inteiro positivo.
## merge\_tree\_min\_bytes\_for\_concurrent\_read\_for\_remote\_filesystem
O número mínimo de bytes a serem lidos de um arquivo para que o motor [MergeTree](/pt-BR/reference/engines/table-engines/mergetree-family/mergetree) possa paralelizar a leitura ao ler de um sistema de arquivos remoto. Não recomendamos usar essa configuração.
Valores possíveis:
* Inteiro positivo.
## merge\_tree\_min\_bytes\_for\_seek
Se a distância entre dois blocos de dados a serem lidos em um arquivo for menor que `merge_tree_min_bytes_for_seek` bytes, o ClickHouse lerá sequencialmente uma faixa do arquivo que contém ambos os blocos, evitando assim uma operação de seek adicional.
Valores possíveis:
* Qualquer inteiro positivo.
## merge\_tree\_min\_bytes\_per\_task\_for\_remote\_reading
**Aliases**: `filesystem_prefetch_min_bytes_for_single_read_task`
Número mínimo de bytes lidos por tarefa.
## merge\_tree\_min\_read\_task\_size
Limite inferior estrito para o tamanho da tarefa (mesmo quando o número de grânulos é baixo e o número de threads disponíveis é alto, não alocaremos tarefas menores
## merge\_tree\_min\_rows\_for\_concurrent\_read
Se o número de linhas a serem lidas de um arquivo de uma tabela [MergeTree](/pt-BR/reference/engines/table-engines/mergetree-family/mergetree) exceder `merge_tree_min_rows_for_concurrent_read`, o ClickHouse tentará realizar a leitura concorrente desse arquivo em várias threads.
Valores possíveis:
* Inteiro positivo.
## merge\_tree\_min\_rows\_for\_concurrent\_read\_for\_remote\_filesystem
O número mínimo de linhas que devem ser lidas de um arquivo antes que o motor [MergeTree](/pt-BR/reference/engines/table-engines/mergetree-family/mergetree) possa paralelizar a leitura ao ler de um sistema de arquivos remoto. Não recomendamos usar essa configuração.
Possíveis valores:
* Inteiro positivo.
## merge\_tree\_min\_rows\_for\_seek
Se a distância entre dois blocos de dados a serem lidos em um arquivo for menor que `merge_tree_min_rows_for_seek` linhas, o ClickHouse não faz seek no arquivo, mas lê os dados sequencialmente.
Valores possíveis:
* Qualquer número inteiro positivo.
## merge\_tree\_read\_split\_ranges\_into\_intersecting\_and\_non\_intersecting\_injection\_probability
Para testes do `PartsSplitter` - divide os intervalos de leitura em intervalos que se intersectam e que não se intersectam sempre que houver leitura do MergeTree, com a probabilidade especificada.
## merge\_tree\_storage\_snapshot\_sleep\_ms
Injeta um atraso artificial (em milissegundos) ao criar um snapshot de armazenamento para tabelas MergeTree.
Usado apenas para testes e depuração.
Valores possíveis:
* 0 - Sem atraso (padrão)
* N - Atraso em milissegundos
## merge\_tree\_use\_const\_size\_tasks\_for\_remote\_reading
Define se tarefas de tamanho constante devem ser usadas para ler de uma tabela remota.
## merge\_tree\_use\_deserialization\_prefixes\_cache
Habilita o cache dos metadados das colunas a partir dos prefixos dos arquivos durante a leitura em discos remotos no MergeTree.
## merge\_tree\_use\_prefixes\_deserialization\_thread\_pool
Habilita o uso do pool de threads para a leitura paralela de prefixos em partes no formato Wide no MergeTree. O tamanho desse pool de threads é controlado pela configuração do servidor `max_prefixes_deserialization_thread_pool_size`.
## merge\_tree\_use\_v1\_object\_and\_dynamic\_serialization
Quando ativado, a versão de serialização V1 dos tipos JSON e Dynamic será usada no MergeTree em vez da V2. A alteração dessa configuração só tem efeito após a reinicialização do servidor.
## metrics\_perf\_events\_enabled
Se ativado, alguns eventos de perf serão medidos durante a execução das consultas.
## metrics\_perf\_events\_list
Lista de métricas de perf separadas por vírgulas que serão medidas durante a execução das consultas. Em branco significa todos os eventos. Consulte `PerfEventInfo` no código-fonte para ver os eventos disponíveis.
## min\_bytes\_to\_use\_direct\_io
O volume mínimo de dados necessário para usar acesso de E/S direta ao disco de armazenamento.
O ClickHouse usa essa configuração ao ler dados de tabelas. Se o volume total de armazenamento de todos os dados a serem lidos exceder `min_bytes_to_use_direct_io` bytes, o ClickHouse lerá os dados do disco de armazenamento com a opção `O_DIRECT`.
Valores possíveis:
* 0 — A E/S direta está desabilitada.
* Inteiro positivo.
## min\_bytes\_to\_use\_mmap\_io
Esta é uma configuração experimental. Define a quantidade mínima de memória para ler arquivos grandes sem copiar dados do kernel para o espaço do usuário. O valor recomendado é de cerca de 64 MB, porque [mmap/munmap](https://en.wikipedia.org/wiki/Mmap) é lento. Isso só faz sentido para arquivos grandes e só ajuda se os dados estiverem no cache de páginas.
Valores possíveis:
* Inteiro positivo.
* 0 — Arquivos grandes são lidos apenas com cópia de dados do kernel para o espaço do usuário.
## min\_chunk\_bytes\_for\_parallel\_parsing
* Tipo: inteiro sem sinal
* Valor padrão: 1 MiB
O tamanho mínimo do fragmento, em bytes, que cada thread fará o parsing em paralelo.
## min\_compress\_block\_size
Para tabelas [MergeTree](/pt-BR/reference/engines/table-engines/mergetree-family/mergetree). Para reduzir a latência no processamento de consultas, um bloco é comprimido ao gravar a próxima marca se seu tamanho for de pelo menos `min_compress_block_size`. Por padrão, 65.536.
O tamanho real do bloco, se os dados descomprimidos forem menores que `max_compress_block_size`, não fica abaixo desse valor nem do volume de dados de uma marca.
Vejamos um exemplo. Suponha que `index_granularity` tenha sido definido como 8192 durante a criação da tabela.
Estamos gravando uma coluna do tipo UInt32 (4 bytes por valor). Ao gravar 8192 linhas, o total será de 32 KB de dados. Como min\_compress\_block\_size = 65.536, um bloco comprimido será formado a cada duas marcas.
Estamos gravando uma coluna de URL do tipo String (tamanho médio de 60 bytes por valor). Ao gravar 8192 linhas, o volume médio será de pouco menos de 500 KB de dados. Como isso é mais que 65.536, um bloco comprimido será formado para cada marca. Nesse caso, ao ler dados do disco no intervalo de uma única marca, dados extras não serão descomprimidos.
Esta é uma configuração de nível avançado, e você não deve alterá-la se estiver apenas começando a usar o ClickHouse.
## min\_count\_to\_compile\_aggregate\_expression
O número mínimo de expressões agregadas idênticas necessário para iniciar a compilação JIT. Funciona apenas se a configuração [compile\_aggregate\_expressions](#compile_aggregate_expressions) estiver habilitada.
Valores possíveis:
* Inteiro positivo.
* 0 — Expressões agregadas idênticas são sempre compiladas por JIT.
## min\_count\_to\_compile\_expression
Número mínimo de execuções da mesma expressão antes de ela ser compilada.
## min\_count\_to\_compile\_sort\_description
O número de descrições de ordenação idênticas antes da compilação JIT
## min\_execution\_speed
Velocidade mínima de execução em linhas por segundo. Verificada em cada bloco de dados quando
[`timeout_before_checking_execution_speed`](/pt-BR/reference/settings/session-settings#timeout_before_checking_execution_speed)
expira. Se a velocidade de execução for inferior, uma exceção é lançada.
## min\_execution\_speed\_bytes
A quantidade mínima de bytes processados por segundo. Verificada em cada bloco de dados quando
[`timeout_before_checking_execution_speed`](/pt-BR/reference/settings/session-settings#timeout_before_checking_execution_speed)
expira. Se a velocidade de execução for menor, uma exceção será lançada.
## min\_external\_table\_block\_size\_bytes
Combina os blocos enviados à tabela externa até atingirem o tamanho especificado em bytes, caso não sejam grandes o suficiente.
## min\_external\_table\_block\_size\_rows
Combina os blocos passados para a tabela externa até atingirem o tamanho especificado em linhas, se os blocos não forem grandes o suficiente.
## min\_filtered\_ratio\_for\_lazy\_final
Proporção mínima de marcas filtradas pela análise de índice para a otimização lazy de FINAL. Se menos do que essa fração de marcas for filtrada, o sistema volta ao FINAL normal. O valor 0 desabilita essa verificação.
## min\_free\_disk\_bytes\_to\_perform\_insert
Mínimo de bytes de espaço livre em disco para realizar um insert.
## min\_free\_disk\_ratio\_to\_perform\_insert
Proporção mínima de espaço livre em disco necessária para realizar uma inserção.
## min\_free\_disk\_space\_for\_temporary\_data
O espaço mínimo em disco que deve ser mantido ao gravar dados temporários usados na ordenação externa e na agregação.
## min\_hit\_rate\_to\_use\_consecutive\_keys\_optimization
Taxa mínima de acerto de um cache usada na otimização de chaves consecutivas na agregação para mantê-la habilitada
## min\_insert\_block\_size\_bytes
O tamanho mínimo dos blocos (em bytes) a serem formados para inserção em uma tabela.
Essa configuração funciona em conjunto com min\_insert\_block\_size\_rows e controla a formação de blocos nos mesmos contextos (análise do formato e operações INSERT). Consulte min\_insert\_block\_size\_rows para obter informações detalhadas sobre quando e como essas configurações são aplicadas.
Valores possíveis:
* Inteiro positivo.
* 0 — a configuração não participa da formação de blocos.
## min\_insert\_block\_size\_bytes\_for\_materialized\_views
Define o número mínimo de bytes em um bloco que pode ser inserido em uma tabela por uma consulta `INSERT`. Blocos menores são agrupados em blocos maiores. Essa configuração é aplicada apenas a blocos inseridos em [visão materializada](/pt-BR/reference/statements/create/view). Ao ajustar essa configuração, você controla o agrupamento de blocos ao enviar para a visão materializada e evita o uso excessivo de memória.
Valores possíveis:
* Qualquer número inteiro positivo.
* 0 — Agrupamento desativado.
**Veja também**
* [min\_insert\_block\_size\_bytes](#min_insert_block_size_bytes)
## min\_insert\_block\_size\_rows
O tamanho mínimo dos blocos (em linhas) a serem formados para inserção em uma tabela.
Esta configuração controla a formação de blocos em dois contextos:
1. Análise de formato: Quando o servidor analisa formatos de entrada baseados em linhas (CSV, TSV, JSONEachRow etc.) de qualquer interface (HTTP, clickhouse-client com dados inline, gRPC, PostgreSQL wire protocol), os blocos são emitidos quando:
* Ambos min\_insert\_block\_size\_rows AND min\_insert\_block\_size\_bytes são atingidos, OR
* max\_insert\_block\_size\_rows OR max\_insert\_block\_size\_bytes é atingido
Observação: ao usar clickhouse-client ou clickhouse-local para ler de um arquivo, o próprio cliente analisa os dados, e esta configuração se aplica no lado do cliente.
2. Operações de INSERT: Durante consultas INSERT e quando os dados fluem por visões materializadas, o comportamento desta configuração depende de `use_strict_insert_block_limits`:
* Quando habilitado: Os blocos são emitidos quando:
* Limiares mínimos (AND): Ambos min\_insert\_block\_size\_rows AND min\_insert\_block\_size\_bytes são atingidos
* Limiares máximos (OR): max\_insert\_block\_size\_rows OR max\_insert\_block\_size\_bytes é atingido
* Quando desabilitado (padrão): Os blocos são emitidos quando min\_insert\_block\_size\_rows OR min\_insert\_block\_size\_bytes é atingido. As configurações max\_insert\_block\_size não são aplicadas.
Valores possíveis:
* Inteiro positivo.
* 0 — a configuração não participa da formação de blocos.
## min\_insert\_block\_size\_rows\_for\_materialized\_views
Define o número mínimo de linhas no bloco que pode ser inserido em uma tabela por uma consulta `INSERT`. Blocos menores são agrupados em blocos maiores. Essa configuração é aplicada somente aos blocos inseridos em [visão materializada](/pt-BR/reference/statements/create/view). Ao ajustar essa configuração, você controla o agrupamento de blocos durante o envio para a visão materializada e evita uso excessivo de memória.
Valores possíveis:
* Qualquer inteiro positivo.
* 0 — Agrupamento desabilitado.
**Veja também**
* [min\_insert\_block\_size\_rows](#min_insert_block_size_rows)
## min\_joined\_block\_size\_bytes
Tamanho mínimo do bloco, em bytes, para os blocos de entrada e saída do JOIN (se o algoritmo de JOIN oferecer suporte a isso). Blocos pequenos serão consolidados. 0 significa ilimitado.
## min\_joined\_block\_size\_rows
Tamanho mínimo do bloco, em linhas, para os blocos de entrada e saída do JOIN (se o algoritmo de JOIN oferecer suporte). Blocos pequenos serão mesclados. 0 significa sem limite.
## min\_os\_cpu\_wait\_time\_ratio\_to\_throw
Razão mínima entre os tempos de espera da CPU do SO (métrica OSCPUWaitMicroseconds) e de atividade (métrica OSCPUVirtualTimeMicroseconds) para considerar a rejeição de consultas. Usa-se interpolação linear entre a razão mínima e a máxima para calcular a probabilidade; nesse ponto, a probabilidade é 0.
## min\_outstreams\_per\_resize\_after\_split
Especifica o número mínimo de fluxos de saída de um processador `Resize` ou `StrictResize` após a divisão ser realizada durante a geração do pipeline. Se o número resultante de fluxos for menor que esse valor, a operação de divisão não ocorrerá.
### O que é um nó Resize
Um nó `Resize` é um processador no pipeline de consulta que ajusta o número de fluxos de dados que passam pelo pipeline. Ele pode aumentar ou diminuir o número de fluxos para equilibrar a carga de trabalho entre vários threads ou processadores. Por exemplo, se uma consulta exigir mais paralelismo, o nó `Resize` pode dividir um único fluxo em vários fluxos. Por outro lado, ele pode mesclar vários fluxos em menos fluxos para consolidar o processamento de dados.
O nó `Resize` garante que os dados sejam distribuídos uniformemente entre os fluxos, mantendo a estrutura dos blocos de dados. Isso ajuda a otimizar a utilização de recursos e a melhorar o desempenho da consulta.
### Por que o nó Resize precisa ser dividido
Durante a execução do pipeline, `ExecutingGraph::Node::status_mutex` do nó `Resize`, que fica no centro do fluxo, enfrenta forte contenção, especialmente em ambientes com muitos núcleos de CPU, e isso leva a:
1. Aumento da latência de `ExecutingGraph::updateNode`, impactando diretamente o desempenho da consulta.
2. Desperdício excessivo de ciclos de CPU com contenção de spin-lock (`native_queued_spin_lock_slowpath`), reduzindo a eficiência.
3. Redução da utilização da CPU, limitando o paralelismo e o throughput.
### Como o nó Resize é dividido
1. O número de streams de saída é verificado para garantir que a divisão possa ser feita: os streams de saída de cada processador dividido atingem ou excedem o limiar `min_outstreams_per_resize_after_split`.
2. O nó `Resize` é dividido em nós `Resize` menores, com a mesma quantidade de portas, cada um lidando com um subconjunto de streams de entrada e saída.
3. Cada grupo é processado de forma independente, reduzindo a contenção de lock.
### Divisão do nó Resize com entradas/saídas arbitrárias
Em alguns casos, quando as entradas/saídas não são divisíveis pelo número de nós `Resize` resultantes da divisão, algumas entradas são conectadas a `NullSource`s e algumas saídas são conectadas a `NullSink`s. Isso permite que a divisão ocorra sem afetar o fluxo geral de dados.
### Finalidade da configuração
A configuração `min_outstreams_per_resize_after_split` garante que a divisão de nós `Resize` faça sentido e evita a criação de um número muito pequeno de streams, o que poderia levar a um processamento paralelo ineficiente. Ao impor um número mínimo de streams de saída, essa configuração ajuda a manter o equilíbrio entre paralelismo e sobrecarga, otimizando a execução da consulta em cenários que envolvem divisão e mesclagem de streams.
### Desativando a configuração
Para desativar o split dos nós `Resize`, defina esta configuração como 0. Isso impedirá o split dos nós `Resize` durante a geração do pipeline, permitindo que mantenham sua estrutura original, sem serem divididos em nós menores.
## min\_table\_rows\_to\_use\_projection\_index
Se o número estimado de linhas a serem lidas da tabela for maior ou igual a esse limite, o ClickHouse tentará usar o índice de projeção durante a execução da consulta.
## mongodb\_throw\_on\_unsupported\_query
Se habilitado, as tabelas do MongoDB retornarão erro quando não for possível gerar uma consulta do MongoDB. Caso contrário, o ClickHouse lê a tabela inteira e a processa localmente. Esta opção não se aplica quando 'allow\_experimental\_analyzer=0'.
## move\_all\_conditions\_to\_prewhere
Move todas as condições aplicáveis de WHERE para PREWHERE
## move\_primary\_key\_columns\_to\_end\_of\_prewhere
Move para o final da cadeia de AND as condições PREWHERE que contêm colunas da chave primária. É provável que essas condições já sejam consideradas durante a análise da chave primária e, portanto, contribuam pouco para a filtragem PREWHERE.
## multiple\_joins\_try\_to\_keep\_original\_names
Não adiciona aliases à lista de expressões de nível superior na reescrita de múltiplas junções
## mutations\_execute\_nondeterministic\_on\_initiator
Se for `true`, funções constantes não determinísticas (por exemplo, a função `now()`) serão executadas no iniciador e substituídas por literais em consultas `UPDATE` e `DELETE`. Isso ajuda a manter os dados em sincronia entre as réplicas ao executar mutações com funções constantes não determinísticas. Valor padrão: `false`.
## mutations\_execute\_subqueries\_on\_initiator
Se `true`, as subconsultas escalares são executadas no iniciador e substituídas por valores literais nas consultas `UPDATE` e `DELETE`. Valor padrão: `false`.
## mutations\_max\_literal\_size\_to\_replace
O tamanho máximo, em bytes, do literal serializado a ser substituído em consultas `UPDATE` e `DELETE`. Só tem efeito se pelo menos uma das duas configurações acima estiver habilitada. Valor padrão: 16384 (16 KiB).
## mutations\_sync
Permite executar consultas `ALTER TABLE ... UPDATE|DELETE|MATERIALIZE INDEX|MATERIALIZE PROJECTION|MATERIALIZE COLUMN|MATERIALIZE STATISTICS` ([mutações](/pt-BR/reference/statements/alter#mutations)) de forma síncrona.
Valores possíveis:
| Valor | Descrição |
| ----- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `0` | As mutações são executadas de forma assíncrona. |
| `1` | A consulta aguarda a conclusão de todas as mutações no servidor atual. |
| `2` | A consulta aguarda a conclusão de todas as mutações em todas as réplicas (se existirem). |
| `3` | A consulta aguarda apenas as réplicas ativas. Compatível apenas com `SharedMergeTree`. Para `ReplicatedMergeTree`, comporta-se da mesma forma que `mutations_sync = 2`. |
## mysql\_datatypes\_support\_level
Define como os tipos do MySQL são convertidos nos tipos correspondentes do ClickHouse. É uma lista separada por vírgulas, com qualquer combinação de `decimal`, `datetime64`, `date2Date32` ou `date2String`. Todos os mapeamentos modernos (`decimal`, `datetime64`, `date2Date32`) são ativados por padrão.
* `decimal`: converte os tipos `NUMERIC` e `DECIMAL` em `Decimal` quando a precisão permitir.
* `datetime64`: converte os tipos `DATETIME` e `TIMESTAMP` em `DateTime64` em vez de `DateTime` quando a precisão não for `0`.
* `date2Date32`: converte `DATE` em `Date32` em vez de `Date`. Tem precedência sobre `date2String`.
* `date2String`: converte `DATE` em `String` em vez de `Date`. É substituído por `datetime64`.
## mysql\_map\_fixed\_string\_to\_text\_in\_show\_columns
Quando ativado, o tipo de dado [FixedString](/pt-BR/reference/data-types/fixedstring) do ClickHouse será exibido como `TEXT` em [SHOW COLUMNS](/pt-BR/reference/statements/show#show_columns).
Só tem efeito quando a conexão é feita por meio do protocolo wire do MySQL.
* 0 - Usar `BLOB`.
* 1 - Usar `TEXT`.
## mysql\_map\_string\_to\_text\_in\_show\_columns
Quando ativado, o tipo de dados [String](/pt-BR/reference/data-types/string) do ClickHouse será exibido como `TEXT` em [SHOW COLUMNS](/pt-BR/reference/statements/show#show_columns).
Só tem efeito quando a conexão é feita pelo MySQL wire protocol.
* 0 - Usar `BLOB`.
* 1 - Usar `TEXT`.
## mysql\_max\_rows\_to\_insert
O número máximo de linhas na inserção em lote do engine MySQL
## network\_compression\_method
O codec usado para compactar a comunicação entre cliente/servidor e servidor/servidor.
Valores possíveis:
* `NONE` — sem compactação.
* `LZ4` — usa o codec LZ4.
* `LZ4HC` — usa o codec LZ4HC.
* `ZSTD` — usa o codec ZSTD.
**Veja também**
* [network\_zstd\_compression\_level](#network_zstd_compression_level)
## network\_zstd\_compression\_level
Ajusta o nível de compressão ZSTD. Usado apenas quando [network\_compression\_method](#network_compression_method) está definido como `ZSTD`.
Valores possíveis:
* Número inteiro positivo de 1 a 15.
## normalize\_function\_names
Normalizar nomes de funções para seus respectivos nomes canônicos
## number\_of\_mutations\_to\_delay
Se a tabela contiver pelo menos essa quantidade de mutações não concluídas, a velocidade das mutações da tabela será reduzida artificialmente. 0 - desabilitado
## number\_of\_mutations\_to\_throw
Se a tabela contiver pelo menos essa quantidade de mutações não concluídas, gere a exceção 'Too many mutations ...'. 0 - desabilitado
## odbc\_bridge\_connection\_pool\_size
Tamanho do pool de conexões para cada string de configuração de conexão no ODBC bridge.
## odbc\_bridge\_use\_connection\_pooling
Usa pool de conexões na ODBC bridge. Se definido como false, uma nova conexão é criada a cada vez.
## offset
Define o número de linhas a serem ignoradas antes de começar a retornar linhas da consulta. Ele ajusta o offset definido pela cláusula [OFFSET](/pt-BR/reference/statements/select/offset), de modo que esses dois valores sejam somados.
Valores possíveis:
* 0 — Nenhuma linha é ignorada.
* Inteiro positivo.
**Exemplo**
Tabela de entrada:
```sql theme={null}
CREATE TABLE test (i UInt64) ENGINE = MergeTree() ORDER BY i;
INSERT INTO test SELECT number FROM numbers(500);
```
Consulta:
```sql theme={null}
SET limit = 5;
SET offset = 7;
SELECT * FROM test LIMIT 10 OFFSET 100;
```
Resultado:
```text theme={null}
┌───i─┐
│ 107 │
│ 108 │
│ 109 │
└─────┘
```
## opentelemetry\_start\_keeper\_trace\_probability
Probabilidade de iniciar um trace para uma requisição do ZooKeeper, haja ou não um trace pai.
Valores possíveis:
* 'auto' - Equivale à configuração opentelemetry\_start\_trace\_probability
* 0 — O rastreamento está desabilitado
* 0 a 1 — Probabilidade (por exemplo, 1.0 = sempre ativado)
## opentelemetry\_start\_trace\_probability
Define a probabilidade de o ClickHouse iniciar um rastreamento para consultas executadas (se nenhum [contexto de rastreamento](https://www.w3.org/TR/trace-context/) pai for fornecido).
Valores possíveis:
* 0 — O rastreamento de todas as consultas executadas é desabilitado (se nenhum contexto de rastreamento pai for fornecido).
* Número de ponto flutuante positivo no intervalo \[0..1]. Por exemplo, se o valor da configuração for `0,5`, o ClickHouse poderá iniciar um rastreamento, em média, para metade das consultas.
* 1 — O rastreamento de todas as consultas executadas é habilitado.
## opentelemetry\_trace\_cpu\_scheduling
Coleta spans do OpenTelemetry para o escalonamento preemptivo de CPU da carga de trabalho.
## opentelemetry\_trace\_processors
Coleta spans de OpenTelemetry para processadores.
## optimize\_aggregation\_in\_order
Habilita a otimização de [GROUP BY](/pt-BR/reference/statements/select/group-by) em consultas [SELECT](/pt-BR/reference/statements/select) para a agregação de dados na ordem correspondente em tabelas [MergeTree](/pt-BR/reference/engines/table-engines/mergetree-family/mergetree).
Valores possíveis:
* 0 — a otimização de `GROUP BY` está desabilitada.
* 1 — a otimização de `GROUP BY` está habilitada.
**Veja também**
* [Otimização de GROUP BY](/pt-BR/reference/statements/select/group-by#group-by-optimization-depending-on-table-sorting-key)
## optimize\_aggregators\_of\_group\_by\_keys
Elimina os agregadores min/max/any/anyLast das chaves de GROUP BY na seção SELECT
## optimize\_and\_compare\_chain
Propaga comparações com constantes em cadeias AND para melhorar a capacidade de filtragem. Suporta os operadores `<`, `<=`, `>`, `>=`, `=` e combinações entre eles. Por exemplo, `(a < b) AND (b < c) AND (c < 5)` se tornaria `(a < b) AND (b < c) AND (c < 5) AND (b < 5) AND (a < 5)`.
## optimize\_append\_index
Use [restrições](/pt-BR/reference/statements/create/table#constraints) para adicionar a condição do índice. O padrão é `false`.
Valores possíveis:
* true, false
## optimize\_arithmetic\_operations\_in\_aggregate\_functions
Move operações aritméticas para fora das funções de agregação
## optimize\_const\_name\_size
Substitui por um escalar e usa um hash como nome para constantes grandes (o tamanho é estimado pelo comprimento do nome).
Valores possíveis:
* inteiro positivo - comprimento máximo do nome,
* 0 — sempre,
* inteiro negativo - nunca.
## optimize\_count\_from\_files
Ativa ou desativa a otimização da contagem do número de linhas em arquivos em diferentes formatos de entrada. Aplica-se a table functions/motores `file`/`s3`/`url`/`hdfs`/`azureBlobStorage`.
Valores possíveis:
* 0 — Otimização desativada.
* 1 — Otimização ativada.
## optimize\_dictget\_tuple\_element
Reescreve `tupleElement(dictGet('dict', ('a', 'b', 'c'), key), 2)` como `dictGet('dict', 'b', key)` para evitar buscar atributos de Dicionário desnecessários. Suporta acesso posicional (`.1`, `.2`, ...) e nomeado (`.b`) e também se aplica a `dictGetOrDefault` quando o argumento padrão é uma tupla constante ou um `tuple(...)` de constantes.
## optimize\_distinct\_in\_order
Ativa a otimização de DISTINCT se algumas colunas em DISTINCT formarem um prefixo da chave de ordenação. Por exemplo, um prefixo da chave de ordenação em MergeTree ou da cláusula ORDER BY
## optimize\_distributed\_group\_by\_sharding\_key
Otimiza consultas `GROUP BY sharding_key`, evitando agregações custosas no servidor iniciador (o que reduz o uso de memória da consulta nesse servidor).
Os seguintes tipos de consultas são suportados (bem como todas as combinações entre eles):
* `SELECT DISTINCT [..., ]sharding_key[, ...] FROM dist`
* `SELECT ... FROM dist GROUP BY sharding_key[, ...]`
* `SELECT ... FROM dist GROUP BY sharding_key[, ...] ORDER BY x`
* `SELECT ... FROM dist GROUP BY sharding_key[, ...] LIMIT 1`
* `SELECT ... FROM dist GROUP BY sharding_key[, ...] LIMIT 1 BY x`
Os seguintes tipos de consultas não são suportados (o suporte a alguns deles poderá ser adicionado posteriormente):
* `SELECT ... GROUP BY sharding_key[, ...] WITH TOTALS`
* `SELECT ... GROUP BY sharding_key[, ...] WITH ROLLUP`
* `SELECT ... GROUP BY sharding_key[, ...] WITH CUBE`
* `SELECT ... GROUP BY sharding_key[, ...] SETTINGS extremes=1`
Valores possíveis:
* 0 — Desativado.
* 1 — Ativado.
Veja também:
* [distributed\_group\_by\_no\_merge](#distributed_group_by_no_merge)
* [distributed\_push\_down\_limit](#distributed_push_down_limit)
* [optimize\_skip\_unused\_shards](#optimize_skip_unused_shards)
No momento, isso exige `optimize_skip_unused_shards` (o motivo é que, no futuro, isso poderá ser ativado por padrão e só funcionará corretamente se os dados tiverem sido inseridos por meio de uma tabela Distributed, ou seja, se os dados estiverem distribuídos de acordo com `sharding_key`).
## optimize\_dry\_run\_check\_part
Quando ativado, `OPTIMIZE ... DRY RUN` valida a parte mesclada resultante com `checkDataPart`. Se a verificação falhar, uma exceção será gerada.
## optimize\_empty\_string\_comparisons
Converte expressões como `col = ''` ou `'' = col` em `empty(col)` e `col != ''` ou `'' != col` em `notEmpty(col)`,
somente quando `col` for do tipo `String` ou `FixedString`.
Permite extrair expressões comuns de disjunções em expressões WHERE, PREWHERE, ON, HAVING e QUALIFY. Uma expressão lógica como `(A AND B) OR (A AND C)` pode ser reescrita como `A AND (B OR C)`, o que pode ajudar a aproveitar:
* índices em expressões de filtro simples
* a otimização de CROSS JOIN para INNER JOIN
## optimize\_functions\_to\_subcolumns
Habilita ou desabilita a otimização que converte algumas funções para a leitura de subcolunas. Isso reduz a quantidade de dados lidos.
Estas funções podem ser convertidas:
* [length](/pt-BR/reference/functions/regular-functions/array-functions#length) para ler a subcoluna [size0](/pt-BR/reference/data-types/array#array-size).
* [empty](/pt-BR/reference/functions/regular-functions/array-functions#empty) para ler a subcoluna [size0](/pt-BR/reference/data-types/array#array-size).
* [notEmpty](/pt-BR/reference/functions/regular-functions/array-functions#notEmpty) para ler a subcoluna [size0](/pt-BR/reference/data-types/array#array-size).
* [isNull](/pt-BR/reference/functions/regular-functions/functions-for-nulls#isNull) para ler a subcoluna [null](/pt-BR/reference/data-types/nullable#finding-null).
* [isNotNull](/pt-BR/reference/functions/regular-functions/functions-for-nulls#isNotNull) para ler a subcoluna [null](/pt-BR/reference/data-types/nullable#finding-null).
* [count](/pt-BR/reference/functions/aggregate-functions/count) para ler a subcoluna [null](/pt-BR/reference/data-types/nullable#finding-null).
* [mapKeys](/pt-BR/reference/functions/regular-functions/tuple-map-functions#mapKeys) para ler a subcoluna [keys](/pt-BR/reference/data-types/map#reading-subcolumns-of-map).
* [mapValues](/pt-BR/reference/functions/regular-functions/tuple-map-functions#mapValues) para ler a subcoluna [values](/pt-BR/reference/data-types/map#reading-subcolumns-of-map).
Valores possíveis:
* 0 — Otimização desativada.
* 1 — Otimização ativada.
## optimize\_group\_by\_constant\_keys
Otimiza o GROUP BY quando todas as chaves no bloco são constantes
## optimize\_group\_by\_function\_keys
Elimina funções de outras chaves na cláusula GROUP BY
## optimize\_if\_chain\_to\_multiif
Substitui sequências de if(cond1, then1, if(cond2, ...)) por multiIf. Atualmente, isso não é vantajoso para tipos numéricos.
## optimize\_if\_transform\_strings\_to\_enum
Substitui argumentos do tipo String em If e Transform por enum. Desabilitado por padrão, pois isso pode causar uma alteração inconsistente em uma consulta Distributed, o que levaria à falha dela.
## optimize\_injective\_functions\_in\_group\_by
Substitui funções injetivas pelos respectivos argumentos na cláusula GROUP BY
## optimize\_injective\_functions\_inside\_uniq
Remove funções injetivas de um argumento dentro de funções uniq\*().
## optimize\_inverse\_dictionary\_lookup
Evita repetir a busca inversa no dicionário ao fazer buscas mais rápidas em um conjunto pré-computado de possíveis valores de chave.
## optimize\_min\_equality\_disjunction\_chain\_length
O tamanho mínimo da expressão `expr = x1 OR ... expr = xN` para otimizaçã
## optimize\_min\_inequality\_conjunction\_chain\_length
O tamanho mínimo da expressão `expr <> x1 AND ... expr <> xN` para otimizaçã
## optimize\_move\_to\_prewhere
Ativa ou desativa a otimização automática de [PREWHERE](/pt-BR/reference/statements/select/prewhere) em consultas [SELECT](/pt-BR/reference/statements/select).
Funciona apenas com tabelas [\*MergeTree](/pt-BR/reference/engines/table-engines/mergetree-family).
Valores possíveis:
* 0 — A otimização automática de `PREWHERE` está desativada.
* 1 — A otimização automática de `PREWHERE` está ativada.
## optimize\_move\_to\_prewhere\_if\_final
Habilita ou desabilita a otimização automática de [PREWHERE](/pt-BR/reference/statements/select/prewhere) em consultas [SELECT](/pt-BR/reference/statements/select) com o modificador [FINAL](/pt-BR/reference/statements/select/from#final-modifier).
Funciona apenas com tabelas [\*MergeTree](/pt-BR/reference/engines/table-engines/mergetree-family).
Valores possíveis:
* 0 — A otimização automática de `PREWHERE` em consultas `SELECT` com o modificador `FINAL` está desabilitada.
* 1 — A otimização automática de `PREWHERE` em consultas `SELECT` com o modificador `FINAL` está habilitada.
**Veja também**
* configuração [optimize\_move\_to\_prewhere](#optimize_move_to_prewhere)
## optimize\_multiif\_to\_if
Substitui 'multiIf' por 'if' quando há apenas uma condição.
## optimize\_normalize\_count\_variants
Reescreve funções de agregação semanticamente equivalentes a count() como count().
## optimize\_on\_insert
Habilita ou desabilita a transformação de dados antes da inserção, como se a mesclagem tivesse sido feita nesse bloco (de acordo com o mecanismo da tabela).
Valores possíveis:
* 0 — Desabilitado.
* 1 — Habilitado.
**Exemplo**
A diferença entre habilitado e desabilitado:
Consulta:
```sql theme={null}
SET optimize_on_insert = 1;
CREATE TABLE test1 (`FirstTable` UInt32) ENGINE = ReplacingMergeTree ORDER BY FirstTable;
INSERT INTO test1 SELECT number % 2 FROM numbers(5);
SELECT * FROM test1;
SET optimize_on_insert = 0;
CREATE TABLE test2 (`SecondTable` UInt32) ENGINE = ReplacingMergeTree ORDER BY SecondTable;
INSERT INTO test2 SELECT number % 2 FROM numbers(5);
SELECT * FROM test2;
```
Resultado:
```text theme={null}
┌─FirstTable─┐
│ 0 │
│ 1 │
└────────────┘
┌─SecondTable─┐
│ 0 │
│ 0 │
│ 0 │
│ 1 │
│ 1 │
└─────────────┘
```
Observe que esta configuração afeta o comportamento da [visão materializada](/pt-BR/reference/statements/create/view#materialized-view).
## optimize\_or\_like\_chain
Otimiza múltiplas condições OR LIKE em `multiMatchAny`. Essa otimização não deve ser habilitada por padrão, porque em alguns casos prejudica a análise de índices.
## optimize\_qbit\_distance\_function\_reads
Substitui funções de distância no tipo de dado `QBit` por equivalentes que leem do armazenamento somente as colunas necessárias para o cálculo.
## optimize\_read\_in\_order
Habilita a otimização de [ORDER BY](/pt-BR/reference/statements/select/order-by#optimization-of-data-reading) em consultas [SELECT](/pt-BR/reference/statements/select) para ler dados de tabelas [MergeTree](/pt-BR/reference/engines/table-engines/mergetree-family/mergetree).
Valores possíveis:
* 0 — a otimização de `ORDER BY` está desativada.
* 1 — a otimização de `ORDER BY` está ativada.
**Veja também**
* [cláusula ORDER BY](/pt-BR/reference/statements/select/order-by#optimization-of-data-reading)
## optimize\_redundant\_functions\_in\_order\_by
Remove funções do ORDER BY se o argumento também estiver no ORDER BY
## optimize\_respect\_aliases
Se estiver definido como true, respeitará aliases em WHERE/GROUP BY/ORDER BY, o que ajudará na eliminação de partições/índices secundários/optimize\_aggregation\_in\_order/optimize\_read\_in\_order/optimize\_trivial\_count
## optimize\_rewrite\_aggregate\_function\_with\_if
Reescreve funções de agregação que têm uma expressão if como argumento, quando forem logicamente equivalentes.
Por exemplo, `avg(if(cond, col, null))` pode ser reescrita como `avgOrNullIf(cond, col)`. Isso pode melhorar o desempenho.
Suportado apenas com o analisador (`enable_analyzer = 1`).
## optimize\_rewrite\_array\_exists\_to\_has
Reescreve funções `arrayExists()` para `has()` quando forem logicamente equivalentes. Por exemplo, `arrayExists(x -> x = 1, arr)` pode ser reescrita como `has(arr, 1)`
## optimize\_rewrite\_like\_perfect\_affix
Reescreve expressões LIKE com prefixo ou sufixo perfeitos (por exemplo, `col LIKE 'ClickHouse%'`) como funções startsWith ou endsWith (por exemplo, `startsWith(col, 'ClickHouse')`).
## optimize\_rewrite\_regexp\_functions
Reescreve funções relacionadas a expressões regulares para formas mais simples e eficientes
## optimize\_rewrite\_sum\_if\_to\_count\_if
Reescreve as funções `sumIf()` e `sum(if())` como a função `countIf()` quando forem logicamente equivalentes
## optimize\_skip\_merged\_partitions
Habilita ou desabilita a otimização da consulta [OPTIMIZE TABLE ... FINAL](/pt-BR/reference/statements/optimize) se houver apenas uma parte com nível > 0 e ela não tiver TTL expirado.
* `OPTIMIZE TABLE ... FINAL SETTINGS optimize_skip_merged_partitions=1`
Por padrão, a consulta `OPTIMIZE TABLE ... FINAL` reescreve a parte mesmo quando há apenas uma única parte.
Valores possíveis:
* 1 - Habilita a otimização.
* 0 - Desabilita a otimização.
## optimize\_skip\_unused\_shards
Habilita ou desabilita a omissão de shards não utilizados em consultas [SELECT](/pt-BR/reference/statements/select) que tenham uma condição da chave de sharding em `WHERE/PREWHERE`, e ativa otimizações relacionadas para consultas distribuídas (por exemplo, agregação pela chave de sharding).
Pressupõe que os dados estejam distribuídos pela chave de sharding; caso contrário, a consulta produzirá um resultado incorreto.
Valores possíveis:
* 0 — Desabilitado.
* 1 — Habilitado.
## optimize\_skip\_unused\_shards\_limit
Limite para o número de valores da chave de sharding; desativa `optimize_skip_unused_shards` quando o limite é atingido.
Valores demais podem exigir um volume significativo de processamento, enquanto o benefício é duvidoso, já que, se você tiver um número muito grande de valores em `IN (...)`, muito provavelmente a consulta será enviada a todos os shards de qualquer maneira.
## optimize\_skip\_unused\_shards\_nesting
Controla [`optimize_skip_unused_shards`](#optimize_skip_unused_shards) (portanto, ainda requer [`optimize_skip_unused_shards`](#optimize_skip_unused_shards)) e depende do nível de aninhamento da consulta distribuída (no caso em que você tem uma tabela `Distributed` que consulta outra tabela `Distributed`).
Valores possíveis:
* 0 — Desabilitado; `optimize_skip_unused_shards` sempre funciona.
* 1 — Habilita `optimize_skip_unused_shards` apenas no primeiro nível.
* 2 — Habilita `optimize_skip_unused_shards` até o segundo nível.
## optimize\_skip\_unused\_shards\_rewrite\_in
Reescreve `IN` na consulta para shards remotos a fim de excluir valores que não pertencem ao shard (requer `optimize_skip_unused_shards`).
Valores possíveis:
* 0 — Desabilitado.
* 1 — Habilitado.
## optimize\_sorting\_by\_input\_stream\_properties
Otimiza a ordenação com base nas propriedades de ordenação do fluxo de entrada
## optimize\_substitute\_columns
Use [restrições](/pt-BR/reference/statements/create/table#constraints) na substituição de colunas. O padrão é `false`.
Valores possíveis:
* true, false
## optimize\_syntax\_fuse\_functions
Permite mesclar funções de agregação com o mesmo argumento. Reescreve consultas que contêm pelo menos duas funções de agregação entre [sum](/pt-BR/reference/functions/aggregate-functions/sum), [count](/pt-BR/reference/functions/aggregate-functions/count) e [avg](/pt-BR/reference/functions/aggregate-functions/avg) com o mesmo argumento para [sumCount](/pt-BR/reference/functions/aggregate-functions/sumCount).
Valores possíveis:
* 0 — Funções com o mesmo argumento não são mescladas.
* 1 — Funções com o mesmo argumento são mescladas.
**Exemplo**
Consulta:
```sql theme={null}
CREATE TABLE fuse_tbl(a Int8, b Int8) Engine = Log;
SET optimize_syntax_fuse_functions = 1;
EXPLAIN SYNTAX run_query_tree_passes = 1 SELECT sum(a), sum(b), count(b), avg(b) from fuse_tbl FORMAT TSV;
```
Resultado:
```text theme={null}
SELECT
sum(__table1.a) AS `sum(a)`,
tupleElement(sumCount(__table1.b), 1) AS `sum(b)`,
tupleElement(sumCount(__table1.b), 2) AS `count(b)`,
divide(tupleElement(sumCount(__table1.b), 1), toFloat64(tupleElement(sumCount(__table1.b), 2))) AS `avg(b)`
FROM default.fuse_tbl AS __table1
```
## optimize\_throw\_if\_noop
Ativa ou desativa o lançamento de uma exceção se uma consulta [OPTIMIZE](/pt-BR/reference/statements/optimize) não executar uma mesclagem.
Por padrão, `OPTIMIZE` retorna com sucesso mesmo que não faça nada. Essa configuração permite diferenciar essas situações e obter o motivo na mensagem de exceção.
Possible values:
* 1 — O lançamento de uma exceção está ativado.
* 0 — O lançamento de uma exceção está desativado.
## optimize\_time\_filter\_with\_preimage
col >= '2023-01-01' AND col <= '2023-12-31')"}]}]} />
Otimiza predicados de Date e DateTime convertendo funções em comparações equivalentes, sem conversões (ex.: `toYear(col) = 2023 -> col >= '2023-01-01' AND col <= '2023-12-31'`)
## optimize\_trivial\_approximate\_count\_query
Usa um valor aproximado para a otimização de contagem trivial em mecanismos de armazenamento que oferecem suporte a esse tipo de estimativa, por exemplo, EmbeddedRocksDB.
Valores possíveis:
* 0 — Otimização desabilitada.
* 1 — Otimização habilitada.
## optimize\_trivial\_count\_query
Ativa ou desativa a otimização da consulta trivial `SELECT count() FROM table` com base nos metadados do MergeTree. Se precisar usar segurança em nível de linha, desative essa configuração.
Valores possíveis:
* 0 — Otimização desativada.
* 1 — Otimização ativada.
Veja também:
* [optimize\_functions\_to\_subcolumns](#optimize_functions_to_subcolumns)
## optimize\_trivial\_group\_by\_limit\_query
Habilita ou desabilita a otimização de uma consulta trivial `SELECT key_expr FROM table GROUP BY key_expr LIMIT n` (sem funções de agregação na projeção, sem cláusulas `HAVING`/`ORDER BY`/`LIMIT BY`/window e sem modificadores `GROUP BY`) ao definir `max_rows_to_group_by = n + offset` com `group_by_overflow_mode = 'any'`. A agregação é interrompida assim que `n + offset` chaves distintas são produzidas.
A otimização é suprimida quando o usuário definiu explicitamente `group_by_overflow_mode` como um valor diferente de `any` (para preservar a escolha explícita de `throw`/`break`) e quando o usuário já definiu um `max_rows_to_group_by` mais restritivo (a otimização seria um no-op).
Valores possíveis:
* 0 — Otimização desabilitada.
* 1 — Otimização habilitada.
## optimize\_trivial\_insert\_select
Otimiza a consulta trivial 'INSERT INTO table SELECT ... FROM TABLES'
## optimize\_truncate\_order\_by\_after\_group\_by\_keys
Remover os elementos finais de ORDER BY quando todas as chaves de GROUP BY já estiverem cobertas pelo prefixo de ORDER BY.
## optimize\_uniq\_to\_count
Reescreve `uniq` e suas variantes (exceto `uniqUpTo`) como `count` se a subconsulta tiver `DISTINCT` ou cláusula `GROUP BY`.
## optimize\_use\_implicit\_projections
Escolhe automaticamente projeções implícitas para executar consultas SELECT
## optimize\_use\_projection\_filtering
Permite usar projeções para filtrar intervalos de partes, mesmo quando elas não são selecionadas para executar a consulta SELECT.
## optimize\_use\_projections
**Aliases**: `allow_experimental_projection_optimization`
Ativa ou desativa a otimização de [projeções](/pt-BR/reference/engines/table-engines/mergetree-family/mergetree#projections) ao processar consultas `SELECT`.
Possible values:
* 0 — Otimização de projeções desativada.
* 1 — Otimização de projeções ativada.
## optimize\_using\_constraints
Use [restrições](/pt-BR/reference/statements/create/table#constraints) para otimizar consultas. O padrão é `false`.
Valores possíveis:
* true, false
## os\_threads\_nice\_value\_materialized\_view
Valor nice do Linux para threads da visão materializada. Valores menores significam maior prioridade de CPU.
Requer a capability CAP\_SYS\_NICE; caso contrário, não tem efeito.
Valores possíveis: -20 a 19.
## os\_threads\_nice\_value\_query
**Aliases**: `os_thread_priority`
Valor nice do Linux para threads de processamento de consultas. Valores menores significam maior prioridade de CPU.
Requer a capability CAP\_SYS\_NICE; caso contrário, não produz efeito.
Possible values: -20 a 19.
## page\_cache\_block\_size
Tamanho dos fragmentos de arquivo a serem armazenados no cache de páginas em espaço do usuário, em bytes. Todas as leituras que passarem pelo cache serão arredondadas para cima para um múltiplo desse tamanho.
Esta configuração pode ser ajustada por consulta, mas entradas do cache com tamanhos de bloco diferentes não podem ser reutilizadas. Alterar esta configuração efetivamente invalida as entradas existentes no cache.
Um valor mais alto, como 1 MiB, é bom para consultas de alta vazão, e um valor mais baixo, como 64 KiB, é bom para consultas pontuais de baixa latência.
## page\_cache\_inject\_eviction
O cache de páginas em userspace às vezes invalida páginas aleatoriamente. Destina-se a testes.
## page\_cache\_lookahead\_blocks
Em caso de miss no userspace page cache, lê até essa quantidade de blocos consecutivos de uma só vez do armazenamento subjacente, caso eles também não estejam no cache. Cada bloco tem page\_cache\_block\_size bytes.
Um valor mais alto é bom para consultas com alto throughput, enquanto consultas pontuais de baixa latência funcionam melhor sem readahead.
## page\_cache\_max\_coalesced\_bytes
Quando `readBigAt` preenche o cache de páginas em espaço de usuário, falhas de cache consecutivas são agrupadas em uma única leitura do armazenamento subjacente. Esta configuração limita, em bytes, o tamanho de uma leitura coalescida; sequências mais longas de falhas são divididas em múltiplas leituras. Ela limita o uso transitório de memória do buffer temporário durante leituras paralelas a frio.
Um valor mais alto reduz o número de requisições HTTP em varreduras a frio no armazenamento de objetos; um valor mais baixo reduz o pico de memória transitória.
## paimon\_target\_snapshot\_id
Leitura direcionada de snapshot no nível da consulta para o modo incremental do Paimon. Quando >0, o leitor buscará apenas o delta
do snapshot\_id especificado, sem avançar o watermark confirmado.
Padrão: -1 (desabilitado)
## parallel\_distributed\_insert\_select
Habilita a consulta distribuída `INSERT ... SELECT` em paralelo.
Se executarmos consultas `INSERT INTO distributed_table_a SELECT ... FROM distributed_table_b`, e ambas as tabelas usarem o mesmo cluster, e ambas forem [replicadas](/pt-BR/reference/engines/table-engines/mergetree-family/replication) ou não replicadas, essa consulta será processada localmente em cada shard.
Valores possíveis:
* `0` — Desabilitado.
* `1` — `SELECT` será executado em cada shard a partir da tabela subjacente do motor Distributed.
* `2` — `SELECT` e `INSERT` serão executados em cada shard, da/para a tabela subjacente do motor Distributed.
Desde a v25.4, `INSERT ... SELECT` de uma origem `ReplicatedMergeTree` ou `SharedMergeTree` também pode ser paralelizado entre réplicas. Para habilitar:
* `parallel_distributed_insert_select = 2`
* `enable_parallel_replicas = 1`
## parallel\_hash\_join\_threshold
Quando um algoritmo de join baseado em hash é usado, esse limite ajuda a decidir entre `hash` e `parallel_hash` (somente se a estimativa do tamanho da tabela à direita estiver disponível).
O primeiro é usado quando sabemos que o tamanho da tabela à direita está abaixo do limite.
## parallel\_non\_joined\_rows\_processing
Permite que várias threads processem em paralelo as linhas sem correspondência da tabela à direita durante JOINs RIGHT e FULL.
Isso pode acelerar a fase de linhas sem correspondência ao usar o algoritmo de join `parallel_hash` com tabelas grandes.
Quando desabilitada, as linhas sem correspondência são processadas por uma única thread.
## parallel\_replica\_offset
Esta é uma configuração interna que não deve ser usada diretamente e representa um detalhe de implementação do modo de 'réplicas paralelas'. Essa configuração será definida automaticamente pelo servidor iniciador, em consultas distribuídas, com o índice da réplica que participa do processamento da consulta entre as réplicas paralelas.
## parallel\_replicas\_allow\_in\_with\_subquery
Se true, a subconsulta de IN será executada em cada réplica seguidora.
## parallel\_replicas\_allow\_materialized\_views
Permite o uso de visões materializadas com réplicas paralelas
## parallel\_replicas\_allow\_view\_over\_mergetree
Permite que réplicas paralelas executem a consulta externa de uma view simples sobre tabelas `MergeTree` (em vez da consulta interna da view), melhorando a paralelização entre os nós. Também se aplica a views `UNION ALL` cujos ramos leem de tabelas `MergeTree` diferentes.
## parallel\_replicas\_connect\_timeout\_ms
O timeout, em milissegundos, para se conectar a uma réplica remota durante a execução de consultas com réplicas paralelas. Se o timeout expirar, a réplica correspondente não será usada para a execuçã
## parallel\_replicas\_count
Esta é uma configuração interna que não deve ser usada diretamente e representa um detalhe de implementação do modo de 'réplicas paralelas'. Essa configuração será definida automaticamente pelo servidor iniciador, em consultas distribuídas, com o número de réplicas paralelas que participam do processamento da consulta.
## parallel\_replicas\_custom\_key
Uma expressão inteira arbitrária que pode ser usada para dividir o trabalho entre as réplicas de uma tabela específica.
O valor pode ser qualquer expressão inteira.
Dê preferência a expressões simples que usem chaves primárias.
Se a configuração for usada em um cluster composto por um único shard com várias réplicas, essas réplicas serão convertidas em shards virtuais.
Caso contrário, ela se comportará da mesma forma que a chave `SAMPLE`: usará várias réplicas de cada shard.
## parallel\_replicas\_custom\_key\_range\_lower
Permite que o filtro do tipo `range` divida o trabalho de forma equilibrada entre as réplicas com base no intervalo personalizado `[parallel_replicas_custom_key_range_lower, INT_MAX]`.
Quando usada em conjunto com [parallel\_replicas\_custom\_key\_range\_upper](#parallel_replicas_custom_key_range_upper), essa configuração permite que o filtro divida de forma equilibrada o trabalho entre as réplicas no intervalo `[parallel_replicas_custom_key_range_lower, parallel_replicas_custom_key_range_upper]`.
Observação: essa configuração não faz com que dados adicionais sejam filtrados durante o processamento da consulta; em vez disso, ela altera os pontos em que o filtro de intervalo divide a faixa `[0, INT_MAX]` para processamento paralelo.
## parallel\_replicas\_custom\_key\_range\_upper
Permite que o tipo de filtro `range` divida o trabalho uniformemente entre as réplicas com base no intervalo personalizado `[0, parallel_replicas_custom_key_range_upper]`. Um valor 0 desativa o limite superior, definindo-o como o valor máximo da expressão de chave personalizada.
Quando usado em conjunto com [parallel\_replicas\_custom\_key\_range\_lower](#parallel_replicas_custom_key_range_lower), permite que o filtro divida uniformemente o trabalho entre as réplicas no intervalo `[parallel_replicas_custom_key_range_lower, parallel_replicas_custom_key_range_upper]`.
Observação: essa configuração não faz com que dados adicionais sejam filtrados durante o processamento da consulta; em vez disso, ela altera os pontos em que o filtro de intervalo divide o intervalo `[0, INT_MAX]` para processamento paralelo
## parallel\_replicas\_filter\_pushdown
Permite fazer pushdown de filtros para a parte da consulta que as réplicas paralelas escolhem executar
## parallel\_replicas\_for\_cluster\_engines
Substitui os motores de função de tabela por suas alternativas -Cluster
## parallel\_replicas\_for\_non\_replicated\_merge\_tree
Se true, o ClickHouse também usará o algoritmo de réplicas paralelas para tabelas MergeTree não replicadas.
## parallel\_replicas\_index\_analysis\_only\_on\_coordinator
A análise de índices é realizada apenas na réplica coordenadora e ignorada nas demais réplicas. Só tem efeito quando parallel\_replicas\_local\_pla
## parallel\_replicas\_insert\_select\_local\_pipeline
Usa o pipeline local durante INSERT SELECT distribuído com réplicas paralelas
## parallel\_replicas\_local\_plan
Criar plano local para a réplica local
## parallel\_replicas\_mark\_segment\_size
As partes são divididas virtualmente em segmentos para serem distribuídas entre as réplicas para leitura em paralelo. Esta configuração controla o tamanho desses segmentos. Não é recomendável alterá-la até que você tenha absoluta certeza do que está fazendo. O valor deve estar no intervalo \[128; 16384]
## parallel\_replicas\_min\_number\_of\_rows\_per\_replica
Limita o número de réplicas usadas em uma consulta a (linhas estimadas para ler / min\_number\_of\_rows\_per\_replica). O máximo ainda é limitado por 'max\_parallel\_replicas'
## parallel\_replicas\_mode
Tipo de filtro a ser usado com chave personalizada para réplicas paralelas. default - usa a operação de módulo na chave personalizada; range - usa um filtro de intervalo na chave personalizada, utilizando todos os valores possíveis para o tipo de valor da chave personalizada.
## parallel\_replicas\_only\_with\_analyzer
O analyzer deve estar habilitado para usar réplicas paralelas. Com o analyzer desabilitado, a execução da consulta faz fallback para a execução local, mesmo que a leitura paralela a partir de réplicas esteja habilitada. Não há suporte para usar réplicas paralelas sem o analyzer habilitado
## parallel\_replicas\_prefer\_local\_join
Se true, e o JOIN puder ser executado com o algoritmo de réplicas paralelas, e todos os armazenamentos da parte direita do JOIN forem \*MergeTree, será usado JOIN local em vez de GLOBAL JOIN.
## parallel\_replicas\_prefer\_local\_replica
Quando habilitada (padrão), a réplica local é sempre incluída no conjunto de réplicas usado para leitura paralela.
Quando desabilitada, a réplica local não recebe nenhuma preferência, e as réplicas são selecionadas exclusivamente pelo algoritmo de balanceamento de carga.
Isso permite que consultas com `max_parallel_replicas = 1` sejam direcionadas a outro host, o que pode melhorar a localidade de cache quando muitas consultas curtas são distribuídas em um cluster.
## parallel\_replicas\_support\_projection
A otimização de projeções pode ser aplicada em réplicas paralelas. Só tem efeito quando parallel\_replicas\_local\_plan está habilitado e aggregation\_in\_order está inativo.
## parallel\_view\_processing
Habilita o envio de dados para views anexadas de forma concorrente em vez de sequencial.
## parallelize\_output\_from\_storages
Paraleliza a saída na etapa de leitura do armazenamento. Isso permite paralelizar o processamento da consulta logo após a leitura do armazenamento, quando possível
## parsedatetime\_e\_requires\_space\_padding
O formatador '%e' na função 'parseDateTime' exige que dias com um único dígito sejam preenchidos com espaço; por exemplo, ' 2' é aceito, mas '2' gera um erro.
## parsedatetime\_parse\_without\_leading\_zeros
Os formatadores '%c', '%l' e '%k' na função 'parseDateTime' interpretam meses e horas sem zeros à esquerda.
## partial\_merge\_join\_left\_table\_buffer\_bytes
Se não for 0, agrupa os blocos da tabela à esquerda em blocos maiores para uso no lado esquerdo do partial merge join. Consome até 2x a memória especificada por thread de join.
## partial\_merge\_join\_rows\_in\_right\_blocks
Limita o tamanho dos blocos de dados do lado direito do JOIN no algoritmo partial merge join para consultas [JOIN](/pt-BR/reference/statements/select/join).
No servidor ClickHouse:
1. Divide os dados do lado direito do JOIN em blocos com até o número especificado de linhas.
2. Cria um índice para cada bloco com base nos valores mínimo e máximo.
3. Descarrega os blocos preparados para o disco, se possível.
Valores possíveis:
* Qualquer inteiro positivo. Faixa de valores recomendada: \[1000, 100000].
## partial\_result\_on\_first\_cancel
Permite que a consulta retorne um resultado parcial após ser cancelada.
## parts\_to\_delay\_insert
Se a tabela de destino contiver pelo menos essa quantidade de partes ativas em uma única partição, as inserções na tabela serão artificialmente desaceleradas.
## parts\_to\_throw\_insert
Se houver mais do que esse número de partes ativas em uma única partição da tabela de destino, gere a exceção 'Too many parts ...'.
## per\_part\_index\_stats
Registra estatísticas do índice por parte
## poll\_interval
Bloqueia o loop de espera da consulta no servidor pelo número especificado de segundos.
## polyglot\_dialect
Dialeto SQL de origem do transpiler polyglot (por exemplo, 'sqlite', 'mysql', 'postgresql', 'snowflake', 'duckdb').
## postgresql\_connection\_attempt\_timeout
Tempo limite de conexão, em segundos, para uma única tentativa de conexão com o endpoint do PostgreSQL.
O valor é passado como parâmetro `connect_timeout` da URL de conexão.
## postgresql\_connection\_pool\_auto\_close\_connection
Feche a conexão antes de devolvê-la ao pool.
## postgresql\_connection\_pool\_retries
Número de tentativas de push/pop do pool de conexões para o engine PostgreSQL de tabela e de banco de dados.
## postgresql\_connection\_pool\_size
Tamanho do pool de conexões do mecanismo de tabela PostgreSQL e do mecanismo de banco de dados.
## postgresql\_connection\_pool\_wait\_timeout
Tempo limite de push/pop do pool de conexões quando o pool está vazio para o PostgreSQL table engine e o database engine. Por padrão, ele ficará bloqueado quando o pool estiver vazio.
## postgresql\_fault\_injection\_probability
Probabilidade aproximada de falha nas consultas internas do PostgreSQL (para replicação). O valor válido está no intervalo \[0.0f, 1.0f]
## predicate\_statistics\_sample\_rate
Coleta estatísticas de seletividade de predicados em `system.predicate_statistics_log`. Quando definido como N > 0, aproximadamente 1/N das consultas é amostrado (pelo ID da consulta). 0 significa desabilitado.
## prefer\_column\_name\_to\_alias
Ativa ou desativa o uso dos nomes originais das colunas em vez de aliases em expressões e cláusulas de consulta. Isso é especialmente importante quando o alias é igual ao nome da coluna; consulte [Expression Aliases](/pt-BR/reference/syntax#notes-on-usage). Ative essa configuração para tornar as regras de sintaxe de aliases no ClickHouse mais compatíveis com a maioria dos outros motores de banco de dados.
Valores possíveis:
* 0 — O nome da coluna é substituído pelo alias.
* 1 — O nome da coluna não é substituído pelo alias.
**Exemplo**
A diferença entre habilitado e desabilitado:
Consulta:
```sql theme={null}
SET prefer_column_name_to_alias = 0;
SELECT avg(number) AS number, max(number) FROM numbers(10);
```
Resultado:
```text theme={null}
Received exception from server (version 21.5.1):
Code: 184. DB::Exception: Received from localhost:9000. DB::Exception: Aggregate function avg(number) is found inside another aggregate function in query: While processing avg(number) AS number.
```
Consulta:
```sql theme={null}
SET prefer_column_name_to_alias = 1;
SELECT avg(number) AS number, max(number) FROM numbers(10);
```
Resultado:
```text theme={null}
┌─number─┬─max(number)─┐
│ 4.5 │ 9 │
└────────┴─────────────┘
```
## prefer\_external\_sort\_block\_bytes
Prefere o número máximo de bytes por bloco para ordenação externa, reduzindo o uso de memória durante a mesclagem.
## prefer\_global\_in\_and\_join
Habilita a substituição dos operadores `IN`/`JOIN` por `GLOBAL IN`/`GLOBAL JOIN`.
Valores possíveis:
* 0 — Desabilitado. Os operadores `IN`/`JOIN` não são substituídos por `GLOBAL IN`/`GLOBAL JOIN`.
* 1 — Habilitado. Os operadores `IN`/`JOIN` são substituídos por `GLOBAL IN`/`GLOBAL JOIN`.
**Uso**
Embora `SET distributed_product_mode=global` possa alterar o comportamento das consultas em tabelas distribuídas, ele não é adequado para tabelas locais nem para tabelas de recursos externos. É nesse ponto que a configuração `prefer_global_in_and_join` se torna útil.
Por exemplo, podemos ter nós de consulta que contêm tabelas locais, que não são adequadas para distribuição. Precisamos distribuir esses dados dinamicamente durante o processamento distribuído com a palavra-chave `GLOBAL` — `GLOBAL IN`/`GLOBAL JOIN`.
Outro caso de uso de `prefer_global_in_and_join` é o acesso a tabelas criadas por motores externos. Essa configuração ajuda a reduzir o número de chamadas a fontes externas ao fazer join dessas tabelas: apenas uma chamada por consulta.
**Veja também:**
* [Subconsultas distribuídas](/pt-BR/reference/statements/in#distributed-subqueries) para mais informações sobre como usar `GLOBAL IN`/`GLOBAL JOIN`
## prefer\_localhost\_replica
Habilita/desabilita o uso preferencial da réplica `localhost` ao processar consultas distribuídas.
Possíveis valores:
* 1 — o ClickHouse sempre envia a consulta para a réplica `localhost`, se ela existir.
* 0 — o ClickHouse usa a estratégia de balanceamento especificada pela configuração [load\_balancing](#load_balancing).
Desative essa configuração se você usar [max\_parallel\_replicas](#max_parallel_replicas) sem [parallel\_replicas\_custom\_key](#parallel_replicas_custom_key).
Se [parallel\_replicas\_custom\_key](#parallel_replicas_custom_key) estiver definido, desative essa configuração apenas se ela for usada em um cluster com vários shards contendo várias réplicas.
Se ela for usada em um cluster com um único shard e várias réplicas, desativar essa configuração terá efeitos negativos.
## prefer\_warmed\_unmerged\_parts\_seconds
Só tem efeito no ClickHouse Cloud. Se uma parte mesclada tiver menos do que esta quantidade de segundos e não estiver pré-aquecida (consulte [cache\_populated\_by\_fetch](/pt-BR/reference/settings/merge-tree-settings#cache_populated_by_fetch)), mas todas as suas partes de origem estiverem disponíveis e pré-aquecidas, as consultas SELECT lerão dessas partes em vez da parte mesclada. Apenas para Replicated-/SharedMergeTree. Observe que isso verifica apenas se o CacheWarmer processou a parte; se a parte tiver sido carregada no cache por outro mecanismo, ela ainda será considerada fria até que o CacheWarmer a processe; se tiver sido aquecida e depois removida do cache, ainda assim será considerada quente.
## preferred\_block\_size\_bytes
Esta configuração ajusta o tamanho do bloco de dados para o processamento de consultas e representa um ajuste fino adicional em relação à configuração mais genérica 'max\_block\_size'. Se as colunas forem grandes e, com 'max\_block\_size' linhas, o tamanho do bloco provavelmente ultrapassar a quantidade de bytes especificada, ele será reduzido para melhorar a localidade de cache da CPU.
## preferred\_max\_column\_in\_block\_size\_bytes
Limite do tamanho máximo da coluna no bloco durante a leitura. Ajuda a reduzir a quantidade de falhas de cache. Deve ficar próximo ao tamanho do cache L2.
## preferred\_optimize\_projection\_name
Se for definido como uma string não vazia, o ClickHouse tentará aplicar a projeção especificada na consulta.
Valores possíveis:
* string: nome da projeção preferida
## prefetch\_buffer\_size
O tamanho máximo do buffer de prefetch para leitura no sistema de arquivos.
## print\_pretty\_type\_names
Permite exibir nomes de tipos com aninhamento profundo de forma legível, com recuos, na consulta `DESCRIBE` e na função `toTypeName()`.
Exemplo:
```sql theme={null}
CREATE TABLE test (a Tuple(b String, c Tuple(d Nullable(UInt64), e Array(UInt32), f Array(Tuple(g String, h Map(String, Array(Tuple(i String, j UInt64))))), k Date), l Nullable(String))) ENGINE=Memory;
DESCRIBE TABLE test FORMAT TSVRaw SETTINGS print_pretty_type_names=1;
```
```
a Tuple(
b String,
c Tuple(
d Nullable(UInt64),
e Array(UInt32),
f Array(Tuple(
g String,
h Map(
String,
Array(Tuple(
i String,
j UInt64
))
)
)),
k Date
),
l Nullable(String)
)
```
## priority
Prioridade da consulta. 1 — a mais alta; quanto maior o valor, menor a prioridade; 0 — não usar prioridades.
## promql\_database
Especifica o nome do banco de dados usado pelo dialeto 'promql'. Uma string vazia significa o banco de dados atual.
## promql\_evaluation\_time
**Aliases**: `evaluation_time`
Define o horário de avaliação a ser usado com o dialeto promql. 'auto' significa o horário atual.
## promql\_table
Especifica o nome de uma tabela TimeSeries usada pelo dialeto 'promql'.
## push\_external\_roles\_in\_interserver\_queries
Habilita o envio dos papéis do usuário do nó de origem para outros nós ao executar uma consulta.
## query\_cache\_compress\_entries
Comprime as entradas no [cache de consultas](/pt-BR/concepts/features/performance/caches/query-cache). Reduz o consumo de memória do cache de consultas ao custo de inserções e leituras mais lentas.
Valores possíveis:
* 0 - Desativado
* 1 - Ativado
## query\_cache\_for\_subqueries
Se ativado, os resultados das subconsultas podem ser gravados no [cache de consultas](/pt-BR/concepts/features/performance/caches/query-cache) e lidos dele. Isso permite propagar `use_query_cache` para todas as subconsultas.
Valores possíveis:
* 0 - Desativado
* 1 - Ativado
## query\_cache\_max\_entries
O número máximo de resultados de consultas que o usuário atual pode armazenar no [cache de consultas](/pt-BR/concepts/features/performance/caches/query-cache). 0 significa ilimitado.
Valores possíveis:
* Número inteiro >= 0.
## query\_cache\_max\_size\_in\_bytes
A quantidade máxima de memória (em bytes) que o usuário atual pode alocar no [cache de consultas](/pt-BR/concepts/features/performance/caches/query-cache). 0 significa sem limite.
Valores possíveis:
* Inteiro positivo >= 0.
## query\_cache\_min\_query\_duration
Duração mínima, em milissegundos, que uma consulta precisa ser executada para que seu resultado seja armazenado no [cache de consultas](/pt-BR/concepts/features/performance/caches/query-cache).
Valores possíveis:
* Inteiro >= 0.
## query\_cache\_min\_query\_runs
Número mínimo de vezes que uma consulta `SELECT` precisa ser executada antes que seu resultado seja armazenado no [cache de consultas](/pt-BR/concepts/features/performance/caches/query-cache).
Valores possíveis:
* Número inteiro positivo >= 0.
## query\_cache\_nondeterministic\_function\_handling
Controla como o [cache de consultas](/pt-BR/concepts/features/performance/caches/query-cache) lida com consultas `SELECT` que usam funções não determinísticas, como `rand()` ou `now()`.
Valores possíveis:
* `'throw'` - Lança uma exceção e não armazena o resultado da consulta em cache.
* `'save'` - Armazena o resultado da consulta em cache.
* `'ignore'` - Não armazena o resultado da consulta em cache e não lança uma exceção.
## query\_cache\_share\_between\_users
Se ativada, o resultado de consultas `SELECT` armazenadas no [cache de consultas](/pt-BR/concepts/features/performance/caches/query-cache) pode ser lido por outros usuários.
Não é recomendável habilitar essa configuração por motivos de segurança.
Valores possíveis:
* 0 - Desativado
* 1 - Ativado
## query\_cache\_squash\_partial\_results
Agrupa blocos de resultados parciais em blocos do tamanho de [max\_block\_size](#max_block_size). Reduz o desempenho das inserções no [cache de consultas](/pt-BR/concepts/features/performance/caches/query-cache), mas melhora a compressibilidade das entradas de cache (consulte [query\_cache\_compress-entries](#query_cache_compress_entries)).
Valores possíveis:
* 0 - Desabilitado
* 1 - Habilitado
## query\_cache\_system\_table\_handling
Controla como o [cache de consultas](/pt-BR/concepts/features/performance/caches/query-cache) lida com consultas `SELECT` em tabelas do sistema, ou seja, tabelas nos bancos de dados `system.*` e `information_schema.*`.
Valores possíveis:
* `'throw'` - Lança uma exceção e não armazena em cache o resultado da consulta.
* `'save'` - Armazena em cache o resultado da consulta.
* `'ignore'` - Não armazena em cache o resultado da consulta nem lança uma exceção.
## query\_cache\_tag
Uma string que funciona como rótulo para entradas do [cache de consultas](/pt-BR/concepts/features/performance/caches/query-cache).
As mesmas consultas com rótulos diferentes são consideradas diferentes pelo cache de consultas.
Valores possíveis:
* Qualquer string
## query\_cache\_ttl
Após esse período, em segundos, as entradas no [cache de consultas](/pt-BR/concepts/features/performance/caches/query-cache) ficam desatualizadas.
Valores possíveis:
* Inteiro positivo >= 0.
## query\_metric\_log\_interval
O intervalo, em milissegundos, em que o [query\_metric\_log](/pt-BR/reference/system-tables/query_metric_log) de consultas individuais é coletado.
Se for definido como qualquer valor negativo, assumirá o valor de `collect_interval_milliseconds` da [configuração query\_metric\_log](/pt-BR/reference/settings/server-settings/settings#query_metric_log) ou, se ela não estiver presente, usará o valor padrão de 1000.
Para desativar a coleta de uma única consulta, defina `query_metric_log_interval` como 0.
Valor padrão: -1
## query\_plan\_aggregation\_in\_order
Ativa ou desativa a otimização de agregação em ordem no nível do plano de consulta.
Só tem efeito se a configuração [`query_plan_enable_optimizations`](#query_plan_enable_optimizations) estiver definida como 1.
Esta é uma configuração de nível avançado que deve ser usada apenas para depuração por desenvolvedores. A configuração pode mudar no futuro de formas incompatíveis com versões anteriores ou ser removida.
Valores possíveis:
* 0 - Desabilita
* 1 - Habilita
## query\_plan\_convert\_any\_join\_to\_semi\_or\_anti\_join
Permite converter ANY JOIN em SEMI ou ANTI JOIN se o filtro após o JOIN sempre resultar em falso para linhas correspondentes ou não correspondentes
## query\_plan\_convert\_join\_to\_in
Permite converter `JOIN` em subconsulta com `IN` se as colunas de saída pertencerem apenas à tabela da esquerda. Pode gerar resultados incorretos com JOINs diferentes de ANY (por exemplo, ALL JOINs, que é o padrão).
## query\_plan\_convert\_outer\_join\_to\_inner\_join
Permite converter `OUTER JOIN` em `INNER JOIN` se o filtro após o `JOIN` sempre eliminar valores padrão
## query\_plan\_direct\_read\_from\_text\_index
Permite executar a filtragem de busca de texto completo usando apenas o índice de texto invertido no plano de consulta.
## query\_plan\_display\_internal\_aliases
Exibe aliases internos (como \_\_table1) no EXPLAIN PLAN em vez dos especificados na consulta original.
## query\_plan\_enable\_multithreading\_after\_window\_functions
Habilita o multithreading após a avaliação das funções de janela para permitir o processamento de streams em paralelo
## query\_plan\_enable\_optimizations
Ativa ou desativa a otimização de consultas no nível do plano de consulta.
Esta é uma configuração de nível avançado que deve ser usada apenas por desenvolvedores para depuração. A configuração pode mudar no futuro de formas incompatíveis com versões anteriores ou ser removida.
Valores possíveis:
* 0 - Desabilita todas as otimizações no nível do plano de consulta
* 1 - Habilita as otimizações no nível do plano de consulta (mas otimizações individuais ainda podem ser desabilitadas por meio de suas próprias configurações)
## query\_plan\_execute\_functions\_after\_sorting
Ativa ou desativa uma otimização no nível do plano de consulta que move expressões para após as etapas de ordenação.
Só entra em vigor se a configuração [`query_plan_enable_optimizations`](#query_plan_enable_optimizations) for 1.
Esta é uma configuração de nível avançado que deve ser usada apenas para depuração por desenvolvedores. A configuração poderá mudar no futuro de maneiras incompatíveis com versões anteriores ou ser removida.
Valores possíveis:
* 0 - Desabilita
* 1 - Habilita
## query\_plan\_filter\_push\_down
Ativa ou desativa uma otimização no nível do plano de consulta que desloca os filtros para baixo no plano de execução.
Só tem efeito se a configuração [query\_plan\_enable\_optimizations](#query_plan_enable_optimizations) estiver definida como 1.
Esta é uma configuração de nível avançado que deve ser usada apenas para depuração por desenvolvedores. A configuração pode mudar no futuro de formas incompatíveis com versões anteriores ou ser removida.
Valores possíveis:
* 0 - Desativar
* 1 - Ativar
## query\_plan\_join\_shard\_by\_pk\_ranges
Aplica sharding ao JOIN se as chaves de junção contiverem um prefixo da PRIMARY KEY em ambas as tabelas. Compatível com os algoritmos hash, parallel\_hash e full\_sorting\_merge. Normalmente não acelera as consultas, mas pode reduzir o consumo de memória.
## query\_plan\_join\_swap\_table
Determina qual lado do join deve ser a tabela de build (também chamada de inner, aquela inserida na tabela hash em um hash join) no plano de consulta. Essa configuração tem suporte apenas para strictness de join `ALL` com a cláusula `JOIN ON`. Os valores possíveis são:
* 'auto': Permite que o planner decida qual tabela usar como tabela de build.
* 'false': Nunca troca as tabelas (a tabela da direita é a tabela de build).
* 'true': Sempre troca as tabelas (a tabela da esquerda é a tabela de build).
## query\_plan\_lift\_up\_array\_join
Ativa ou desativa uma otimização em nível de plano de consulta que move cláusulas ARRAY JOIN para cima no plano de execução.
Só entra em vigor se a configuração [query\_plan\_enable\_optimizations](#query_plan_enable_optimizations) for 1.
Esta é uma configuração de nível avançado que deve ser usada apenas para depuração por desenvolvedores. A configuração pode mudar no futuro de formas incompatíveis com versões anteriores ou ser removida.
Valores possíveis:
* 0 - Desabilita
* 1 - Habilita
## query\_plan\_lift\_up\_union
Ativa ou desativa uma otimização em nível de plano de consulta que move subárvores maiores do plano de consulta para o union, permitindo otimizações adicionais.
Só tem efeito se a configuração [`query_plan_enable_optimizations`](#query_plan_enable_optimizations) estiver definida como 1.
Esta é uma configuração de nível avançado que deve ser usada apenas para depuração por desenvolvedores. A configuração pode mudar no futuro de maneiras incompatíveis com versões anteriores ou ser removida.
Valores possíveis:
* 0 - Desabilita
* 1 - Habilita
## query\_plan\_max\_limit\_for\_lazy\_materialization
Controla o valor máximo que permite usar o plano de consulta para a otimização de materialização tardia. Se for zero, não há limite.
## query\_plan\_max\_limit\_for\_top\_k\_optimization
Define o valor máximo de limite que permite avaliar o plano de consulta para a otimização TopK usando o índice de omissão minmax e a filtragem dinâmica por limiar. Se for zero, não há limite.
## query\_plan\_max\_optimizations\_to\_apply
Limita o número total de otimizações aplicadas ao plano da consulta; consulte a configuração [query\_plan\_enable\_optimizations](#query_plan_enable_optimizations).
Útil para evitar tempos de otimização excessivos em consultas complexas.
Na consulta EXPLAIN PLAN, para de aplicar otimizações após esse limite ser atingido e retorna o plano como está.
Na execução normal de consultas, se o número real de otimizações exceder essa configuração, uma exceção será lançada.
Esta é uma configuração de nível avançado que deve ser usada apenas para depuração por desenvolvedores. A configuração pode mudar no futuro de formas incompatíveis com versões anteriores ou ser removida.
## query\_plan\_max\_step\_description\_length
Comprimento máximo da descrição do passo no EXPLAIN PLAN.
## query\_plan\_merge\_expressions
Ativa ou desativa uma otimização no nível do plano de consulta que mescla filtros consecutivos.
Só entra em vigor se a configuração [query\_plan\_enable\_optimizations](#query_plan_enable_optimizations) for 1.
Esta é uma configuração de nível avançado que deve ser usada apenas para debugging por desenvolvedores. A configuração pode mudar no futuro de formas incompatíveis com versões anteriores ou ser removida.
Valores possíveis:
* 0 - Desabilita
* 1 - Habilita
## query\_plan\_merge\_filter\_into\_join\_condition
Permite mesclar o filtro à condição de `JOIN` e converter `CROSS JOIN` em `INNER`.
## query\_plan\_merge\_filters
Permite mesclar filtros no plano de consulta.
## query\_plan\_optimize\_join\_order\_algorithm
Especifica quais algoritmos de ordem de JOIN devem ser usados durante a otimização do plano de consulta. Os seguintes algoritmos estão disponíveis:
* 'greedy' - algoritmo guloso básico - é rápido, mas pode não produzir a melhor ordem de join
* 'dpsize' - implementa o algoritmo DPsize, atualmente apenas para junções Inner - considera todas as ordens de join possíveis e encontra a mais otimizada, mas pode ser lento para consultas com muitas tabelas e predicados de join.
É possível especificar vários algoritmos, por exemplo, 'dpsize,greedy'.
## query\_plan\_optimize\_join\_order\_limit
Otimiza a ordem das junções dentro da mesma subconsulta. No momento, há suporte apenas para casos muito limitados.
O valor é o número máximo de tabelas a serem otimizadas.
## query\_plan\_optimize\_join\_order\_randomize
Quando diferente de zero, o otimizador da ordem de join usa cardinalidades e NDVs gerados aleatoriamente em vez de estatísticas reais.
Quando definido como 1, uma semente aleatória é gerada; quando definido como um valor > 1, esse valor é usado diretamente como semente.
Essa opção se destina a testes para identificar erros causados por diferentes ordenações de join.
## query\_plan\_optimize\_lazy\_final
Otimize a leitura com FINAL do ReplacingMergeTree criando um conjunto de chaves primárias e usando-o na análise de índices.
## query\_plan\_optimize\_lazy\_materialization
Usa o plano de consulta na otimização de materialização tardia.
## query\_plan\_optimize\_prewhere
Permite aplicar push down do filtro à expressão PREWHERE em armazenamentos compatíveis
## query\_plan\_push\_down\_limit
Ativa ou desativa uma otimização no nível do plano de consulta que move cláusulas `LIMIT` para baixo no plano de execução.
Só tem efeito se a configuração [query\_plan\_enable\_optimizations](#query_plan_enable_optimizations) estiver definida como 1.
Esta é uma configuração de nível especialista que só deve ser usada para depuração por desenvolvedores. A configuração poderá mudar no futuro de maneiras incompatíveis com versões anteriores ou ser removida.
Valores possíveis:
* 0 - Desativar
* 1 - Ativar
## query\_plan\_read\_in\_order
Ativa ou desativa a otimização de leitura em ordem no nível do plano de consulta.
Só tem efeito se a configuração [`query_plan_enable_optimizations`](#query_plan_enable_optimizations) estiver definida como 1.
Esta é uma configuração de nível especialista que deve ser usada apenas para depuração por desenvolvedores. A configuração poderá mudar no futuro de formas incompatíveis com versões anteriores ou ser removida.
Valores possíveis:
* 0 - Desabilita
* 1 - Habilita
## query\_plan\_read\_in\_order\_through\_join
Mantém a leitura em ordem da tabela à esquerda em operações JOIN, o que pode ser aproveitado por etapas subsequentes.
## query\_plan\_remove\_redundant\_distinct
Ativa/desativa uma otimização no nível do plano da consulta que remove etapas DISTINCT redundantes.
Só tem efeito se a configuração [`query_plan_enable_optimizations`](#query_plan_enable_optimizations) for 1.
Esta é uma configuração para especialistas, que deve ser usada apenas para depuração por desenvolvedores. A configuração poderá mudar no futuro de formas incompatíveis com versões anteriores ou ser removida.
Valores possíveis:
* 0 - Desativar
* 1 - Ativar
## query\_plan\_remove\_redundant\_sorting
Ativa ou desativa uma otimização no nível do plano de consulta que remove etapas de ordenação redundantes, por exemplo, em subconsultas.
Só tem efeito se a configuração [`query_plan_enable_optimizations`](#query_plan_enable_optimizations) estiver definida como 1.
Esta é uma configuração de nível avançado que deve ser usada apenas para depuração por desenvolvedores. A configuração pode mudar no futuro de maneiras incompatíveis com versões anteriores ou ser removida.
Valores possíveis:
* 0 - Desabilita
* 1 - Habilita
## query\_plan\_remove\_unused\_columns
Ativa ou desativa uma otimização no nível do plano de consulta que tenta remover colunas não utilizadas (tanto de entrada quanto de saída) das etapas do plano de consulta.
Só surte efeito se a configuração [query\_plan\_enable\_optimizations](#query_plan_enable_optimizations) estiver definida como 1.
Esta é uma configuração de nível avançado que deve ser usada apenas para depuração por desenvolvedores. A configuração pode mudar no futuro de formas incompatíveis com versões anteriores ou ser removida.
Valores possíveis:
* 0 - Desabilita
* 1 - Habilita
## query\_plan\_reuse\_storage\_ordering\_for\_window\_functions
**Aliases**: `optimize_read_in_window_order`
Ativa ou desativa uma otimização no nível do plano de consulta que usa a ordenação do armazenamento ao ordenar funções de janela.
Só tem efeito se a configuração [`query_plan_enable_optimizations`](#query_plan_enable_optimizations) estiver definida como 1.
Esta é uma configuração de nível avançado que só deve ser usada para depuração por desenvolvedores. A configuração pode mudar no futuro de maneiras incompatíveis com versões anteriores ou ser removida.
Valores possíveis:
* 0 - Desabilita
* 1 - Habilita
## query\_plan\_split\_filter
Esta é uma configuração de nível avançado que deve ser usada apenas para depuração por desenvolvedores. A configuração pode mudar no futuro de formas incompatíveis com versões anteriores ou ser removida.
Ativa ou desativa uma otimização no nível do plano de consulta que divide filtros em expressões.
Só tem efeito se a configuração [query\_plan\_enable\_optimizations](#query_plan_enable_optimizations) estiver definida como 1.
Valores possíveis:
* 0 - Desabilita
* 1 - Habilita
## query\_plan\_text\_index\_add\_hint
Permite adicionar uma dica (predicado adicional) ao filtro gerado a partir do índice de texto invertido no plano de consulta.
## query\_plan\_top\_k\_through\_join
Ativa ou desativa uma otimização no nível do plano de consulta que propaga `ORDER BY ... LIMIT n` através de um join quando a chave de ordenação faz referência apenas a colunas do lado preservado pelo join (LEFT/RIGHT). Ela restringe quantas linhas a entrada do lado preservado deve produzir antes do join.
Só tem efeito se a configuração [query\_plan\_enable\_optimizations](#query_plan_enable_optimizations) for 1.
Valores possíveis:
* 0 - Desativar
* 1 - Ativar
## query\_plan\_try\_use\_vector\_search
Ativa ou desativa uma otimização no nível do plano de consulta que tenta usar o índice de similaridade vetorial.
Só tem efeito se a configuração [`query_plan_enable_optimizations`](#query_plan_enable_optimizations) for 1.
Esta é uma configuração de nível avançado que deve ser usada apenas para depuração por desenvolvedores. A configuração pode mudar no futuro de formas incompatíveis com versões anteriores ou ser removida.
Valores possíveis:
* 0 - Desabilitar
* 1 - Habilitar
## query\_profiler\_cpu\_time\_period\_ns
Define o período de um temporizador do clock da CPU do [profiler de consulta](/pt-BR/concepts/features/performance/troubleshoot/sampling-query-profiler). Esse temporizador contabiliza apenas o tempo de CPU.
Valores possíveis:
* Um número inteiro positivo de nanossegundos.
Valores recomendados:
* 10000000 (100 vezes por segundo) nanossegundos ou mais para consultas individuais.
* 1000000000 (uma vez por segundo) para profiling em todo o cluster.
* 0 para desativar o temporizador.
Veja também:
* Tabela de sistema [trace\_log](/pt-BR/reference/system-tables/trace_log)
## query\_profiler\_real\_time\_period\_ns
Define o período de um temporizador de tempo real do [profiler de consultas](/pt-BR/concepts/features/performance/troubleshoot/sampling-query-profiler). O temporizador de tempo real mede o tempo de relógio.
Valores possíveis:
* Número inteiro positivo, em nanossegundos.
Valores recomendados:
* 10000000 (100 vezes por segundo) nanossegundos ou menos para consultas individuais.
* 1000000000 (uma vez por segundo) para profiling em todo o cluster.
* 0 para desligar o temporizador.
Veja também:
* Tabela de sistema [trace\_log](/pt-BR/reference/system-tables/trace_log)
Valor padrão no Cloud: `3000000000`.
## queue\_max\_wait\_ms
O tempo de espera na fila de requisições, caso o número de requisições simultâneas exceda o máximo.
## rabbitmq\_max\_wait\_ms
O tempo de espera para ler do RabbitMQ antes de tentar novamente.
## read\_backoff\_max\_throughput
Configuração para reduzir o número de threads em caso de leituras lentas. Conta eventos quando a taxa de leitura for menor que essa quantidade de bytes por segundo.
## read\_backoff\_min\_concurrency
Configuração para tentar manter o número mínimo de threads em caso de leituras lentas.
## read\_backoff\_min\_events
Configuração para reduzir o número de threads em caso de leituras lentas. Número de eventos após o qual o número de threads será reduzido.
## read\_backoff\_min\_interval\_between\_events\_ms
Configuração para reduzir o número de threads em caso de leituras lentas. Ignore o evento se o anterior tiver ocorrido há menos de um determinado intervalo de tempo.
## read\_backoff\_min\_latency\_ms
Configuração para reduzir o número de threads em caso de leituras lentas. Considere apenas as leituras que levaram pelo menos esse tempo.
## read\_from\_distributed\_cache\_if\_exists\_otherwise\_bypass\_cache
Só tem efeito no ClickHouse Cloud. É o mesmo que read\_from\_filesystem\_cache\_if\_exists\_otherwise\_bypass\_cache, mas para o distributed cache.
## read\_from\_filesystem\_cache\_if\_exists\_otherwise\_bypass\_cache
Permite usar o cache do sistema de arquivos em modo passivo — aproveitar as entradas de cache já existentes, mas sem adicionar novas entradas ao cache. Se você definir essa configuração para consultas ad hoc pesadas e deixá-la desabilitada para consultas curtas em tempo real, isso ajudará a evitar o esgotamento do cache por consultas muito pesadas e a melhorar a eficiência geral do sistema.
## read\_from\_page\_cache\_if\_exists\_otherwise\_bypass\_cache
Use o cache de páginas no espaço do usuário no modo passivo, semelhante a read\_from\_filesystem\_cache\_if\_exists\_otherwise\_bypass\_cache.
## read\_in\_order\_two\_level\_merge\_threshold
Número mínimo de partes que precisam ser lidas para executar a etapa de mesclagem preliminar durante a leitura multithread na ordem da chave primária.
## read\_in\_order\_use\_buffering
Usar bufferização antes da mesclagem ao ler seguindo a ordem da chave primária. Isso aumenta o paralelismo da execuçã
## read\_in\_order\_use\_virtual\_row
Usa linha virtual ao ler na ordem da chave primária ou de sua função monotônica. Isso é útil ao pesquisar em várias partes, pois apenas as relevantes são acessadas.
## read\_in\_order\_use\_virtual\_row\_per\_block
Quando ativado junto com `read_in_order_use_virtual_row`, emite uma linha virtual após cada bloco lido (não apenas no início de cada parte).
Isso permite que `MergingSortedTransform` repriorize as fontes com mais frequência, o que é útil quando filtros posteriores descartam muitas linhas e os dados estão distribuídos de forma desigual entre as partes.
Observe que isso desativa a otimização `read_in_order_use_buffering` e a mesclagem preliminar (`read_in_order_two_level_merge_threshold`) para leitura.
## read\_overflow\_mode
O que fazer quando o limite é excedido.
## read\_overflow\_mode\_leaf
Define o que acontece quando o volume de dados lidos excede um dos limites no leaf.
Opções possíveis:
* `throw`: gera uma exceção (padrão).
* `break`: interrompe a execução da consulta e retorna o resultado parcial.
## read\_priority
Prioridade para ler dados do sistema de arquivos local ou do sistema de arquivos remoto. Suportado apenas com o método 'pread\_threadpool' para sistema de arquivos local e com o método `threadpool` para sistema de arquivos remoto.
## read\_through\_distributed\_cache
Tem efeito apenas no ClickHouse Cloud. Permite a leitura do cache distribuído
## readonly
0 - sem restrições de leitura. 1 - apenas solicitações de leitura, bem como a alteração de configurações explicitamente permitidas. 2 - apenas solicitações de leitura, bem como a alteração de configurações, exceto da configuração 'readonly'.
## receive\_data\_timeout\_ms
Tempo limite da conexão para receber o primeiro pacote de dados ou um pacote com progresso positivo da réplica
## receive\_timeout
Tempo limite para receber dados pela rede, em segundos. Se nenhum byte for recebido nesse intervalo, uma exceção será gerada. Se você definir essa configuração no cliente, o 'send\_timeout' do socket também será definido na extremidade correspondente da conexão no servidor.
## recursive\_cte\_max\_steps\_in\_type\_inference
Número máximo de iterações para inferir tipos de coluna em CTEs recursivas. Os tipos de coluna são determinados pela aplicação iterativa de `getLeastSupertype` aos lados não recursivo e recursivo da UNION ALL até haver convergência. Defina como 0 para desativar o alargamento de tipos e usar apenas os tipos da parte não recursiva.
## regexp\_dict\_allow\_hyperscan
Permite que o dicionário `regexp_tree` use a biblioteca Hyperscan.
## regexp\_dict\_flag\_case\_insensitive
Usa correspondência sem diferenciar maiúsculas de minúsculas para um Dicionário regexp\_tree. Pode ser sobrescrita em expressões individuais com (?i) e (?-i).
## regexp\_dict\_flag\_dotall
Permite que '.' corresponda a caracteres de quebra de linha em um dicionário regexp\_tree.
## regexp\_max\_matches\_per\_row
Define o número máximo de correspondências de uma única expressão regular por linha. Use isso para evitar sobrecarga de memória ao usar uma expressão regular gulosa na função [extractAllGroupsHorizontal](/pt-BR/reference/functions/regular-functions/string-search-functions#extractAllGroupsHorizontal).
Possíveis valores:
* Inteiro positivo.
## reject\_expensive\_hyperscan\_regexps
Rejeita padrões cuja avaliação com hyperscan provavelmente será custosa (devido à explosão de estados do NFA)
## remerge\_sort\_lowered\_memory\_bytes\_ratio
Se o uso de memória após o remerge não for reduzido nessa proporção, o remerge será desativado.
## remote\_filesystem\_read\_method
Método de leitura de dados do filesystem remoto; um dos seguintes: read, threadpool.
## remote\_filesystem\_read\_prefetch
Deve usar pré-busca ao ler dados do sistema de arquivos remoto.
## remote\_fs\_read\_backoff\_max\_tries
Número máximo de tentativas de leitura com backoff
## remote\_fs\_read\_max\_backoff\_ms
Tempo máximo de espera ao tentar ler dados de um disco remoto
## remote\_read\_min\_bytes\_for\_seek
Número mínimo de bytes necessário para que a leitura remota (url, s3) faça seek, em vez de ler com ignore.
## rename\_files\_after\_processing
* **Tipo:** String
* **Valor padrão:** String vazia
Esta configuração permite especificar um padrão de renomeação para arquivos processados pela função de tabela `file`. Quando a opção é definida, todos os arquivos lidos pela função de tabela `file` serão renomeados de acordo com o padrão especificado com placeholders, somente se o processamento dos arquivos for bem-sucedido.
### Marcadores substitutos
* `%a` — Nome completo do arquivo original (por exemplo, "sample.csv").
* `%f` — Nome do arquivo original sem extensão (por exemplo, "sample").
* `%e` — Extensão original do arquivo, com ponto (por exemplo, ".csv").
* `%t` — Timestamp (em microssegundos).
* `%%` — Sinal de porcentagem ("%").
### Exemplo
* Opção: `--rename_files_after_processing="processed_%f_%t%e"`
* Consulta: `SELECT * FROM file('sample.csv')`
Se a leitura de `sample.csv` for concluída com sucesso, o arquivo será renomeado para `processed_sample_1683473210851438.csv`
## replace\_running\_query
Ao usar a interface HTTP, o parâmetro 'query\_id' pode ser informado. Ele pode ser qualquer string que sirva como identificador da consulta.
Se já existir uma consulta do mesmo usuário com o mesmo 'query\_id', o comportamento dependerá do parâmetro 'replace\_running\_query'.
`0` (padrão) – Gerar uma exceção (não permitir que a consulta seja executada se já houver uma consulta com o mesmo 'query\_id' em execução).
`1` – Cancelar a consulta antiga e iniciar a nova.
Defina este parâmetro como 1 para implementar sugestões de condições de segmentação. Ao digitar o próximo caractere, se a consulta antiga ainda não tiver terminado, ela deverá ser cancelada.
## replace\_running\_query\_max\_wait\_ms
O tempo de espera para que a consulta com o mesmo `query_id` em execução termine, quando a configuração [replace\_running\_query](#replace_running_query) está ativa.
Valores possíveis:
* Inteiro positivo.
* 0 — Lança uma exceção que não permite executar uma nova consulta se o servidor já estiver executando uma consulta com o mesmo `query_id`.
## replication\_wait\_for\_inactive\_replica\_timeout
Especifica por quanto tempo (em segundos) deve-se aguardar que réplicas inativas executem as consultas [`ALTER`](/pt-BR/reference/statements/alter), [`OPTIMIZE`](/pt-BR/reference/statements/optimize) ou [`TRUNCATE`](/pt-BR/reference/statements/truncate).
Valores possíveis:
* `0` — Não aguardar.
* Inteiro negativo — Aguarda por tempo ilimitado.
* Inteiro positivo — Número de segundos de espera.
## restore\_replace\_external\_dictionary\_source\_to\_null
Substitui fontes externas de dicionário por Null durante a restauração. Útil para testes
## restore\_replace\_external\_engines\_to\_null
Apenas para testes. Substitui todos os motores externos por Null para evitar o início de conexões externas.
## restore\_replace\_external\_table\_functions\_to\_null
Para fins de teste. Substitui todas as funções de tabela externas por Null para evitar iniciar conexões externas.
## restore\_replicated\_merge\_tree\_to\_shared\_merge\_tree
Substitui o mecanismo de tabela de Replicated*MergeTree -> Shared*MergeTree durante o RESTORE.
Valor padrão no Cloud: `1`.
## result\_overflow\_mode
Valor padrão no Cloud: `throw`
Define o que fazer se o volume do resultado exceder um dos limites.
Valores possíveis:
* `throw`: lançar uma exceção (padrão).
* `break`: interromper a execução da consulta e retornar o resultado parcial, como se os
dados de origem tivessem se esgotado.
Usar 'break' é semelhante a usar LIMIT. `Break` interrompe a execução apenas no
nível do bloco. Isso significa que a quantidade de linhas retornadas será maior que
[`max_result_rows`](/pt-BR/reference/settings/session-settings#max_result_rows), será um múltiplo de [`max_block_size`](/pt-BR/reference/settings/session-settings#max_block_size)
e dependerá de [`max_threads`](/pt-BR/reference/settings/session-settings#max_threads).
**Exemplo**
```sql title="Query" theme={null}
SET max_threads = 3, max_block_size = 3333;
SET max_result_rows = 3334, result_overflow_mode = 'break';
SELECT *
FROM numbers_mt(100000)
FORMAT Null;
```
```text title="Result" theme={null}
6666 rows in set. ...
```
## rewrite\_count\_distinct\_if\_with\_count\_distinct\_implementation
Permite reescrever `countDistcintIf` usando a configuração [count\_distinct\_implementation](#count_distinct_implementation).
Valores possíveis:
* true — Permitir.
* false — Não permitir.
## rewrite\_in\_to\_join
Reescreve expressões como 'x IN subconsulta' para JOIN. Isso pode ser útil para otimizar toda a consulta com reordenação de JOINs.
## rows\_before\_aggregation
Quando ativada, o ClickHouse fornecerá o valor exato da estatística rows\_before\_aggregation, que representa o número de linhas lidas antes da agregaçã
## s3\_allow\_multipart\_copy
Permite cópia em múltiplas partes no S3.
## s3\_allow\_parallel\_part\_upload
Usa várias threads para upload multipart no S3. Isso pode resultar em uso de memória ligeiramente maior
## s3\_check\_objects\_after\_upload
Verifique cada objeto enviado ao S3 com uma requisição HEAD para garantir que o upload foi bem-sucedido
## s3\_connect\_timeout\_ms
Tempo limite da conexão com o host dos disks S3.
## s3\_create\_new\_file\_on\_insert
Habilita ou desabilita a criação de um novo arquivo a cada inserção em tabelas com engine S3. Se estiver habilitado, a cada inserção será criado um novo objeto no S3 com a chave, seguindo um padrão como este:
inicial: `data.Parquet.gz` -> `data.1.Parquet.gz` -> `data.2.Parquet.gz`, etc.
Valores possíveis:
* 0 — a consulta `INSERT` cria um novo arquivo ou falha se o arquivo já existir e `s3_truncate_on_insert` não estiver definido.
* 1 — a consulta `INSERT` cria um novo arquivo a cada inserção, usando um sufixo (a partir do segundo), se `s3_truncate_on_insert` não estiver definido.
Veja mais detalhes [aqui](/pt-BR/integrations/connectors/data-ingestion/AWS/integrating-s3-with-clickhouse#inserting-data).
## s3\_disable\_checksum
Não calcule um checksum ao enviar um arquivo para o S3. Isso acelera as gravações ao evitar etapas excessivas de processamento do arquivo. Em geral, isso é seguro, pois os dados das tabelas MergeTree já têm checksum calculado pelo ClickHouse de qualquer forma e, quando o S3 é acessado via HTTPS, a camada TLS já fornece integridade durante a transferência pela rede. Embora checksums adicionais no S3 ofereçam uma defesa em profundidade.
## s3\_ignore\_file\_doesnt\_exist
Ignore a ausência do arquivo caso ele não exista ao ler determinadas chaves.
Valores possíveis:
* 1 — `SELECT` retorna um resultado vazio.
* 0 — `SELECT` lança uma exceção.
## s3\_list\_object\_keys\_size
Número máximo de arquivos que podem ser retornados em um lote pela solicitação ListObject
## s3\_max\_connections
O número máximo de conexões por servidor.
## s3\_max\_get\_burst
Número máximo de solicitações que podem ser emitidas simultaneamente antes de atingir o limite de solicitações por segundo. Por padrão, (0) equivale a `s3_max_get_rps`
## s3\_max\_get\_rps
Limite da taxa de solicitações GET para o S3 por segundo antes do throttling. Zero significa ilimitado.
## s3\_max\_inflight\_parts\_for\_one\_file
O número máximo de partes carregadas simultaneamente em uma solicitação de upload multipart. 0 significa ilimitado.
## s3\_max\_part\_number
Número máximo de partes no upload em partes para o S3.
## s3\_max\_put\_burst
Número máximo de solicitações que podem ser feitas simultaneamente antes de atingir o limite de solicitações por segundo. Por padrão (0), equivale a `s3_max_put_rps`
## s3\_max\_put\_rps
Limite da taxa de requisições PUT no S3 por segundo antes da aplicação de throttling. Zero significa ilimitado.
## s3\_max\_single\_operation\_copy\_size
Tamanho máximo para uma operação única de cópia no S3. Esta configuração é usada apenas se s3\_allow\_multipart\_copy for true.
## s3\_max\_single\_part\_upload\_size
O tamanho máximo do objeto para upload em uma única parte no S3.
## s3\_max\_single\_read\_retries
O número máximo de tentativas durante uma única leitura do S3.
## s3\_max\_unexpected\_write\_error\_retries
O número máximo de tentativas em caso de erros inesperados durante a gravação no S3.
## s3\_max\_upload\_part\_size
O tamanho máximo da parte a ser carregada durante um upload multiparte para o S3.
## s3\_min\_upload\_part\_size
O tamanho mínimo da parte a ser enviada durante um upload multipart para o S3.
## s3\_path\_filter\_limit
Número máximo de valores de `_path` que podem ser extraídos dos filtros da consulta para serem usados na iteração de arquivos
em vez da listagem com glob. 0 significa desativado.
## s3\_request\_timeout\_ms
Tempo limite de inatividade para envio e recebimento de dados de/para o S3. A operação falhará se uma única chamada TCP de leitura ou gravação ficar bloqueada por esse período.
## s3\_skip\_empty\_files
Ativa ou desativa o ignoramento de arquivos vazios em tabelas do motor [S3](/pt-BR/reference/engines/table-engines/integrations/s3).
Valores possíveis:
* 0 — `SELECT` gera uma exceção se o arquivo vazio não for compatível com o formato solicitado.
* 1 — `SELECT` retorna um resultado vazio para um arquivo vazio.
## s3\_slow\_all\_threads\_after\_network\_error
Quando definido como `true`, todas as threads que executam requisições ao S3 para o mesmo endpoint de backup ficam mais lentas
depois que qualquer requisição individual ao S3 encontra um erro de rede passível de nova tentativa, como timeout de socket.
Quando definido como `false`, cada thread lida com o backoff das requisições ao S3 de forma independente das demais.
## s3\_strict\_upload\_part\_size
O tamanho exato da parte a ser enviada durante o upload multiparte para o S3 (algumas implementações não oferecem suporte a partes com tamanho variável).
## s3\_throw\_on\_zero\_files\_match
Gerar um erro quando a solicitação ListObjects não encontrar nenhum arquivo
## s3\_truncate\_on\_insert
Habilita ou desabilita o truncamento antes das inserções em tabelas com engine S3. Se estiver desabilitado, uma exceção será lançada nas tentativas de inserção caso um objeto S3 já exista.
Valores possíveis:
* 0 — a consulta `INSERT` cria um novo arquivo ou falha se o arquivo já existir e `s3_create_new_file_on_insert` não estiver definido.
* 1 — a consulta `INSERT` substitui o conteúdo existente do arquivo pelos novos dados.
Veja mais detalhes [aqui](/pt-BR/integrations/connectors/data-ingestion/AWS/integrating-s3-with-clickhouse#inserting-data).
## s3\_upload\_part\_size\_multiply\_factor
Multiplique `s3_min_upload_part_size` por este fator sempre que `s3_multiply_parts_count_threshold` partes forem enviadas em uma única gravação no S3.
## s3\_upload\_part\_size\_multiply\_parts\_count\_threshold
Sempre que essa quantidade de partes for enviada ao S3, `s3_min_upload_part_size` será multiplicado por `s3_upload_part_size_multiply_factor`.
## s3\_uri\_style
Força o estilo de endpoint do S3. Valores possíveis: auto, virtual\_hosted, path.
## s3\_use\_adaptive\_timeouts
Quando definido como `true`, para todas as requisições ao S3, as duas primeiras tentativas são feitas com timeouts de envio e recebimento baixos.
Quando definido como `false`, todas as tentativas são feitas com os mesmos timeouts.
## s3\_validate\_request\_settings
Ativa a validação das configurações de requisição do S3.
Valores possíveis:
* 1 — validar as configurações.
* 0 — não validar as configurações.
## s3queue\_default\_zookeeper\_path
Prefixo padrão do caminho no ZooKeeper para o mecanismo S3Queue
## s3queue\_enable\_logging\_to\_s3queue\_log
Habilita a gravação em system.s3queue\_log. O valor pode ser substituído para cada tabela por meio das configurações da tabela
## s3queue\_keeper\_fault\_injection\_probability
Probabilidade de injeção de falha no Keeper para o S3Queue.
## s3queue\_migrate\_old\_metadata\_to\_buckets
Migra a estrutura antiga de metadados da tabela S3Queue para uma nova
## schema\_inference\_cache\_require\_modification\_time\_for\_url
Usa o schema do cache para URL com validação do horário da última modificação (para URLs com cabeçalho Last-Modified)
## schema\_inference\_use\_cache\_for\_azure
Usa cache na inferência de esquema ao usar a função de tabela do Azure
## schema\_inference\_use\_cache\_for\_file
Use o cache na inferência de esquema ao usar a função de tabela file
## schema\_inference\_use\_cache\_for\_hdfs
Usa cache na inferência de esquema ao usar a função de tabela hdfs
## schema\_inference\_use\_cache\_for\_s3
Usa cache na inferência de esquema ao usar a função de tabela S3
## schema\_inference\_use\_cache\_for\_url
Use o cache na inferência de esquema ao usar a função de tabela url
## secondary\_indices\_enable\_bulk\_filtering
Habilita o algoritmo de filtragem em lote para índices. A expectativa é que ele seja sempre superior, mas esta configuração existe por motivos de compatibilidade e controle.
## select\_sequential\_consistency
O comportamento dessa configuração difere entre SharedMergeTree e ReplicatedMergeTree; consulte [SharedMergeTree consistency](/pt-BR/products/cloud/features/infrastructure/shared-merge-tree#consistency) para mais informações sobre o comportamento de `select_sequential_consistency` no SharedMergeTree.
Ativa ou desativa a consistência sequencial para consultas `SELECT`. Exige que `insert_quorum_parallel` esteja desativado (embora seja ativado por padrão).
Valores possíveis:
* 0 — Desativado.
* 1 — Ativado.
Uso
Quando a consistência sequencial está ativada, o ClickHouse permite que o cliente execute a consulta `SELECT` apenas nas réplicas que contêm dados de todas as consultas `INSERT` anteriores executadas com `insert_quorum`. Se o cliente acessar uma réplica parcial, o ClickHouse gerará uma exceção. A consulta `SELECT` não incluirá dados que ainda não tenham sido gravados no quórum de réplicas.
Quando `insert_quorum_parallel` está ativado (o padrão), `select_sequential_consistency` não funciona. Isso ocorre porque consultas `INSERT` paralelas podem ser gravadas em diferentes conjuntos de réplicas de quórum, portanto não há garantia de que uma única réplica tenha recebido todas as gravações.
Veja também:
* [insert\_quorum](#insert_quorum)
* [insert\_quorum\_timeout](#insert_quorum_timeout)
* [insert\_quorum\_parallel](#insert_quorum_parallel)
## send\_logs\_level
Envia logs de texto do servidor ao cliente com o nível mínimo especificado. Valores válidos: 'trace', 'debug', 'information', 'warning', 'error', 'fatal', 'none'
## send\_logs\_source\_regexp
Envia logs de texto do servidor com a regexp especificada para corresponder ao nome da origem do log. Vazio significa todas as origens.
## send\_profile\_events
Habilita ou desabilita o envio de pacotes de [ProfileEvents](/pt-BR/resources/develop-contribute/native-protocol/server#profile-events) para o cliente.
Isso pode ser desabilitado para reduzir o tráfego de rede de clientes que não precisam de eventos de perfil.
Valores possíveis:
* 0 — Desabilitado.
* 1 — Habilitado.
Ativa ou desativa os cabeçalhos de resposta HTTP `X-ClickHouse-Progress` nas respostas do `clickhouse-server`.
Para mais informações, leia a [descrição da interface HTTP](/pt-BR/concepts/features/interfaces/http).
Valores possíveis:
* 0 — Desativado.
* 1 — Ativado.
## send\_table\_structure\_on\_insert\_with\_inline\_data
Se estiver desativada e a consulta INSERT contiver dados inline, o servidor não enviará de volta ao cliente, pelo protocolo nativo, a estrutura da tabela nem os valores padrão das colunas. Em vez disso, o próprio servidor analisará os dados inline. Isso pode melhorar o desempenho de muitas inserções pequenas pelo protocolo nativo.
## send\_timeout
Tempo limite, em segundos, para enviar dados pela rede. Se um cliente precisar enviar dados, mas não conseguir enviar nenhum byte dentro desse intervalo, uma exceção será lançada. Se você definir essa configuração no cliente, o `receive_timeout` do socket também será definido na extremidade correspondente da conexão no servidor.
## serialize\_query\_plan
Serializa o plano da consulta para processamento distribuído
## serialize\_string\_in\_memory\_with\_zero\_byte
Serializa valores String durante a agregação com um byte zero no final. Ative para manter a compatibilidade ao consultar um cluster com versões incompatíveis.
## session\_timezone
Define o fuso horário implícito da sessão ou consulta atual.
O fuso horário implícito é aplicado a valores do tipo DateTime/DateTime64 que não têm um fuso horário explicitamente especificado.
Essa configuração tem precedência sobre o fuso horário implícito configurado globalmente (no nível do servidor).
Um valor de '' (string vazia) significa que o fuso horário implícito da sessão ou consulta atual é igual ao [fuso horário do servidor](/pt-BR/reference/settings/server-settings/settings#timezone).
Você pode usar as funções `timeZone()` e `serverTimeZone()` para obter o fuso horário da sessão e o do servidor.
Valores possíveis:
* Qualquer nome de fuso horário de `system.time_zones`, por exemplo `Europe/Berlin`, `UTC` ou `Zulu`
Exemplos:
```sql theme={null}
SELECT timeZone(), serverTimeZone() FORMAT CSV
"Europe/Berlin","Europe/Berlin"
```
```sql theme={null}
SELECT timeZone(), serverTimeZone() SETTINGS session_timezone = 'Asia/Novosibirsk' FORMAT CSV
"Asia/Novosibirsk","Europe/Berlin"
```
Atribua o fuso horário da sessão 'America/Denver' ao DateTime interno sem especificar o fuso horário explicitamente:
```sql theme={null}
SELECT toDateTime64(toDateTime64('1999-12-12 23:23:23.123', 3), 3, 'Europe/Zurich') SETTINGS session_timezone = 'America/Denver' FORMAT TSV
1999-12-13 07:23:23.123
```
Nem todas as funções que fazem o parse de DateTime/DateTime64 respeitam `session_timezone`. Isso pode levar a erros sutis.
Veja o exemplo e a explicação a seguir.
```sql theme={null}
CREATE TABLE test_tz (`d` DateTime('UTC')) ENGINE = Memory AS SELECT toDateTime('2000-01-01 00:00:00', 'UTC');
SELECT *, timeZone() FROM test_tz WHERE d = toDateTime('2000-01-01 00:00:00') SETTINGS session_timezone = 'Asia/Novosibirsk'
0 rows in set.
SELECT *, timeZone() FROM test_tz WHERE d = '2000-01-01 00:00:00' SETTINGS session_timezone = 'Asia/Novosibirsk'
┌───────────────────d─┬─timeZone()───────┐
│ 2000-01-01 00:00:00 │ Asia/Novosibirsk │
└─────────────────────┴──────────────────┘
```
Isso acontece devido a diferentes pipelines de parsing:
* `toDateTime()` sem um fuso horário explicitamente especificado, usado na primeira consulta `SELECT`, respeita a configuração `session_timezone` e o fuso horário global.
* Na segunda consulta, um DateTime é parseado de uma String e herda o tipo e o fuso horário da coluna existente `d`. Assim, a configuração `session_timezone` e o fuso horário global não são respeitados.
**Veja também**
* [timezone](/pt-BR/reference/settings/server-settings/settings#timezone)
## set\_overflow\_mode
Define o que acontece quando a quantidade de dados excede um dos limites.
Valores possíveis:
* `throw`: gera uma exceção (padrão).
* `break`: interrompe a execução da consulta e retorna o resultado parcial, como se os
dados de origem tivessem se esgotado.
## shared\_merge\_tree\_sequential\_consistency\_initial\_parts\_update\_backoff\_ms
Backoff inicial, em milissegundos, para atualização das partes ao usar `select_sequential_consistency` com `SharedMergeTree`. Disponível apenas no ClickHouse Cloud.
## shared\_merge\_tree\_sequential\_consistency\_max\_parts\_update\_backoff\_ms
Backoff máximo, em milissegundos, para a atualização de partes ao usar `select_sequential_consistency` com `SharedMergeTree`. Disponível apenas no ClickHouse Cloud.
## shared\_merge\_tree\_sequential\_consistency\_parts\_update\_max\_retries
Número máximo de tentativas para atualizar partes ao usar `select_sequential_consistency` com `SharedMergeTree`. Disponível apenas no ClickHouse Cloud.
## shared\_merge\_tree\_sync\_parts\_on\_partition\_operations
Sincroniza automaticamente o conjunto de partes de dados após operações de partição MOVE|REPLACE|ATTACH em tabelas SMT. Apenas no Cloud
## short\_circuit\_function\_evaluation
Permite calcular as funções [if](/pt-BR/reference/functions/regular-functions/conditional-functions#if), [multiIf](/pt-BR/reference/functions/regular-functions/conditional-functions#multiIf), [and](/pt-BR/reference/functions/regular-functions/logical-functions#and) e [or](/pt-BR/reference/functions/regular-functions/logical-functions#or) de acordo com a [avaliação de curto-circuito](https://en.wikipedia.org/wiki/Short-circuit_evaluation). Isso ajuda a otimizar a execução de expressões complexas nessas funções e a evitar possíveis exceções (como divisão por zero quando isso não é esperado).
Valores possíveis:
* `enable` — Habilita a avaliação de curto-circuito para funções às quais ela se aplica (que podem lançar uma exceção ou ser computacionalmente pesadas).
* `force_enable` — Habilita a avaliação de curto-circuito para todas as funções.
* `disable` — Desabilita a avaliação de curto-circuito.
## short\_circuit\_function\_evaluation\_for\_nulls
Otimiza a avaliação de funções que retornam NULL quando qualquer argumento é NULL. Quando a porcentagem de valores NULL nos argumentos da função excede short\_circuit\_function\_evaluation\_for\_nulls\_threshold, o sistema deixa de avaliar a função linha por linha. Em vez disso, retorna NULL imediatamente para todas as linhas, evitando processamento desnecessário.
## short\_circuit\_function\_evaluation\_for\_nulls\_threshold
Limiar da proporção de valores NULL para que funções com argumentos Nullable sejam executadas apenas nas linhas em que todos os argumentos tenham valores não NULL. Aplica-se quando a configuração short\_circuit\_function\_evaluation\_for\_nulls está habilitada.
Quando a proporção de linhas com valores NULL em relação ao total de linhas excede esse limiar, essas linhas com valores NULL não são avaliadas.
## show\_data\_lake\_catalogs\_in\_system\_tables
Permite exibir catálogos do lago de dados nas tabelas do sistema.
## show\_processlist\_include\_internal
Mostra processos auxiliares internos na saída da consulta `SHOW PROCESSLIST`.
Os processos internos incluem recarregamentos de dicionários, recarregamentos de views materializadas atualizáveis, `SELECT`s auxiliares executados em consultas `SHOW ...`, consultas auxiliares `CREATE DATABASE ...` executadas internamente para lidar com tabelas corrompidas, entre outros.
## show\_table\_uuid\_in\_table\_create\_query\_if\_not\_nil
Define como a consulta `SHOW TABLE` é exibida.
Valores possíveis:
* 0 — A consulta será exibida sem o UUID da tabela.
* 1 — A consulta será exibida com o UUID da tabela.
## single\_join\_prefer\_left\_table
Para um único JOIN, em caso de ambiguidade de identificadores, prefira a tabela à esquerda
## skip\_redundant\_aliases\_in\_udf
Aliases redundantes não são usados (substituídos) em funções definidas pelo usuário, para simplificar o uso.
Valores possíveis:
* 1 — Os aliases são ignorados (substituídos) em UDFs.
* 0 — Os aliases não são ignorados (substituídos) em UDFs.
**Exemplo**
A diferença entre ativado e desativado:
Consulta:
```sql theme={null}
SET skip_redundant_aliases_in_udf = 0;
CREATE FUNCTION IF NOT EXISTS test_03274 AS ( x ) -> ((x + 1 as y, y + 2));
EXPLAIN SYNTAX SELECT test_03274(4 + 2);
```
Resultado:
```text theme={null}
SELECT ((4 + 2) + 1 AS y, y + 2)
```
Consulta:
```sql theme={null}
SET skip_redundant_aliases_in_udf = 1;
CREATE FUNCTION IF NOT EXISTS test_03274 AS ( x ) -> ((x + 1 as y, y + 2));
EXPLAIN SYNTAX SELECT test_03274(4 + 2);
```
Resultado:
```text theme={null}
SELECT ((4 + 2) + 1, ((4 + 2) + 1) + 2)
```
## skip\_unavailable\_shards
Ativa ou desativa a omissão silenciosa de shards indisponíveis.
Um shard é considerado indisponível se todas as suas réplicas estiverem indisponíveis. Uma réplica está indisponível nos seguintes casos:
* O ClickHouse não consegue se conectar à réplica por qualquer motivo.
Ao se conectar a uma réplica, o ClickHouse faz várias tentativas. Se todas elas falharem, a réplica será considerada indisponível.
* A réplica não pode ser resolvida por DNS.
Se o hostname da réplica não puder ser resolvido por DNS, isso pode indicar as seguintes situações:
* O host da réplica não tem um registro DNS. Isso pode ocorrer em sistemas com DNS dinâmico, por exemplo, [Kubernetes](https://kubernetes.io), em que os nós podem não ser resolvidos durante períodos de indisponibilidade, e isso não é um erro.
* Erro de configuração. O arquivo de configuração do ClickHouse contém um hostname incorreto.
Valores possíveis:
* 1 — omissão ativada.
Se um shard estiver indisponível, o ClickHouse retorna um resultado com base em dados parciais e não relata problemas de disponibilidade dos nós.
* 0 — omissão desativada.
Se um shard estiver indisponível, o ClickHouse gera uma exceção.
## sleep\_after\_receiving\_query\_ms
Tempo de espera após o recebimento da consulta no TCPHandler
## sleep\_in\_send\_data\_ms
Tempo de espera durante o envio de dados no TCPHandler
## sleep\_in\_send\_tables\_status\_ms
Tempo de espera para enviar a resposta de status das tabelas no TCPHandler
## sort\_overflow\_mode
Define o que acontece se o número de linhas recebidas antes da ordenação exceder algum dos limites.
Valores possíveis:
* `throw`: lançar uma exceção.
* `break`: interromper a execução da consulta e retornar o resultado parcial.
## split\_intersecting\_parts\_ranges\_into\_layers\_final
Divide intervalos de partes sobrepostos em camadas durante a otimização FINAL
## split\_parts\_ranges\_into\_intersecting\_and\_non\_intersecting\_final
Dividir intervalos de partes em sobrepostos e não sobrepostos durante a otimização FINAL
## splitby\_max\_substrings\_includes\_remaining\_string
Controla se a função [splitBy\*()](/pt-BR/reference/functions/regular-functions/splitting-merging-functions), com o argumento `max_substrings` > 0, incluirá a string restante no último elemento do array resultante.
Possible values:
* `0` - A string restante não será incluída no último elemento do array resultante.
* `1` - A string restante será incluída no último elemento do array resultante. Esse é o comportamento da função [`split()`](https://spark.apache.org/docs/3.1.2/api/python/reference/api/pyspark.sql.functions.split.html) do Spark e do método ['string.split()'](https://docs.python.org/3/library/stdtypes.html#str.split) do Python.
## stop\_refreshable\_materialized\_views\_on\_startup
Na inicialização do servidor, impede o agendamento de views materializadas atualizáveis, como se `SYSTEM STOP VIEWS` tivesse sido executado. Depois, você pode iniciá-las manualmente com `SYSTEM START VIEWS` ou `SYSTEM START VIEW `. Também se aplica a views criadas posteriormente. Não tem efeito sobre views materializadas não atualizáveis.
## storage\_file\_read\_method
Método de leitura de dados do arquivo de armazenamento, entre: `read`, `pread`, `mmap`. O método `mmap` não se aplica ao clickhouse-server (ele se destina ao clickhouse-local).
## storage\_system\_stack\_trace\_pipe\_read\_timeout\_ms
Tempo máximo para ler de um pipe e receber informações das threads ao consultar a tabela `system.stack_trace`. Essa configuração é usada para fins de teste e não deve ser alterada pelos usuários.
## stream\_flush\_interval\_ms
Aplica-se a tabelas com streaming em caso de timeout ou quando uma thread gera [max\_insert\_block\_size](#max_insert_block_size) linhas.
O valor padrão é 7500.
Quanto menor o valor, com mais frequência os dados são descarregados na tabela. Definir um valor muito baixo leva a um desempenho ruim.
## stream\_like\_engine\_allow\_direct\_select
Permite executar consultas SELECT diretamente nos motores Kafka, RabbitMQ, FileLog, Redis Streams, S3Queue, AzureQueue e NATS. Se houver visões materializadas anexadas, a consulta SELECT não será permitida, mesmo que essa configuração esteja habilitada.
Se não houver visões materializadas anexadas, habilitar essa configuração permite ler dados. Esteja ciente de que, normalmente, os dados lidos são removidos da fila. Para evitar a remoção dos dados lidos, as configurações relacionadas do motor devem ser definidas corretamente.
## stream\_like\_engine\_insert\_queue
Quando um mecanismo do tipo stream lê de várias filas, o usuário precisará selecionar em qual fila inserir ao gravar. Usado por Redis Streams e NATS.
## stream\_poll\_timeout\_ms
Tempo limite para fazer polling de dados de/para armazenamentos de streaming.
## system\_events\_show\_zero\_values
Permite selecionar eventos com valor zero de [`system.events`](/pt-BR/reference/system-tables/events).
Alguns sistemas de monitoramento exigem que todos os valores das métricas sejam enviados a cada coleta, mesmo que o valor da métrica seja zero.
Valores possíveis:
* 0 — Desabilitado.
* 1 — Habilitado.
**Exemplos**
Consulta
```sql theme={null}
SELECT * FROM system.events WHERE event='QueryMemoryLimitExceeded';
```
Resultado
```text theme={null}
Ok.
```
Consulta
```sql theme={null}
SET system_events_show_zero_values = 1;
SELECT * FROM system.events WHERE event='QueryMemoryLimitExceeded';
```
Resultado
```text theme={null}
┌─event────────────────────┬─value─┬─description───────────────────────────────────────────┐
│ QueryMemoryLimitExceeded │ 0 │ Number of times when memory limit exceeded for query. │
└──────────────────────────┴───────┴───────────────────────────────────────────────────────┘
```
## system\_metric\_log\_show\_zero\_values\_in\_histograms
Controla se dados de histograma com valor zero são gravados na coluna aninhada `histograms` de `system.metric_log`.
Por padrão, histogramas cuja `count` total de observações é zero são ignorados e, dentro de cada histograma emitido, as entradas de bucket sem observações também são omitidas do mapa `histogram`. Ative esta opção para gravar todos os histogramas e todos os buckets independentemente da contagem — útil para sistemas de monitoramento que exigem que toda métrica apareça em cada coleta.
Valores possíveis:
* 0 — Desativado. Histogramas com `count = 0` não são emitidos; os histogramas emitidos incluem apenas buckets que receberam pelo menos uma observação.
* 1 — Ativado. Todos os histogramas são gravados, e cada limite de bucket aparece em `histogram`.
## table\_engine\_read\_through\_distributed\_cache
Só tem efeito no ClickHouse Cloud. Permite a leitura do cache distribuído por meio de motores de tabela / funções de tabela (s3, azure, etc)
## table\_function\_remote\_max\_addresses
Define o número máximo de endereços gerados com base em padrões para a função [remote](/pt-BR/reference/functions/table-functions/remote).
Valores possíveis:
* Inteiro positivo.
## tcp\_keep\_alive\_timeout
Tempo, em segundos, que a conexão deve permanecer ociosa antes que o TCP comece a enviar sondas de keepalive
## temporary\_data\_in\_cache\_reserve\_space\_wait\_lock\_timeout\_milliseconds
Tempo de espera para adquirir o bloqueio do cache para reservar espaço para dados temporários no cache do sistema de arquivos
## temporary\_files\_buffer\_size
Tamanho do buffer dos gravadores de arquivos temporários. Um buffer maior significa menos chamadas de sistema, mas maior consumo de memória.
## temporary\_files\_codec
Define o codec de compressão para arquivos temporários usados em operações de ordenação e join no disco.
Valores possíveis:
* LZ4 — a compressão [LZ4](https://en.wikipedia.org/wiki/LZ4_\(compression_algorithm\)) é aplicada.
* NONE — nenhuma compressão é aplicada.
## text\_index\_hint\_max\_selectivity
Seletividade máxima do filtro para usar a dica gerada a partir do índice de texto invertido.
## text\_index\_like\_max\_postings\_to\_read
Número máximo de postings grandes a serem lidos quando a avaliação de LIKE do índice de texto por varredura de dicionário estiver habilitada.
Requer que `use_text_index_like_evaluation_by_dictionary_scan` esteja habilitado.
## text\_index\_like\_min\_pattern\_length
Comprimento mínimo do termo alfanumérico em um padrão LIKE/ILIKE necessário para usar a avaliação de LIKE do índice de texto por varredura de dicionário.
Padrões menores que esse limite correspondem a muitos tokens do dicionário e são ignorados para evitar varreduras custosas.
Exige que `use_text_index_like_evaluation_by_dictionary_scan` esteja habilitado.
## throw\_if\_no\_data\_to\_insert
Permite ou proíbe INSERTs vazios; está habilitado por padrão (gera um erro ao fazer um INSERT vazio). Aplica-se apenas a INSERTs que usam [`clickhouse-client`](/pt-BR/concepts/features/interfaces/cli) ou a [interface gRPC](/pt-BR/concepts/features/interfaces/grpc).
## throw\_on\_error\_from\_cache\_on\_write\_operations
Ignora o erro do cache durante o armazenamento em cache em operações de gravação (INSERT, merges)
## throw\_on\_max\_partitions\_per\_insert\_block
Permite controlar o comportamento quando `max_partitions_per_insert_block` é atingido.
Valores possíveis:
* `true` - Quando um bloco de inserção atinge `max_partitions_per_insert_block`, uma exceção é lançada.
* `false` - Registra um aviso quando `max_partitions_per_insert_block` é atingido.
Isso pode ser útil se você estiver tentando entender o impacto para os usuários ao alterar [`max_partitions_per_insert_block`](/pt-BR/reference/settings/session-settings#max_partitions_per_insert_block).
## throw\_on\_unsupported\_query\_inside\_transaction
Lança uma exceção se uma consulta sem suporte for usada dentro de uma transação
## timeout\_before\_checking\_execution\_speed
Verifica se a velocidade de execução não está muito baixa (não inferior a `min_execution_speed`)
depois de decorrido o tempo especificado em segundos.
## timeout\_overflow\_mode
Define o que fazer se a consulta demorar mais que `max_execution_time` para ser executada ou se o
tempo estimado de execução for maior que `max_estimated_execution_time`.
Valores possíveis:
* `throw`: lançar uma exceção (padrão).
* `break`: interromper a execução da consulta e retornar o resultado parcial, como se os
dados de origem tivessem se esgotado.
## timeout\_overflow\_mode\_leaf
Define o que acontece quando a consulta em um nó folha é executada por mais tempo do que `max_execution_time_leaf`.
Valores possíveis:
* `throw`: lança uma exceção (padrão).
* `break`: interrompe a execução da consulta e retorna o resultado parcial, como se os
dados de origem tivessem se esgotado.
## totals\_auto\_threshold
O limite para `totals_mode = 'auto'`.
Consulte a seção "modificador WITH TOTALS".
## totals\_mode
Como calcular TOTALS quando há HAVING, bem como quando max\_rows\_to\_group\_by e group\_by\_overflow\_mode = 'any' estão definidos.
Consulte a seção "modificador WITH TOTALS".
## trace\_profile\_events
Habilita ou desabilita a coleta de stacktraces a cada atualização dos eventos de perfil, juntamente com o nome do evento de perfil e o valor do incremento, bem como seu envio para [trace\_log](/pt-BR/reference/system-tables/trace_log).
Valores possíveis:
* 1 — Rastreamento de eventos de perfil habilitado.
* 0 — Rastreamento de eventos de perfil desabilitado.
## trace\_profile\_events\_list
Quando a configuração `trace_profile_events` estiver habilitada, limite os eventos rastreados à lista especificada de nomes separados por vírgula.
Se `trace_profile_events_list` for uma string vazia (o padrão), rastreie todos os profile events.
Valor de exemplo: 'DiskS3ReadMicroseconds,DiskS3ReadRequestsCount,SelectQueryTimeMicroseconds,ReadBufferFromS3Bytes'
O uso dessa configuração permite coletar dados com mais precisão para um grande número de consultas, pois, caso contrário, o grande volume de eventos pode causar overflow na fila interna de logs do sistema, e parte deles será descartada.
## transfer\_overflow\_mode
Define o que acontece quando a quantidade de dados excede um dos limites.
Valores possíveis:
* `throw`: lança uma exceção (padrão).
* `break`: interrompe a execução da consulta e retorna o resultado parcial, como se os
dados de origem tivessem acabado.
## transform\_null\_in
Habilita a igualdade entre valores [NULL](/pt-BR/reference/syntax#null) para o operador [IN](/pt-BR/reference/statements/in).
Por padrão, valores `NULL` não podem ser comparados, porque `NULL` significa um valor indefinido. Assim, a comparação `expr = NULL` deve sempre retornar `false`. Com essa configuração, `NULL = NULL` retorna `true` para o operador `IN`.
Valores possíveis:
* 0 — A comparação entre valores `NULL` no operador `IN` retorna `false`.
* 1 — A comparação entre valores `NULL` no operador `IN` retorna `true`.
**Exemplo**
Considere a tabela `null_in`:
```text theme={null}
┌──idx─┬─────i─┐
│ 1 │ 1 │
│ 2 │ NULL │
│ 3 │ 3 │
└──────┴───────┘
```
Consulta:
```sql theme={null}
SELECT idx, i FROM null_in WHERE i IN (1, NULL) SETTINGS transform_null_in = 0;
```
Resultado:
```text theme={null}
┌──idx─┬────i─┐
│ 1 │ 1 │
└──────┴──────┘
```
Consulta:
```sql theme={null}
SELECT idx, i FROM null_in WHERE i IN (1, NULL) SETTINGS transform_null_in = 1;
```
Resultado:
```text theme={null}
┌──idx─┬─────i─┐
│ 1 │ 1 │
│ 2 │ NULL │
└──────┴───────┘
```
**Veja também**
* [Processamento de NULL em operadores IN](/pt-BR/reference/statements/in#null-processing)
## traverse\_shadow\_remote\_data\_paths
Percorre também os dados congelados (diretório shadow), além dos dados da tabela propriamente dita, ao consultar system.remote\_data\_paths
## union\_default\_mode
Define um modo para combinar os resultados da consulta `SELECT`. A configuração é usada apenas com [UNION](/pt-BR/reference/statements/select/union) quando `UNION ALL` ou `UNION DISTINCT` não são especificados explicitamente.
Valores possíveis:
* `'DISTINCT'` — o ClickHouse retorna linhas como resultado da combinação de consultas, removendo linhas duplicadas.
* `'ALL'` — o ClickHouse retorna todas as linhas como resultado da combinação de consultas, incluindo linhas duplicadas.
* `''` — o ClickHouse gera uma exceção quando usado com `UNION`.
Veja exemplos em [UNION](/pt-BR/reference/statements/select/union).
## unknown\_packet\_in\_send\_data
Enviar pacote desconhecido em vez do enésimo pacote de dados
## update\_parallel\_mode
Determina o comportamento de consultas `UPDATE` simultâneas.
Valores possíveis:
* `sync` - executa todas as consultas `UPDATE` sequencialmente.
* `auto` - executa sequencialmente apenas as consultas `UPDATE` com dependências entre colunas atualizadas em uma consulta e colunas usadas em expressões de outra consulta.
* `async` - não sincroniza as consultas `UPDATE`.
## update\_sequential\_consistency
Se true, o conjunto de partes é atualizado para a versão mais recente antes da execução da atualização.
## url\_base
A URL base usada para resolver URLs relativas na função de tabela [url](/pt-BR/reference/functions/table-functions/url) e no motor de tabela [URL](/pt-BR/reference/engines/table-engines/special/url).
Quando definida, as URLs relativas são resolvidas da seguinte forma:
* URL relativa ao caminho (por exemplo, `data.csv`): combinada com o caminho da URL base de acordo com a RFC 3986. Tudo após a última `/` no caminho base é substituído pela URL relativa, portanto a barra final faz diferença: `https://example.com/dir/` + `data.csv` = `https://example.com/dir/data.csv`, mas `https://example.com/dir` + `data.csv` = `https://example.com/data.csv`. Se a base não tiver caminho (por exemplo, `https://example.com`), uma `/` é inserida: `https://example.com/data.csv`. Segmentos de ponto (`./` e `../`) na URL relativa são normalizados: `https://example.com/dir/` + `../a.csv` = `https://example.com/a.csv`.
* URL relativa ao host (por exemplo, `/test/data.csv`): resolvida com base no esquema e no host da URL base.
* URL relativa ao esquema (por exemplo, `//other.com/test/data.csv`): resolvida usando o esquema da URL base.
* Referência apenas de consulta (por exemplo, `?x=1`): anexada ao caminho da URL base (substituindo qualquer consulta/fragmento existente).
* Referência apenas de fragmento (por exemplo, `#frag`): anexada à URL base, preservando qualquer string de consulta (substituindo qualquer fragmento existente).
* Referência vazia: retorna a URL base sem fragmento.
Por exemplo, se `url_base` for `https://example.com/def/`, então:
* `data.csv` é resolvido para `https://example.com/def/data.csv`
* `/test/data.csv` é resolvido para `https://example.com/test/data.csv`
* `//other.com/test/data.csv` é resolvido para `https://other.com/test/data.csv`
## use\_async\_executor\_for\_materialized\_views
Permite a execução assíncrona e potencialmente multithread da consulta da visão materializada, o que pode acelerar o processamento das visões materializadas durante o INSERT, mas também consumir mais memória.
## use\_cache\_for\_count\_from\_files
Habilita o cache do número de linhas durante a contagem em arquivos nas funções de tabela `file`/`s3`/`url`/`hdfs`/`azureBlobStorage`.
Habilitado por padrão.
## use\_client\_time\_zone
Use o fuso horário do cliente para interpretar valores DateTime em formato de string, em vez de usar o fuso horário do servidor.
## use\_compact\_format\_in\_distributed\_parts\_names
Usa o formato compacto para armazenar blocos para INSERT em segundo plano (`distributed_foreground_insert`) em tabelas com engine `Distributed`.
Valores possíveis:
* 0 — Usa o formato de diretório `user[:password]@host:port#default_database`.
* 1 — Usa o formato de diretório `[shard{shard_index}[_replica{replica_index}]]`.
- com `use_compact_format_in_distributed_parts_names=0`, alterações na definição do cluster não serão aplicadas ao INSERT em segundo plano.
- com `use_compact_format_in_distributed_parts_names=1`, alterar a ordem dos nós na definição do cluster mudará o `shard_index`/`replica_index`, portanto tenha isso em mente.
## use\_concurrency\_control
Respeita o controle de concorrência do servidor (consulte as configurações globais `concurrent_threads_soft_limit_num` e `concurrent_threads_soft_limit_ratio_to_cores` do servidor). Se estiver desabilitado, permite usar um número maior de threads mesmo que o servidor esteja sobrecarregado (não é recomendado para uso normal e é necessário principalmente para testes).
Valor padrão no Cloud: `0`.
## use\_hash\_table\_stats\_for\_join\_reordering
Ativa o uso das estatísticas coletadas da tabela hash para estimativa de cardinalidade durante a reordenação de junções
## use\_hedged\_requests
Ativa a lógica de hedged requests para consultas remotas. Isso permite estabelecer várias conexões com diferentes réplicas para uma consulta.
Uma nova conexão é ativada caso a(s) conexão(ões) existente(s) com a(s) réplica(s) não tenha(m) sido estabelecida(s) dentro de `hedged_connection_timeout`
ou nenhum dado tenha sido recebido dentro de `receive_data_timeout`. A consulta usa a primeira conexão que envia um pacote de progresso não vazio (ou um pacote de dados, se `allow_changing_replica_until_first_data_packet`);
as demais conexões são canceladas. Há suporte para consultas com `max_parallel_replicas > 1`.
Ativado por padrão.
Valor padrão no Cloud: `0`.
## use\_hive\_partitioning
Quando habilitada, o ClickHouse detectará o particionamento no estilo Hive no caminho (`/name=value/`) em motores de tabela semelhantes a arquivos [File](/pt-BR/reference/functions/table-functions/file#hive-style-partitioning)/[S3](/pt-BR/reference/functions/table-functions/s3#hive-style-partitioning)/[URL](/pt-BR/reference/functions/table-functions/url#hive-style-partitioning)/[HDFS](/pt-BR/reference/functions/table-functions/hdfs#hive-style-partitioning)/[AzureBlobStorage](/pt-BR/reference/functions/table-functions/azureBlobStorage#hive-style-partitioning) e permitirá usar colunas de partição como colunas virtuais na consulta. Essas colunas virtuais terão os mesmos nomes do caminho particionado, mas começarão com `_`.
## use\_iceberg\_metadata\_files\_cache
Se estiver ativada, a função de tabela Iceberg e o armazenamento Iceberg poderão usar o cache de arquivos de metadados do Iceberg.
Valores possíveis:
* 0 - Desabilitado
* 1 - Habilitado
## use\_iceberg\_partition\_pruning
Usa a poda de partições do Iceberg para tabelas Iceberg
## use\_index\_for\_in\_with\_subqueries
Tenta usar um índice se houver uma subconsulta ou uma expressão de tabela no lado direito do operador IN.
## use\_index\_for\_in\_with\_subqueries\_max\_values
O tamanho máximo do conjunto no lado direito do operador IN para usar o índice da tabela na filtragem. Isso permite evitar a degradação do desempenho e o aumento do uso de memória devido à preparação de estruturas de dados adicionais para queries grandes. Zero significa sem limite.
## use\_join\_disjunctions\_push\_down
Habilita o pushdown das partes conectadas por OR das condições de JOIN para os respectivos lados de entrada ("pushdown parcial").
Isso permite que os motores de armazenamento apliquem o filtro mais cedo, o que pode reduzir a quantidade de dados lidos.
A otimização preserva a semântica e é aplicada somente quando cada ramo OR de nível superior contribui com pelo menos um
predicado determinístico para o lado de destino.
## use\_legacy\_to\_time
Quando habilitada, permite usar a função toTime legada, que converte uma data com hora em uma determinada data fixa, preservando a hora.
Caso contrário, usa uma nova função toTime, que converte diferentes tipos de dados no tipo Time.
A função legada antiga também permanece acessível incondicionalmente como toTimeWithFixedDate.
## use\_page\_cache\_for\_disks\_without\_file\_cache
Use o cache de páginas no espaço do usuário para discos remotos que não tenham o cache do sistema de arquivos habilitado.
## use\_page\_cache\_for\_local\_disks
Use o cache de páginas em espaço de usuário ao ler de discos locais. É usado para testes e dificilmente melhora o desempenho na prática. Requer local\_filesystem\_read\_method = 'pread' ou 'read'. Não desativa o cache de páginas do SO; min\_bytes\_to\_use\_direct\_io pode ser usado para isso. Afeta apenas tabelas comuns, não a table function file() nem o table engine File().
## use\_page\_cache\_for\_object\_storage
Use o cache de páginas em userspace ao ler a partir de funções de tabela de armazenamento de objetos (s3, azure, hdfs) e motores de tabela (S3, Azure, HDFS).
## use\_page\_cache\_with\_distributed\_cache
Usa o cache de páginas em espaço do usuário quando o distributed cache está em uso.
## use\_paimon\_partition\_pruning
Usa a eliminação de partições do Paimon para funções de tabela do Paimon
## use\_parquet\_metadata\_cache
Quando ativado, o formato Parquet pode usar o cache de metadados do Parquet.
Valores possíveis:
* 0 - Desabilitado
* 1 - Habilitado
## use\_partition\_pruning
**Aliases**: `use_partition_key`
Usa a chave de partição para fazer a poda de partições durante a execução de consultas em tabelas MergeTree.
Valores possíveis:
* 0 — Desabilitado.
* 1 — Habilitado.
## use\_primary\_key
Usa a chave primária para podar grânulos durante a execução de consultas em tabelas MergeTree.
Valores possíveis:
* 0 — Desabilitado.
* 1 — Habilitado.
## use\_query\_cache
Se ativada, consultas `SELECT` podem usar o [cache de consultas](/pt-BR/concepts/features/performance/caches/query-cache). Os parâmetros [enable\_reads\_from\_query\_cache](#enable_reads_from_query_cache)
e [enable\_writes\_to\_query\_cache](#enable_writes_to_query_cache) controlam de forma mais detalhada como o cache é usado.
Valores possíveis:
* 0 - Desabilitado
* 1 - Habilitado
## use\_query\_condition\_cache
Ativa o [cache de condição de consulta](/pt-BR/concepts/features/performance/caches/query-condition-cache). O cache armazena intervalos de grânulos em data parts que não satisfazem a condição da cláusula `WHERE`
e reutiliza essas informações como um índice efêmero para consultas subsequentes.
Valores possíveis:
* 0 - Desativado
* 1 - Ativado
## use\_roaring\_bitmap\_iceberg\_positional\_deletes
Usa roaring bitmap para exclusões posicionais do Iceberg.
## use\_skip\_indexes
Usa data skipping indexes durante a execução da consulta.
Valores possíveis:
* 0 — Desativado.
* 1 — Ativado.
## use\_skip\_indexes\_for\_disjunctions
Avalia filtros da cláusula `WHERE` com condições mistas de `AND` e `OR` usando skip indexes. Exemplo: `WHERE A = 5 AND (B = 5 OR C = 5)`.
Se desabilitada, os skip indexes ainda são usados para avaliar condições da cláusula `WHERE`, mas elas devem conter apenas cláusulas combinadas com `AND`.
Valores possíveis:
* 0 — Desabilitado.
* 1 — Habilitado.
## use\_skip\_indexes\_for\_top\_k
Habilita o uso de data skipping indexes para filtragem TopK.
Quando habilitado, se existir um índice minmax de data skipping na coluna em uma consulta `ORDER BY LIMIT n`, o otimizador tentará usar o índice minmax para ignorar grânulos que não sejam relevantes para o resultado final. Isso pode reduzir a latência da consulta.
Valores possíveis:
* 0 — Desabilitado.
* 1 — Habilitado.
## use\_skip\_indexes\_if\_final
Controla se os skip indexes são usados ao executar uma consulta com o modificador FINAL.
Os skip indexes podem excluir linhas (grânulos) que contêm os dados mais recentes, o que pode levar a resultados incorretos em uma consulta com o modificador FINAL. Quando essa configuração está habilitada, os skip indexes são aplicados mesmo com o modificador FINAL, o que pode melhorar o desempenho, mas com o risco de ignorar atualizações recentes. Essa configuração deve ser habilitada em conjunto com a configuração use\_skip\_indexes\_if\_final\_exact\_mode (o padrão é habilitado).
Valores possíveis:
* 0 — Desabilitado.
* 1 — Habilitado.
## use\_skip\_indexes\_if\_final\_exact\_mode
Controla se os grânulos retornados por um índice de salto são expandidos para partes mais novas a fim de retornar resultados corretos ao executar uma consulta com o modificador FINAL.
O uso de índices de salto pode excluir linhas (grânulos) que contêm os dados mais recentes, o que pode levar a resultados incorretos. Esta configuração pode garantir resultados corretos ao examinar partes mais novas que se sobrepõem aos intervalos retornados pelo índice de salto. Esta configuração só deve ser desativada se resultados aproximados, com base na consulta ao índice de salto, forem aceitáveis para uma aplicação.
Possíveis valores:
* 0 — Desativado.
* 1 — Ativado.
## use\_skip\_indexes\_on\_data\_read
Habilita o uso de data skipping indexes durante a leitura dos dados.
Quando habilitada, os skip indexes são avaliados dinamicamente no momento em que cada grânulo de dados é lido, em vez de serem analisados antecipadamente antes do início da execução da consulta. Isso pode reduzir a latência de inicialização da consulta.
Valores possíveis:
* 0 — Desabilitado.
* 1 — Habilitado.
## use\_statistics
/// preferível a 'allow\_statistics\_optimize' para manter a consistência com 'use\_primary\_key' e 'use\_skip\_indexes'
Permite usar estatísticas para otimizar consultas
## use\_statistics\_cache
Use o cache de estatísticas em uma consulta para evitar a sobrecarga de carregar estatísticas de todas as partes
## use\_statistics\_for\_part\_pruning
Usa estatísticas para filtrar partes durante a execução da consulta.
Quando habilitado, a poda em consultas SELECT usará estatísticas de coluna (por exemplo, estatísticas MinMax) para eliminar partes que não podem conter dados correspondentes antes da leitura de quaisquer dados.
Possíveis valores:
* 0 — Desabilitado.
* 1 — Habilitado.
## use\_strict\_insert\_block\_limits
Quando habilitada, aplica estritamente os limites mínimo e máximo de tamanho do bloco de insert.
Um bloco é emitido quando:
* Limiares mínimos (AND): Ambos `min_insert_block_size_rows` AND `min_insert_block_size_bytes` são atingidos.
* Limiares máximos (OR): `max_insert_block_size_rows` OR `max_insert_block_size_bytes` é atingido.
Quando desabilitada, um bloco é emitido quando:
* Limiares mínimos (OR): `min_insert_block_size_rows` OR `min_insert_block_size_bytes` é atingido.
**Observação**: Se as configurações máximas forem menores que as configurações mínimas, os limites máximos terão precedência, e os blocos serão emitidos antes de os limiares mínimos serem atingidos.
**Observação**: Essa configuração é desabilitada automaticamente para async inserts, porque async inserts anexam tokens de desduplicação por entrada que são incompatíveis com a divisão de blocos necessária para aplicar limites estritos.
Desabilitada por padrão.
## use\_structure\_from\_insertion\_table\_in\_table\_functions
Usa a estrutura da tabela de inserção em vez da inferência de esquema dos dados. Valores possíveis: 0 - desabilitado, 1 - habilitado, 2 - automático
Define se deve ser usado um cache do cabeçalho desserializado do índice de texto.
Usar o cache do cabeçalho do índice de texto pode reduzir significativamente a latência e aumentar a taxa de transferência ao trabalhar com um grande número de consultas de índice de texto.
## use\_text\_index\_like\_evaluation\_by\_dictionary\_scan
Ativa a avaliação de consultas LIKE/ILIKE por varredura no dicionário do índice de texto invertido.
## use\_text\_index\_postings\_cache
Define se deve ser usado um cache de listas de postings desserializadas do índice de texto.
Usar o cache de postings do índice de texto pode reduzir significativamente a latência e aumentar a taxa de transferência ao trabalhar com um grande volume de consultas de índice de texto.
## use\_text\_index\_tokens\_cache
Define se deve ser usado um cache de informações desserializadas de tokens do índice de texto.
Usar o cache de tokens do índice de texto pode reduzir significativamente a latência e aumentar o throughput ao trabalhar com um grande número de consultas de índice de texto.
## use\_top\_k\_dynamic\_filtering
Habilita a otimização de filtragem dinâmica ao executar uma consulta `ORDER BY LIMIT n`.
Quando habilitada, o executor da consulta tentará ignorar grânulos e linhas que não farão parte das `top N` linhas finais no conjunto de resultados. Essa otimização é inerentemente dinâmica, e as melhorias de latência dependem da distribuição dos dados e da presença de outros predicados na consulta.
Valores possíveis:
* 0 — Desabilitado.
* 1 — Habilitado.
## use\_top\_k\_dynamic\_filtering\_for\_variable\_length\_types
Permite que `use_top_k_dynamic_filtering` seja aplicado quando a coluna de ordenação tem um tipo de dados de comprimento variável (por exemplo, `String`, `Array`, `Map`, `Tuple` contendo elementos de comprimento variável).
Para esses tipos, a comparação de limiar por linha feita pelo filtro dinâmico pode custar mais do que a economia gerada quando o mínimo lexicográfico da coluna predomina (por exemplo, quando há principalmente strings vazias) e poucos grânulos podem ser ignorados. Nesse caso, o filtro dinâmico piora a latência da consulta em vez de melhorá-la.
Quando essa configuração é `0`, a filtragem dinâmica fica restrita a colunas cujos valores têm um tamanho máximo fixo na memória (números, `Date`, `DateTime`, `FixedString`, `Enum`, `Nullable` desses tipos, `Tuple` desses tipos). Quando definida como `1`, a filtragem dinâmica também se aplica a tipos de comprimento variável.
Valores possíveis:
* 0 — Desabilitado.
* 1 — Habilitado.
## use\_uncompressed\_cache
Define se deve usar um cache de blocos não comprimidos. Aceita 0 ou 1. Por padrão, 0 (desabilitado).
Usar o cache não comprimido (apenas para tabelas da família MergeTree) pode reduzir significativamente a latência e aumentar a taxa de transferência ao trabalhar com um grande número de consultas curtas. Habilite essa configuração para usuários que enviam solicitações curtas com frequência. Observe também o parâmetro de configuração [uncompressed\_cache\_size](/pt-BR/reference/settings/server-settings/settings#uncompressed_cache_size) (definido apenas no arquivo de configuração) – o tamanho dos blocos do cache não comprimido. Por padrão, ele é 8 GiB. O cache não comprimido é preenchido conforme necessário, e os dados menos usados são excluídos automaticamente.
Para consultas que leem pelo menos um volume de dados relativamente grande (um milhão de linhas ou mais), o cache não comprimido é desabilitado automaticamente para economizar espaço para consultas realmente pequenas. Isso significa que você pode manter a configuração 'use\_uncompressed\_cache' sempre definida como 1.
## use\_variant\_as\_common\_type
Permite usar o tipo `Variant` como tipo de resultado das funções [if](/pt-BR/reference/functions/regular-functions/conditional-functions#if)/[multiIf](/pt-BR/reference/functions/regular-functions/conditional-functions#multiIf)/[array](/pt-BR/reference/functions/regular-functions/array-functions)/[map](/pt-BR/reference/functions/regular-functions/tuple-map-functions) quando não há um tipo comum entre os tipos de argumento.
Exemplo:
```sql theme={null}
SET use_variant_as_common_type = 1;
SELECT toTypeName(if(number % 2, number, range(number))) as variant_type FROM numbers(1);
SELECT if(number % 2, number, range(number)) as variant FROM numbers(5);
```
```text theme={null}
┌─variant_type───────────────────┐
│ Variant(Array(UInt64), UInt64) │
└────────────────────────────────┘
┌─variant───┐
│ [] │
│ 1 │
│ [0,1] │
│ 3 │
│ [0,1,2,3] │
└───────────┘
```
```sql theme={null}
SET use_variant_as_common_type = 1;
SELECT toTypeName(multiIf((number % 4) = 0, 42, (number % 4) = 1, [1, 2, 3], (number % 4) = 2, 'Hello, World!', NULL)) AS variant_type FROM numbers(1);
SELECT multiIf((number % 4) = 0, 42, (number % 4) = 1, [1, 2, 3], (number % 4) = 2, 'Hello, World!', NULL) AS variant FROM numbers(4);
```
```text theme={null}
─variant_type─────────────────────────┐
│ Variant(Array(UInt8), String, UInt8) │
└──────────────────────────────────────┘
┌─variant───────┐
│ 42 │
│ [1,2,3] │
│ Hello, World! │
│ ᴺᵁᴸᴸ │
└───────────────┘
```
```sql theme={null}
SET use_variant_as_common_type = 1;
SELECT toTypeName(array(range(number), number, 'str_' || toString(number))) as array_of_variants_type from numbers(1);
SELECT array(range(number), number, 'str_' || toString(number)) as array_of_variants FROM numbers(3);
```
```text theme={null}
┌─array_of_variants_type────────────────────────┐
│ Array(Variant(Array(UInt64), String, UInt64)) │
└───────────────────────────────────────────────┘
┌─array_of_variants─┐
│ [[],0,'str_0'] │
│ [[0],1,'str_1'] │
│ [[0,1],2,'str_2'] │
└───────────────────┘
```
```sql theme={null}
SET use_variant_as_common_type = 1;
SELECT toTypeName(map('a', range(number), 'b', number, 'c', 'str_' || toString(number))) as map_of_variants_type from numbers(1);
SELECT map('a', range(number), 'b', number, 'c', 'str_' || toString(number)) as map_of_variants FROM numbers(3);
```
```text theme={null}
┌─map_of_variants_type────────────────────────────────┐
│ Map(String, Variant(Array(UInt64), String, UInt64)) │
└─────────────────────────────────────────────────────┘
┌─map_of_variants───────────────┐
│ {'a':[],'b':0,'c':'str_0'} │
│ {'a':[0],'b':1,'c':'str_1'} │
│ {'a':[0,1],'b':2,'c':'str_2'} │
└───────────────────────────────┘
```
## use\_variant\_default\_implementation\_for\_comparisons
Habilita ou desabilita a implementação padrão para o tipo Variant em funções de comparação.
## use\_with\_fill\_by\_sorting\_prefix
As colunas que precedem as colunas WITH FILL na cláusula ORDER BY formam o prefixo de ordenação. As linhas com valores diferentes no prefixo de ordenação são preenchidas de forma independente
## validate\_enum\_literals\_in\_operators
Se habilitada, valida literais de enum em operadores como `IN`, `NOT IN`, `==`, `!=` com base no tipo enum e lança uma exceção caso o literal não seja um valor válido do enum.
## validate\_mutation\_query
Valide as consultas de mutação antes de aceitá-las. As mutações são executadas em segundo plano, e a execução de uma consulta inválida fará com que as mutações fiquem travadas, exigindo intervenção manual.
Altere essa configuração somente se você encontrar um bug de incompatibilidade com versões anteriores.
## validate\_polygons
Ativa ou desativa a geração de uma exceção na função [pointInPolygon](/pt-BR/reference/functions/regular-functions/geo/coordinates#pointinpolygon) se o polígono for autointersectante ou autotangente.
Possíveis valores:
* 0 — A geração de uma exceção está desativada. `pointInPolygon` aceita polígonos inválidos e pode retornar resultados incorretos para eles.
* 1 — A geração de uma exceção está ativada.
## variant\_throw\_on\_type\_mismatch
Ao aplicar uma função a uma coluna [Variant](/pt-BR/reference/data-types/variant) usando a implementação padrão,
controla o que acontece com as linhas cujo tipo real é incompatível com a função:
* `true` (padrão) — gera uma exceção.
* `false` — retorna `NULL` para essas linhas.
## vector\_search\_filter\_strategy
Se uma consulta de busca vetorial tiver uma cláusula WHERE, essa configuração determina se ela será avaliada primeiro (pré-filtragem) ou se o índice de similaridade vetorial será consultado primeiro (pós-filtragem). Valores possíveis:
* 'auto' - Pós-filtragem (a semântica exata pode mudar no futuro).
* 'postfilter' - Use o índice de similaridade vetorial para identificar os vizinhos mais próximos e, em seguida, aplique outros filtros
* 'prefilter' - Avalie primeiro os outros filtros e, em seguida, execute uma busca por força bruta para identificar os vizinhos.
## vector\_search\_index\_fetch\_multiplier
**Aliases**: `vector_search_postfilter_multiplier`
Multiplica por esse valor o número de vizinhos mais próximos obtidos do vector similarity index. Só se aplica à pós-filtragem com outros predicados ou se a configuração 'vector\_search\_with\_rescoring = 1'.
## vector\_search\_with\_rescoring
Define se o ClickHouse faz rescoring para consultas que usam o índice de similaridade vetorial.
Sem rescoring, o índice de similaridade vetorial retorna diretamente as linhas com as melhores correspondências.
Com rescoring, as linhas são extrapoladas para o nível de grânulo, e todas as linhas no grânulo são verificadas novamente.
Na maioria das situações, o rescoring traz apenas um ganho marginal de precisão, mas degrada significativamente o desempenho das consultas de busca vetorial.
Observação: uma consulta executada sem rescoring e com parallel replicas habilitadas pode usar rescoring como fallback.
## wait\_changes\_become\_visible\_after\_commit\_mode
Aguarda que as alterações confirmadas se tornem efetivamente visíveis no snapshot mais recente
## wait\_for\_async\_insert
Se true, espera o processamento do insert assíncrono
## wait\_for\_async\_insert\_timeout
Tempo limite de espera pelo processamento da inserção assíncrona
## wait\_for\_window\_view\_fire\_signal\_timeout
Tempo limite de espera pelo sinal de disparo da window view no processamento em tempo de evento
## webassembly\_udf\_max\_fuel
Limite de fuel por execução de instância de UDF WebAssembly. Cada instrução de WebAssembly consome uma certa quantidade de fuel.
Defina 0 para não haver limite.
## webassembly\_udf\_max\_input\_block\_size
Número máximo de linhas passadas para uma UDF do WebAssembly em um único bloco. Defina como 0 para processar todas as linhas de uma só vez.
## webassembly\_udf\_max\_instances
Número máximo de instâncias de WebAssembly UDF que podem ser executadas em paralelo por função.
## webassembly\_udf\_max\_memory
Limite de memória em bytes por instância de UDF em WebAssembly.
## window\_view\_clean\_interval
O intervalo de limpeza da window view, em segundos, para remover dados desatualizados.
## window\_view\_heartbeat\_interval
O intervalo de heartbeat, em segundos, para indicar que a consulta watch está ativa.
## workload
Nome do workload usado para acessar recursos
## write\_full\_path\_in\_iceberg\_metadata
Grava caminhos completos (incluindo s3://) nos arquivos de metadados do Iceberg.
## write\_through\_distributed\_cache
Só tem efeito no ClickHouse Cloud. Permite gravar no distributed cache (a gravação no S3 também será realizada pelo distributed cache)
## write\_through\_distributed\_cache\_buffer\_size
Só tem efeito no ClickHouse Cloud. Define o tamanho do buffer para o cache distribuído write-through. Se for 0, usará o tamanho de buffer que teria sido usado se não houvesse cache distribuído.
## zstd\_window\_log\_max
Permite selecionar o valor máximo de window log do ZSTD (não será usado para a família MergeTree)