> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-fbfa8bee.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
> Configurações do MergeTree que estão em `system.merge_tree_settings`
# Configurações das tabelas MergeTree
export const SettingsInfoBlock = ({type, default_value, changeable_without_restart}) => {
const cells = [["Tipo", {type}], ["Valor padrão", {default_value}]];
if (changeable_without_restart) {
const isYes = String(changeable_without_restart).trim().toLowerCase() === "yes";
const badge = isYes ? Sim : Não;
cells.push(["Pode ser alterado sem reiniciar", badge]);
}
return
{cells.map(([h]) => | {h} | )}
{cells.map(([h, v]) => | {v} | )}
;
};
export const galaxyOnClick = eventName => () => {
try {
if (typeof window !== "undefined" && window.galaxy && eventName) {
window.galaxy.track(eventName, {
interaction: "click"
});
}
} catch (e) {}
};
export const BetaBadge = ({link, galaxyTrack, galaxyEvent}) => {
if (link) {
return
Beta
;
}
return ;
};
export const ExperimentalBadge = () => {
return ;
};
A tabela de sistema `system.merge_tree_settings` mostra as configurações do MergeTree definidas globalmente.
As configurações do MergeTree podem ser definidas na seção `merge_tree` do arquivo de configuração do servidor ou especificadas individualmente para cada tabela `MergeTree` na
cláusula `SETTINGS` da instrução `CREATE TABLE`.
Exemplo de como personalizar a configuração `max_suspicious_broken_parts`:
Configure o padrão para todas as tabelas `MergeTree` no arquivo de configuração do servidor:
```text theme={null}
5
```
Definido para uma tabela específica:
```sql theme={null}
CREATE TABLE tab
(
`A` Int64
)
ENGINE = MergeTree
ORDER BY tuple()
SETTINGS max_suspicious_broken_parts = 500;
```
Altere as configurações de uma tabela específica usando `ALTER TABLE ... MODIFY SETTING`:
```sql theme={null}
ALTER TABLE tab MODIFY SETTING max_suspicious_broken_parts = 100;
-- redefinir para o padrão global (valor de system.merge_tree_settings)
ALTER TABLE tab RESET SETTING max_suspicious_broken_parts;
```
## Configurações do MergeTree
## adaptive\_write\_buffer\_initial\_size
Tamanho inicial de um buffer de escrita adaptativo
## add\_implicit\_sign\_column\_constraint\_for\_collapsing\_engine
Se true, adiciona uma restrição implícita à coluna `sign` de uma tabela CollapsingMergeTree
ou VersionedCollapsingMergeTree para permitir apenas valores válidos (`1` e `-1`).
## add\_minmax\_index\_for\_block\_number\_column
Quando ativada, um índice min-max implícito (skipping) é adicionado à coluna virtual persistente `_block_number`.
Requer `enable_block_number_column = 1` para ter efeito. O índice é criado somente durante mesclagens,
não durante inserts: no momento do insert, o número do bloco é provisório e indexaria um valor constante.
## add\_minmax\_index\_for\_block\_offset\_column
Quando habilitada, um índice min-max implícito (skipping) é adicionado à coluna virtual persistente `_block_offset`.
Requer `enable_block_offset_column = 1` para ter efeito. O índice é criado apenas durante mesclagens,
não durante inserções.
## add\_minmax\_index\_for\_numeric\_columns
Quando habilitada, índices min-max (skipping) são adicionados a todas as colunas numéricas
da tabela.
## add\_minmax\_index\_for\_string\_columns
Quando ativada, adiciona índices min-max (skipping) a todas as colunas do tipo string da tabela.
## add\_minmax\_index\_for\_temporal\_columns
Quando ativada, índices min-max (skipping) são adicionados a todas as colunas Date, Date32, Time, Time64, DateTime e DateTime64 da tabela
## allow\_coalescing\_columns\_in\_partition\_or\_order\_key
Quando ativada, permite usar colunas de coalescência em uma tabela CoalescingMergeTree
na partição ou na chave de ordenação.
## allow\_commit\_order\_projection
Habilita projeções por ordem de commit que armazenam as colunas virtuais `_block_number` e `_block_offset`, preservando a ordem original de inserção durante as operações de mesclagem.
Requer que `enable_block_number_column` e `enable_block_offset_column` estejam habilitados.
## allow\_experimental\_replacing\_merge\_with\_cleanup
Permite mesclagens CLEANUP experimentais para ReplacingMergeTree com a
coluna `is_deleted`. Quando habilitada, essa opção permite usar `OPTIMIZE ... FINAL CLEANUP` para
mesclar manualmente todas as partes de uma partição em uma única parte e remover
quaisquer linhas excluídas.
Também permite habilitar a execução automática dessas mesclagens em segundo plano
com as configurações `min_age_to_force_merge_seconds`,
`min_age_to_force_merge_on_partition_only` e
`enable_replacing_merge_with_cleanup_for_min_age_to_force_merge`.
## allow\_experimental\_reverse\_key
Configuração obsoleta, sem efeito.
## allow\_floating\_point\_partition\_key
Permite o uso de números de ponto flutuante como chave de partição.
Valores possíveis:
* `0` — Chave de partição com ponto flutuante não permitida.
* `1` — Chave de partição com ponto flutuante permitida.
## allow\_nullable\_key
Permite usar tipos Nullable como chaves primárias.
## allow\_part\_offset\_column\_in\_projections
Permite usar a coluna '\_part\_offset' na consulta SELECT de projeções.
## allow\_reduce\_blocking\_parts\_task
Tarefa em segundo plano que reduz as partes bloqueadoras em tabelas shared merge tree.
Somente no ClickHouse Cloud
## allow\_remote\_fs\_zero\_copy\_replication
Não use essa configuração em produção, pois ela ainda não está pronta.
## allow\_summing\_columns\_in\_partition\_or\_order\_key
Quando ativada, permite que colunas de soma em uma tabela SummingMergeTree sejam usadas
na partição ou na chave de ordenação.
## allow\_suspicious\_indices
Rejeita índices primários/secundários e chaves de ordenação com expressões idênticas
## allow\_tuple\_element\_aggregation
Quando habilitada, elementos individuais em colunas Tuple participam da
agregação durante a mesclagem em SummingMergeTree, AggregatingMergeTree e
CoalescingMergeTree. Tuples aninhadas são expandidas recursivamente para que todos os
elementos finais sejam agregados de forma independente. Essa configuração é imutável
e deve ser especificada no momento da criação da tabela.
## allow\_vertical\_merges\_from\_compact\_to\_wide\_parts
Permite mesclagens verticais de partes compact para partes wide. Esta configuração deve ter
o mesmo valor em todas as réplicas.
## alter\_column\_secondary\_index\_mode
Configura se comandos `ALTER` que modificam colunas cobertas por índices secundários devem ser permitidos e qual ação deve ser tomada caso
sejam permitidos. Por padrão, esses comandos `ALTER` são permitidos, e os índices são reconstruídos.
Valores possíveis:
* `rebuild` (padrão): Reconstrói todos os índices secundários afetados pela coluna no comando `ALTER`.
* `throw`: Impede qualquer `ALTER` de colunas cobertas por índices secundários **explícitos**, gerando uma exceção. Índices implícitos ficam fora dessa restrição e serão reconstruídos.
* `drop`: Remove os índices secundários dependentes. As novas partes não terão os índices, exigindo `MATERIALIZE INDEX` para recriá-los.
* `compatibility`: Corresponde ao comportamento original: `throw` em `ALTER ... MODIFY COLUMN` e `rebuild` em `ALTER ... UPDATE/DELETE`.
* `ignore`: Destina-se a uso por especialistas. Deixa os índices em um estado inconsistente, o que pode permitir resultados de consulta incorretos.
## always\_fetch\_merged\_part
Se estiver definido como true, esta réplica nunca mescla partes e sempre baixa partes mescladas
de outras réplicas.
Valores possíveis:
* true, false
## always\_use\_copy\_instead\_of\_hardlinks
Sempre copie os dados em vez de usar hardlinks durante mutações/substituições/desanexações
e assim por diante.
## apply\_patches\_on\_merge
Se true, as partes de patch são aplicadas durante as mesclagens
## assign\_part\_uuids
Quando ativada, um identificador exclusivo de parte será atribuído a cada nova parte.
Antes de ativar, verifique se todas as réplicas oferecem suporte à versão 4 de UUID.
## async\_block\_ids\_cache\_update\_wait\_ms
Por quanto tempo cada iteração de insert aguardará pela atualização de async\_block\_ids\_cache
## async\_insert
Se true, os dados da consulta INSERT são armazenados na fila e depois gravados
na tabela em segundo plano.
## auto\_statistics\_types
Lista separada por vírgulas dos tipos de estatísticas calculados automaticamente em todas as colunas compatíveis.
Tipos de estatísticas compatíveis: basic, tdigest, countmin, minmax, uniq.
## background\_task\_preferred\_step\_execution\_time\_ms
Tempo-alvo para a execução de um passo de mesclagem ou mutação. Pode ser excedido se
um passo demorar mais
## cache\_populated\_by\_fetch
Esta configuração se aplica apenas ao ClickHouse Cloud.
Quando `cache_populated_by_fetch` está desativada (configuração padrão), novas partes de dados
são carregadas no cache do sistema de arquivos apenas quando uma consulta é executada e precisa
dessas partes.
Se estiver ativada, `cache_populated_by_fetch` fará com que todos os nós carreguem
novas partes de dados do armazenamento para o cache do sistema de arquivos sem exigir a execução de uma consulta
para acionar esse carregamento.
**Veja também**
* [ignore\_cold\_parts\_seconds](/pt-BR/reference/settings/session-settings#ignore_cold_parts_seconds)
* [prefer\_warmed\_unmerged\_parts\_seconds](/pt-BR/reference/settings/session-settings#prefer_warmed_unmerged_parts_seconds)
* [cache\_warmer\_threads](/pt-BR/reference/settings/session-settings#cache_warmer_threads)
## cache\_populated\_by\_fetch\_filename\_regexp
Esta configuração se aplica apenas ao ClickHouse Cloud.
Se não estiver vazio, apenas os arquivos que corresponderem a esta regex serão pré-carregados no cache após o fetch (se `cache_populated_by_fetch` estiver habilitado).
## check\_delay\_period
Configuração obsoleta; não tem efeito.
## check\_sample\_column\_is\_correct
Habilita, na criação da tabela, a verificação de que o tipo de dados de uma coluna de amostragem ou de uma expressão de amostragem está correto. O tipo de dados deve ser um dos
[tipos inteiros sem sinal](/pt-BR/reference/data-types/int-uint): `UInt8`, `UInt16`,
`UInt32`, `UInt64`.
Valores possíveis:
* `true` — A verificação está habilitada.
* `false` — A verificação é desabilitada na criação da tabela.
Valor padrão: `true`.
Por padrão, o servidor ClickHouse verifica, na criação da tabela, o tipo de dados de
uma coluna de amostragem ou de uma expressão de amostragem. Se você já tiver tabelas com
uma expressão de amostragem incorreta e não quiser que o servidor gere uma exceção
durante a inicialização, defina `check_sample_column_is_correct` como `false`.
## clean\_deleted\_rows
Configuração obsoleta, sem efeito.
## cleanup\_delay\_period
Período mínimo para remover logs antigos da fila, hashes de blocos e partes.
## cleanup\_delay\_period\_random\_add
Adiciona a cleanup\_delay\_period um valor com distribuição uniforme de 0 a x segundos
para evitar o efeito de thundering herd e o DoS subsequente no ZooKeeper em caso de
um número muito grande de tabelas.
## cleanup\_thread\_preferred\_points\_per\_iteration
Tamanho de lote preferido para limpeza em segundo plano (os pontos são abstratos, mas 1 ponto
equivale aproximadamente a 1 bloco inserido).
## cleanup\_threads
Configuração obsoleta, sem efeito.
## clone\_replica\_zookeeper\_create\_get\_part\_batch\_size
Tamanho do lote para solicitações get-part multi-create do ZooKeeper ao clonar a réplica.
## columns\_and\_secondary\_indices\_sizes\_lazy\_calculation
Calcula os tamanhos das colunas e dos índices secundários sob demanda na primeira solicitação, em vez
de calculá-los na inicialização da tabela.
## columns\_to\_prewarm\_mark\_cache
Lista de colunas para pré-aquecer o cache de marcas (se estiver habilitado). Em branco significa todas as colunas
## compact\_parts\_max\_bytes\_to\_buffer
Disponível apenas no ClickHouse Cloud. Número máximo de bytes que podem ser gravados em uma
única stripe em partes compactas
## compact\_parts\_max\_granules\_to\_buffer
Disponível apenas no ClickHouse Cloud. Número máximo de grânulos a serem gravados em uma
única stripe de partes compactas
## compact\_parts\_merge\_max\_bytes\_to\_prefetch\_part
Disponível apenas no ClickHouse Cloud. Tamanho máximo da parte compacta para ser lida
inteiramente na memória durante a mesclagem.
## compatibility\_allow\_sampling\_expression\_not\_in\_primary\_key
Permite criar uma tabela com expressão de amostragem fora da chave primária. Isso é
necessário apenas para permitir temporariamente a execução do servidor com tabelas incorretas, por
compatibilidade com versões anteriores.
## compress\_marks
As marcas oferecem suporte à compressão, reduzem o tamanho do arquivo de marcas e aceleram a transmissão
na rede.
## compress\_per\_column\_in\_compact\_parts
Controla o layout físico das partes compactas. Se true (padrão), cada coluna em um grânulo
inicia um novo bloco comprimido, permitindo que o ClickHouse evite ler colunas desnecessárias
do disco. Se false, todas as colunas dentro de um grânulo são agrupadas no mesmo bloco comprimido,
melhorando a taxa de compressão, mas exigindo que mais dados sejam descomprimidos durante as leituras.
Isso é vantajoso para workloads que sempre leem todas as colunas (por exemplo, projeções).
## compress\_primary\_key
Permite a compressão da chave primária, reduzindo o tamanho do arquivo da chave primária e acelerando a transmissão pela rede.
## concurrent\_part\_removal\_threshold
Ativa a remoção concorrente de partes (consulte 'max\_part\_removal\_threads') somente se
o número de partes de dados inativas for, no mínimo, este valor.
## concurrent\_part\_removal\_threshold\_for\_remote\_disk
É o mesmo que `concurrent_part_removal_threshold`, mas usado quando pelo
menos uma parte sendo removida está armazenada em um disco remoto. O valor padrão é menor
porque cada remoção de parte no armazenamento remoto normalmente exige uma ida e volta na
rede (por exemplo, um `DELETE` HTTP por parte no armazenamento de objetos), então uma
remoção em série de até mesmo 100 partes pode fazer um `DROP TABLE` ficar bloqueado por dezenas de
segundos.
## deduplicate\_merge\_projection\_mode
Define se é permitido criar projeção para uma tabela com MergeTree não clássico,
ou seja, que não seja (Replicated, Shared) MergeTree. A opção ignore existe apenas por
compatibilidade e pode resultar em resposta incorreta. Caso contrário, se permitido,
define qual ação deve ser executada ao fazer mesclagem de projeções: descartar ou reconstruir. Portanto, o
MergeTree clássico ignoraria essa configuração. Ela também controla `OPTIMIZE DEDUPLICATE`,
mas tem efeito sobre todos os membros da família MergeTree. Assim como a
opção `lightweight_mutation_projection_mode`, ela também é em nível de part.
Valores possíveis:
* `ignore`
* `throw`
* `drop`
* `rebuild`
## default\_compression\_codec
Especifica o codec de compressão padrão a ser usado caso nenhum tenha sido definido para uma coluna específica na declaração da tabela.
Ordem de seleção do codec de compressão para uma coluna:
1. Codec de compressão definido para a coluna na declaração da tabela
2. Codec de compressão definido em `default_compression_codec` (esta configuração)
3. Codec de compressão padrão definido nas configurações de `compression`
Valor padrão: uma string vazia (não definido).
## detach\_not\_byte\_identical\_parts
Ativa ou desativa o desanexamento de uma parte de dados em uma réplica após uma mesclagem ou uma
mutação, caso ela não seja idêntica byte a byte às partes de dados em outras réplicas. Se
desativada, a parte de dados é removida. Ative essa configuração se quiser
analisar essas partes posteriormente.
A configuração se aplica a tabelas `MergeTree` com
[replicação de dados](/pt-BR/reference/engines/table-engines/mergetree-family/replacingmergetree) habilitada.
Valores possíveis:
* `0` — As partes são removidas.
* `1` — As partes são desanexadas.
## detach\_old\_local\_parts\_when\_cloning\_replica
Não remova partes locais antigas ao reparar uma réplica perdida.
Valores possíveis:
* `true`
* `false`
## disable\_detach\_partition\_for\_zero\_copy\_replication
Desabilita a consulta DETACH PARTITION para replicação zero-copy.
## disable\_fetch\_partition\_for\_zero\_copy\_replication
Desativa a consulta FETCH PARTITION para replicação zero copy.
## disable\_freeze\_partition\_for\_zero\_copy\_replication
Desabilita a consulta FREEZE PARTITION para replicação zero copy.
## disco
Nome do disco de armazenamento. Pode ser especificado no lugar da política de armazenamento.
## distributed\_index\_analysis\_min\_indexes\_bytes\_to\_activate
Tamanho mínimo dos índices (data skipping e chave primária) em disco (mas descomprimidos) para ativar a análise distribuída de índices
## distributed\_index\_analysis\_min\_parts\_to\_activate
Número mínimo de partes para ativar a análise distribuída de índices
## dynamic\_serialization\_version
Versão de serialização do tipo de dados Dynamic. Necessária para compatibilidade.
Possíveis valores:
* `v1`
* `v2`
* `v3`
## enable\_block\_number\_column
Ativa a persistência da coluna \_block\_number em cada linha.
## enable\_block\_offset\_column
Persiste a coluna virtual `_block_offset` durante as mesclagens.
## enable\_index\_granularity\_compression
Comprime, na memória, os valores da granularidade do índice, se possível
## enable\_max\_bytes\_limit\_for\_min\_age\_to\_force\_merge
Define se as configurações `min_age_to_force_merge_seconds` e
`min_age_to_force_merge_on_partition_only` devem respeitar a configuração
`max_bytes_to_merge_at_max_space_in_pool`.
Valores possíveis:
* `true`
* `false`
## enable\_mixed\_granularity\_parts
Habilita ou desabilita a transição para o controle do tamanho do grânulo com a
configuração `index_granularity_bytes`. Antes da versão 19.11, havia apenas a
configuração `index_granularity` para restringir o tamanho do grânulo. A
configuração `index_granularity_bytes` melhora o desempenho do ClickHouse ao
selecionar dados de tabelas com linhas grandes (dezenas ou centenas de megabytes).
Se você tiver tabelas com linhas grandes, poderá habilitar essa configuração nessas tabelas
para melhorar a eficiência das consultas `SELECT`.
## enable\_replacing\_merge\_with\_cleanup\_for\_min\_age\_to\_force\_merge
Define se mesclagens `CLEANUP` devem ser usadas para ReplacingMergeTree ao mesclar partições
até uma única parte. Requer que `allow_experimental_replacing_merge_with_cleanup`,
`min_age_to_force_merge_seconds` e `min_age_to_force_merge_on_partition_only`
estejam habilitados.
Valores possíveis:
* `true`
* `false`
## enable\_the\_endpoint\_id\_with\_zookeeper\_name\_prefix
Ativa o ID do endpoint com o prefixo do nome do ZooKeeper para a tabela ReplicatedMergeTree.
## enable\_vertical\_merge\_algorithm
Habilita o uso do algoritmo de mesclagem vertical.
## enforce\_index\_structure\_match\_on\_partition\_manipulation
Se esta configuração estiver habilitada para a tabela de destino de uma
consulta de manipulação de partição (`ATTACH/MOVE/REPLACE PARTITION`), os índices e as
projeções deverão ser idênticos entre as tabelas de origem e de destino. Caso
contrário, a tabela de destino poderá ter um superconjunto dos índices e das
projeções da tabela de origem.
## escape\_index\_filenames
Antes da versão 26.1, não fazíamos escape de símbolos especiais em nomes de arquivos criados para índices secundários, o que podia fazer com que alguns
caracteres em nomes de índices gerassem partes corrompidas. Isso foi adicionado exclusivamente por motivos de compatibilidade. Não deve ser alterado, a menos que você
esteja lendo partes antigas com índices que usam caracteres não ASCII em seus nomes.
## escape\_variant\_subcolumn\_filenames
Escapa símbolos especiais nos nomes de arquivos criados para subcolunas do tipo de dado Variant em partes Wide da tabela MergeTree. Necessário para compatibilidade.
## exclude\_deleted\_rows\_for\_part\_size\_in\_merge
Se habilitada, a estimativa do tamanho real das partes de dados (ou seja, excluindo as linhas
que foram removidas por meio de `DELETE FROM`) será usada ao selecionar
partes para mesclagem. Observe que esse comportamento só é acionado para partes de dados
afetadas por `DELETE FROM` executado depois que esta configuração for habilitada.
Valores possíveis:
* `true`
* `false`
**Veja também**
* [load\_existing\_rows\_count\_for\_old\_parts](#load_existing_rows_count_for_old_parts)
configuração
## exclude\_materialize\_skip\_indexes\_on\_merge
Exclui a lista de skip indexes fornecida, delimitada por vírgulas, para que eles não sejam criados nem armazenados durante as mesclagens. Não tem efeito se
[materialize\_skip\_indexes\_on\_merge](#materialize_skip_indexes_on_merge) for false.
Os skip indexes excluídos ainda serão criados e armazenados por uma consulta
[MATERIALIZE INDEX](/pt-BR/reference/statements/alter/skipping-index#materialize-index) explícita ou durante INSERTs, dependendo da
configuração de sessão [materialize\_skip\_indexes\_on\_insert](/pt-BR/reference/settings/session-settings#materialize_skip_indexes_on_insert).
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() SETTINGS exclude_materialize_skip_indexes_on_merge = 'idx_a';
INSERT INTO tab SELECT number, number / 50 FROM numbers(100); -- a configuração não tem efeito em INSERTs
-- idx_a será excluído da atualização durante merge em background ou explícito via OPTIMIZE TABLE FINAL
-- é possível excluir múltiplos índices fornecendo uma lista
ALTER TABLE tab MODIFY SETTING exclude_materialize_skip_indexes_on_merge = 'idx_a, idx_b';
-- configuração padrão, nenhum índice excluído de ser atualizado durante o merge
ALTER TABLE tab MODIFY SETTING exclude_materialize_skip_indexes_on_merge = '';
```
## execute\_merges\_on\_single\_replica\_time\_threshold
Quando essa configuração tem um valor maior que zero, apenas uma única réplica inicia
a mesclagem imediatamente, e as outras réplicas aguardam até esse período para
baixar o resultado em vez de executar mesclagens localmente. Se a réplica escolhida
não concluir a mesclagem durante esse período, ocorre o fallback para o
comportamento padrão.
Valores possíveis:
* Qualquer inteiro positivo.
## fault\_probability\_after\_part\_commit
Para testes. Não altere isso.
## fault\_probability\_before\_part\_commit
Para testes. Não altere isto.
## finished\_mutations\_to\_keep
Quantos registros sobre mutações concluídas devem ser mantidos. Se for zero, mantenha
todos eles.
## force\_read\_through\_cache\_for\_merges
Forçar leitura via cache do sistema de arquivos para mesclagens
## fsync\_after\_insert
Executa fsync para cada parte inserida. Reduz significativamente o desempenho das
inserções; não é recomendado usar com partes wide.
## fsync\_part\_directory
Executa fsync no diretório da parte após todas as operações da parte (gravações, renomeações etc.).
## in\_memory\_parts\_enable\_wal
Configuração obsoleta, sem efeito.
## in\_memory\_parts\_insert\_sync
Configuração obsoleta, sem efeito.
## inactive\_parts\_to\_delay\_insert
Se o número de partes inativas em uma única partição da tabela exceder
o valor de `inactive_parts_to_delay_insert`, um `INSERT` será
retardado artificialmente.
Isso é útil quando o servidor não consegue limpar as partes com rapidez suficiente.
Valores possíveis:
* Qualquer número inteiro positivo.
## inactive\_parts\_to\_throw\_insert
Se o número de partes inativas em uma única partição for maior que o
valor de `inactive_parts_to_throw_insert`, o `INSERT` é interrompido com o
seguinte erro:
> "Muitas partes inativas (N). A limpeza das partes está ocorrendo de forma significativamente
> mais lenta do que os inserts" exceção."
Valores possíveis:
* Qualquer número inteiro positivo.
## index\_granularity
Número máximo de linhas de dados entre as marcas de um índice. Ou seja, quantas linhas
correspondem a um valor da chave primária.
## index\_granularity\_bytes
Tamanho máximo dos grânulos de dados, em bytes.
Para restringir o tamanho do grânulo apenas pelo número de linhas, defina-o como `0` (não recomendado).
## initialization\_retry\_period
Período entre novas tentativas de inicialização da tabela, em segundos.
## kill\_delay\_period
Configuração obsoleta; não tem efeito.
## kill\_delay\_period\_random\_add
Configuração obsoleta; não tem efeito.
## kill\_threads
Configuração obsoleta, sem efeito.
## lightweight\_mutation\_projection\_mode
Por padrão, a exclusão leve `DELETE` não funciona em tabelas com
projeções. Isso acontece porque linhas em uma projeção podem ser afetadas por uma
operação `DELETE`. Por isso, o valor padrão é `throw`. No entanto, esta
opção pode alterar esse comportamento. Com o valor `drop` ou `rebuild`,
as exclusões passarão a funcionar com projeções. `drop` excluirá a projeção, então
isso pode ser rápido na consulta atual, já que a projeção é removida, mas mais lento em
consultas futuras, pois não haverá nenhuma projeção anexada. `rebuild` reconstruirá a
projeção, o que pode afetar o desempenho da consulta atual, mas
pode acelerar consultas futuras. Um ponto positivo é que essas opções
funcionam apenas no nível da parte, o que significa que projeções na parte que não
for afetada permanecerão intactas, em vez de acionar alguma ação como
drop ou rebuild.
Valores possíveis:
* `throw`
* `drop`
* `rebuild`
## load\_existing\_rows\_count\_for\_old\_parts
Se habilitado junto com [exclude\_deleted\_rows\_for\_part\_size\_in\_merge](#exclude_deleted_rows_for_part_size_in_merge),
a contagem de linhas excluídas das partes de dados existentes será calculada durante a
inicialização da tabela. Observe que isso pode tornar mais lento o carregamento da tabela durante a inicialização.
Valores possíveis:
* `true`
* `false`
**Veja também**
* configuração [exclude\_deleted\_rows\_for\_part\_size\_in\_merge](#exclude_deleted_rows_for_part_size_in_merge)
## lock\_acquire\_timeout\_for\_background\_operations
Para operações em segundo plano, como mesclagens, mutações etc., quantos segundos esperar antes de falhar ao adquirir bloqueios da tabela.
## map\_buckets\_coefficient
O coeficiente usado nas estratégias `sqrt` e `linear` de [map\_buckets\_strategy](#map_buckets_strategy) para calcular o número de buckets com base no tamanho médio do map.
Para a estratégia `sqrt`: `round(map_buckets_coefficient * sqrt(avg_map_size))`.
Para a estratégia `linear`: `round(map_buckets_coefficient * avg_map_size)`.
Ignorado quando `map_buckets_strategy` é `constant`.
## map\_buckets\_min\_avg\_size
O tamanho médio mínimo do map (número de chaves por linha) necessário para aplicar a serialização `with_buckets`.
Se o tamanho médio do map for menor que esse valor, será usado um único bucket, independentemente das outras configurações de bucket.
Um valor de `0` desativa esse limite e sempre aplica a estratégia de bucketing.
Essa configuração é útil para evitar a sobrecarga da serialização em buckets para maps pequenos, em que o benefício é insignificante.
## map\_buckets\_strategy
Controla a estratégia de escolha do número de buckets na serialização `with_buckets` de `Map`, com base no tamanho médio do Map.
Valores possíveis:
* constant — Sempre usa [max\_buckets\_in\_map](#max_buckets_in_map) como número de buckets, independentemente do tamanho médio do Map.
* sqrt — Usa `round(map_buckets_coefficient * sqrt(avg_map_size))` como número de buckets, limitado ao intervalo `[1, max_buckets_in_map]`.
* linear — Usa `round(map_buckets_coefficient * avg_map_size)` como número de buckets, limitado ao intervalo `[1, max_buckets_in_map]`.
## map\_serialization\_version
Controla o método de serialização usado para colunas `Map`.
Valores possíveis:
* basic — Usa a serialização padrão de `Map`.
* with\_buckets — Divide as chaves em buckets durante a serialização. O uso de buckets melhora a leitura de chaves individuais no Map.
O número de buckets na serialização `with_buckets` é determinado por [max\_buckets\_in\_map](#max_buckets_in_map) e [map\_buckets\_strategy](#map_buckets_strategy).
## map\_serialization\_version\_for\_zero\_level\_parts
Esta configuração permite especificar uma versão de serialização diferente para colunas
`Map` em partes de nível zero criadas durante as inserções.
Isso pode ser útil para manter a serialização `basic` nas partes de nível zero, a fim de evitar
queda de desempenho durante as inserções, enquanto se usa `with_buckets` para partes mescladas.
## marks\_compress\_block\_size
Tamanho do bloco de compressão das marcas; é o tamanho real do bloco a ser comprimido.
## marks\_compression\_codec
Codec de compressão usado pelas marcas; como as marcas são pequenas e ficam em cache,
a compressão padrão é ZSTD(3).
## materialize\_projections\_on\_insert
Quando habilitada, os INSERTs criam novas partes com projeções.
Caso contrário, elas podem ser criadas por um [MATERIALIZE PROJECTION](/pt-BR/reference/statements/alter/projection#materialize-projection) explícito
ou durante mesclagens com [materialize\_projections\_on\_merge](/pt-BR/reference/settings/merge-tree-settings#materialize_projections_on_merge).
## materialize\_projections\_on\_merge
Quando habilitada, uma mesclagem recria uma projeção que está ausente em todas as suas partes de origem (por exemplo, porque elas foram
inseridas com `materialize_projections_on_insert = 0`), para que a parte mesclada passe a ter a projeção.
As mesclagens ainda combinam apenas partes que compartilham o mesmo conjunto de projeções. Para preencher uma projeção em todas as partes existentes,
use um [MATERIALIZE PROJECTION](/pt-BR/reference/statements/alter/projection#materialize-projection) explícito. As projeções
também são criadas durante INSERTs com [materialize\_projections\_on\_insert](/pt-BR/reference/settings/merge-tree-settings#materialize_projections_on_insert).
## materialize\_skip\_indexes\_on\_merge
Quando habilitado, as mesclagens criam e armazenam índices de skipping para novas partes.
Caso contrário, eles podem ser criados/armazenados com um [MATERIALIZE INDEX](/pt-BR/reference/statements/alter/skipping-index#materialize-index) explícito
ou [durante INSERTs](/pt-BR/reference/settings/session-settings#materialize_skip_indexes_on_insert).
Veja também [exclude\_materialize\_skip\_indexes\_on\_merge](#exclude_materialize_skip_indexes_on_merge) para um controle mais granular.
## materialize\_statistics\_on\_merge
Quando habilitada, as mesclagens geram e armazenam estatísticas para novas partes.
Caso contrário, elas podem ser criadas/armazenadas explicitamente com [MATERIALIZE STATISTICS](/pt-BR/reference/statements/alter/statistics)
ou [durante INSERTs](/pt-BR/reference/settings/session-settings#materialize_statistics_on_insert)
## materialize\_ttl\_recalculate\_only
Recalcula as informações de TTL apenas ao executar MATERIALIZE TTL
## max\_avg\_part\_size\_for\_too\_many\_parts
A verificação de 'too many parts' com base em 'parts\_to\_delay\_insert' e
'parts\_to\_throw\_insert' ficará ativa somente se o tamanho médio da parte (na
partição relevante) não for maior que o limite especificado. Se ele for
maior que o limite especificado, os INSERTs não serão nem atrasados nem
rejeitados. Isso permite ter centenas de terabytes em uma única tabela, em um
único servidor, se as partes forem mescladas com sucesso em partes maiores. Isso
não afeta os limites de partes inativas nem o total de partes.
## max\_buckets\_in\_map
O número máximo de buckets para a serialização de `Map`. Funciona com a serialização `with_buckets` de `Map`.
O número efetivo de buckets é determinado por [map\_buckets\_strategy](#map_buckets_strategy).
O valor máximo permitido é 256.
## max\_bytes\_to\_merge\_at\_max\_space\_in\_pool
O tamanho total máximo das partes (em bytes) a ser combinado em uma única parte, se
houver recursos suficientes disponíveis. Corresponde aproximadamente ao maior
tamanho de parte possível criado por uma mesclagem automática em segundo plano. (0 significa que as mesclagens serão desabilitadas)
Valores possíveis:
* Qualquer inteiro não negativo.
O agendador de mesclagem analisa periodicamente os tamanhos e o número de partes nas
partições e, se houver recursos livres suficientes no pool, inicia
mesclagens em segundo plano. As mesclagens ocorrem até que o tamanho total das partes de origem seja
maior que `max_bytes_to_merge_at_max_space_in_pool`.
As mesclagens iniciadas por [OPTIMIZE FINAL](/pt-BR/reference/statements/optimize)
ignoram `max_bytes_to_merge_at_max_space_in_pool` (apenas o espaço livre em disco
é levado em consideração).
## max\_bytes\_to\_merge\_at\_min\_space\_in\_pool
O tamanho total máximo das partes (em bytes) a serem mescladas em uma única
parte, com o mínimo de recursos disponíveis no pool em segundo plano.
Valores possíveis:
* Qualquer inteiro positivo.
`max_bytes_to_merge_at_min_space_in_pool` define o tamanho total máximo das
partes que podem ser mescladas apesar da falta de espaço disponível em disco (no pool).
Isso é necessário para reduzir o número de partes pequenas e a chance de erros
`Too many parts`.
As mesclagens reservam espaço em disco equivalente ao dobro do tamanho total das partes mescladas.
Assim, com uma pequena quantidade de espaço livre em disco, pode ocorrer uma situação
em que há espaço livre, mas esse espaço já está reservado por grandes mesclagens em andamento,
de modo que outras mesclagens não consigam começar, e o número de partes pequenas cresce
a cada inserção.
## max\_cleanup\_delay\_period
Período máximo para a limpeza de logs antigos da fila, hashes de blocos e partes.
## 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. Você também pode especificar essa configuração nas configurações globais
(consulte a configuração [max\_compress\_block\_size](/pt-BR/reference/settings/merge-tree-settings#max_compress_block_size)).
O valor especificado quando a tabela é criada substitui o valor global
dessa configuração.
## max\_concurrent\_queries
Número máximo de consultas executadas simultaneamente relacionadas à tabela MergeTree.
As consultas ainda estarão sujeitas a outras configurações de `max_concurrent_queries`.
Valores possíveis:
* Inteiro positivo.
* `0` — Sem limite.
Valor padrão: `0` (sem limite).
**Exemplo**
```xml theme={null}
50
```
## max\_delay\_to\_insert
O valor, em segundos, usado para calcular o atraso do `INSERT` caso o
número de partes ativas em uma única partição exceda o
valor de [parts\_to\_delay\_insert](#parts_to_delay_insert).
Valores possíveis:
* Qualquer inteiro positivo.
O atraso (em milissegundos) do `INSERT` é calculado pela fórmula:
```code theme={null}
max_k = parts_to_throw_insert - parts_to_delay_insert
k = 1 + parts_count_in_partition - parts_to_delay_insert
delay_milliseconds = pow(max_delay_to_insert * 1000, k / max_k)
```
Por exemplo, se uma partição tiver 299 partes ativas e parts\_to\_throw\_insert
\= 300, parts\_to\_delay\_insert = 150, max\_delay\_to\_insert = 1, o `INSERT` é
atrasado em `pow( 1 * 1000, (1 + 299 - 150) / (300 - 150) ) = 1000`
milissegundos.
A partir da versão 23.1, a fórmula foi alterada para:
```code theme={null}
allowed_parts_over_threshold = parts_to_throw_insert - parts_to_delay_insert
parts_over_threshold = parts_count_in_partition - parts_to_delay_insert + 1
delay_milliseconds = max(min_delay_to_insert_ms, (max_delay_to_insert * 1000)
* parts_over_threshold / allowed_parts_over_threshold)
```
Por exemplo, se uma partição tiver 224 partes ativas e parts\_to\_throw\_insert
\= 300, parts\_to\_delay\_insert = 150, max\_delay\_to\_insert = 1,
min\_delay\_to\_insert\_ms = 10, o `INSERT` será adiado em `max( 10, 1 * 1000 *
(224 - 150 + 1) / (300 - 150) ) = 500` milissegundos.
## max\_delay\_to\_mutate\_ms
Atraso máximo para a mutação de uma tabela MergeTree, em milissegundos, se houver muitas
mutações não concluídas
## max\_digestion\_size\_per\_segment
Configuração obsoleta, sem efeito.
## max\_file\_name\_length
O comprimento máximo do nome do arquivo para mantê-lo como está, sem aplicar hash.
Só tem efeito se a configuração `replace_long_file_name_to_hash` estiver habilitada.
O valor dessa configuração não inclui o comprimento da extensão do arquivo. Portanto,
recomenda-se defini-la abaixo do comprimento máximo do nome de arquivo (geralmente 255
bytes), com alguma margem para evitar erros no sistema de arquivos.
## max\_files\_to\_modify\_in\_alter\_columns
Não aplique ALTER se o número de arquivos a serem modificados (excluídos, adicionados)
for maior que esta configuração.
Valores possíveis:
* Qualquer número inteiro positivo.
Valor padrão: 75
## max\_files\_to\_remove\_in\_alter\_columns
Não aplique ALTER se o número de arquivos a serem excluídos for maior que esta
configuração.
Valores possíveis:
* Qualquer número inteiro positivo.
## max\_merge\_delayed\_streams\_for\_parallel\_write
O número máximo de streams (colunas) que podem ser descarregados em paralelo
(análogo a max\_insert\_delayed\_streams\_for\_parallel\_write para mesclagens). Funciona
apenas para mesclagens verticais.
## max\_merge\_selecting\_sleep\_ms
Tempo máximo de espera antes de tentar novamente selecionar partes para mesclagem após nenhuma
parte ter sido selecionada. Uma configuração menor acionará com frequência tarefas de seleção em
background\_schedule\_pool, o que resulta em uma grande quantidade de
solicitações ao ZooKeeper em clusters de grande escala
## max\_number\_of\_merges\_with\_ttl\_in\_pool
Quando houver
mais mesclagens com entradas TTL no pool do que o número especificado, não atribua
uma nova mesclagem com TTL. Isso serve para deixar threads livres para mesclagens regulares e
evitar "Too many parts"
## max\_number\_of\_mutations\_for\_replica
Limita o número de mutações de partes por réplica ao valor especificado.
Zero significa que não há limite para o número de mutações por réplica (a execução ainda pode
ser restringida por outras configurações).
## max\_part\_loading\_threads
Configuração obsoleta, sem efeito.
## max\_part\_removal\_threads
Configuração obsoleta; não tem efeito.
## max\_partitions\_to\_read
Limita o número máximo de partições que podem ser acessadas em uma 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:
* Qualquer número inteiro positivo.
Você também pode especificar a configuração de complexidade da consulta [max\_partitions\_to\_read](/pt-BR/reference/settings/session-settings#max_partitions_to_read)
no nível de consulta / sessão / perfil.
## max\_parts\_in\_total
Se o número total de partes ativas em todas as partições de uma tabela exceder o
valor de `max_parts_in_total`, o `INSERT` será interrompido com a exceção `Too many parts
(N)`.
Valores possíveis:
* Qualquer número inteiro positivo.
Um grande número de partes em uma tabela reduz o desempenho das consultas do ClickHouse
e aumenta o tempo de inicialização do ClickHouse. Na maioria das vezes, isso é consequência de um
design inadequado (erros na escolha de uma estratégia de particionamento — partições
muito pequenas).
## max\_parts\_to\_merge\_at\_once
Número máximo de partes que podem ser mescladas de uma só vez (0 - desabilitado). Não afeta a
consulta OPTIMIZE FINAL.
## max\_postpone\_time\_for\_failed\_mutations\_ms
O tempo máximo de adiamento para mutações que falharam.
## max\_postpone\_time\_for\_failed\_replicated\_fetches\_ms
O tempo máximo de adiamento para fetches replicados com falha.
## max\_postpone\_time\_for\_failed\_replicated\_merges\_ms
O tempo máximo de adiamento para mesclagens replicadas que falharam.
## max\_postpone\_time\_for\_failed\_replicated\_tasks\_ms
O tempo máximo de adiamento para uma tarefa replicada com falha. O valor é usado se a tarefa não for um fetch, merge ou mutation.
## max\_projections
O número máximo de projeções da MergeTree.
## max\_replicated\_fetches\_network\_bandwidth
Limita a velocidade máxima de transferência de dados pela rede, em bytes por
segundo, para fetches [replicados](/pt-BR/reference/engines/table-engines/mergetree-family/replication).
Esta configuração é aplicada a uma tabela específica, ao contrário da
configuração [`max_replicated_fetches_network_bandwidth_for_server`](/pt-BR/reference/settings/merge-tree-settings#max_replicated_fetches_network_bandwidth),
que é aplicada ao servidor.
Você pode limitar tanto a rede do servidor quanto a rede de uma tabela específica, mas, para
isso, o valor da configuração no nível da tabela deve ser menor que o
valor no nível do servidor. Caso contrário, o servidor considera apenas a
configuração `max_replicated_fetches_network_bandwidth_for_server`.
A configuração não é aplicada com total precisão.
Valores possíveis:
* Inteiro positivo.
* `0` — Ilimitado.
Valor padrão: `0`.
**Uso**
Pode ser usada para limitar a velocidade durante a replicação de dados ao adicionar ou substituir
novos nós.
## max\_replicated\_logs\_to\_keep
Quantos registros podem haver no log do ClickHouse Keeper se houver uma
réplica inativa. Uma réplica inativa é considerada perdida quando esse número é ultrapassado.
Valores possíveis:
* Qualquer número inteiro positivo.
## max\_replicated\_merges\_in\_queue
Quantas tarefas de mesclagem e mutação de partes são permitidas simultaneamente na
fila do ReplicatedMergeTree.
## max\_replicated\_merges\_with\_ttl\_in\_queue
Quantas tarefas de mesclagem de partes com TTL são permitidas simultaneamente na
fila do ReplicatedMergeTree.
## max\_replicated\_mutations\_in\_queue
Quantas tarefas de mutação de partes são permitidas simultaneamente na
fila do ReplicatedMergeTree.
## max\_replicated\_sends\_network\_bandwidth
Limita a velocidade máxima da troca de dados pela rede, em bytes por
segundo, para envios [replicados](/pt-BR/reference/engines/table-engines/mergetree-family/replacingmergetree).
Essa configuração é aplicada a uma tabela específica, ao contrário da
configuração [`max_replicated_sends_network_bandwidth_for_server`](/pt-BR/reference/settings/merge-tree-settings#max_replicated_sends_network_bandwidth),
que é aplicada ao servidor.
Você pode limitar tanto a rede do servidor quanto a rede de uma tabela específica, mas,
para isso, o valor da configuração no nível da tabela deve ser menor que
o valor no nível do servidor. Caso contrário, o servidor considera apenas a
configuração `max_replicated_sends_network_bandwidth_for_server`.
A configuração não é aplicada com total precisão.
Valores possíveis:
* Inteiro positivo.
* `0` — Ilimitado.
**Uso**
Pode ser usada para limitar a velocidade ao replicar dados para adicionar ou substituir
novos nós.
## max\_suspicious\_broken\_parts
Se o número de partes corrompidas em uma única partição exceder o valor de
`max_suspicious_broken_parts`, a exclusão automática não será permitida.
Valores possíveis:
* Qualquer número inteiro positivo.
## max\_suspicious\_broken\_parts\_bytes
Tamanho máximo total de todas as partes corrompidas; se for excedido, a exclusão automática será impedida.
Valores possíveis:
* Qualquer número inteiro positivo.
## max\_uncompressed\_bytes\_in\_patches
O tamanho máximo, em bytes, dos dados não comprimidos em todas as partes de patch.
Se a quantidade de dados em todas as partes de patch exceder esse valor, as atualizações leves serão rejeitadas.
0 - ilimitado.
## merge\_max\_block\_size
O número de linhas lidas das partes mescladas para a memória.
Valores possíveis:
* Qualquer inteiro positivo.
A mesclagem lê linhas das partes em blocos de `merge_max_block_size` linhas e, em seguida,
mescla e grava o resultado em uma nova parte. O bloco lido é colocado na RAM,
portanto `merge_max_block_size` afeta a quantidade de RAM necessária para a mesclagem.
Assim, as mesclagens podem consumir uma grande quantidade de RAM em tabelas com linhas muito largas
(se o tamanho médio da linha for 100kb, então, ao mesclar 10 partes,
(100kb \* 10 \* 8192) = \~ 8GB de RAM). Ao diminuir `merge_max_block_size`,
você pode reduzir a quantidade de RAM necessária para uma mesclagem, mas ela ficará mais lenta.
## merge\_max\_block\_size\_bytes
Quantos bytes em blocos devem ser gerados para operações de merge. Por padrão,
tem o mesmo valor de `index_granularity_bytes`.
## merge\_max\_bytes\_to\_prewarm\_cache
Disponível apenas no ClickHouse Cloud. Tamanho máximo da parte (compact ou packed)
para pré-aquecer o cache durante a mesclagem.
## merge\_max\_dynamic\_subcolumns\_in\_compact\_part
O número máximo de subcolunas dinâmicas que pode ser criado em cada coluna na parte de dados Compact após a mesclagem.
Isso permite controlar o número de subcolunas dinâmicas na parte Compact, independentemente dos parâmetros dinâmicos especificados no tipo de dado.
Por exemplo, se a tabela tiver uma coluna com o tipo JSON(max\_dynamic\_paths=1024) e a configuração merge\_max\_dynamic\_subcolumns\_in\_compact\_part estiver definida como 128,
após a mesclagem na parte de dados Compact, o número de caminhos dinâmicos será reduzido para 128 nessa parte, e apenas 128 caminhos serão gravados como subcolunas dinâmicas.
## merge\_max\_dynamic\_subcolumns\_in\_wide\_part
O número máximo de subcolunas dinâmicas que podem ser criadas em cada coluna na parte de dados Wide após a mesclagem.
Isso permite reduzir o número de arquivos criados na parte de dados Wide, independentemente dos parâmetros dinâmicos especificados no tipo de dados.
Por exemplo, se a tabela tiver uma coluna do tipo JSON(max\_dynamic\_paths=1024) e a configuração merge\_max\_dynamic\_subcolumns\_in\_wide\_part estiver definida como 128,
após a mesclagem para a parte de dados Wide, o número de caminhos dinâmicos será reduzido para 128 nessa parte, e apenas 128 caminhos serão gravados como subcolunas dinâmicas.
## merge\_selecting\_sleep\_ms
Tempo mínimo de espera antes de tentar novamente selecionar partes para mesclagem após nenhuma
parte ter sido selecionada. Uma configuração mais baixa acionará com frequência tarefas de seleção no
background\_schedule\_pool, o que resulta em uma grande quantidade de solicitações
ao ZooKeeper em clusters de grande porte
## merge\_selecting\_sleep\_slowdown\_factor
O tempo de espera da tarefa de seleção de mesclagem é multiplicado por esse fator quando
não há nada para mesclar e dividido quando uma mesclagem é atribuída
## merge\_selector\_algorithm
O algoritmo para selecionar partes para a atribuição de merges
## merge\_selector\_base
Afeta a amplificação de escrita das
mesclagens atribuídas (configuração para especialistas; não altere se você não entende
o que ela faz). Funciona para os seletores de mesclagem Simple e StochasticSimple
## merge\_selector\_blurry\_base\_scale\_factor
Controla quando a lógica é acionada em relação ao número de partes na
partição. Quanto maior o fator, mais tardia será a reação.
## merge\_selector\_enable\_heuristic\_to\_lower\_max\_parts\_to\_merge\_at\_once
Ativa a heurística para o seletor de mesclagem simples, que reduz o limite máximo para a escolha de mesclagens.
Com isso, o número de mesclagens simultâneas aumentará, o que pode ajudar com erros
TOO\_MANY\_PARTS, mas, ao mesmo tempo, isso aumentará a amplificação de escrita.
## merge\_selector\_enable\_heuristic\_to\_remove\_small\_parts\_at\_right
Habilita a heurística de seleção de partes para mesclagem que remove as partes do lado
direito do intervalo, se o tamanho delas for menor que a proporção especificada (0.01) de sum\_size.
Funciona para os seletores de mesclagem Simple e StochasticSimple
## merge\_selector\_heuristic\_to\_lower\_max\_parts\_to\_merge\_at\_once\_exponent
Controla o valor do expoente usado nas fórmulas que constroem a curva de redução. Reduzir o expoente
diminuirá a amplitude das mesclagens, o que aumentará a amplificação de gravação. O inverso também é verdadeiro.
## merge\_selector\_window\_size
Quantas partes analisar de uma vez.
## merge\_total\_max\_bytes\_to\_prewarm\_cache
Disponível apenas no ClickHouse Cloud. Tamanho máximo total das partes para
pré-aquecer o cache durante a mesclagem.
## merge\_tree\_clear\_old\_broken\_detached\_parts\_ttl\_timeout\_seconds
Configuração obsoleta, sem efeito.
## merge\_tree\_clear\_old\_parts\_interval\_seconds
Define o intervalo, em segundos, para o ClickHouse executar a limpeza de
partes antigas, WALs e mutações.
Valores possíveis:
* Qualquer número inteiro positivo.
## merge\_tree\_clear\_old\_temporary\_directories\_interval\_seconds
Define o intervalo, em segundos, para que o ClickHouse execute a limpeza de
diretórios temporários antigos.
Valores possíveis:
* Qualquer número inteiro positivo.
## merge\_tree\_enable\_clear\_old\_broken\_detached
Configuração obsoleta; não tem efeito.
## merge\_with\_recompression\_ttl\_timeout
Atraso mínimo, em segundos, antes de repetir uma mesclagem com TTL de recompressão.
## merge\_with\_ttl\_timeout
Atraso mínimo, em segundos, antes de repetir uma mesclagem com TTL de exclusão.
## merge\_workload
Usado para regular como os recursos são utilizados e compartilhados entre mesclagens e
outras cargas de trabalho. O valor especificado é usado como o valor da configuração `workload` para
as mesclagens em segundo plano desta tabela. Se não for especificado (cadeia vazia), então
é usada a configuração do servidor `merge_workload`.
**Veja também**
* [Agendamento de cargas de trabalho](/pt-BR/concepts/features/configuration/server-config/workload-scheduling)
## min\_absolute\_delay\_to\_close
Atraso absoluto mínimo para fechar, parar de atender solicitações e deixar de
retornar Ok durante a verificação de status.
## min\_age\_to\_force\_merge\_on\_partition\_only
Se `min_age_to_force_merge_seconds` deve ser aplicado apenas à partição como um todo,
e não a um subconjunto.
Por padrão, ignora a configuração `max_bytes_to_merge_at_max_space_in_pool` (veja
`enable_max_bytes_limit_for_min_age_to_force_merge`).
Valores possíveis:
* true, false
## min\_age\_to\_force\_merge\_seconds
Mescla as partes se cada parte no intervalo for mais antiga que o valor de
`min_age_to_force_merge_seconds`.
Por padrão, ignora a configuração `max_bytes_to_merge_at_max_space_in_pool`
(consulte `enable_max_bytes_limit_for_min_age_to_force_merge`).
Valores possíveis:
* Inteiro positivo.
## min\_bytes\_for\_compact\_part
Configuração obsoleta, sem efeito.
## min\_bytes\_for\_full\_part\_storage
Disponível apenas no ClickHouse Cloud. Tamanho mínimo descompactado, em bytes, para
usar o tipo full de armazenamento para a parte de dados em vez de packed
## min\_bytes\_for\_wide\_part
Número mínimo de bytes/linhas em uma parte de dados que pode ser armazenada no
formato `Wide`. Você pode definir uma delas, as duas ou nenhuma dessas configurações.
## min\_bytes\_to\_prewarm\_caches
Tamanho mínimo (em bytes não comprimidos) para pré-aquecer o mark cache e o cache do índice primário
de novas partes
## min\_bytes\_to\_rebalance\_partition\_over\_jbod
Define a quantidade mínima de bytes para habilitar o balanceamento ao distribuir novas
partes grandes entre os discos do volume [JBOD](https://en.wikipedia.org/wiki/Non-RAID_drive_architectures).
Valores possíveis:
* Inteiro positivo.
* `0` — O balanceamento está desabilitado.
**Uso**
O valor da configuração `min_bytes_to_rebalance_partition_over_jbod` não deve
ser menor que o valor de
[max\_bytes\_to\_merge\_at\_max\_space\_in\_pool](/pt-BR/reference/settings/merge-tree-settings#max_bytes_to_merge_at_max_space_in_pool)
/ 1024. Caso contrário, o ClickHouse lança uma exceção.
## min\_columns\_to\_activate\_adaptive\_write\_buffer
Permite reduzir o uso de memória em tabelas com muitas colunas usando buffers adaptativos de gravação.
Valores possíveis:
* 0 - ilimitado
* 1 - sempre ativado
## min\_compress\_block\_size
Tamanho mínimo dos blocos de dados não comprimidos necessário para a compressão ao
gravar a próxima mark. Você também pode especificar essa configuração nas configurações globais
(consulte a configuração [min\_compress\_block\_size](/pt-BR/reference/settings/merge-tree-settings#min_compress_block_size)).
O valor especificado quando a tabela é criada substitui o valor global
dessa configuração.
## min\_compressed\_bytes\_to\_fsync\_after\_fetch
Número mínimo de bytes comprimidos para executar fsync em uma parte após o fetch (0 - desabilitado)
## min\_compressed\_bytes\_to\_fsync\_after\_merge
Número mínimo de bytes comprimidos para executar `fsync` na parte após o merge (0 - desabilitado)
## min\_delay\_to\_insert\_ms
Atraso mínimo para inserir dados em uma tabela MergeTree, em milissegundos, se houver
muitas partes ainda não mescladas em uma única partição.
## min\_delay\_to\_mutate\_ms
Atraso mínimo para realizar mutações em uma tabela MergeTree, em milissegundos, se houver muitas
mutações não concluídas
## min\_free\_disk\_bytes\_to\_perform\_insert
O número mínimo de bytes que devem estar livres em disco para
inserir dados. Se o número de bytes livres disponíveis for menor que
`min_free_disk_bytes_to_perform_insert`, uma exceção será lançada e a
inserção não será executada. Observe que esta configuração:
* leva em conta a configuração `keep_free_space_bytes`.
* não leva em conta a quantidade de dados que será gravada pela
operação `INSERT`.
* só é verificada se um número positivo (diferente de zero) de bytes for especificado
Possíveis valores:
* Qualquer inteiro positivo.
Se `min_free_disk_bytes_to_perform_insert` e `min_free_disk_ratio_to_perform_insert`
forem especificados, o ClickHouse considerará o valor que permitirá realizar
inserções com uma quantidade maior de memória livre.
## min\_free\_disk\_ratio\_to\_perform\_insert
A proporção mínima de espaço livre em relação ao espaço total em disco para realizar um `INSERT`. Deve ser um
valor de ponto flutuante entre 0 e 1. Observe que esta configuração:
* leva em consideração a configuração `keep_free_space_bytes`.
* não leva em consideração a quantidade de dados que será gravada pela
operação `INSERT`.
* só é verificada se uma proporção positiva (não zero) for especificada
Valores possíveis:
* Float, 0.0 - 1.0
Observe que, se `min_free_disk_ratio_to_perform_insert` e
`min_free_disk_bytes_to_perform_insert` forem especificadas, o ClickHouse se baseará
no valor que permitir realizar inserts com uma maior quantidade de
espaço livre em disco.
## min\_index\_granularity\_bytes
Tamanho mínimo permitido dos grânulos de dados, em bytes.
Para evitar a criação acidental de tabelas com `index_granularity_bytes`
muito baixo.
## min\_level\_for\_full\_part\_storage
Disponível apenas no ClickHouse Cloud. Nível mínimo da parte para
usar o tipo de armazenamento full para a parte de dados em vez de packed
## min\_level\_for\_wide\_part
Nível mínimo da parte para que uma parte de dados seja criada no formato `Wide` em vez de `Compact`.
## min\_marks\_to\_honor\_max\_concurrent\_queries
O número mínimo de marcas lidas pela consulta para que a configuração [max\_concurrent\_queries](#max_concurrent_queries) seja aplicada.
As consultas ainda serão limitadas por outras configurações de `max_concurrent_queries`.
Valores possíveis:
* Inteiro positivo.
* `0` — Desativado (o limite de `max_concurrent_queries` não se aplica a nenhuma consulta).
**Exemplo**
```xml theme={null}
10
```
## min\_merge\_bytes\_to\_use\_direct\_io
O volume mínimo de dados para a operação de mesclagem necessário para usar
acesso de E/S direta ao disco de armazenamento. Ao mesclar partes de dados, o ClickHouse calcula
o volume total de armazenamento de todos os dados a serem mesclados. Se o volume exceder
`min_merge_bytes_to_use_direct_io` bytes, o ClickHouse lê e grava os
dados no disco de armazenamento usando a interface de E/S direta (opção `O_DIRECT`).
Se `min_merge_bytes_to_use_direct_io = 0`, a E/S direta será desabilitada.
## min\_parts\_to\_merge\_at\_once
Quantidade mínima de partes de dados que o seletor de merge pode escolher para mesclar de uma vez
(configuração de nível especialista; não altere se você não entender o que ela faz).
0 - desabilitado. Funciona para os seletores de merge Simple e StochasticSimple.
## min\_relative\_delay\_to\_close
Atraso mínimo em relação às outras réplicas para fechar, parar de atender
solicitações e não retornar Ok durante a verificação de status.
## min\_relative\_delay\_to\_measure
Calcula o atraso relativo da réplica apenas se o atraso absoluto não for menor que
esse valor.
## min\_relative\_delay\_to\_yield\_leadership
Configuração obsoleta, sem efeito.
## min\_replicated\_logs\_to\_keep
Mantenha aproximadamente esta quantidade dos registros mais recentes no log do ZooKeeper, mesmo que estejam
obsoletos. Isso não afeta o funcionamento das tabelas: é usado apenas para diagnosticar o
log do ZooKeeper antes da limpeza.
Valores possíveis:
* Qualquer número inteiro positivo.
## min\_rows\_for\_compact\_part
Configuração obsoleta; não tem efeito.
## min\_rows\_for\_full\_part\_storage
Disponível apenas no ClickHouse Cloud. Número mínimo de linhas para usar o tipo de
armazenamento completo para a parte de dados em vez do formato compactado
## min\_rows\_for\_wide\_part
Número mínimo de linhas para criar uma parte de dados no formato `Wide` em vez de `Compact`.
## min\_rows\_to\_fsync\_after\_merge
Número mínimo de linhas para executar `fsync` na parte após a mesclagem (0 - desabilitado)
## mutation\_workload
Usado para controlar como os recursos são utilizados e compartilhados entre mutações e
outras cargas de trabalho. O valor especificado é usado como valor da configuração `workload` para
as mutações em segundo plano desta tabela. Se não for especificado (string vazia),
será usada a configuração do servidor `mutation_workload`.
**Veja também**
* [Agendamento de cargas de trabalho](/pt-BR/concepts/features/configuration/server-config/workload-scheduling)
## non\_replicated\_deduplication\_window
O número dos blocks inseridos mais recentemente na tabela
[MergeTree](/pt-BR/reference/engines/table-engines/mergetree-family/mergetree) não replicada
cujas somas de hash são armazenadas para verificação de duplicatas.
Valores possíveis:
* Qualquer número inteiro positivo.
* `0` (desabilita a desduplicação).
É usado um mecanismo de desduplicação, semelhante ao das tabelas replicadas (consulte a
configuração [replicated\_deduplication\_window](#replicated_deduplication_window)).
As somas de hash das partes criadas são gravadas em um arquivo local em um disco.
## notify\_newest\_block\_number
Notifica o número do bloco mais recente ao SharedJoin ou SharedSet. Somente no ClickHouse Cloud.
## nullable\_serialization\_version
Determina o método de serialização usado para colunas `Nullable(T)`.
Valores possíveis:
* basic — Usa a serialização padrão para `Nullable(T)`.
* allow\_sparse — Permite que `Nullable(T)` use codificação esparsa.
## number\_of\_free\_entries\_in\_pool\_to\_execute\_mutation
Quando houver menos entradas livres no pool do que o número especificado, não
execute mutações de partes. Isso serve para manter threads livres para merges regulares e
evitar erros de "Too many parts".
Valores possíveis:
* Qualquer número inteiro positivo.
**Uso**
O valor da configuração `number_of_free_entries_in_pool_to_execute_mutation`
deve ser menor que o valor de [background\_pool\_size](/pt-BR/reference/settings/server-settings/settings#background_pool_size)
* [background\_merges\_mutations\_concurrency\_ratio](/pt-BR/reference/settings/server-settings/settings#background_merges_mutations_concurrency_ratio).
Caso contrário, o ClickHouse lançará uma exceção.
## number\_of\_free\_entries\_in\_pool\_to\_execute\_optimize\_entire\_partition
Quando houver menos entradas livres no pool do que o número especificado, não
execute a otimização da partição inteira em segundo plano (essa tarefa é gerada
quando `min_age_to_force_merge_seconds` é definido e
`min_age_to_force_merge_on_partition_only` é habilitado). Isso serve para deixar threads livres
para merges regulares e evitar "Too many parts".
Valores possíveis:
* Inteiro positivo.
O valor da configuração `number_of_free_entries_in_pool_to_execute_optimize_entire_partition`
deve ser menor que o valor de
[background\_pool\_size](/pt-BR/reference/settings/server-settings/settings#background_pool_size)
* [background\_merges\_mutations\_concurrency\_ratio](/pt-BR/reference/settings/server-settings/settings#background_merges_mutations_concurrency_ratio).
Caso contrário, ClickHouse lança uma exceção.
## number\_of\_free\_entries\_in\_pool\_to\_lower\_max\_size\_of\_merge
Quando houver menos do que o número especificado de entradas disponíveis no pool
(ou na fila de replicação), comece a reduzir o tamanho máximo da merge a ser processada
(ou a ser colocada na fila).
Isso permite processar merges menores, sem preencher o pool com merges
de longa duração.
Valores possíveis:
* Qualquer número inteiro positivo.
## number\_of\_mutations\_to\_delay
Se a tabela tiver pelo menos
essa quantidade de mutações não concluídas, desacelere artificialmente as mutações da tabela.
Desativado se definido como 0
## number\_of\_mutations\_to\_throw
Se a tabela tiver pelo menos esse número de mutações não concluídas, gera a exceção 'Too many mutations'.
Desativado se definido como 0
## number\_of\_partitions\_to\_consider\_for\_merge
Disponível apenas no ClickHouse Cloud. Até as N principais partições serão
consideradas para merge. As partições são escolhidas de forma aleatória e ponderada, em que o peso
é a quantidade de partes de dados que podem sofrer merge nessa partição.
## object\_serialization\_version
Versão de serialização do tipo de dado JSON. Necessária para compatibilidade.
Valores possíveis:
* `v1`
* `v2`
* `v3`
Somente a versão `v3` oferece suporte à alteração da versão de serialização dos dados compartilhados.
## object\_shared\_data\_buckets\_for\_compact\_part
O número de buckets da serialização de dados compartilhados em JSON em partes compactas. Funciona com as serializações de dados compartilhados `map_with_buckets` e `advanced`.
O valor máximo permitido é 256.
## object\_shared\_data\_buckets\_for\_wide\_part
O número de buckets usados na serialização de dados compartilhados em JSON em partes Wide. Funciona com as serializações de dados compartilhados `map_with_buckets` e `advanced`.
O valor máximo permitido é 256.
## object\_shared\_data\_serialization\_version
Versão de serialização para dado compartilhado no tipo de dado JSON.
Valores possíveis:
* `map` - armazena dado compartilhado como `Map(String, String)`
* `map_with_buckets` - armazena dado compartilhado como várias colunas `Map(String, String)` separadas. O uso de buckets melhora a leitura de caminhos individuais de dado compartilhado.
* `advanced` - serialização especial de dado compartilhado projetada para melhorar significativamente a leitura de caminhos individuais de dado compartilhado.
Observe que essa serialização aumenta o tamanho de armazenamento de dado compartilhado em disco, porque armazenamos muitas informações adicionais.
O número de buckets para as serializações `map_with_buckets` e `advanced` é determinado pelas configurações
[object\_shared\_data\_buckets\_for\_compact\_part](#object_shared_data_buckets_for_compact_part)/[object\_shared\_data\_buckets\_for\_wide\_part](#object_shared_data_buckets_for_wide_part).
## object\_shared\_data\_serialization\_version\_for\_zero\_level\_parts
Esta configuração permite especificar diferentes versões de serialização dos
dados compartilhados no tipo JSON para partes de nível zero criadas durante inserções.
Recomenda-se não usar a serialização de dados compartilhados `advanced` para partes de nível zero, pois isso pode aumentar
significativamente o tempo de inserção.
## old\_parts\_lifetime
O tempo (em segundos) durante o qual partes inativas são armazenadas para proteger contra perda de dados
durante reinicializações inesperadas do servidor.
Valores possíveis:
* Qualquer número inteiro positivo.
Após mesclar várias partes em uma nova parte, o ClickHouse marca as partes
originais como inativas e as exclui somente após `old_parts_lifetime` segundos.
As partes inativas são removidas se não estiverem sendo usadas por consultas em execução, ou seja, se
o `refcount` da parte for 1.
`fsync` não é chamado para novas partes, portanto, por algum tempo, as novas partes existem apenas
na RAM do servidor (cache do SO). Se o servidor for reiniciado inesperadamente, as novas
partes podem ser perdidas ou danificadas. Para proteger os dados, as partes inativas não são excluídas
imediatamente.
Durante a inicialização, o ClickHouse verifica a integridade das partes. Se a parte
mesclada estiver danificada, o ClickHouse devolve as partes inativas à lista de partes ativas
e depois as mescla novamente. Em seguida, a parte danificada é renomeada (o prefixo `broken_`
é adicionado) e movida para a pasta `detached`. Se a parte mesclada não estiver
danificada, então as partes inativas originais são renomeadas (o prefixo `ignored_`
é adicionado) e movidas para a pasta `detached`.
O valor padrão de `dirty_expire_centisecs` (uma configuração do kernel Linux) é de 30
segundos (o tempo máximo em que os dados gravados ficam armazenados apenas na RAM), mas, sob
carga intensa no sistema de disco, os dados podem ser gravados bem mais tarde. Experimentalmente,
foi escolhido o valor de 480 segundos para `old_parts_lifetime`, período durante o qual
uma nova parte tem gravação garantida em disco.
## optimize\_row\_order
Controla se a ordem das linhas deve ser otimizada durante inserções para melhorar a
compressibilidade da parte da tabela recém-inserida.
Só tem efeito em tabelas comuns com engine MergeTree. Não faz nada em
tabelas com engines MergeTree especializadas (por exemplo, CollapsingMergeTree).
As tabelas MergeTree são compactadas (opcionalmente) usando [codecs de compressão](/pt-BR/reference/statements/create/table#column_compression_codec).
Codecs de compressão genéricos, como LZ4 e ZSTD, atingem taxas máximas de compactação
se os dados apresentarem padrões. Sequências longas do mesmo valor normalmente
são compactadas muito bem.
Se essa configuração estiver habilitada, o ClickHouse tentará armazenar os dados nas
partes recém-inseridas em uma ordem de linhas que minimize o número de sequências de valores iguais
ao longo das colunas da nova parte da tabela.
Em outras palavras, um número pequeno de sequências de valores iguais significa que as sequências individuais
são longas e compactam bem.
Encontrar a ordem ideal das linhas é computacionalmente inviável (NP-hard).
Por isso, o ClickHouse usa uma heurística para encontrar rapidamente uma ordem de linhas que
ainda assim melhore as taxas de compactação em relação à ordem original das linhas.
Heurística para encontrar uma ordem de linhas
Em geral, é possível reordenar livremente as linhas de uma tabela (ou parte da tabela),
pois o SQL considera equivalentes a mesma tabela (parte da tabela) em ordens de linhas diferentes.
Essa liberdade de reordenar linhas é restrita quando uma chave primária é definida
para a tabela. No ClickHouse, uma chave primária `C1, C2, ..., CN` impõe que
as linhas da tabela sejam ordenadas pelas colunas `C1`, `C2`, ... `Cn` ([clustered index](https://en.wikipedia.org/wiki/Database_index#Clustered)).
Como resultado, as linhas só podem ser reordenadas dentro de "classes de equivalência" de linhas,
ou seja, linhas que têm os mesmos valores nas colunas da chave primária.
A intuição é que chaves primárias de alta cardinalidade, por exemplo, chaves primárias
que envolvem uma coluna de timestamp `DateTime64`, levam a muitas classes de equivalência
pequenas. Da mesma forma, tabelas com chave primária de baixa cardinalidade criam poucas
classes de equivalência grandes. Uma tabela sem chave primária representa o caso extremo
de uma única classe de equivalência que abrange todas as linhas.
Quanto menos numerosas e maiores forem as classes de equivalência, maior será o grau
de liberdade ao reordenar as linhas.
A heurística aplicada para encontrar a melhor ordem de linhas dentro de cada classe de equivalência
é sugerida por D. Lemire e O. Kaser em
[Reordering columns for smaller indexes](https://doi.org/10.1016/j.ins.2011.02.002)
e se baseia em ordenar as linhas dentro de cada classe de equivalência por cardinalidade
crescente das colunas que não fazem parte da chave primária.
Ela executa três passos:
1. Encontrar todas as classes de equivalência com base nos valores das linhas nas colunas da chave primária.
2. Para cada classe de equivalência, calcular (normalmente estimar) as cardinalidades
das colunas que não fazem parte da chave primária.
3. Para cada classe de equivalência, ordenar as linhas em ordem de cardinalidade crescente
das colunas que não fazem parte da chave primária.
Se habilitada, as operações de insert incorrem em custos adicionais de CPU para analisar e
otimizar a ordem das linhas dos novos dados. Espera-se que INSERTs levem de 30% a 50%
mais tempo, dependendo das características dos dados.
As taxas de compactação de LZ4 ou ZSTD melhoram, em média, de 20% a 40%.
Essa configuração funciona melhor para tabelas sem chave primária ou com chave primária de baixa cardinalidade,
ou seja, uma tabela com apenas poucos valores distintos de chave primária.
Não se espera que chaves primárias de alta cardinalidade, por exemplo, envolvendo colunas de timestamp do tipo
`DateTime64`, se beneficiem dessa configuração.
## packed\_skip\_index\_max\_bytes
.idx2` / `.mrk2`. A decisão é tomada por subfluxo no momento da gravação."}]}]} />
Limiar (bytes serializados em disco, ou seja, após a cadeia de compressão e hashing
do subfluxo) abaixo do qual um subfluxo de skip-index é agrupado em um único arquivo
`skp_idx.packed` por parte, em vez de ser gravado como um arquivo separado `skp_idx_.idx2` / `.mrk2`.
Subfluxos maiores que isso permanecem no layout legado por arquivo. A decisão é
tomada independentemente por subfluxo no momento da gravação, portanto uma única parte pode ter índices pequenos
(por exemplo, `minmax`) empacotados e grandes (por exemplo, um `bloom_filter` pesado) gravados por arquivo. Defina como 0
para desabilitar totalmente o empacotamento (padrão).
Cada subfluxo de skip-index, na prática, consiste em um arquivo de dados e um arquivo de marcas; ambos ficam em buffer
na memória até o limiar antes que a decisão de spill seja tomada. Portanto, a memória de pico durante
a gravação escala com `2 * packed_skip_index_max_bytes * (number of substreams that stay
below the threshold)`.
Índices de texto completo não são compatíveis com esta configuração e nunca são empacotados.
O empacotamento reduz a pressão sobre os inodes quando muitos índices de skipping são definidos em uma tabela (por exemplo,
com `add_minmax_index_for_numeric_columns`).
O formato em disco é autodescritivo: os leitores detectam `skp_idx.packed` e leem subfluxos empacotados
a partir dele de forma transparente. Alterar esta configuração afeta apenas partes recém-gravadas;
as partes existentes mantêm o layout que tinham no momento da gravação.
Limitação conhecida: `system.data_skipping_indices.data_uncompressed_bytes` e
`system.parts.secondary_indices_uncompressed_bytes` reportam o tamanho comprimido para subfluxos empacotados
(o índice do arquivo não armazena tamanhos descomprimidos). Isso é apenas cosmético no
monitoramento, com uma consequência funcional:
`distributed_index_analysis_min_indexes_bytes_to_activate` compara com
`data_uncompressed`, portanto um índice empacotado que comprime bem (`set` ou `bloom_filter` em
strings) pode não ultrapassar o limiar de ativação, mesmo que o tamanho real descomprimido ultrapassasse esse limite.
O fallback é o plano de consulta normal, não um resultado incorreto.
## part\_minmax\_index\_columns
Seleciona quais colunas são cobertas pelo índice min-max de cada parte. Cada valor habilita um grupo adicional de colunas além do anterior.
Valores possíveis:
* `partition_key_only` — apenas as colunas da chave de partição são rastreadas.
* `with_block_number_offset` — colunas da chave de partição mais as colunas virtuais persistidas `_block_number` e `_block_offset`. Habilita o pruning em nível de parte por essas colunas.
## part\_moves\_between\_shards\_delay\_seconds
Tempo de espera antes/depois da movimentação de partes entre shards.
## part\_moves\_between\_shards\_enable
Recurso Experimental/Incompleto para mover partes entre shards. Não leva em
conta expressões de sharding.
## parts\_to\_delay\_insert
Se o número de partes ativas em uma única partição exceder o valor
`parts_to_delay_insert`, um `INSERT` será artificialmente retardado.
Valores possíveis:
* Qualquer inteiro positivo.
O ClickHouse faz com que o `INSERT` demore mais (adiciona um 'sleep') para que o
processo de mesclagem em segundo plano consiga mesclar as partes mais rapidamente do que elas são adicionadas.
## parts\_to\_throw\_insert
Se o número de partes ativas em uma única partição exceder o valor de
`parts_to_throw_insert`, o `INSERT` será interrompido com a exceção `Too many
parts (N). Merges are processing significantly slower than inserts`.
Valores possíveis:
* Qualquer inteiro positivo.
Para atingir o desempenho máximo das consultas `SELECT`, é necessário
minimizar o número de partes processadas; consulte [Merge Tree](/pt-BR/resources/develop-contribute/introduction/architecture#merge-tree).
Antes da versão 23.6, essa configuração estava definida como 300. Você pode definir um
valor mais alto; isso reduzirá a probabilidade do erro `Too many parts`,
mas, ao mesmo tempo, o desempenho de `SELECT` pode ser degradado. Além disso, em caso
de problema de mesclagem (por exemplo, devido a espaço em disco insuficiente), você
só o perceberá mais tarde do que com o valor original de 300.
## prefer\_fetch\_merged\_part\_size\_threshold
Se a soma dos tamanhos das partes exceder esse limite e o tempo desde a
criação de uma entrada de log de replicação for maior que
`prefer_fetch_merged_part_time_threshold`, será preferível buscar a parte mesclada
de uma réplica em vez de fazer a mesclagem localmente. Isso acelera mesclagens muito longas.
Valores possíveis:
* Qualquer inteiro positivo.
## prefer\_fetch\_merged\_part\_time\_threshold
Se o tempo decorrido desde a criação de uma entrada no log de replicação (ClickHouse Keeper ou ZooKeeper)
exceder esse limite, e a soma dos tamanhos das partes for
maior que `prefer_fetch_merged_part_size_threshold`, então prefira obter a
parte mesclada de uma réplica em vez de fazer a mesclagem localmente. Isso ajuda a acelerar
mesclagens muito longas.
Valores possíveis:
* Qualquer inteiro positivo.
## prewarm\_mark\_cache
Se true, o cache de marcas será
pré-aquecido ao salvar marcas no cache de marcas durante inserts, mesclagens, fetches e na
inicialização do servidor
## prewarm\_primary\_key\_cache
Se true, o cache do índice primário
será pré-aquecido ao salvar marcas no cache de marcas durante inserções, mesclagens,
fetches e na inicialização do servidor
## primary\_key\_compress\_block\_size
Tamanho do bloco de compressão da chave primária, ou seja, o tamanho real do bloco a ser comprimido.
## primary\_key\_compression\_codec
Codec de compressão usado pela chave primária; ela é pequena o suficiente e fica em cache, portanto o padrão é ZSTD(3).
## primary\_key\_lazy\_load
Carrega a chave primária na memória no
primeiro uso, em vez de durante a inicialização da tabela. Isso pode economizar memória quando há
um grande número de tabelas.
## primary\_key\_ratio\_of\_unique\_prefix\_values\_to\_skip\_suffix\_columns
Se o valor de uma coluna da chave primária em uma parte de dados mudar pelo menos
nessa proporção de vezes, pule o carregamento das colunas seguintes na memória. Isso permite economizar
uso de memória ao não carregar colunas inúteis da chave primária.
## propagate\_types\_serialization\_versions\_to\_nested\_types
Se true, versões de serialização como string\_serialization\_version serão propagadas para dentro de tipos aninhados, como Array/Map/Nullable/JSON/etc. Se desabilitado, a versão de serialização terá efeito apenas nas colunas de nível superior desse tipo e Tuple el
## ratio\_of\_defaults\_for\_sparse\_serialization
Proporção mínima entre o número de valores *padrão* e o número de *todos* os valores
em uma coluna. Definir esse valor faz com que a coluna seja armazenada usando
serializações esparsas.
Se uma coluna for esparsa (contiver principalmente zeros), o ClickHouse poderá codificá-la em
um formato esparso e otimizar automaticamente os cálculos — os dados não
precisam ser totalmente descomprimidos durante as queries. Para habilitar essa serialização
esparsa, defina a configuração `ratio_of_defaults_for_sparse_serialization`
como menor que 1.0. Se o valor for maior ou igual a 1.0,
as colunas sempre serão gravadas usando a serialização completa normal.
Valores possíveis:
* Float entre `0` e `1` para habilitar a serialização esparsa
* `1.0` (ou maior) se você não quiser usar serialização esparsa
**Exemplo**
Observe que a coluna `s` na tabela a seguir é uma string vazia em 95% das
linhas. Em `my_regular_table`, não usamos serialização esparsa, e em
`my_sparse_table`, definimos `ratio_of_defaults_for_sparse_serialization` como
0.95:
```sql theme={null}
CREATE TABLE my_regular_table
(
`id` UInt64,
`s` String
)
ENGINE = MergeTree
ORDER BY id;
INSERT INTO my_regular_table
SELECT
number AS id,
number % 20 = 0 ? toString(number): '' AS s
FROM
numbers(10000000);
CREATE TABLE my_sparse_table
(
`id` UInt64,
`s` String
)
ENGINE = MergeTree
ORDER BY id
SETTINGS ratio_of_defaults_for_sparse_serialization = 0.95;
INSERT INTO my_sparse_table
SELECT
number,
number % 20 = 0 ? toString(number): ''
FROM
numbers(10000000);
```
Observe que a coluna `s` em `my_sparse_table` ocupa menos espaço em disco:
```sql theme={null}
SELECT table, name, data_compressed_bytes, data_uncompressed_bytes FROM system.columns
WHERE table LIKE 'my_%_table';
```
```response theme={null}
┌─table────────────┬─name─┬─data_compressed_bytes─┬─data_uncompressed_bytes─┐
│ my_regular_table │ id │ 37790741 │ 75488328 │
│ my_regular_table │ s │ 2451377 │ 12683106 │
│ my_sparse_table │ id │ 37790741 │ 75488328 │
│ my_sparse_table │ s │ 2283454 │ 9855751 │
└──────────────────┴──────┴───────────────────────┴─────────────────────────┘
```
Você pode verificar se uma coluna usa a codificação esparsa consultando a
coluna `serialization_kind` da tabela `system.parts_columns`:
```sql theme={null}
SELECT column, serialization_kind FROM system.parts_columns
WHERE table LIKE 'my_sparse_table';
```
Você pode ver quais partes de `s` foram armazenadas com a serialização esparsa:
```response theme={null}
┌─column─┬─serialization_kind─┐
│ id │ Default │
│ s │ Default │
│ id │ Default │
│ s │ Default │
│ id │ Default │
│ s │ Sparse │
│ id │ Default │
│ s │ Sparse │
│ id │ Default │
│ s │ Sparse │
│ id │ Default │
│ s │ Sparse │
│ id │ Default │
│ s │ Sparse │
│ id │ Default │
│ s │ Sparse │
│ id │ Default │
│ s │ Sparse │
│ id │ Default │
│ s │ Sparse │
│ id │ Default │
│ s │ Sparse │
└────────┴────────────────────┘
```
## reduce\_blocking\_parts\_sleep\_ms
Disponível apenas no ClickHouse Cloud. Tempo mínimo de espera antes de tentar
reduzir novamente as partes bloqueantes, caso nenhum intervalo tenha sido descartado/substituído. Uma configuração mais baixa
acionará tarefas em background\_schedule\_pool com frequência, o que
resulta em um grande volume de solicitações ao zookeeper em clusters de grande escala
## refresh\_parts\_interval
Se for maior que zero, atualiza a lista de partes de dados no sistema de arquivos subjacente para verificar se os dados foram atualizados diretamente nele.
Só pode ser definido se a tabela estiver localizada em disks readonly (o que significa que esta é uma réplica readonly, enquanto os dados estão sendo gravados por outra réplica).
## refresh\_statistics\_interval
O intervalo de atualização do cache de estatísticas, em segundos. Se definido como zero, a atualização será desativada.
## remote\_fs\_execute\_merges\_on\_single\_replica\_time\_threshold
Quando esta configuração tem um valor maior que zero, apenas uma única réplica inicia
a mesclagem imediatamente se a parte mesclada estiver no armazenamento compartilhado.
A replicação zero-copy não está pronta para produção
A replicação zero-copy é desativada por padrão no ClickHouse na versão 22.8 e
posteriores.
Este recurso não é recomendado para uso em produção.
Valores possíveis:
* Qualquer inteiro positivo.
## remote\_fs\_zero\_copy\_path\_compatible\_mode
Executa o zero-copy em modo compatível durante o processo de conversão.
## remote\_fs\_zero\_copy\_zookeeper\_path
Caminho do ZooKeeper para informações de zero-copy independentes de tabela.
## remove\_empty\_parts
Remove as partes vazias após terem sido eliminadas por TTL, mutação ou pelo algoritmo de mesclagem
de collapsing.
## remove\_rolled\_back\_parts\_immediately
Configuração de um recurso experimental ainda incompleto.
## remove\_unused\_patch\_parts
Remove em segundo plano as partes de patch aplicadas a todas as partes ativas.
## replace\_long\_file\_name\_to\_hash
Se o nome de arquivo da coluna for muito longo (mais de 'max\_file\_name\_length'
bytes), substitua-o por SipHash128
## replicated\_can\_become\_leader
Se `true`, as réplicas de tabelas replicadas neste nó tentarão
assumir a liderança.
Valores possíveis:
* `true`
* `false`
## replicated\_deduplication\_window
O número de blocos inseridos mais recentemente para os quais o ClickHouse Keeper armazena
somas de hash para verificar duplicatas.
Valores possíveis:
* Qualquer inteiro positivo.
* 0 (desabilita a desduplicação)
O comando `Insert` cria um ou mais blocos (partes). Para
[desduplicação de inserção](/pt-BR/reference/engines/table-engines/mergetree-family/replication),
ao gravar em tabelas replicadas, o ClickHouse grava as somas de hash das
partes criadas no ClickHouse Keeper. As somas de hash são armazenadas apenas para os
`replicated_deduplication_window` blocos mais recentes. As somas de hash mais antigas são
removidas do ClickHouse Keeper.
Um valor alto para `replicated_deduplication_window` torna os `Inserts` mais lentos,
porque mais entradas precisam ser comparadas. A soma de hash é calculada a partir
da composição dos nomes e tipos dos campos e dos dados da parte
inserida (fluxo de bytes).
## replicated\_deduplication\_window\_for\_async\_inserts
O número de blocos inseridos de forma assíncrona mais recentemente para os quais o ClickHouse Keeper
armazena somas de hash para verificar duplicatas.
Valores possíveis:
* Qualquer inteiro positivo.
* 0 (desabilita a desduplicação para async\_inserts)
O comando [Async Insert](/pt-BR/reference/settings/session-settings#async_insert) será
armazenado em cache em um ou mais blocos (partes). Para [desduplicação de inserção](/pt-BR/reference/engines/table-engines/mergetree-family/replication),
ao gravar em tabelas replicadas, o ClickHouse grava as somas de hash de cada
insert no ClickHouse Keeper. As somas de hash são armazenadas apenas para os
`replicated_deduplication_window_for_async_inserts` blocos mais recentes. As somas de hash
mais antigas são removidas do ClickHouse Keeper.
Um valor alto de `replicated_deduplication_window_for_async_inserts` torna
`Async Inserts` mais lento, porque precisa comparar mais entradas.
A soma de hash é calculada com base na composição dos nomes e tipos dos campos
e nos dados do insert (fluxo de bytes).
## replicated\_deduplication\_window\_seconds
O número de segundos após o qual as somas de hash dos blocos inseridos são
removidas do ClickHouse Keeper.
Valores possíveis:
* Qualquer inteiro positivo.
Semelhante a [replicated\_deduplication\_window](#replicated_deduplication_window),
`replicated_deduplication_window_seconds` especifica por quanto tempo armazenar somas de hash
de blocos para desduplicação de inserção. Somas de hash mais antigas que
`replicated_deduplication_window_seconds` são removidas do ClickHouse Keeper,
mesmo que sejam menos de ` replicated_deduplication_window`.
O tempo é relativo ao horário do registro mais recente, não ao tempo
de relógio. Se for o único registro, ele será armazenado para sempre.
## replicated\_deduplication\_window\_seconds\_for\_async\_inserts
O número de segundos após os quais as somas de hash dos async inserts são
removidas do ClickHouse Keeper.
Possíveis valores:
* Qualquer número inteiro positivo.
Semelhante a [replicated\_deduplication\_window\_for\_async\_inserts](#replicated_deduplication_window_for_async_inserts),
`replicated_deduplication_window_seconds_for_async_inserts` especifica por
quanto tempo armazenar somas de hash de blocos para a desduplicação de async inserts. Somas de hash
mais antigas que `replicated_deduplication_window_seconds_for_async_inserts` são
removidas do ClickHouse Keeper, mesmo que sejam inferiores a
`replicated_deduplication_window_for_async_inserts`.
O tempo é relativo ao momento do registro mais recente, não ao tempo
de relógio. Se esse for o único registro, ele será armazenado para sempre.
## replicated\_fetches\_http\_connection\_timeout
Configuração obsoleta, sem efeito.
## replicated\_fetches\_http\_receive\_timeout
Configuração obsoleta, sem efeito.
## replicated\_fetches\_http\_send\_timeout
Configuração obsoleta, sem efeito.
## replicated\_fetches\_min\_part\_level
Nível mínimo da parte para busca em outras réplicas. As partes com nível abaixo desse limite são adiadas
(mantidas na fila de replicação e reavaliadas a cada ciclo de agendamento, não ignoradas permanentemente).
Use 1 para adiar a busca de partes de nível 0 (não mescladas), reduzindo a sobrecarga de replicação durante ingestão intensa.
Padrão: 0 (buscar todas as partes, independentemente do nível).
## replicated\_fetches\_min\_part\_level\_timeout\_seconds
Tempo limite, em segundos, após o qual uma parte abaixo de replicated\_fetches\_min\_part\_level será obtida mesmo assim.
Use 0 para desabilitar o tempo limite (partes abaixo do nível mínimo são adiadas indefinidamente até serem mescladas).
Padrão: 300 (força a obtenção após 5 minutos).
## replicated\_max\_mutations\_in\_one\_entry
Número máximo de comandos de mutação que podem ser combinados e executados em
uma única entrada MUTATE\_PART (0 significa sem limite)
## replicated\_max\_parallel\_fetches
Configuração obsoleta, não faz nada.
## replicated\_max\_parallel\_fetches\_for\_host
Configuração obsoleta; não tem efeito.
## replicated\_max\_parallel\_fetches\_for\_table
Configuração obsoleta; não tem efeito.
## replicated\_max\_parallel\_sends
Configuração obsoleta; não tem efeito.
## replicated\_max\_parallel\_sends\_for\_table
Configuração obsoleta, sem efeito.
## replicated\_max\_ratio\_of\_wrong\_parts
Se a proporção de partes incorretas em relação ao número total de partes for menor que esse valor,
permite a inicialização.
Valores possíveis:
* Float, 0.0 - 1.0
## search\_orphaned\_parts\_disks
O ClickHouse verifica todos os discos em busca de partes órfãs após qualquer ATTACH ou CREATE de tabela,
para evitar que partes de dados passem despercebidas em discos não definidos (não incluídos na política).
As partes órfãs se originam de uma reconfiguração de armazenamento potencialmente insegura, por exemplo, quando um disco é excluído da política de armazenamento.
Essa configuração limita o escopo da busca de discos com base nas características deles.
Valores possíveis:
* any - o escopo não é limitado.
* local - o escopo é limitado aos discos locais.
* none - escopo vazio, não pesquisar
## serialization\_info\_version
Versão das informações de serialização usada ao gravar `serialization.json`.
Essa configuração é necessária para garantir a compatibilidade durante upgrades do cluster.
Valores possíveis:
* `basic` - Formato básico.
* `with_types` - Formato com o campo adicional `types_serialization_versions`, permitindo versões de serialização por tipo.
Isso faz com que configurações como `string_serialization_version` tenham efeito.
Durante upgrades graduais, defina isso como `basic` para que os novos servidores gerem
partes de dados compatíveis com os servidores antigos. Após a conclusão do upgrade,
mude para `WITH_TYPES` para habilitar versões de serialização por tipo.
## share\_nested\_offsets
Quando habilitada (padrão), colunas Array com nomes pontilhados que compartilham um prefixo comum (por exemplo, n.a e n.b)
são tratadas como parte de uma estrutura Nested: elas compartilham um único arquivo de offsets em disco (por exemplo, n.size0),
e seus tamanhos de array são verificados para garantir que sejam iguais durante o INSERT.
Quando desabilitada, cada coluna Array recebe seu próprio arquivo de offsets independente, nomes pontilhados não têm semântica
especial, e uma coluna escalar pode coexistir com colunas Array pontilhadas que compartilham o mesmo prefixo
(por exemplo, n UInt32 ao lado de n.a Array(String)). Essa configuração é imutável após a criação da tabela.
## shared\_merge\_tree\_activate\_coordinated\_merges\_tasks
Ativa o reescalonamento de tarefas de merges coordenados. Isso pode ser útil mesmo quando
shared\_merge\_tree\_enable\_coordinated\_merges=0, porque isso alimentará as estatísticas do coordenador de merges
e ajudará na inicialização a frio.
## shared\_merge\_tree\_create\_per\_replica\_metadata\_nodes
Habilita a criação, por réplica, dos nós /metadata e /columns no ZooKeeper.
Disponível apenas no ClickHouse Cloud
## shared\_merge\_tree\_disable\_merges\_and\_mutations\_assignment
Interrompe a atribuição de merges no shared merge tree. Disponível apenas no ClickHouse
Cloud
## shared\_merge\_tree\_empty\_partition\_lifetime
Por quantos segundos uma partição será armazenada no Keeper se não tiver partes.
## shared\_merge\_tree\_enable\_automatic\_empty\_partitions\_cleanup
Habilita a limpeza das entradas do Keeper de partições vazias.
## shared\_merge\_tree\_enable\_coordinated\_merges
Habilita a estratégia de mesclagens coordenadas
Habilita a gravação de atributos nas partes virtuais e o commit de blocos no Keeper
## shared\_merge\_tree\_enable\_outdated\_parts\_check
Ativa a verificação de partes desatualizadas. Disponível apenas no ClickHouse Cloud
## shared\_merge\_tree\_idle\_parts\_update\_seconds
Intervalo, em segundos, para atualização de partes quando ela não é acionada por um watch do ZooKeeper no shared merge tree. Disponível apenas no ClickHouse Cloud
## shared\_merge\_tree\_initial\_parts\_update\_backoff\_ms
Backoff inicial para atualização das partes. Disponível apenas no ClickHouse Cloud
## shared\_merge\_tree\_interserver\_http\_connection\_timeout\_ms
Tempo limite da conexão HTTP entre servidores. Disponível apenas no ClickHouse Cloud
## shared\_merge\_tree\_interserver\_http\_timeout\_ms
Limites de tempo para a comunicação HTTP entre servidores. Disponível apenas no ClickHouse
Cloud
## shared\_merge\_tree\_leader\_update\_period\_random\_add\_seconds
Adiciona a shared\_merge\_tree\_leader\_update\_period um valor com distribuição uniforme de 0 a x segundos para evitar o efeito manada. Disponível apenas no ClickHouse Cloud
## shared\_merge\_tree\_leader\_update\_period\_seconds
Período máximo para verificar novamente a liderança para atualização das partes. Disponível apenas no
ClickHouse Cloud
## shared\_merge\_tree\_max\_outdated\_parts\_to\_process\_at\_once
Número máximo de partes desatualizadas que o líder tentará confirmar para remoção em uma única requisição HTTP. Disponível apenas no ClickHouse Cloud.
## shared\_merge\_tree\_max\_parts\_update\_backoff\_ms
Tempo máximo de backoff para atualização de partes. Disponível apenas no ClickHouse Cloud
## shared\_merge\_tree\_max\_parts\_update\_leaders\_in\_total
Número máximo total de líderes de atualização de partes. Disponível apenas no ClickHouse Cloud
## shared\_merge\_tree\_max\_parts\_update\_leaders\_per\_az
Número máximo de líderes de atualização de partes. Disponível apenas no ClickHouse Cloud
## shared\_merge\_tree\_max\_replicas\_for\_parts\_deletion
Número máximo de réplicas que participarão da exclusão de partes (thread killer). Disponível apenas no ClickHouse Cloud
## shared\_merge\_tree\_max\_replicas\_to\_merge\_parts\_for\_each\_parts\_range
Número máximo de réplicas que tentarão atribuir merges potencialmente
conflitantes (permite evitar conflitos redundantes na atribuição de merges). 0 significa desativado. Disponível
apenas no ClickHouse Cloud
## shared\_merge\_tree\_max\_suspicious\_broken\_parts
Número máximo de partes corrompidas para SMT; acima disso, a desanexação automática é negada.
## shared\_merge\_tree\_max\_suspicious\_broken\_parts\_bytes
Tamanho máximo total de todas as partes corrompidas do SMT; se for excedido, a desanexação automática será negada.
## shared\_merge\_tree\_memo\_ids\_remove\_timeout\_seconds
Por quanto tempo armazenamos os IDs de memoização de insert para evitar ações incorretas durante
novas tentativas de insert. Disponível apenas no ClickHouse Cloud
## shared\_merge\_tree\_merge\_coordinator\_election\_check\_period\_ms
Intervalo entre execuções da thread de eleição do coordenador de merges
## shared\_merge\_tree\_merge\_coordinator\_factor
Fator de variação de tempo para o atraso da thread do coordenador
## shared\_merge\_tree\_merge\_coordinator\_fetch\_fresh\_metadata\_period\_ms
Com que frequência o coordenador de merges deve sincronizar com o ZooKeeper para obter metadados atualizados
## shared\_merge\_tree\_merge\_coordinator\_max\_merge\_request\_size
Número de merges que o coordenador pode solicitar ao MergerMutator de uma só vez
## shared\_merge\_tree\_merge\_coordinator\_max\_period\_ms
Tempo máximo entre as execuções da thread do coordenador de merges
## shared\_merge\_tree\_merge\_coordinator\_merges\_prepare\_count
Número de entradas de merge que o coordinator deve preparar e distribuir entre os workers.
Quando definido como 'auto', equivale ao número máximo de tarefas de merge permitidas em uma única réplica multiplicado pelo número de réplicas ativas.
## shared\_merge\_tree\_merge\_coordinator\_min\_period\_ms
Tempo mínimo entre execuções da thread do coordenador de merge
## shared\_merge\_tree\_merge\_worker\_fast\_timeout\_ms
Tempo limite que a thread de trabalho de merge usará caso seja necessário atualizar seu estado após uma ação imediata
## shared\_merge\_tree\_merge\_worker\_regular\_timeout\_ms
Tempo entre execuções da thread do merge worker
## shared\_merge\_tree\_outdated\_parts\_group\_size
Número de réplicas que ficarão no mesmo grupo de hash rendezvous para a limpeza de partes desatualizadas.
Disponível apenas no ClickHouse Cloud.
## shared\_merge\_tree\_partitions\_hint\_ratio\_to\_reload\_merge\_pred\_for\_mutations
Recarrega o predicado de merge na tarefa de seleção de merge/mutate quando a proporção `/` for maior que a configuração. Disponível apenas
no ClickHouse Cloud
## shared\_merge\_tree\_parts\_load\_batch\_size
Quantidade de jobs de metadados para buscar partes a serem agendados de uma só vez. Disponível apenas no
ClickHouse Cloud
## shared\_merge\_tree\_postpone\_next\_merge\_for\_locally\_merged\_parts\_ms
Tempo durante o qual uma parte mesclada localmente é mantida sem iniciar uma nova mesclagem que
inclua essa parte. Isso dá a outras réplicas a oportunidade de buscar a parte e iniciar essa mesclagem.
Disponível apenas no ClickHouse Cloud.
## shared\_merge\_tree\_postpone\_next\_merge\_for\_locally\_merged\_parts\_rows\_threshold
Tamanho mínimo da parte (em linhas) para adiar a atribuição da próxima mesclagem logo após
mesclá-la localmente. Disponível apenas no ClickHouse Cloud.
## shared\_merge\_tree\_range\_for\_merge\_window\_size
Tempo para manter uma parte mesclada localmente sem iniciar uma nova mesclagem que contenha
essa parte. Isso dá a outras réplicas a chance de buscar a parte e iniciar essa mesclagem.
Disponível apenas no ClickHouse Cloud
## shared\_merge\_tree\_read\_virtual\_parts\_from\_leader
Lê partes virtuais do líder quando possível. Disponível apenas no ClickHouse
Cloud
## shared\_merge\_tree\_replica\_set\_max\_lifetime\_seconds
Com que frequência as réplicas tentarão atualizar o conjunto de réplicas em segundo plano. A próxima execução terá uma variação aleatória
uniforme em \[0, value] segundos. Exceção: value = 0 não segue essa regra;
a implementação aplica um mínimo de 200 ms, portanto a próxima execução terá uma variação aleatória em \[0, 200] ms.
## shared\_merge\_tree\_try\_fetch\_part\_in\_memory\_data\_from\_replicas
Se habilitada, todas as réplicas tentam buscar em outras réplicas os dados em memória da parte (como a chave primária,
as informações de partição etc.) quando esses dados já existirem nelas.
## shared\_merge\_tree\_try\_fetch\_part\_in\_memory\_data\_from\_replicas\_on\_startup
Se habilitada, todas as réplicas tentam, na inicialização, buscar de outras réplicas os dados em memória da parte (como
chave primária, informações de partição e assim por diante) quando eles já existirem nelas.
## shared\_merge\_tree\_update\_replica\_flags\_delay\_ms
Com que frequência a réplica tentará recarregar suas flags com base no agendamento em segundo plano.
## shared\_merge\_tree\_use\_metadata\_hints\_cache
Permite solicitar sugestões de cache do FS a partir do cache em memória de outras réplicas. Disponível apenas no ClickHouse Cloud
## shared\_merge\_tree\_use\_outdated\_parts\_compact\_format
Usa o formato compact para partes desatualizadas: reduz a carga sobre o Keeper, melhora
o processamento de partes desatualizadas. Disponível apenas no ClickHouse Cloud
## shared\_merge\_tree\_use\_too\_many\_parts\_count\_from\_virtual\_parts
Se estiver habilitado, o contador de excesso de partes usará os dados compartilhados no Keeper, e não o estado da réplica local. Disponível apenas no ClickHouse Cloud
## shared\_merge\_tree\_use\_zookeeper\_connection\_pool
Se habilitada, a SharedMergeTree usa uma das sessões do ZooKeeper em pool no nível do servidor.
## shared\_merge\_tree\_virtual\_parts\_discovery\_batch
Quantas descobertas de partições devem ser agrupadas em um lote
## simultaneous\_parts\_removal\_limit
Se houver muitas partes desatualizadas, a thread de limpeza tentará excluir até
`simultaneous_parts_removal_limit` partes em uma única iteração.
`simultaneous_parts_removal_limit` definido como `0` significa sem limite.
## sleep\_before\_commit\_local\_part\_in\_replicated\_table\_ms
Para testes. Não altere isso.
## sleep\_before\_loading\_outdated\_parts\_ms
Para fins de teste. Não altere.
## storage\_policy
Nome da política de armazenamento em disco
## string\_serialization\_version
Controla o formato de serialização para colunas `String` de nível superior.
Essa configuração só tem efeito quando `serialization_info_version` está definido como "with\_types".
Quando definido como `with_size_stream`, colunas `String` de nível superior são serializadas com uma
subcoluna `.size` separada para armazenar os comprimentos das strings, em vez de inline. Isso permite
subcolunas `.size` reais e pode melhorar a eficiência da compressão.
Tipos `String` aninhados (por exemplo, dentro de `Nullable`, `LowCardinality`, `Array` ou `Map`)
não são afetados, exceto quando aparecem em um `Tuple`.
Valores possíveis:
* `single_stream` — Usa o formato de serialização padrão com tamanhos inline.
* `with_size_stream` — Usa um stream de tamanho separado para colunas `String` de nível superior.
## table\_disk
Este é o disco da tabela; o caminho/endpoint deve apontar para os dados da tabela, não para
os dados do banco de dados. Só pode ser definido para s3\_plain/s3\_plain\_rewritable/web.
## table\_readonly
Se estiver definido como true, a tabela ficará em modo somente leitura. Qualquer tentativa de inserir dados ou modificar a tabela falhará.
## temporary\_directories\_lifetime
Por quantos segundos os diretórios tmp\_ devem ser mantidos. Você não deve reduzir esse valor,
porque operações de merge e mutações podem não conseguir funcionar com um valor baixo
dessa configuração.
## text\_index\_dictionary\_block\_frontcoding\_compression
Compressão front-coding padrão para blocos do dicionário do índice de texto.
Pode ser substituída pelo argumento explícito do índice `dictionary_block_frontcoding_compression`.
## text\_index\_dictionary\_block\_size
Tamanho padrão do bloco do dicionário para índices de texto.
Pode ser substituído pelo argumento de índice explícito `dictionary_block_size`.
## text\_index\_posting\_list\_block\_size
Tamanho de bloco padrão da posting list em índices de texto (linhas).
Pode ser sobrescrito pelo argumento de índice explícito `posting_list_block_size`.
## text\_index\_posting\_list\_codec
Codec padrão da posting list para índices de texto.
Pode ser substituído pelo argumento de índice explícito `posting_list_codec`.
## try\_fetch\_recompressed\_part\_timeout
Tempo limite (em segundos) antes de iniciar a mesclagem com recompressão. Durante esse
tempo, o ClickHouse tenta buscar a parte recomprimida da réplica à qual foi atribuída
essa mesclagem com recompressão.
A recompressão é lenta na maioria dos casos, portanto não iniciamos a mesclagem com
recompressão até que esse tempo limite seja atingido e tentamos buscar a parte recomprimida da
réplica à qual foi atribuída essa mesclagem com recompressão.
Valores possíveis:
* Qualquer número inteiro positivo.
## ttl\_only\_drop\_parts
Controla se as partes de dados são removidas por completo em tabelas MergeTree quando todas as
linhas dessa parte expiram de acordo com suas configurações de `TTL`.
Quando `ttl_only_drop_parts` está desabilitado (padrão), apenas as linhas que
expiraram com base em suas configurações de `TTL` são removidas.
Quando `ttl_only_drop_parts` está habilitado, a parte inteira é removida se todas as
linhas dessa parte expiraram de acordo com suas configurações de `TTL`.
## use\_adaptive\_write\_buffer\_for\_dynamic\_subcolumns
Permite usar buffers de escrita adaptativos durante a gravação de subcolunas dinâmicas para
reduzir o uso de memória
## use\_async\_block\_ids\_cache
Se for `true`, armazena em cache as somas de hash dos async inserts.
Valores possíveis:
* `true`
* `false`
Um bloco que contenha vários async inserts gerará várias somas de hash.
Quando alguns inserts estiverem duplicados, o Keeper retornará apenas uma
soma de hash duplicada em uma RPC, o que causará retries de RPC desnecessários.
Esse cache monitorará o caminho das somas de hash no Keeper. Se atualizações forem detectadas
no Keeper, o cache será atualizado o mais rápido possível, para que possamos
filtrar os inserts duplicados na memória.
## use\_compact\_variant\_discriminators\_serialization
Ativa o modo compacto para a serialização binária de discriminadores no tipo de dados Variant.
Esse modo permite usar consideravelmente menos memória para armazenar discriminadores
nas partes quando há predominantemente uma variante ou muitos valores NULL.
## use\_const\_adaptive\_granularity
Sempre use granularidade constante para a parte inteira. Isso permite comprimir, na
memória, os valores da granularidade do índice. Isso pode ser útil em cargas de trabalho
extremamente grandes com tabelas estreitas.
## use\_metadata\_cache
Configuração obsoleta; não tem efeito.
## use\_minimalistic\_checksums\_in\_zookeeper
Usa o formato pequeno (dezenas de bytes) para os checksums das partes no ZooKeeper em vez
do formato comum (dezenas de KB). Antes de habilitar, verifique se todas as réplicas suportam
o novo formato.
Método de armazenamento dos cabeçalhos das partes de dados no ZooKeeper. Se ativado, o ZooKeeper
armazena menos dados. Para mais detalhes, consulte [aqui](/pt-BR/reference/settings/server-settings/settings#use_minimalistic_part_header_in_zookeeper).
## use\_primary\_key\_cache
Usa cache para o índice primário
em vez de manter todos os índices na memória. Pode ser útil para tabelas muito grandes
## vertical\_merge\_algorithm\_min\_bytes\_to\_activate
Tamanho mínimo (aproximado), em bytes descomprimidos, das partes em mesclagem para ativar o
algoritmo de mesclagem vertical.
## vertical\_merge\_algorithm\_min\_columns\_to\_activate
Número mínimo de colunas não PK para ativar o algoritmo de mesclagem vertical.
## vertical\_merge\_algorithm\_min\_rows\_to\_activate
Soma mínima (aproximada) de linhas nas
partes que estão sendo mescladas para ativar o algoritmo de mesclagem vertical.
## vertical\_merge\_optimize\_lightweight\_delete
Se true, a exclusão leve é otimizada durante a mesclagem vertical.
## vertical\_merge\_optimize\_ttl\_delete
Se true, a exclusão de linhas por TTL é otimizada na mesclagem vertical. Em vez de forçar a mesclagem horizontal,
o filtro TTL é avaliado e passado ao algoritmo de mesclagem, que define flags de ignorar nas fontes de linhas.
## vertical\_merge\_remote\_filesystem\_prefetch
Se true, o pré-carregamento de dados do sistema de arquivos remoto é usado para a coluna seguinte durante a mesclagem
## wait\_for\_unique\_parts\_send\_before\_shutdown\_ms
Antes do desligamento, a tabela aguardará o tempo necessário para que as partes
únicas (existentes apenas na réplica atual) sejam obtidas por outras réplicas (0 significa
desativado).
## write\_ahead\_log\_bytes\_to\_fsync
Configuração obsoleta; não tem efeito.
## write\_ahead\_log\_interval\_ms\_to\_fsync
Configuração obsoleta; não tem efeito.
## write\_ahead\_log\_max\_bytes
Configuração obsoleta; não tem efeito.
## write\_final\_mark
Configuração obsoleta, não tem efeito.
## write\_marks\_for\_substreams\_in\_compact\_parts
Habilita a gravação de marcas para cada substream, em vez de para cada coluna, em partes compactas.
Isso permite ler com eficiência subcolunas individuais da parte de dados.
Por exemplo, a coluna `t Tuple(a String, b UInt32, c Array(Nullable(UInt32)))` é serializada nos seguintes substreams:
* `t.a` para dados String do elemento de Tuple `a`
* `t.b` para dados UInt32 do elemento de Tuple `b`
* `t.c.size0` para os tamanhos do array do elemento de Tuple `c`
* `t.c.null` para o mapa de NULL dos elementos do array aninhado do elemento de Tuple `c`
* `t.c` para dados UInt32 dos elementos do array aninhado do elemento de Tuple `c`
Quando essa configuração está habilitada, gravaremos uma marca para cada um desses 5 substreams, o que significa que poderemos ler
separadamente, se necessário, os dados de cada substream individual a partir do grânulo. Por exemplo, se quisermos ler a subcoluna `t.c`, leremos apenas os dados dos
substreams `t.c.size0`, `t.c.null` e `t.c` e não leremos dados dos substreams `t.a` e `t.b`. Quando essa configuração está desabilitada,
gravaremos uma marca apenas para a coluna de nível superior `t`, o que significa que sempre leremos todos os dados da coluna a partir do grânulo, mesmo que precisemos apenas dos dados de alguns substreams.
## zero\_copy\_concurrent\_part\_removal\_max\_postpone\_ratio
Porcentagem máxima de partes de nível superior cuja remoção pode ser adiada para obter
intervalos independentes menores. Recomenda-se não alterar.
## zero\_copy\_concurrent\_part\_removal\_max\_split\_times
Profundidade máxima de recursão para dividir intervalos independentes de partes desatualizadas em intervalos menores. Recomenda-se não alterar.
## zero\_copy\_merge\_mutation\_min\_parts\_size\_sleep\_before\_lock
Se a replicação zero copy estiver habilitada, aguarde um intervalo aleatório antes de tentar
adquirir o bloqueio, dependendo do tamanho das partes para merge ou mutation
## zero\_copy\_merge\_mutation\_min\_parts\_size\_sleep\_no\_scale\_before\_lock
Se a replicação zero copy estiver habilitada, aguarde um intervalo aleatório de até 500 ms
antes de tentar adquirir o bloqueio para merge ou mutação.
## zookeeper\_session\_expiration\_check\_period
Período de verificação da expiração da sessão do ZooKeeper, em segundos.
Valores possíveis:
* Qualquer número inteiro positivo.