Todas as configurações abaixo também estão disponíveis na tabela system.settings. Essas configurações são geradas automaticamente a partir do código-fonte.
Adiciona o cabeçalho HTTP CORS.
Uma expressão de filtro adicional aplicada ao resultado da consulta SELECT.
Essa configuração não é aplicada a nenhuma subconsulta.
Exemplo
INSERT INTO table_1 VALUES (1, 'a'), (2, 'bb'), (3, 'ccc'), (4, 'dddd');
SElECT * FROM table_1;
┌─x─┬─y────┐
│ 1 │ a │
│ 2 │ bb │
│ 3 │ ccc │
│ 4 │ dddd │
└───┴──────┘
SELECT *
FROM table_1
SETTINGS additional_result_filter = 'x != 2'
┌─x─┬─y────┐
│ 1 │ a │
│ 3 │ ccc │
│ 4 │ dddd │
└───┴──────┘
INSERT INTO table_1 VALUES (1, 'a'), (2, 'bb'), (3, 'ccc'), (4, 'dddd');
SELECT * FROM table_1;
┌─x─┬─y────┐
│ 1 │ a │
│ 2 │ bb │
│ 3 │ ccc │
│ 4 │ dddd │
└───┴──────┘
SELECT *
FROM table_1
SETTINGS additional_table_filters = {'table_1': 'x != 2'}
┌─x─┬─y────┐
│ 1 │ a │
│ 3 │ ccc │
│ 4 │ dddd │
└───┴──────┘
state — String binária com o estado serializado (padrão). Esse é o comportamento padrão, em que os valores de AggregateFunction são esperados como dados binários.value — O formato espera um único valor do argumento da função de agregação ou, no caso de vários argumentos, uma tupla com eles. Eles serão desserializados usando o IDataType ou DataTypeTuple correspondente e, em seguida, agregados para formar o estado.array — O formato espera um Array de valores, conforme descrito na opção value acima. Todos os elementos do array serão agregados para formar o estado.
Exemplos
Para uma tabela com a estrutura:
CREATE TABLE example (
user_id UInt64,
avg_session_length AggregateFunction(avg, UInt32)
);
aggregate_function_input_format = 'value':
INSERT INTO example FORMAT CSV
123,456
aggregate_function_input_format = 'array':
INSERT INTO example FORMAT CSV
123,"[456,789,101]"
value e array são mais lentos do que o formato state padrão, pois exigem a criação e a agregação de valores na inserção.
aggregate_functions_null_for_empty
- 0 — Desativado.
- 1 — Ativado.
Exemplo
Considere a seguinte consulta com funções de agregação:
SELECT SUM(-1), MAX(0) FROM system.one WHERE 0;
aggregate_functions_null_for_empty = 0, o resultado seria:
┌─SUM(-1)─┬─MAX(0)─┐
│ 0 │ 0 │
└─────────┴────────┘
aggregate_functions_null_for_empty = 1, o resultado seria:
┌─SUMOrNull(-1)─┬─MAXOrNull(0)─┐
│ NULL │ NULL │
└───────────────┴──────────────┘
aggregation_in_order_max_block_bytes
aggregation_memory_efficient_merge_threads
ai_function_max_api_calls_per_query
prompt) em todas as chamadas de API da função de IA em uma única consulta. Esse total é contabilizado cumulativamente com base nas respostas do provedor. Observe que esse limite pode ser excedido pelo equivalente aos tokens de entrada de uma chamada, pois o número de tokens de entrada de uma chamada não é conhecido com antecedência. Defina como 0 para desabilitar.
ai_function_max_output_tokens_per_query
ai_function_retry_initial_delay_ms.
ai_function_request_timeout_sec
ai_function_max_retries.
ai_function_retry_initial_delay_ms
ai_function_throw_on_error
ai_function_throw_on_quota_exceeded
ai_function_max_input_tokens_per_query, ai_function_max_output_tokens_per_query ou ai_function_max_api_calls_per_query) interrompe a consulta com uma exceção. Se false, as linhas restantes recebem o valor padrão do tipo da coluna (string vazia para String).
allow_aggregate_partitions_independently
allow_archive_path_syntax
<archive> :: <file> se o arquivo compactado tiver a extensão correta.
allow_asynchronous_read_from_io_pool_for_merge_tree
allow_calculating_subcolumns_sizes_for_merge_tree_reading
allow_changing_replica_until_first_data_packet
receive_data_timeout); caso contrário, a troca de réplica é desabilitada após a primeira vez em que houver progresso.
allow_create_index_without_type
allow_custom_error_code_in_throwif
allow_deprecated_database_ordinary
allow_deprecated_error_prone_window_functions
allow_deprecated_snowflake_conversion_functions
snowflakeToDateTime, snowflakeToDateTime64, dateTimeToSnowflake e dateTime64ToSnowflake estão obsoletas e desativadas por padrão.
Use as funções snowflakeIDToDateTime, snowflakeIDToDateTime64, dateTimeToSnowflakeID e dateTime64ToSnowflakeID no lugar.
Para reativar as funções obsoletas (por exemplo, durante um período de transição), defina esta configuração como true.
allow_deprecated_syntax_for_merge_tree
allow_dynamic_type_in_join_keys
allow_execute_multiif_columnar
allow_experimental_ai_functions
aiGenerateContent). Essas funções fazem chamadas HTTP externas para provedores de IA.
allow_experimental_analyzer
enable_analyzer
Permite o novo analyzer de consulta.
allow_experimental_cleanup_old_data_files_compaction
allow_experimental_codecs
allow_experimental_database_glue_catalog
allow_database_glue_catalog
Permite usar o engine de banco de dados experimental DataLakeCatalog com catalog_type = ‘glue’
Valor padrão no Cloud: 1.
allow_experimental_database_hms_catalog
allow_experimental_database_iceberg
allow_database_iceberg
Permite usar o engine de banco de dados experimental DataLakeCatalog com catalog_type = ‘iceberg’
Valor padrão no Cloud: 1.
allow_experimental_database_materialized_postgresql
allow_experimental_database_paimon_rest_catalog
allow_experimental_database_unity_catalog
allow_database_unity_catalog
Permite o mecanismo de banco de dados experimental DataLakeCatalog com catalog_type = ‘unity’
Valor padrão no Cloud: 1.
allow_experimental_delta_kernel_rs
allow_experimental_delta_lake_writes
allow_experimental_expire_snapshots
ALTER TABLE ... EXECUTE expire_snapshots.
allow_experimental_funnel_functions
allow_experimental_geo_types_in_iceberg
geometry e geography do Iceberg como o tipo Geometry (Variant) do ClickHouse.
allow_experimental_hash_functions
allow_experimental_iceberg_compaction
allow_experimental_join_right_table_sorting
join_to_sort_minimum_perkey_rows e join_to_sort_maximum_table_rows forem atendidas, a tabela da direita será reordenada por chave para melhorar o desempenho em um hash join left ou inner.
allow_experimental_json_lazy_type_hints
allow_experimental_kafka_offsets_storage_in_keeper
allow_experimental_kusto_dialect
allow_experimental_materialized_postgresql_table
allow_experimental_nlp_functions
allow_experimental_nullable_tuple_type
Nullable (por exemplo, de colunas Dynamic, Variant, JSON ou Tuple).
Use allow_nullable_tuple_in_extracted_subcolumns para controlar se as subcolunas de tupla extraídas podem ser Nullable.
allow_experimental_object_storage_queue_hive_partitioning
allow_experimental_paimon_storage_engine
allow_experimental_parallel_reading_from_replicas
enable_parallel_replicas
Usa até max_parallel_replicas réplicas de cada shard para executar consultas SELECT. A leitura é paralelizada e coordenada dinamicamente. 0 - desabilitado, 1 - habilitado, desabilita silenciosamente em caso de falha, 2 - habilitado, gera uma exceção em caso de falha
allow_experimental_polyglot_dialect
allow_experimental_prql_dialect
allow_experimental_query_deduplication
allow_experimental_time_series_aggregate_functions
allow_experimental_ts_to_grid_aggregate_function
Funções de agregação experimentais timeSeries* para reamostragem de séries temporais no estilo Prometheus e cálculo de taxa e delta.
allow_experimental_time_series_table
- 0 — o motor de tabela TimeSeries está desabilitado.
- 1 — o motor de tabela TimeSeries está habilitado.
allow_experimental_unique_key
UNIQUE KEY em motores da família MergeTree.
allow_experimental_window_view
allow_experimental_ytsaurus_dictionary_source
allow_experimental_ytsaurus_table_engine
allow_experimental_ytsaurus_table_function
allow_fuzz_query_functions
fuzzQuery, que aplica mutações aleatórias de AST a uma string de consulta.
allow_general_join_planning
getClientHTTPHeader, que possibilita obter o valor de um header da requisição HTTP atual. Ela não é habilitada por padrão por motivos de segurança, porque alguns headers, como Cookie, podem conter informações sensíveis. Observe que os headers X-ClickHouse-* e Authentication são sempre restritos e não podem ser obtidos com essa função.
Permite funções que usam a biblioteca Hyperscan. Desative para evitar tempos de compilação potencialmente longos e o uso excessivo de recursos.
allow_iceberg_remove_orphan_files
ALTER TABLE ... EXECUTE remove_orphan_files() em tabelas Iceberg.
allow_insert_into_iceberg
allow_experimental_insert_into_iceberg
Permite executar consultas insert no Iceberg.
allow_introspection_functions
- 1 — Funções de introspecção ativadas.
- 0 — Funções de introspecção desativadas.
Veja também
allow_key_condition_coalesce_rewrite
coalesce(a_1, ..., a_N) <op> const (e, de forma equivalente, ifNull, ou com a constante à esquerda) como a disjunção (a_1 <op> const) OR (a_1 IS NULL AND a_2 <op> const) OR ... OR (a_1 IS NULL AND ... AND a_{N-1} IS NULL AND a_N <op> const) antes da análise de índices, para que a chave primária por coluna e os skip indexes em cada a_i possam ser usados. Formas parcialmente constantes, como coalesce(a, 42, b) e coalesce(a, b, 42), são tratadas: a lista de argumentos é normalizada como o próprio coalesce faz (literais NULL são descartados, e argumentos após o primeiro não-Nullable são descartados), e uma constante final não NULL, se houver, é incluída como o ramo final. A reescrita é estritamente aditiva para a poda de índices; a filtragem em tempo de execução ainda usa o predicado original.
allow_materialized_view_with_bad_select
allow_named_collection_override_by_default
allow_nonconst_timezone_arguments
allow_nondeterministic_mutations
dictGet.
Como, por exemplo, os dicionários podem ficar dessincronizados entre os nós, mutações que extraem valores deles não são permitidas por padrão em tabelas replicadas. Ativar essa configuração permite esse comportamento, mas passa a ser responsabilidade do usuário garantir que os dados usados estejam sincronizados em todos os nós.
Exemplo
<profiles>
<default>
<allow_nondeterministic_mutations>1</allow_nondeterministic_mutations>
<!-- ... -->
</default>
<!-- ... -->
</profiles>
allow_nondeterministic_optimize_skip_unused_shards
rand ou dictGet, já que esta última tem algumas ressalvas em relação a atualizações) na chave de sharding.
Valores possíveis:
- 0 — Não permitido.
- 1 — Permitido.
allow_nullable_tuple_in_extracted_subcolumns
Tuple(...) podem ser tipadas como Nullable(Tuple(...)).
false: Retorna Tuple(...) e usa valores padrão da tupla para linhas em que a subcoluna está ausente.true: Retorna Nullable(Tuple(...)) e usa NULL para linhas em que a subcoluna está ausente.
Essa configuração controla apenas o comportamento das subcolunas extraídas.
Ela não controla se colunas Nullable(Tuple(...)) podem ser criadas em tabelas; isso é controlado por allow_experimental_nullable_tuple_type.
O ClickHouse usa o valor dessa configuração carregado na inicialização do servidor.
Alterações feitas com SET ou SETTINGS no nível da consulta não alteram o comportamento das subcolunas extraídas.
Para alterar o comportamento das subcolunas extraídas, atualize allow_nullable_tuple_in_extracted_subcolumns na configuração do perfil de inicialização (por exemplo, em users.xml) e reinicie o servidor.
allow_prefetched_read_pool_for_local_filesystem
allow_prefetched_read_pool_for_remote_filesystem
allow_push_predicate_ast_for_distributed_subqueries
allow_push_predicate_when_subquery_contains_with
allow_rank_dense_rank_arguments
RANK e DENSE_RANK para fins de retrocompatibilidade.
De acordo com o padrão SQL, RANK e DENSE_RANK não recebem argumentos — elas classificam as linhas com base
apenas na janela OVER (ORDER BY ...). Em versões do ClickHouse anteriores à 26.5, consultas como
RANK(x) OVER (...) aceitavam e ignoravam silenciosamente o argumento, o que gerava confusão para os usuários
(o argumento visível sugeria que influenciava a classificação, mas não influenciava).
Quando essa configuração é false (o padrão), RANK e DENSE_RANK rejeitam quaisquer argumentos e
lançam NUMBER_OF_ARGUMENTS_DOESNT_MATCH. Quando definida como true, o comportamento permissivo legado é
restaurado — os argumentos são ignorados silenciosamente, em linha com o comportamento anterior à 26.5.
allow_reorder_prewhere_conditions
SETTINGS após FORMAT em consultas INSERT é permitido ou não. Não é recomendável usar isso, pois parte de SETTINGS pode ser interpretada como valores.
Exemplo:
INSERT INTO FUNCTION null('foo String') SETTINGS max_threads=1 VALUES ('bar');
allow_settings_after_format_in_insert:
SET allow_settings_after_format_in_insert=1;
INSERT INTO FUNCTION null('foo String') VALUES ('bar') SETTINGS max_threads=1;
- 0 — Não permitir.
- 1 — Permitir.
Use esta configuração apenas por compatibilidade com versões anteriores, se seus casos de uso dependerem da sintaxe antiga.
allow_experimental_statistics
Permite definir colunas com estatísticas e manipular essas estatísticas.
allow_statistics_optimize
allow_statistic_optimize
Permite usar estatísticas para otimizar consultas.
Se estiver definido como true, permite especificar codecs de compressão sem utilidade.
allow_suspicious_fixed_string_types
allow_suspicious_low_cardinality_types
FixedString(8_bytes_or_less).
Para valores fixos pequenos, o uso de LowCardinality geralmente é ineficiente, porque o ClickHouse armazena um índice numérico para cada linha. Como resultado:
- O uso de espaço em disco pode aumentar.
- O consumo de RAM pode ser maior, dependendo do tamanho do dicionário.
- Algumas funções podem ficar mais lentas devido a operações adicionais de codificação/decodificação.
Os tempos de merge em tabelas com o motor MergeTree podem aumentar por todos os motivos descritos acima.
Valores possíveis:
- 1 — O uso de
LowCardinality não é restrito.
- 0 — O uso de
LowCardinality é restrito.
allow_suspicious_primary_key
PRIMARY KEY/ORDER BY considerados suspeitos para MergeTree (isto é, SimpleAggregateFunction).
allow_suspicious_ttl_expressions
allow_suspicious_types_in_group_by
allow_suspicious_types_in_order_by
ORDER BY.
allow_suspicious_variant_types
allow_unrestricted_reads_from_keeper
alter_move_to_space_execute_async
alter_partition_verbose_result
- 0 — desabilita a verbosidade.
- 1 — habilita a verbosidade.
Exemplo
CREATE TABLE test(a Int64, d Date, s String) ENGINE = MergeTree PARTITION BY toYYYYMDECLARE(d) ORDER BY a;
INSERT INTO test VALUES(1, '2021-01-01', '');
INSERT INTO test VALUES(1, '2021-01-01', '');
ALTER TABLE test DETACH PARTITION ID '202101';
ALTER TABLE test ATTACH PARTITION ID '202101' SETTINGS alter_partition_verbose_result = 1;
┌─command_type─────┬─partition_id─┬─part_name────┬─old_part_name─┐
│ ATTACH PARTITION │ 202101 │ 202101_7_7_0 │ 202101_5_5_0 │
│ ATTACH PARTITION │ 202101 │ 202101_8_8_0 │ 202101_6_6_0 │
└──────────────────┴──────────────┴──────────────┴───────────────┘
ALTER TABLE test FREEZE SETTINGS alter_partition_verbose_result = 1;
┌─command_type─┬─partition_id─┬─part_name────┬─backup_name─┬─backup_path───────────────────┬─part_backup_path────────────────────────────────────────────┐
│ FREEZE ALL │ 202101 │ 202101_7_7_0 │ 8 │ /var/lib/clickhouse/shadow/8/ │ /var/lib/clickhouse/shadow/8/data/default/test/202101_7_7_0 │
│ FREEZE ALL │ 202101 │ 202101_8_8_0 │ 8 │ /var/lib/clickhouse/shadow/8/ │ /var/lib/clickhouse/shadow/8/data/default/test/202101_8_8_0 │
└──────────────┴──────────────┴──────────────┴─────────────┴───────────────────────────────┴─────────────────────────────────────────────────────────────┘
replication_alter_partitions_sync
Permite especificar o comportamento de espera para ações executadas em réplicas por consultas ALTER, OPTIMIZE ou TRUNCATE.
Valores possíveis:
0 — Não esperar.1 — Aguardar a própria execução.2 — Aguardar todos.3 - Aguardar apenas as réplicas ativas.
Valor padrão no Cloud: 0.
alter_sync se aplica apenas a tabelas Replicated e SharedMergeTree; não tem efeito ao alterar tabelas que não sejam Replicated nem Shared.
ALTER que contêm comandos UPDATE.
Valores possíveis:
heavy - executa uma mutação normal.lightweight - executa uma atualização leve, se possível; caso contrário, executa uma mutação normal.lightweight_force - executa uma atualização leve, se possível; caso contrário, gera uma exceção.
analyze_index_with_space_filling_curves
ORDER BY mortonEncode(x, y) ou ORDER BY hilbertEncode(x, y), e a consulta tiver condições sobre seus argumentos, por exemplo, x >= 10 AND x <= 20 AND y >= 20 AND y <= 30, use a curva de preenchimento espacial para a análise do índice.
analyzer_compatibility_allow_compound_identifiers_in_unflatten_nested
SELECT a.b.c FROM table ARRAY JOIN a não funciona, e SELECT a FROM table não inclui a coluna a.b.c no resultado de Nested a.
analyzer_compatibility_join_using_top_level_identifier
SELECT a + 1 AS b FROM t1 JOIN t2 USING (b), o join será realizado por t1.a + 1 = t2.b, em vez de t1.b = t2.b).
Quando habilitado, o analisador substitui views comuns (não materializadas, não parametrizadas) pelas subconsultas que as definem, permitindo otimizações entre camadas, como o pushdown de predicados e o pruning de colunas.
any_join_distinct_right_table_keys
ANY INNER|LEFT JOIN.
Use esta configuração apenas para compatibilidade com versões anteriores, se seus casos de uso dependerem do comportamento legado de JOIN.
- Os resultados das operações
t1 ANY LEFT JOIN t2 e t2 ANY RIGHT JOIN t1 não são iguais, porque o ClickHouse usa a lógica de mapeamento de chaves entre tabelas da esquerda para a direita, de muitos para um.
- Os resultados das operações
ANY INNER JOIN contêm todas as linhas da tabela à esquerda, assim como nas operações SEMI LEFT JOIN.
Quando o comportamento legado está desabilitado:
- Os resultados das operações
t1 ANY LEFT JOIN t2 e t2 ANY RIGHT JOIN t1 são iguais, porque o ClickHouse usa a lógica que fornece mapeamento de chaves de um para muitos em operações ANY RIGHT JOIN.
- Os resultados das operações
ANY INNER JOIN contêm uma linha por chave de ambas as tabelas, a da esquerda e a da direita.
Valores possíveis:
- 0 — O comportamento legado está desabilitado.
- 1 — O comportamento legado está habilitado.
Veja também:
Habilita a filtragem de linhas excluídas com exclusão leve. Se estiver desabilitado, uma consulta poderá ler essas linhas. Isso é útil para cenários de depuração e de “recuperação” de exclusões
Se true, mutações (UPDATEs e DELETEs) que não estiverem materializadas na data part serão aplicadas durante SELECTs.
Se true, patch parts (que representam atualizações leves) são aplicadas nas consultas SELECT.
apply_patch_parts_join_cache_buckets
apply_prewhere_after_final
apply_row_policy_after_final
- 0 — A política de linha e PREWHERE são aplicados antes de FINAL (padrão).
- 1 — A política de linha e PREWHERE são aplicados após FINAL.
apply_settings_from_server
users.xml ou consultas como ALTER USER), não por meio do cliente (argumentos de linha de comando do cliente, consulta SET ou seção SETTINGS da consulta SELECT). Pelo cliente, ela pode ser alterada para false, mas não pode ser alterada para true (porque o servidor não enviará as configurações se o profile do usuário tiver apply_settings_from_server = false).
Observe que, inicialmente (24.12), havia uma configuração do servidor (send_settings_to_client), mas depois ela foi substituída por essa configuração do cliente, para facilitar o uso.
archive_adaptive_buffer_max_size_bytes
arrow_flight_request_descriptor_type
- ‘path’ — Use FlightDescriptor::Path (padrão, funciona com a maioria dos servidores Arrow Flight)
- ‘command’ — Use FlightDescriptor::Command com uma consulta SELECT (obrigatório para o Dremio)
Quando false (padrão), o fuzzer de AST do lado do servidor (controlado por ast_fuzzer_runs) aplica fuzzing apenas a consultas somente leitura (SELECT, EXPLAIN, SHOW, DESCRIBE, EXISTS). Quando true, o fuzzing é aplicado a todos os tipos de consulta, incluindo DDL e INSERT.
Habilita o AST fuzzer no lado do servidor, que executa consultas aleatórias após cada consulta normal, descartando os resultados.
- 0: desabilitado (padrão).
- Um valor entre 0 e 1 (sem incluir os extremos): probabilidade de executar uma única consulta com fuzzing.
- Um valor >= 1: número de consultas com fuzzing a executar por consulta normal.
O fuzzer acumula fragmentos de AST de todas as consultas em todas as sessões, produzindo mutações cada vez mais interessantes ao longo do tempo. As consultas com fuzzing que falham são descartadas silenciosamente; os resultados nunca são retornados ao cliente.
asterisk_include_alias_columns
SELECT *).
Valores possíveis:
- 0 - desabilitado
- 1 - habilitado
asterisk_include_materialized_columns
SELECT *).
Valores possíveis:
- 0 - desabilitado
- 1 - habilitado
asterisk_include_virtual_columns
SELECT *).
Valores possíveis:
- 0 - desabilitado
- 1 - habilitado
Se true, os dados da consulta INSERT são armazenados em uma fila e depois gravados na tabela em segundo plano. Se wait_for_async_insert for false, a consulta INSERT será processada quase instantaneamente; caso contrário, o cliente aguardará até que os dados sejam gravados na tabela
async_insert_busy_timeout_decrease_rate
async_insert_busy_timeout_increase_rate
async_insert_busy_timeout_max_ms
async_insert_busy_timeout_ms
Tempo máximo de espera, a partir do recebimento dos primeiros dados, antes de descarregar os dados coletados por consulta.
Valor padrão no Cloud: 1000 (1s).
async_insert_busy_timeout_min_ms
async_insert_max_data_size
104857600 (100 MiB).
async_insert_max_query_number
async_insert_deduplicate for 1.
async_insert_poll_timeout_ms
async_insert_use_adaptive_busy_timeout
async_query_sending_for_remote
automatic_parallel_replicas_min_bytes_per_replica
automatic_parallel_replicas_mode=1). 0 significa sem limiar.
O número total de bytes a serem lidos é estimado com base nas estatísticas coletadas.
automatic_parallel_replicas_mode
enable_analyzer = 1, enable_parallel_replicas != 0, parallel_replicas_local_plan = 1 e que cluster_for_parallel_replicas seja fornecido.
0 - desativado, 1 - ativado, 2 - somente a coleta de estatísticas está ativada (a alternância para a execução com réplicas paralelas está desativada).
azure_allow_parallel_part_upload
azure_check_objects_after_upload
azure_create_new_file_on_insert
azure_ignore_file_doesnt_exist
- 1 —
SELECT retorna resultado vazio.
- 0 —
SELECT gera uma exceção.
azure_list_object_keys_size
azure_max_blocks_in_multipart_upload
azure_max_get_rps
Limite para a taxa de solicitações GET ao Azure por segundo antes que o throttling seja aplicado. Zero significa ilimitado.
azure_max_inflight_parts_for_one_file
azure_max_put_rps
Limite da taxa de requisições PUT no Azure por segundo antes da aplicação de throttling. Zero significa sem limite.
Número máximo permitido de saltos de redirecionamento do Azure.
azure_max_single_part_copy_size
azure_max_single_part_upload_size
azure_max_single_read_retries
azure_max_unexpected_write_error_retries
azure_max_upload_part_size
azure_min_upload_part_size
azure_sdk_retry_initial_backoff_ms
azure_sdk_retry_max_backoff_ms
- 0 —
SELECT gera uma exceção se o arquivo vazio não for compatível com o formato solicitado.
- 1 —
SELECT retorna um resultado vazio para um arquivo vazio.
azure_strict_upload_part_size
azure_throw_on_zero_files_match
- 1 —
SELECT lança uma exceção.
- 0 —
SELECT retorna um resultado vazio.
Ativa ou desativa o TRUNCATE antes do insert em tabelas do engine Azure.
azure_upload_part_size_multiply_factor
azure_upload_part_size_multiply_parts_count_threshold
azure_use_adaptive_timeouts
true, as duas primeiras tentativas de todas as solicitações ao Azure são feitas com timeouts baixos de envio e recebimento.
Quando definido como false, todas as tentativas são feitas com os mesmos timeouts.
backup_restore_batch_size_for_keeper_multi
backup_restore_batch_size_for_keeper_multiread
backup_restore_failure_after_host_disconnected_for_seconds
backup_restore_finish_timeout_after_error_sec
backup_restore_keeper_fault_injection_probability
backup_restore_keeper_fault_injection_seed
backup_restore_keeper_max_retries
backup_restore_keeper_max_retries_while_handling_error
backup_restore_keeper_max_retries_while_initializing
backup_restore_keeper_retry_initial_backoff_ms
backup_restore_keeper_retry_max_backoff_ms
60000.
backup_restore_keeper_value_max_size
backup_restore_s3_retry_attempts
backup_restore_s3_retry_initial_backoff_ms
backup_restore_s3_retry_max_backoff_ms
backup_restore_s3_retry_jitter_factor
backup_restore_s3_retry_max_backoff_ms. Deve estar no intervalo [0.0, 1.0]
backup_restore_s3_retry_max_backoff_ms
backup_slow_all_threads_after_retryable_s3_error
true, todas as threads que executam requisições ao S3 para o mesmo endpoint de backup ficam mais lentas
depois que qualquer requisição individual ao S3 encontrar um erro do S3 passível de nova tentativa, como ‘Slow Down’.
Quando definido como false, cada thread lida com o backoff das requisições ao S3 independentemente das demais.
Só tem efeito no ClickHouse Cloud. Número de threads em segundo plano para baixar especulativamente novas partes de dados para o cache do sistema de arquivos quando cache_populated_by_fetch estiver habilitado. Zero para desabilitar.
calculate_text_stack_trace
cancel_http_readonly_queries_on_client_close
SELECT) quando um cliente fecha a conexão sem aguardar a resposta.
Valor padrão no Cloud: 1.
cast_ipv4_ipv6_default_on_conversion_error
Nullable em operações CAST.
Quando a configuração está habilitada e o argumento da função CAST é Nullable, o resultado também é convertido para o tipo Nullable. Quando a configuração está desabilitada, o resultado sempre tem exatamente o tipo de destino.
Valores possíveis:
- 0 — O resultado de
CAST tem exatamente o tipo de destino especificado.
- 1 — Se o tipo do argumento for
Nullable, o resultado de CAST será convertido em Nullable(DestinationDataType).
Exemplos
A consulta a seguir resulta exatamente no tipo de dado de destino:
SET cast_keep_nullable = 0;
SELECT CAST(toNullable(toInt32(0)) AS Int32) as x, toTypeName(x);
┌─x─┬─toTypeName(CAST(toNullable(toInt32(0)), 'Int32'))─┐
│ 0 │ Int32 │
└───┴───────────────────────────────────────────────────┘
Nullable:
SET cast_keep_nullable = 1;
SELECT CAST(toNullable(toInt32(0)) AS Int32) as x, toTypeName(x);
┌─x─┬─toTypeName(CAST(toNullable(toInt32(0)), 'Int32'))─┐
│ 0 │ Nullable(Int32) │
└───┴───────────────────────────────────────────────────┘
cast_string_to_date_time_mode
-
'best_effort' — Ativa o parsing estendido.
O ClickHouse pode analisar o formato básico YYYY-MM-DD HH:MM:SS e todos os formatos de data e hora ISO 8601. Por exemplo, '2018-06-08T01:02:03.000Z'.
-
'best_effort_us' — Semelhante a best_effort (veja a diferença em parseDateTimeBestEffortUS
-
'basic' — Usa o parser básico.
O ClickHouse pode analisar apenas o formato básico YYYY-MM-DD HH:MM:SS ou YYYY-MM-DD. Por exemplo, 2019-08-20 10:18:56 ou 2019-08-20.
Veja também:
cast_string_to_dynamic_use_inference
cast_string_to_variant_use_inference
check_named_collection_dependencies
check_query_single_value_result
MergeTree .
Valores possíveis:
- 0 — a consulta mostra o status de verificação de cada data part individual da tabela.
- 1 — a consulta mostra o status geral de verificação da tabela.
check_referential_table_dependencies
1.
cloud_mode_database_engine
2.
A família de engines permitida no Cloud.
- 0 - permite tudo
- 1 - reescreve DDLs para usar *ReplicatedMergeTree
- 2 - reescreve DDLs para usar SharedMergeTree
- 3 - reescreve DDLs para usar SharedMergeTree, exceto quando um disco remoto é especificado explicitamente
- 4 - igual a 3, mas também usa Alias em vez de Distributed (a tabela Alias apontará para a tabela de destino da tabela Distributed, portanto usará a tabela local correspondente)
UInt64 para minimizar a parte pública
Valor padrão no Cloud: 2.
cluster_for_parallel_replicas
default.
cluster_function_process_archive_on_multiple_nodes
true, aumenta o desempenho do processamento de arquivos compactados em funções de cluster. Deve ser definido como false para garantir compatibilidade e evitar erros durante a atualização para 25.7+ ao usar funções de cluster com arquivos compactados em versões anteriores.
cluster_table_function_buckets_batch_size
bucket. O sistema acumula os dados até que pelo menos essa quantidade seja atingida. O tamanho real pode ser ligeiramente maior para se alinhar aos limites dos dados.
cluster_table_function_split_granularity
file — cada tarefa processa um arquivo inteiro.bucket — as tarefas são criadas por bloco de dados interno dentro de um arquivo (por exemplo, row groups de Parquet).
Escolher uma granularidade mais fina (como bucket) pode melhorar o paralelismo ao trabalhar com um número pequeno de arquivos grandes.
Por exemplo, se um arquivo Parquet contiver vários row groups, habilitar a granularidade bucket permite que cada grupo seja processado de forma independente por diferentes workers.
collect_hash_table_stats_during_aggregation
collect_hash_table_stats_during_joins
compatibility faz com que o ClickHouse use as configurações padrão de uma versão anterior do ClickHouse, informada no próprio valor da configuração.
Se algumas configurações estiverem definidas com valores diferentes do padrão, esses valores serão respeitados (apenas as configurações que não tiverem sido modificadas serão afetadas pela configuração compatibility).
Essa configuração aceita um número de versão do ClickHouse como string, como 22.3 ou 22.8. Um valor vazio significa que essa configuração está desabilitada.
Desabilitada por padrão.
No ClickHouse Cloud, a configuração de compatibilidade padrão no nível do serviço precisa ser definida pelo suporte do ClickHouse Cloud. Abra um chamado para solicitar essa definição.
No entanto, a configuração compatibility pode ser substituída nos níveis de usuário, função, perfil, consulta ou sessão usando os mecanismos padrão de configuração do ClickHouse, como SET compatibility = '22.3' em uma sessão ou SETTINGS compatibility = '22.3' em uma consulta. compatibility_ignore_auto_increment_in_create_table
compatibility_ignore_collation_in_create_table
compatibility_s3_presigned_url_query_in_path
compile_aggregate_expressions
- 0 — A agregação é feita sem compilação JIT.
- 1 — A agregação é feita com compilação JIT.
Veja também
Compila algumas funções escalares e operadores em código nativo.
Compila a descrição da ordenação em código nativo.
Tempo limite da conexão se não houver réplicas.
connect_timeout_with_failover_ms
connect_timeout_with_failover_secure_ms
connection_pool_max_wait_ms
- Inteiro positivo.
- 0 — Sem timeout.
connections_with_failover_max_tries
true, uma consulta SELECT será convertida para a forma normal conjuntiva (CNF). Em alguns casos, reescrever uma consulta em CNF pode resultar em uma execução mais rápida (veja esta issue no GitHub para mais detalhes).
Por exemplo, observe como a consulta SELECT abaixo não é modificada (comportamento padrão):
EXPLAIN SYNTAX
SELECT *
FROM
(
SELECT number AS x
FROM numbers(20)
) AS a
WHERE ((x >= 1) AND (x <= 5)) OR ((x >= 10) AND (x <= 15))
SETTINGS convert_query_to_cnf = false;
┌─explain────────────────────────────────────────────────────────┐
│ SELECT x │
│ FROM │
│ ( │
│ SELECT number AS x │
│ FROM numbers(20) │
│ WHERE ((x >= 1) AND (x <= 5)) OR ((x >= 10) AND (x <= 15)) │
│ ) AS a │
│ WHERE ((x >= 1) AND (x <= 5)) OR ((x >= 10) AND (x <= 15)) │
│ SETTINGS convert_query_to_cnf = 0 │
└────────────────────────────────────────────────────────────────┘
convert_query_to_cnf como true e ver o que muda:
EXPLAIN SYNTAX
SELECT *
FROM
(
SELECT number AS x
FROM numbers(20)
) AS a
WHERE ((x >= 1) AND (x <= 5)) OR ((x >= 10) AND (x <= 15))
SETTINGS convert_query_to_cnf = true;
WHERE foi reescrita em CNF, mas o conjunto de resultados permanece idêntico — a lógica booleana não muda:
┌─explain───────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│ SELECT x │
│ FROM │
│ ( │
│ SELECT number AS x │
│ FROM numbers(20) │
│ WHERE ((x <= 15) OR (x <= 5)) AND ((x <= 15) OR (x >= 1)) AND ((x >= 10) OR (x <= 5)) AND ((x >= 10) OR (x >= 1)) │
│ ) AS a │
│ WHERE ((x >= 10) OR (x >= 1)) AND ((x >= 10) OR (x <= 5)) AND ((x <= 15) OR (x >= 1)) AND ((x <= 15) OR (x <= 5)) │
│ SETTINGS convert_query_to_cnf = 1 │
└───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
right, o que significa que o plano descorrelacionado conterá RIGHT JOINs com a entrada da subconsulta no lado direito.
Valores possíveis:
left - O processo de descorrelação produzirá LEFT JOINs, e a tabela de entrada aparecerá no lado esquerdo.right - O processo de descorrelação produzirá RIGHT JOINs, e a tabela de entrada aparecerá no lado direito.
Usa expressões de filtro para inferir expressões equivalentes e substituí-las em vez de criar um CROSS JOIN.
Usa buffer na memória para a entrada de subconsultas correlacionadas para evitar sua reavaliação.
count_distinct_implementation
uniq* deve ser usada para executar a construção COUNT(DISTINCT …).
Valores possíveis:
count_distinct_optimization
count_matches_stop_at_empty_match
countMatches.
Ativa IF NOT EXISTS para a instrução CREATE por padrão. Se esta configuração ou IF NOT EXISTS estiver especificado e uma tabela com o nome informado já existir, nenhuma exceção será lançada.
create_index_ignore_unique
create_replicated_merge_tree_fault_injection_probability
create_table_empty_primary_key_by_default
cross_join_min_bytes_to_compress
cross_join_min_rows_to_compress
cross_to_inner_join_rewrite
data_type_default_nullable
- 1 — Os tipos de dados nas definições de coluna são definidos como
Nullable por padrão.
- 0 — Os tipos de dados nas definições de coluna são definidos, por padrão, como não
Nullable.
database_atomic_wait_for_drop_and_detach_synchronously
SYNC a todas as consultas DROP e DETACH.
Valores possíveis:
- 0 — A execução das consultas será adiada.
- 1 — As consultas serão executadas sem atraso.
Define se deve gerar erro ou não caso não haja permissões para obter os metadados da tabela no mecanismo de banco de dados DataLakeCatalog.
database_replicated_allow_explicit_uuid
database_replicated_allow_heavy_create
database_replicated_allow_only_replicated_engine
1.
database_replicated_allow_replicated_engine_arguments
database_replicated_always_detach_permanently
database_replicated_enforce_synchronous_settings
database_replicated_initial_query_timeout_sec
- Inteiro positivo.
- 0 — Ilimitado.
database_shared_drop_table_delay_seconds
UNDROP TABLE.
Verifica overflow em operações aritméticas e de comparação com decimais
deduplicate_blocks_in_dependent_materialized_views
INSERT INTO (para tabelas Replicated*).
Essa configuração substitui insert_deduplicate e async_insert_deduplicate.
Essa configuração tem três valores possíveis:
- disable — A desduplicação é desabilitada para a consulta
INSERT INTO.
- enable — A desduplicação é habilitada para a consulta
INSERT INTO.
- backward_compatible_choice — A desduplicação é habilitada se
insert_deduplicate ou async_insert_deduplicate estiverem habilitados para o tipo específico de insert.
deduplicate_insert_select
INSERT SELECT (para tabelas Replicated*).
Essa configuração substitui insert_deduplicate e deduplicate_insert em consultas INSERT SELECT.
Essa configuração tem quatro valores possíveis:
- disable — A desduplicação fica desabilitada para a consulta
INSERT SELECT.
- force_enable — A desduplicação é habilitada para a consulta
INSERT SELECT. Se o resultado do SELECT não for estável, uma exceção é gerada.
- enable_when_possible — A desduplicação é habilitada se
insert_deduplicate estiver habilitado e o resultado do SELECT for estável; caso contrário, fica desabilitada.
- enable_even_for_bad_queries - A desduplicação é habilitada se
insert_deduplicate estiver habilitado. Se o resultado do SELECT não for estável, um aviso é registrado no log, mas a consulta é executada com desduplicação. Esta opção existe para compatibilidade com versões anteriores. Considere usar outras opções, pois ela pode levar a resultados inesperados.
default_materialized_view_sql_security
DEFINER.
default_max_bytes_in_join
max_bytes_in_join não está definido.
default_normal_view_sql_security
SQL SECURITY ao criar uma view normal. Mais sobre SQL security.
O valor padrão é INVOKER.
Mecanismo de tabela padrão usado quando ENGINE não é definido em uma instrução CREATE.
Valores possíveis:
- uma string que representa qualquer nome válido de mecanismo de tabela
Valor padrão no Cloud: SharedMergeTree.
Exemplo
Consulta:
SET default_table_engine = 'Log';
SELECT name, value, changed FROM system.settings WHERE name = 'default_table_engine';
┌─name─────────────────┬─value─┬─changed─┐
│ default_table_engine │ Log │ 1 │
└──────────────────────┴───────┴─────────┘
Engine usará o mecanismo de tabela Log:
Consulta:
CREATE TABLE my_table (
x UInt32,
y UInt32
);
SHOW CREATE TABLE my_table;
┌─statement────────────────────────────────────────────────────────────────┐
│ CREATE TABLE default.my_table
(
`x` UInt32,
`y` UInt32
)
ENGINE = Log
└──────────────────────────────────────────────────────────────────────────┘
default_temporary_table_engine
Engine usará o mecanismo de tabela Log:
Consulta:
SET default_temporary_table_engine = 'Log';
CREATE TEMPORARY TABLE my_table (
x UInt32,
y UInt32
);
SHOW CREATE TEMPORARY TABLE my_table;
┌─statement────────────────────────────────────────────────────────────────┐
│ CREATE TEMPORARY TABLE default.my_table
(
`x` UInt32,
`y` UInt32
)
ENGINE = Log
└──────────────────────────────────────────────────────────────────────────┘
DEFINER padrão ao criar uma VIEW. Mais sobre SQL security.
O valor padrão é CURRENT_USER.
defer_partition_pruning_after_final
FINAL em tabelas cujas
colunas da chave de partição não fazem parte da chave de ordenação. Esse é o comportamento seguro em termos de corretude
introduzido na 26.3: FINAL pode precisar desduplicar linhas que compartilham uma chave primária, mas estão
em partições diferentes, e a poda de partições excluiria silenciosamente essas linhas da
entrada da desduplicação.
Quando desativada, a poda de partições é aplicada mesmo com FINAL, restaurando o comportamento
anterior à 26.3. Isso pode ser substancialmente mais rápido para consultas com predicados WHERE na
coluna de partição, mas só é correto quando linhas com a mesma chave primária não podem existir
em partições diferentes — por exemplo, tabelas de log de eventos cuja coluna de partição é definida no momento da inserção
e nunca muda.
Essa configuração afeta apenas tabelas particionadas cujas colunas da chave de partição não estão contidas
na chave de ordenação; para outras tabelas, a poda de partições é sempre aplicada.
Valores possíveis:
- 0 — Aplicar a poda de partições antes de
FINAL (comportamento anterior à 26.3, mais rápido, mas inseguro no caso geral).
- 1 — Adiar a poda de partições para depois de
FINAL (padrão, seguro em termos de corretude).
delta_lake_enable_engine_predicate
delta_lake_enable_expression_visitor_logging
delta_lake_insert_max_bytes_in_data_file
delta_lake_insert_max_rows_in_data_file
delta_lake_reload_schema_for_consistency
delta_lake_snapshot_end_version
delta_lake_snapshot_start_version
delta_lake_snapshot_version
delta_lake_throw_on_engine_predicate_error
describe_include_subcolumns
- 0 — As subcolunas não são incluídas em consultas
DESCRIBE.
- 1 — As subcolunas são incluídas em consultas
DESCRIBE.
Exemplo
Veja um exemplo da instrução DESCRIBE.
describe_include_virtual_columns
dictionary_use_async_executor
dictionary_validate_primary_key_type
id de layouts simples será convertido implicitamente para UInt64.
Define o que acontece quando a quantidade de dados excede um dos limites.
Valores possíveis:
throw: lançar uma exceção (padrão).break: interromper a execução da consulta e retornar o resultado parcial, como se os
dados de origem tivessem se esgotado.
distributed_aggregation_memory_efficient
distributed_background_insert_batch
distributed_directory_monitor_batch_inserts
Ativa/desativa o envio em lote dos dados inseridos.
Quando o envio em lote está ativado, o motor de tabela Distributed tenta enviar vários arquivos de dados inseridos em uma única operação, em vez de enviá-los separadamente. O envio em lote melhora o desempenho do cluster ao aproveitar melhor os recursos do servidor e da rede.
Possible values:
- 1 — Ativado.
- 0 — Desativado.
distributed_background_insert_max_sleep_time_ms
distributed_directory_monitor_max_sleep_time_ms
Intervalo máximo para que o motor de tabela Distributed envie dados. Limita o crescimento exponencial do intervalo definido na configuração distributed_background_insert_sleep_time_ms.
Valores possíveis:
- Um número inteiro positivo de milissegundos.
distributed_background_insert_sleep_time_ms
distributed_directory_monitor_sleep_time_ms
Intervalo base para o motor de tabela Distributed enviar dados. O intervalo real aumenta exponencialmente em caso de erro.
Valores possíveis:
- Um número inteiro positivo de milissegundos.
distributed_background_insert_split_batch_on_failure
distributed_directory_monitor_split_batch_on_failure
Habilita/desabilita a divisão de batches em caso de falha.
Às vezes, o envio de um batch específico para o shard remoto pode falhar por causa de algum pipeline posterior complexo (ou seja, MATERIALIZED VIEW com GROUP BY), devido a Memory limit exceeded ou erros semelhantes. Nesse caso, tentar novamente não ajudará (e isso deixará os envios distribuídos da tabela travados), mas enviar os arquivos desse batch um a um pode fazer com que o INSERT seja bem-sucedido.
Portanto, definir essa configuração como 1 desabilitará o batching para esses batches (ou seja, desabilita temporariamente distributed_background_insert_batch para batches com falha).
Valores possíveis:
- 1 — Habilitado.
- 0 — Desabilitado.
Essa configuração também afeta batches corrompidos (que podem aparecer devido ao encerramento anormal do servidor (máquina) e à ausência de fsync_after_insert/fsync_directories para o motor de tabela Distributed). Você não deve depender da divisão automática de batches, pois isso pode prejudicar o desempenho.
distributed_background_insert_timeout
insert_distributed_timeout
Tempo limite para a consulta INSERT em distributed. Essa configuração é usada apenas com insert_distributed_sync habilitado. O valor 0 significa que não há tempo limite.
distributed_cache_alignment
distributed_cache_bypass_connection_pool
distributed_cache_connect_backoff_max_ms
distributed_cache_connect_backoff_min_ms
distributed_cache_connect_max_tries
distributed_cache_connect_timeout_ms
distributed_cache_credentials_refresh_period_seconds
distributed_cache_data_packet_ack_window
distributed_cache_discard_connection_if_unread_data
distributed_cache_fetch_metrics_only_from_current_az
distributed_cache_file_cache_name
distributed_cache_log_mode
distributed_cache_max_unacked_inflight_packets
distributed_cache_min_bytes_for_seek
distributed_cache_pool_behaviour_on_limit
distributed_cache_prefer_bigger_buffer_size
distributed_cache_read_only_from_current_az
distributed_cache_read_request_max_tries
distributed_cache_receive_response_wait_milliseconds
distributed_cache_receive_timeout_milliseconds
20000.
distributed_cache_receive_timeout_ms
distributed_cache_send_timeout_ms
distributed_cache_tcp_keep_alive_timeout_ms
distributed_cache_throw_on_error
distributed_cache_use_clients_cache_for_read
distributed_cache_use_clients_cache_for_write
distributed_cache_wait_connection_from_pool_milliseconds
distributed_cache_write_request_max_tries
distributed_connections_pool_size
distributed_ddl_entry_format_version
6.
distributed_ddl_output_mode
throw — Retorna o conjunto de resultados com o status de execução da consulta para todos os hosts em que a consulta foi concluída. Se a consulta falhar em alguns hosts, a primeira exceção será relançada. Se a consulta ainda não tiver sido concluída em alguns hosts e distributed_ddl_task_timeout for excedido, a exceção TIMEOUT_EXCEEDED será lançada.none — É semelhante a throw, mas a consulta DDL distribuída não retorna conjunto de resultados.null_status_on_timeout — Retorna NULL como status de execução em algumas linhas do conjunto de resultados, em vez de lançar TIMEOUT_EXCEEDED, se a consulta ainda não tiver sido concluída nos hosts correspondentes.never_throw — Não lança TIMEOUT_EXCEEDED nem relança exceções se a consulta falhar em alguns hosts.none_only_active - semelhante a none, mas não espera por réplicas inativas do banco de dados Replicated. Observação: com esse modo, é impossível saber que a consulta não foi executada em alguma réplica e será executada em segundo plano.null_status_on_timeout_only_active — semelhante a null_status_on_timeout, mas não espera por réplicas inativas do banco de dados Replicatedthrow_only_active — semelhante a throw, mas não espera por réplicas inativas do banco de dados Replicated
Valor padrão no Cloud: none_only_active.
distributed_ddl_task_timeout
- Inteiro positivo.
- 0 — Modo assíncrono.
- Inteiro negativo — timeout infinito.
distributed_foreground_insert
insert_distributed_sync
Habilita ou desabilita a inserção síncrona de dados em uma tabela Distributed.
Por padrão, ao inserir dados em uma tabela Distributed, o servidor ClickHouse envia os dados para os nós do cluster em segundo plano. Quando distributed_foreground_insert=1, os dados são processados de forma síncrona, e a operação INSERT só é concluída depois que todos os dados são salvos em todos os shards (pelo menos uma réplica para cada shard se internal_replication for true).
Valores possíveis:
0 — Os dados são inseridos em segundo plano.1 — Os dados são inseridos em modo síncrono.
Valor padrão no Cloud: 1.
Veja também
distributed_group_by_no_merge
0 — Desabilitado (o processamento final da consulta é feito no nó iniciador).1 - Não mescla estados de agregação de diferentes servidores no processamento distribuído de consultas (a consulta é processada completamente no shard, e o iniciador apenas atua como proxy dos dados); pode ser usado quando houver certeza de que há chaves diferentes em shards diferentes.2 - Igual a 1, mas aplica ORDER BY e LIMIT no iniciador (isso não é possível quando a consulta é processada completamente no nó remoto, como em distributed_group_by_no_merge=1); pode ser usado para consultas com ORDER BY e/ou LIMIT.
Exemplo
SELECT *
FROM remote('127.0.0.{2,3}', system.one)
GROUP BY dummy
LIMIT 1
SETTINGS distributed_group_by_no_merge = 1
FORMAT PrettyCompactMonoBlock
┌─dummy─┐
│ 0 │
│ 0 │
└───────┘
SELECT *
FROM remote('127.0.0.{2,3}', system.one)
GROUP BY dummy
LIMIT 1
SETTINGS distributed_group_by_no_merge = 2
FORMAT PrettyCompactMonoBlock
┌─dummy─┐
│ 0 │
└───────┘
distributed_index_analysis
distributed_index_analysis_for_non_shared_merge_tree
distributed_index_analysis_only_on_coordinator
IN (SELECT ...)),
porque, caso contrário, cada réplica seguidora acionaria de forma independente sua própria análise distribuída de índices,
mas torna a análise distribuída de índices menos eficiente se tabelas grandes forem usadas nas subconsultas.
distributed_insert_skip_read_only_replicas
- 0 — INSERT ocorrerá normalmente; se for para uma réplica somente leitura, falhará
- 1 — O iniciador ignorará réplicas somente leitura antes de enviar dados para os shards.
distributed_plan_default_reader_bucket_count
distributed_plan_default_shuffle_join_bucket_count
distributed_plan_execute_locally
distributed_plan_force_exchange_kind
- ” - não força nenhum tipo de operador Exchange, permite que o otimizador escolha,
- ‘Persisted’ - usa arquivos temporários no armazenamento de objetos,
- ‘Streaming’ - transmite os dados de Exchange pela rede.
distributed_plan_force_shuffle_aggregation
distributed_plan_max_rows_to_broadcast
distributed_plan_optimize_exchanges
distributed_plan_prefer_replicas_over_workers
GLOBAL sobre uma tabela distribuída.
Restrições:
- Aplicado apenas a subconsultas
IN e JOIN.
- Somente se a seção
FROM usar uma tabela distribuída com mais de um shard.
- Somente se a subconsulta envolver uma tabela distribuída com mais de um shard.
- Não é usado para a função de tabela remote.
Valores possíveis:
deny — Valor padrão. Proíbe o uso desses tipos de subconsultas (retorna a exceção “Double-distributed in/JOIN subqueries is denied”).local — Substitui o banco de dados e a tabela na subconsulta pelos locais do servidor de destino (shard), mantendo o IN/JOIN normal.global — Substitui a consulta IN/JOIN por GLOBAL IN/GLOBAL JOIN.allow — Permite o uso desses tipos de subconsultas.
distributed_push_down_limit
- O envio de linhas extras pela rede;
- O processamento, no iniciador, de linhas além do limite.
A partir da versão 21.9, não é mais possível obter resultados imprecisos, pois distributed_push_down_limit altera a execução da consulta somente se pelo menos uma das condições abaixo for atendida:
- distributed_group_by_no_merge > 0.
- A consulta não tem
GROUP BY/DISTINCT/LIMIT BY, mas tem ORDER BY/LIMIT.
- A consulta tem
GROUP BY/DISTINCT/LIMIT BY com ORDER BY/LIMIT e:
Valores possíveis:
- 0 — Desabilitado.
- 1 — Habilitado.
Veja também:
distributed_replica_error_cap
- Tipo: inteiro sem sinal
- Valor padrão: 1000
A contagem de erros de cada réplica é limitada a esse valor, evitando que uma única réplica acumule erros em excesso.
Veja também:
distributed_replica_error_half_life
- Tipo: segundos
- Valor padrão: 60 segundos
Controla a rapidez com que os erros em tabelas distribuídas são reduzidos a zero. Se uma réplica ficar indisponível por algum tempo, acumular 5 erros e distributed_replica_error_half_life estiver definido como 1 segundo, então a réplica será considerada normal 3 segundos após o último erro.
Veja também:
distributed_replica_max_ignored_errors
- Tipo: inteiro sem sinal
- Valor padrão: 0
O número de erros que serão ignorados durante a escolha de réplicas (de acordo com o algoritmo load_balancing).
Veja também:
do_not_merge_across_partitions_select_final
dynamic_disk_allow_from_env
from_env na configuração dinâmica de disco (ou seja, nos argumentos da função disk()).
Desativada por padrão para impedir que usuários leiam variáveis de ambiente arbitrárias ao definir o armazenamento da tabela.
dynamic_disk_allow_from_zk
from_zk na configuração de disco dinâmica (ou seja, nos argumentos da função disk()).
Desativada por padrão.
dynamic_disk_allow_include
include na configuração de disco dinâmico (ou seja, nos argumentos da função disk()).
Desativada por padrão.
dynamic_throw_on_type_mismatch
true (padrão) — gera uma exceção.false — retorna NULL para essas linhas.
empty_result_for_aggregation_by_constant_keys_on_empty_set
empty_result_for_aggregation_by_empty_set
enable_adaptive_memory_spill_scheduler
enable_add_distinct_to_in_subqueries
DISTINCT em subconsultas IN. Esta é uma configuração de trade-off: ao habilitá-la, é possível reduzir bastante o tamanho das tabelas temporárias transferidas em subconsultas distribuídas com IN e acelerar significativamente a transferência de dados entre shards, garantindo que apenas valores únicos sejam enviados.
No entanto, habilitar essa configuração exige esforço adicional de merging em cada nó, pois a desduplicação (DISTINCT) precisa ser realizada. Use essa configuração quando a transferência de rede for um gargalo e o custo adicional de merging for aceitável.
enable_automatic_decision_for_merging_across_partitions_for_final
enable_blob_storage_log_for_read_operations
enable_blob_storage_log esteja habilitado.
enable_early_constant_folding
enable_extended_results_for_datetime_functions
Date32 com intervalo ampliado (em comparação com o tipo Date)
ou DateTime64 com intervalo ampliado (em comparação com o tipo DateTime).
Valores possíveis:
0 — As funções retornam Date ou DateTime para todos os tipos de argumentos.1 — As funções retornam Date32 ou DateTime64 para argumentos Date32 ou DateTime64 e Date ou DateTime nos demais casos.
A tabela abaixo mostra o comportamento dessa configuração para várias funções de data e hora.
| Função | enable_extended_results_for_datetime_functions = 0 | enable_extended_results_for_datetime_functions = 1 |
|---|
toStartOfYear | Retorna Date ou DateTime | Retorna Date/DateTime para entradas Date/DateTime
Retorna Date32/DateTime64 para entradas Date32/DateTime64 |
toStartOfISOYear | Retorna Date ou DateTime | Retorna Date/DateTime para entradas Date/DateTime
Retorna Date32/DateTime64 para entradas Date32/DateTime64 |
toStartOfQuarter | Retorna Date ou DateTime | Retorna Date/DateTime para entradas Date/DateTime
Retorna Date32/DateTime64 para entradas Date32/DateTime64 |
toStartOfMonth | Retorna Date ou DateTime | Retorna Date/DateTime para entradas Date/DateTime
Retorna Date32/DateTime64 para entradas Date32/DateTime64 |
toStartOfWeek | Retorna Date ou DateTime | Retorna Date/DateTime para entradas Date/DateTime
Retorna Date32/DateTime64 para entradas Date32/DateTime64 |
toLastDayOfWeek | Retorna Date ou DateTime | Retorna Date/DateTime para entradas Date/DateTime
Retorna Date32/DateTime64 para entradas Date32/DateTime64 |
toLastDayOfMonth | Retorna Date ou DateTime | Retorna Date/DateTime para entradas Date/DateTime
Retorna Date32/DateTime64 para entradas Date32/DateTime64 |
toMonday | Retorna Date ou DateTime | Retorna Date/DateTime para entradas Date/DateTime
Retorna Date32/DateTime64 para entradas Date32/DateTime64 |
toStartOfDay | Retorna DateTime
Observação: resultados incorretos para valores fora do intervalo de 1970 a 2149 | Retorna DateTime para entradas Date/DateTime
Retorna DateTime64 para entradas Date32/DateTime64 |
toStartOfHour | Retorna DateTime
Observação: resultados incorretos para valores fora do intervalo de 1970 a 2149 | Retorna DateTime para entradas Date/DateTime
Retorna DateTime64 para entradas Date32/DateTime64 |
toStartOfFifteenMinutes | Retorna DateTime
Observação: resultados incorretos para valores fora do intervalo de 1970 a 2149 | Retorna DateTime para valores de entrada Date/DateTime
Retorna DateTime64 para valores de entrada Date32/DateTime64 |
toStartOfTenMinutes | Retorna DateTime
Observação: resultados incorretos para valores fora do intervalo de 1970-2149 | Retorna DateTime para entradas Date/DateTime
Retorna DateTime64 para entradas Date32/DateTime64 |
toStartOfFiveMinutes | Retorna DateTime
Observação: resultados incorretos para valores fora do intervalo de 1970 a 2149 | Retorna DateTime para valores de entrada Date/DateTime
Retorna DateTime64 para valores de entrada Date32/DateTime64 |
toStartOfMinute | Retorna DateTime
Observação: resultados incorretos para valores fora do intervalo de 1970 a 2149 | Retorna DateTime para valores de entrada Date/DateTime
Retorna DateTime64 para valores de entrada Date32/DateTime64 |
timeSlot | Retorna DateTime
Observação: resultados incorretos para valores fora do intervalo de 1970-2149 | Retorna DateTime para entradas Date/DateTime
Retorna DateTime64 para entradas Date32/DateTime64 |
enable_filesystem_cache_log
enable_filesystem_cache_on_write_operations
write-through. Se definido como false, o cache write-through é desabilitado para operações de gravação. Se definido como true, o cache write-through é habilitado desde que cache_on_write_operations esteja ativado na seção de configuração do disco de cache da configuração do servidor.
Consulte “Usando cache local” para mais detalhes.
Valor padrão no Cloud: 1.
enable_filesystem_read_prefetches_log
allow_experimental_full_text_index
Quando definido como true, permite usar o índice de texto.
enable_global_with_statement
pread para arquivos HDFS. Por padrão, hdfsPread é usado. Se estiver desativado, hdfsRead e hdfsSeek serão usados para ler arquivos HDFS.
Habilita ou desabilita a compressão de dados na resposta a uma requisição HTTP.
Para mais informações, consulte a descrição da interface HTTP.
Possible values:
- 0 — Desabilitado.
- 1 — Habilitado.
Exibe o stack trace do criador do job quando o job resulta em uma exceção. Desativada por padrão para evitar sobrecarga de desempenho.
enable_join_fixed_hash_table_conversion
enable_join_runtime_filters
enable_join_transitive_predicates
A.x = B.x e B.x = C.x, um predicado sintético A.x = C.x
é adicionado para que o otimizador da ordem dos joins possa considerar planos diretos (A JOIN C).
enable_lazy_columns_replication
enable_lightweight_delete
allow_experimental_lightweight_delete
Habilita mutações de exclusão leve com DELETE para tabelas MergeTree.
enable_lightweight_update
allow_experimental_lightweight_update
Permite o uso de atualizações leves.
Ativa expressões de tabela comuns materializadas; essa opção tem precedência sobre enable_global_with_statement
enable_memory_bound_merging_of_aggregation_results
enable_multiple_prewhere_read_steps
enable_named_columns_in_function_tuple
enable_optimize_predicate_expression
SELECT.
O pushdown de predicados pode reduzir significativamente o tráfego de rede em consultas distribuídas.
Valores possíveis:
- 0 — Desativado.
- 1 — Ativado.
Uso
Considere as seguintes consultas:
SELECT count() FROM test_table WHERE date = '2018-10-10'SELECT count() FROM (SELECT * FROM test_table) WHERE date = '2018-10-10'
Se enable_optimize_predicate_expression = 1, o tempo de execução dessas consultas será o mesmo, porque o ClickHouse aplica WHERE à subconsulta durante o processamento.
Se enable_optimize_predicate_expression = 0, o tempo de execução da segunda consulta será muito maior, porque a cláusula WHERE só é aplicada a todos os dados depois que a subconsulta é concluída.
enable_optimize_predicate_expression_to_final_subquery
ORDER BY ALL; consulte ORDER BY.
Valores possíveis:
- 0 — Desativa ORDER BY ALL.
- 1 — Ativa ORDER BY ALL.
Exemplo
Consulta:
CREATE TABLE TAB(C1 Int, C2 Int, ALL Int) ENGINE=Memory();
INSERT INTO TAB VALUES (10, 20, 30), (20, 20, 10), (30, 10, 20);
SELECT * FROM TAB ORDER BY ALL; -- retorna um erro informando que ALL é ambíguo
SELECT * FROM TAB ORDER BY ALL SETTINGS enable_order_by_all = 0;
┌─C1─┬─C2─┬─ALL─┐
│ 20 │ 20 │ 10 │
│ 30 │ 10 │ 20 │
│ 10 │ 20 │ 30 │
└────┴────┴─────┘
enable_parallel_blocks_marshalling
enable_parsing_to_custom_serialization
enable_positional_arguments
- 0 — Argumentos posicionais não são suportados.
- 1 — Argumentos posicionais são suportados: números de coluna podem ser usados no lugar de nomes de coluna.
Exemplo
Consulta:
CREATE TABLE positional_arguments(one Int, two Int, three Int) ENGINE=Memory();
INSERT INTO positional_arguments VALUES (10, 20, 30), (20, 20, 10), (30, 10, 20);
SELECT * FROM positional_arguments ORDER BY 2,3;
┌─one─┬─two─┬─three─┐
│ 30 │ 10 │ 20 │
│ 20 │ 20 │ 10 │
│ 10 │ 20 │ 30 │
└─────┴─────┴───────┘
enable_positional_arguments_for_projections
Esta é uma configuração avançada, e você não deve alterá-la se estiver apenas começando a usar o ClickHouse.
- 0 — Argumentos posicionais não têm suporte.
- 1 — Argumentos posicionais têm suporte: números de colunas podem ser usados no lugar de nomes de colunas.
enable_producing_buckets_out_of_order_in_aggregation
distributed_aggregation_memory_efficient) produza buckets fora de ordem.
Isso pode melhorar o desempenho quando os tamanhos dos buckets de agregação são desiguais, permitindo que uma réplica envie buckets com IDs mais altos para o iniciador enquanto ainda processa alguns buckets pesados com IDs mais baixos.
A desvantagem é um uso de memória potencialmente maior.
enable_reads_from_query_cache
SELECT são obtidos do cache de consultas.
Valores possíveis:
- 0 - Desabilitado
- 1 - Habilitado
enable_s3_requests_logging
enable_scalar_subquery_optimization
enable_scopes_for_with_statement
enable_shared_storage_snapshot_in_query
SELECT
count()
FROM events
WHERE (_part, _part_offset) IN (
SELECT _part, _part_offset
FROM events
WHERE user_id = 42
)
Ao habilitar esta configuração, a otimização que remove dos snapshots as partes de dados desnecessárias após a conclusão da etapa de planejamento é desativada.
Como resultado, consultas de longa duração podem manter partes obsoletas por toda a sua duração, atrasando a limpeza dessas partes e aumentando a pressão sobre o armazenamento.Atualmente, esta configuração se aplica apenas a tabelas da família MergeTree.
- 0 - Desabilitado
- 1 - Habilitado
enable_sharing_sets_for_mutations
enable_software_prefetch_in_aggregation
enable_software_prefetch_in_join
allow_experimental_time_time64_type
Permite a criação dos tipos de dados Time e Time64.
enable_unaligned_array_join
enable_writes_to_query_cache
SELECT são armazenados no cache de consultas.
Valores possíveis:
- 0 - Desabilitado
- 1 - Habilitado
Se habilitada, permite apenas identificadores que contenham caracteres alfanuméricos e underscores.
engine_file_allow_create_multiple_files
JSON, ORC, Parquet etc.). Se estiver habilitado, a cada insert, um novo arquivo será criado com um nome seguindo este padrão:
data.Parquet -> data.1.Parquet -> data.2.Parquet etc.
Possible values:
- 0 — a consulta
INSERT acrescenta novos dados ao final do arquivo.
- 1 — a consulta
INSERT cria um novo arquivo.
engine_file_empty_if_not_exists
- 0 —
SELECT lança uma exceção.
- 1 —
SELECT retorna um resultado vazio.
engine_file_skip_empty_files
- 0 —
SELECT gera uma exceção se o arquivo vazio não for compatível com o formato solicitado.
- 1 —
SELECT retorna um resultado vazio para um arquivo vazio.
engine_file_truncate_on_insert
- 0 — a consulta
INSERT acrescenta novos dados ao final do arquivo.
- 1 — a consulta
INSERT substitui o conteúdo existente do arquivo pelos novos dados.
engine_url_skip_empty_files
- 0 —
SELECT gera uma exceção se o arquivo vazio não for compatível com o formato solicitado.
- 1 —
SELECT retorna um resultado vazio para um arquivo vazio.
Quando habilitada, o ClickHouse fornecerá o valor exato da estatística rows_before_limit_at_least, mas isso exige que os dados antes do limite sejam lidos por completo
Configura o modo padrão na consulta EXCEPT. Valores possíveis: string vazia, ‘ALL’, ‘DISTINCT’. Se estiver vazia, uma consulta sem modo gerará uma exceção.
exclude_materialize_skip_indexes_on_insert
CREATE TABLE tab
(
a UInt64,
b UInt64,
INDEX idx_a a TYPE minmax,
INDEX idx_b b TYPE set(3)
)
ENGINE = MergeTree ORDER BY tuple();
SET exclude_materialize_skip_indexes_on_insert='idx_a'; -- idx_a não será atualizado no insert
--SET exclude_materialize_skip_indexes_on_insert='idx_a, idx_b'; -- nenhum índice seria atualizado no insert
INSERT INTO tab SELECT number, number / 50 FROM numbers(100); -- apenas idx_b é atualizado
-- como é uma configuração de sessão, pode ser definida individualmente por consulta
INSERT INTO tab SELECT number, number / 50 FROM numbers(100, 100) SETTINGS exclude_materialize_skip_indexes_on_insert='idx_b';
ALTER TABLE tab MATERIALIZE INDEX idx_a; -- esta consulta pode ser usada para materializar o índice explicitamente
SET exclude_materialize_skip_indexes_on_insert = DEFAULT; -- redefine a configuração para o valor padrão
execute_exists_as_scalar_subquery
0.
external_storage_connect_timeout_sec
external_storage_max_read_bytes
external_storage_max_read_rows
external_storage_rw_timeout_sec
external_table_functions_use_nulls
- 0 — A função de tabela usa explicitamente colunas Nullable.
- 1 — A função de tabela usa implicitamente colunas Nullable.
Uso
Se a configuração estiver definida como 0, a função de tabela não cria colunas Nullable e insere valores padrão em vez de NULL. Isso também se aplica a valores NULL dentro de arrays.
external_table_strict_query
extract_kvp_max_pairs_per_row
Número máximo de pares que podem ser produzidos pela função extractKeyValuePairs. Serve como salvaguarda para evitar o consumo excessivo de memória.
Define se os valores extremos (os mínimos e máximos nas colunas do resultado de uma consulta) devem ser contabilizados. Aceita 0 ou 1. O padrão é 0 (desabilitado).
Para mais informações, consulte a seção “Valores extremos”.
fallback_to_stale_replicas_for_distributed_queries
SELECT em uma tabela distribuída que aponta para tabelas replicadas.
Por padrão, 1 (habilitado).
filesystem_cache_allow_background_download
filesystem_cache_boundary_alignment
filesystem_cache_enable_background_download_during_fetch
filesystem_cache_max_download_size
filesystem_cache_prefer_bigger_buffer_size
filesystem_cache_reserve_space_wait_lock_timeout_milliseconds
filesystem_cache_segments_batch_size
filesystem_cache_skip_download_if_exceeds_per_query_cache_write_limit
skip_download_if_exceeds_query_cache
Ignora o download do sistema de arquivos remoto caso exceda o tamanho do cache de consultas
filesystem_prefetch_max_memory_usage
filesystem_prefetch_step_bytes
auto — o melhor passo de prefetch será estimado automaticamente, mas pode não ser o ideal em 100% dos casos. O valor real pode ser diferente por causa da configuração filesystem_prefetch_min_bytes_for_single_read_task
filesystem_prefetch_step_marks
auto — aproximadamente o melhor passo de prefetch será determinado automaticamente, mas pode não ser 100% o ideal. O valor real pode ser diferente por causa da configuração filesystem_prefetch_min_bytes_for_single_read_task
filesystem_prefetches_limit
filesystem_prefetches_max_memory_usage é mais recomendada se você quiser limitar o número de prefetches
Aplica automaticamente o modificador FINAL a todas as tabelas de uma consulta nas quais FINAL é aplicável, incluindo tabelas em JOIN, tabelas em subconsultas e
tabelas distribuídas.
Valores possíveis:
- 0 - desabilitado
- 1 - habilitado
Exemplo:
CREATE TABLE test
(
key Int64,
some String
)
ENGINE = ReplacingMergeTree
ORDER BY key;
INSERT INTO test FORMAT Values (1, 'first');
INSERT INTO test FORMAT Values (1, 'second');
SELECT * FROM test;
┌─key─┬─some───┐
│ 1 │ second │
└─────┴────────┘
┌─key─┬─some──┐
│ 1 │ first │
└─────┴───────┘
SELECT * FROM test SETTINGS final = 1;
┌─key─┬─some───┐
│ 1 │ second │
└─────┴────────┘
SET final = 1;
SELECT * FROM test;
┌─key─┬─some───┐
│ 1 │ second │
└─────┴────────┘
finalize_projection_parts_synchronously
- 1 — A coluna nested é desmembrada em arrays separados.
- 0 — A coluna nested permanece como um único array de tuplas.
Uso
Se a configuração estiver definida como 0, é possível usar um nível arbitrário de aninhamento.
Exemplos
Consulta:
SET flatten_nested = 1;
CREATE TABLE t_nest (`n` Nested(a UInt32, b UInt32)) ENGINE = MergeTree ORDER BY tuple();
SHOW CREATE TABLE t_nest;
┌─statement───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│ CREATE TABLE default.t_nest
(
`n.a` Array(UInt32),
`n.b` Array(UInt32)
)
ENGINE = MergeTree
ORDER BY tuple()
SETTINGS index_granularity = 8192 │
└─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
SET flatten_nested = 0;
CREATE TABLE t_nest (`n` Nested(a UInt32, b UInt32)) ENGINE = MergeTree ORDER BY tuple();
SHOW CREATE TABLE t_nest;
┌─statement──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│ CREATE TABLE default.t_nest
(
`n` Nested(a UInt32, b UInt32)
)
ENGINE = MergeTree
ORDER BY tuple()
SETTINGS index_granularity = 8192 │
└────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
force_aggregate_partitions_independently
force_aggregation_in_order
force_data_skipping_indices
CREATE TABLE data
(
key Int,
d1 Int,
d1_null Nullable(Int),
INDEX d1_idx d1 TYPE minmax GRANULARITY 1,
INDEX d1_null_idx assumeNotNull(d1_null) TYPE minmax GRANULARITY 1
)
Engine=MergeTree()
ORDER BY key;
SELECT * FROM data_01515;
SELECT * FROM data_01515 SETTINGS force_data_skipping_indices=''; -- a consulta produzirá o erro CANNOT_PARSE_TEXT.
SELECT * FROM data_01515 SETTINGS force_data_skipping_indices='d1_idx'; -- a consulta produzirá o erro INDEX_NOT_USED.
SELECT * FROM data_01515 WHERE d1 = 0 SETTINGS force_data_skipping_indices='d1_idx'; -- Ok.
SELECT * FROM data_01515 WHERE d1 = 0 SETTINGS force_data_skipping_indices='`d1_idx`'; -- Ok (exemplo de parser completo).
SELECT * FROM data_01515 WHERE d1 = 0 SETTINGS force_data_skipping_indices='`d1_idx`, d1_null_idx'; -- a consulta produzirá o erro INDEX_NOT_USED, pois d1_null_idx não é utilizado.
SELECT * FROM data_01515 WHERE d1 = 0 AND assumeNotNull(d1_null) = 0 SETTINGS force_data_skipping_indices='`d1_idx`, d1_null_idx'; -- Ok.
force_grouping_standard_compatibility
force_index_by_date=1, o ClickHouse verifica se a consulta tem uma condição na chave de data que possa ser usada para restringir os intervalos de dados. Se não houver uma condição adequada, ele gera uma exceção. No entanto, ele não verifica se a condição reduz a quantidade de dados a serem lidos. Por exemplo, a condição Date != ' 2000-01-01 ' é aceitável mesmo quando corresponde a todos os dados da tabela (ou seja, a execução da consulta exige uma varredura completa). Para mais informações sobre intervalos de dados em tabelas da família MergeTree, consulte MergeTree.
force_optimize_projection
SELECT, quando a otimização de projeções estiver ativada (consulte a configuração optimize_use_projections).
Valores possíveis:
- 0 — A otimização de projeções não é obrigatória.
- 1 — A otimização de projeções é obrigatória.
force_optimize_projection_name
- string: nome da projeção usada em uma consulta
force_optimize_skip_unused_shards
- 0 — Desabilitado. O ClickHouse não lança uma exceção.
- 1 — Habilitado. A execução da consulta é desabilitada somente se a tabela tiver uma chave de sharding.
- 2 — Habilitado. A execução da consulta é desabilitada independentemente de a tabela ter uma chave de sharding definida.
force_optimize_skip_unused_shards_nesting
force_optimize_skip_unused_shards (portanto, ainda requer force_optimize_skip_unused_shards) depende do nível de aninhamento da consulta distribuída (caso em que você tenha uma tabela Distributed que consulta outra tabela Distributed).
Valores possíveis:
- 0 - Desabilitado,
force_optimize_skip_unused_shards sempre funciona.
- 1 — Habilita
force_optimize_skip_unused_shards apenas para o primeiro nível.
- 2 — Habilita
force_optimize_skip_unused_shards até o segundo nível.
Impede a execução da consulta se não for possível usar a chave primária para indexação.
Funciona com tabelas da família MergeTree.
Se force_primary_key=1, o ClickHouse verifica se a consulta tem uma condição na chave primária que possa ser usada para restringir os intervalos de dados. Se não houver uma condição adequada, ele gera uma exceção. No entanto, não verifica se a condição reduz a quantidade de dados a serem lidos. Para mais informações sobre intervalos de dados em tabelas MergeTree, consulte MergeTree.
force_remove_data_recursively_on_drop
.sql. Habilitado por padrão.
Faz sentido desabilitá-lo se o servidor tiver milhões de tabelas pequenas que são constantemente criadas e removidas.
function_date_trunc_return_type_behavior
dateTrunc.
Valores possíveis:
- 0 - Quando o segundo argumento é
DateTime64/Date32, o tipo de retorno será DateTime64/Date32, independentemente da unidade de tempo no primeiro argumento.
- 1 - Para
Date32, o resultado é sempre Date. Para DateTime64, o resultado é DateTime para unidades de tempo second e superiores.
Escolha a implementação da função para um destino ou uma variante específica (experimental). Se estiver em branco, habilite todas elas.
function_json_value_return_type_allow_complex
SELECT JSON_VALUE('{"hello":{"world":"!"}}', '$.hello') settings function_json_value_return_type_allow_complex=true
┌─JSON_VALUE('{"hello":{"world":"!"}}', '$.hello')─┐
│ {"world":"!"} │
└──────────────────────────────────────────────────┘
1 row in set. Elapsed: 0.001 sec.
- true — Permite.
- false — Não permite.
function_json_value_return_type_allow_nullable
NULL quando o valor não existir na função JSON_VALUE.
SELECT JSON_VALUE('{"hello":"world"}', '$.b') settings function_json_value_return_type_allow_nullable=true;
┌─JSON_VALUE('{"hello":"world"}', '$.b')─┐
│ ᴺᵁᴸᴸ │
└────────────────────────────────────────┘
1 row in set. Elapsed: 0.001 sec.
- true — Permite.
- false — Não permite.
function_locate_has_mysql_compatible_argument_order
- 0 — A função
locate aceita os argumentos (haystack, needle[, start_pos]).
- 1 — A função
locate aceita os argumentos (needle, haystack, [, start_pos]) (comportamento compatível com MySQL)
function_range_max_elements_in_block
function_sleep_max_microseconds_per_block
sleep pode suspender a execução em cada bloco. Se um usuário a chamar com um valor maior, ela lança uma exceção. Este é um limite de segurança.
function_visible_width_behavior
visibleWidth. 0 - conta apenas o número de pontos de código; 1 - conta corretamente caracteres de largura zero e caracteres combináveis, conta caracteres de largura total como dois, estima a largura da tabulação e conta caracteres de exclusão.
functions_h3_default_if_invalid
geo_distance_returns_float64_on_float64_arguments
geoDistance, greatCircleDistance e greatCircleAngle forem Float64, retorna Float64 e usa precisão dupla nos cálculos internos. Em versões anteriores do ClickHouse, as funções sempre retornavam Float32.
A função ‘geoToH3’ aceita (lon, lat) se estiver configurada como ‘lon_lat’ e (lat, lon) se estiver configurada como ‘lat_lon’.
glob_expansion_max_elements
grace_hash_join_initial_buckets
grace_hash_join_max_buckets
throw: gera uma exceçãobreak: interrompe a execução da consulta e retorna o resultado parcialany: continua a agregação para as chaves que entraram no conjunto, mas não adiciona novas chaves ao conjunto.
Usar o valor ‘any’ permite executar uma aproximação de GROUP BY. A qualidade dessa
aproximação depende da natureza estatística dos dados.
group_by_two_level_threshold
group_by_two_level_threshold_bytes
ROLLUP, CUBE ou GROUPING SETS são usados, algumas chaves de agregação podem não ser usadas para produzir determinadas linhas de resultado.
As colunas dessas chaves são preenchidas com o valor padrão ou com NULL nas linhas correspondentes, dependendo desta configuração.
Valores possíveis:
- 0 — O valor padrão do tipo da chave de agregação é usado para preencher os valores ausentes.
- 1 — O ClickHouse executa
GROUP BY da mesma forma que o padrão SQL define. Os tipos das chaves de agregação são convertidos para Nullable. As colunas das chaves de agregação correspondentes são preenchidas com NULL nas linhas em que elas não foram usadas.
Veja também:
h3togeo_lon_lat_result_order
hdfs_create_new_file_on_insert
data.Parquet.gz -> data.1.Parquet.gz -> data.2.Parquet.gz, etc.
Valores possíveis:
- 0 — a consulta
INSERT acrescenta novos dados ao final do arquivo.
- 1 — a consulta
INSERT cria um novo arquivo.
hdfs_ignore_file_doesnt_exist
- 1 —
SELECT retorna um resultado vazio.
- 0 —
SELECT gera uma exceção.
O número real de réplicas pode ser especificado quando o arquivo HDFS é criado.
Habilita ou desabilita ignorar arquivos vazios em tabelas com o mecanismo HDFS.
Valores possíveis:
- 0 —
SELECT gera uma exceção se o arquivo vazio não for compatível com o formato solicitado.
- 1 —
SELECT retorna um resultado vazio para um arquivo vazio.
hdfs_throw_on_zero_files_match
- 1 —
SELECT gera uma exceção.
- 0 —
SELECT retorna um resultado vazio.
Ativa ou desativa o truncamento antes de um insert em tabelas com mecanismo HDFS. Se estiver desativado, será gerada uma exceção ao tentar fazer um insert se um arquivo no HDFS já existir.
Valores possíveis:
- 0 — a consulta
INSERT acrescenta novos dados ao final do arquivo.
- 1 — a consulta
INSERT substitui o conteúdo existente do arquivo pelos novos dados.
hedged_connection_timeout_ms
highlight_max_matches_per_row
hnsw_candidate_list_size_for_search
- Qualquer número inteiro positivo.
- 0 - Desabilitado (tempo limite infinito).
Não envie os cabeçalhos HTTP X-ClickHouse-Progress com frequência maior que a do intervalo especificado.
Tempo máximo, em segundos, para ler todos os cabeçalhos da requisição HTTP. Este é um limite total de tempo para toda a fase de processamento dos cabeçalhos, não um timeout por leitura. Protege contra ataques do tipo slowloris, em que um cliente envia dados de cabeçalho lentamente para manter as conexões abertas.
A configuração http_make_head_request permite executar uma solicitação HEAD ao ler dados via HTTP para obter informações sobre o arquivo a ser lido, como seu tamanho. Como ela é habilitada por padrão, pode ser desejável desabilitar essa configuração nos casos em que o servidor não oferece suporte a solicitações HEAD.
Comprimento máximo do nome do campo no cabeçalho HTTP
http_max_field_value_size
http_max_request_param_data_size
http_native_compression_disable_checksumming_on_decompress
gzip ou deflate).
Para mais informações, leia a descrição da interface HTTP.
Valores possíveis:
- 0 — Desativado.
- 1 — Ativado.
Tempo limite para recebimento via HTTP (em segundos).
Valores possíveis:
- Qualquer número inteiro positivo.
- 0 - Desabilitado (tempo limite infinito).
http_response_buffer_size
http_wait_end_of_query está habilitado).
Permite adicionar ou substituir cabeçalhos HTTP que o servidor retornará na resposta com um resultado de consulta bem-sucedido.
Isso afeta apenas a interface HTTP.
Se o cabeçalho já estiver definido por padrão, o valor fornecido o substituirá.
Se o cabeçalho não estiver definido por padrão, ele será adicionado à lista de cabeçalhos.
Os cabeçalhos definidos pelo servidor por padrão e não substituídos por esta configuração permanecerão.
A configuração permite definir um cabeçalho com um valor constante. Atualmente, não há como definir um cabeçalho com um valor calculado dinamicamente.
Nem os nomes nem os valores podem conter caracteres de controle ASCII.
Se você implementar uma aplicação de UI que permita aos usuários modificar configurações, mas ao mesmo tempo tome decisões com base nos cabeçalhos retornados, recomenda-se restringir esta configuração a readonly.
Exemplo: SET http_response_headers = '{"Content-Type": "image/png"}'
http_retry_initial_backoff_ms
http_retry_max_backoff_ms
- Qualquer número inteiro positivo.
- 0 - Desabilitado (tempo limite infinito).
Isso se aplica apenas ao perfil padrão. É necessário reiniciar o servidor para que as alterações entrem em vigor.
http_skip_not_found_url_for_globs
http_zlib_compression_level
iceberg_compaction_data_cleanup
iceberg_compaction_delay_bias
iceberg_data_file_size_lower_threshold_compaction
iceberg_data_file_size_upper_threshold_compaction
iceberg_delete_data_on_drop
drop.
iceberg_expire_default_max_ref_age_ms
history.expire.max-ref-age-ms, usada por expire_snapshots quando essa propriedade não está presente.
iceberg_expire_default_max_snapshot_age_ms
history.expire.max-snapshot-age-ms usado por expire_snapshots quando essa propriedade não está presente.
iceberg_expire_default_min_snapshots_to_keep
history.expire.min-snapshots-to-keep da tabela Iceberg, usado por expire_snapshots quando essa propriedade não está presente.
iceberg_insert_max_bytes_in_data_file
iceberg_insert_max_partitions
iceberg_insert_max_rows_in_data_file
iceberg_max_number_datafiles_to_compact
.metadata.json.
Controla o nível de log de metadados para tabelas Iceberg em system.iceberg_metadata_log.
Em geral, essa configuração pode ser modificada para fins de depuração.
Valores possíveis:
- none - Sem log de metadados.
- metadata - Arquivo raiz metadata.json.
- manifest_list_metadata - Tudo o que está acima + metadados da manifest list avro correspondente a um snapshot.
- manifest_list_entry - Tudo o que está acima + entradas da manifest list avro.
- manifest_file_metadata - Tudo o que está acima + metadados dos manifest files avro percorridos.
- manifest_file_entry - Tudo o que está acima + entradas dos manifest files avro percorridos.
Se for diferente de zero, ignora a busca dos metadados do Iceberg no catálogo remoto se houver um snapshot de metadados em cache mais recente do que a janela de desatualização especificada. Zero significa sempre buscar a versão mais recente dos metadados no catálogo remoto. Definir esse valor como diferente de zero troca um pouco de desatualização por menor latência nas operações de leitura.
iceberg_orphan_files_older_than_seconds
older_than é omitido da chamada do procedimento remove_orphan_files(). O padrão é 259200 (3 dias).
Consulta a tabela Iceberg usando o ID de snapshot especificado.
Consulte a tabela Iceberg usando o snapshot vigente em um timestamp específico.
Tempo limite para encerrar conexões TCP ociosas após o número especificado de segundos.
Valores possíveis:
- Inteiro positivo (0 - encerra imediatamente, após 0 segundos).
ignore_cold_parts_seconds
ignore_data_skipping_indices
CREATE TABLE data
(
key Int,
x Int,
y Int,
INDEX x_idx x TYPE minmax GRANULARITY 1,
INDEX y_idx y TYPE minmax GRANULARITY 1,
INDEX xy_idx (x,y) TYPE minmax GRANULARITY 1
)
Engine=MergeTree()
ORDER BY key;
INSERT INTO data VALUES (1, 2, 3);
SELECT * FROM data;
SELECT * FROM data SETTINGS ignore_data_skipping_indices=''; -- a consulta produzirá o erro CANNOT_PARSE_TEXT.
SELECT * FROM data SETTINGS ignore_data_skipping_indices='x_idx'; -- Ok.
SELECT * FROM data SETTINGS ignore_data_skipping_indices='na_idx'; -- Ok.
SELECT * FROM data WHERE x = 1 AND y = 1 SETTINGS ignore_data_skipping_indices='xy_idx',force_data_skipping_indices='xy_idx' ; -- a consulta produzirá o erro INDEX_NOT_USED, pois xy_idx é explicitamente ignorado.
SELECT * FROM data WHERE x = 1 AND y = 2 SETTINGS ignore_data_skipping_indices='xy_idx';
EXPLAIN indexes = 1 SELECT * FROM data WHERE x = 1 AND y = 2;
Expression ((Projection + Before ORDER BY))
Filter (WHERE)
ReadFromMergeTree (default.data)
Indexes:
PrimaryKey
Condition: true
Parts: 1/1
Granules: 1/1
Skip
Name: x_idx
Description: minmax GRANULARITY 1
Parts: 0/1
Granules: 0/1
Skip
Name: y_idx
Description: minmax GRANULARITY 1
Parts: 0/0
Granules: 0/0
Skip
Name: xy_idx
Description: minmax GRANULARITY 1
Parts: 0/0
Granules: 0/0
xy_idx:
EXPLAIN indexes = 1 SELECT * FROM data WHERE x = 1 AND y = 2 SETTINGS ignore_data_skipping_indices='xy_idx';
Expression ((Projection + Before ORDER BY))
Filter (WHERE)
ReadFromMergeTree (default.data)
Indexes:
PrimaryKey
Condition: true
Parts: 1/1
Granules: 1/1
Skip
Name: x_idx
Description: minmax GRANULARITY 1
Parts: 0/1
Granules: 0/1
Skip
Name: y_idx
Description: minmax GRANULARITY 1
Parts: 0/0
Granules: 0/0
ignore_drop_queries_probability
FORMAT Null será ignorado em consultas EXPLAIN, e o formato de saída padrão será usado no lugar dele.
Se estiver desabilitado, consultas EXPLAIN com FORMAT Null não produzirão saída (comportamento compatível com versões anteriores).
ignore_materialized_views_with_dropped_target_table
ignore_on_cluster_for_replicated_access_entities_queries
ignore_on_cluster_for_replicated_database
ignore_on_cluster_for_replicated_named_collections_queries
ignore_on_cluster_for_replicated_udf_queries
1 + 2 se torna uma consulta válida.
No clickhouse-local, isso é habilitado por padrão e pode ser desabilitado explicitamente.
implicit_table_at_top_level
inject_random_order_for_select_without_order_by
insert_allow_materialized_columns
INSERT (para tabelas Replicated*).
Possíveis valores:
- 0 — Desativado.
- 1 — Ativado.
Por padrão, os blocos inseridos em tabelas replicadas pela instrução INSERT são desduplicados (consulte Replicação de dados).
Em tabelas replicadas, por padrão, apenas os 100 blocos mais recentes de cada partição são desduplicados (consulte replicated_deduplication_window, replicated_deduplication_window_seconds).
Para tabelas não replicadas, consulte non_replicated_deduplication_window.
insert_deduplication_token
insert_deduplication_token é usado para desduplicação apenas quando não está vazio.
Para tabelas replicadas, por padrão, apenas as 100 inserções mais recentes de cada partição são desduplicadas (consulte replicated_deduplication_window, replicated_deduplication_window_seconds).
Para tabelas não replicadas, consulte non_replicated_deduplication_window.
insert_deduplication_token funciona no nível da partição (assim como o checksum insert_deduplication). Várias partições podem ter o mesmo insert_deduplication_token.
CREATE TABLE test_table
( A Int64 )
ENGINE = MergeTree
ORDER BY A
SETTINGS non_replicated_deduplication_window = 100;
INSERT INTO test_table SETTINGS insert_deduplication_token = 'test' VALUES (1);
-- o próximo insert não será desduplicado porque insert_deduplication_token é diferente
INSERT INTO test_table SETTINGS insert_deduplication_token = 'test1' VALUES (1);
-- o próximo insert será desduplicado porque insert_deduplication_token
-- é igual a um dos anteriores
INSERT INTO test_table SETTINGS insert_deduplication_token = 'test' VALUES (2);
SELECT * FROM test_table
┌─A─┐
│ 1 │
└───┘
┌─A─┐
│ 1 │
└───┘
insert_keeper_fault_injection_probability
insert_keeper_fault_injection_seed
insert_keeper_max_retries
- Inteiro positivo.
- 0 — As novas tentativas ficam desabilitadas
Valor padrão no Cloud: 20.
As novas tentativas de solicitações ao Keeper são feitas após um determinado timeout. O timeout é controlado pelas seguintes configurações: insert_keeper_retry_initial_backoff_ms, insert_keeper_retry_max_backoff_ms.
A primeira nova tentativa é feita após o timeout definido por insert_keeper_retry_initial_backoff_ms. Os timeouts subsequentes serão calculados da seguinte forma:
timeout = min(insert_keeper_retry_max_backoff_ms, latest_timeout * 2)
insert_keeper_retry_initial_backoff_ms=100, insert_keeper_retry_max_backoff_ms=10000 e insert_keeper_max_retries=8, então os timeouts serão 100, 200, 400, 800, 1600, 3200, 6400, 10000.
Além da tolerância a falhas, as tentativas de repetição visam proporcionar uma melhor experiência ao usuário — elas permitem evitar o retorno de um erro durante a execução de INSERT se o Keeper for reiniciado, por exemplo, devido a uma atualização.
insert_keeper_retry_initial_backoff_ms
- Inteiro positivo.
- 0 — Sem tempo limite
insert_keeper_retry_max_backoff_ms
- Inteiro positivo.
- 0 — O tempo limite máximo não é limitado
Habilita ou desabilita a inserção de valores padrão no lugar de NULL em colunas com tipo de dado não Nullable.
Se o tipo da coluna não for Nullable e essa configuração estiver desabilitada, a inserção de NULL causará uma exceção. Se o tipo da coluna for Nullable, os valores NULL serão inseridos como estão, independentemente dessa configuração.
Essa configuração se aplica a consultas INSERT … SELECT. Observe que subconsultas SELECT podem ser concatenadas com a cláusula UNION ALL.
Valores possíveis:
- 0 — Inserir
NULL em uma coluna não Nullable causa uma exceção.
- 1 — O valor padrão da coluna é inserido no lugar de
NULL.
Habilita gravações com quorum.
- Se
insert_quorum < 2, as gravações com quorum ficam desabilitadas.
- Se
insert_quorum >= 2, as gravações com quorum ficam habilitadas.
- Se
insert_quorum = 'auto', use o número da maioria (number_of_replicas / 2 + 1) como quorum.
Gravações com quorum
INSERT só é bem-sucedido quando o ClickHouse consegue gravar corretamente os dados em insert_quorum réplicas dentro de insert_quorum_timeout. Se, por qualquer motivo, o número de réplicas com gravações bem-sucedidas não atingir insert_quorum, a gravação será considerada malsucedida, e o ClickHouse excluirá o bloco inserido de todas as réplicas em que os dados já tiverem sido gravados.
Quando insert_quorum_parallel está desabilitado, todas as réplicas do quorum são consistentes, ou seja, contêm dados de todas as consultas INSERT anteriores (a sequência de INSERT é linearizada). Ao ler dados gravados com insert_quorum enquanto insert_quorum_parallel está desabilitado, você pode ativar a consistência sequencial para consultas SELECT usando select_sequential_consistency.
O ClickHouse gera uma exceção:
- Se o número de réplicas disponíveis no momento da consulta for menor que
insert_quorum.
- Quando
insert_quorum_parallel está desabilitado e é feita uma tentativa de gravar dados enquanto o bloco anterior ainda não foi inserido em insert_quorum réplicas. Essa situação pode ocorrer se o usuário tentar executar outra consulta INSERT na mesma tabela antes de a anterior com insert_quorum ser concluída.
Veja também:
Habilita ou desabilita o paralelismo para consultas INSERT com quorum. Se estiver habilitado, consultas INSERT adicionais poderão ser enviadas enquanto as consultas anteriores ainda não tiverem terminado. Se estiver desabilitado, gravações adicionais na mesma tabela serão rejeitadas.
Valores possíveis:
- 0 — Desabilitado.
- 1 — Habilitado.
Veja também:
Tempo limite, em milissegundos, para gravação com quorum. Se o tempo limite expirar e nenhuma gravação tiver sido realizada até então, o ClickHouse gerará uma exceção, e o cliente deverá repetir a consulta para gravar o mesmo bloco na mesma ou em qualquer outra réplica.
Veja também:
Se não for 0, especifica o shard da tabela Distributed no qual os dados serão inseridos sincronicamente.
Se o valor de insert_shard_id estiver incorreto, o servidor lançará uma exceção.
Para obter o número de shards em requested_cluster, você pode verificar a config do servidor ou usar esta consulta:
SELECT uniq(shard_num) FROM system.clusters WHERE cluster = 'requested_cluster';
- 0 — Desativado.
- Qualquer número de
1 a shards_num da tabela Distributed correspondente.
Exemplo
Consulta:
CREATE TABLE x AS system.numbers ENGINE = MergeTree ORDER BY number;
CREATE TABLE x_dist AS x ENGINE = Distributed('test_cluster_two_shards_localhost', currentDatabase(), x);
INSERT INTO x_dist SELECT * FROM numbers(5) SETTINGS insert_shard_id = 1;
SELECT * FROM x_dist ORDER BY number ASC;
┌─number─┐
│ 0 │
│ 0 │
│ 1 │
│ 1 │
│ 2 │
│ 2 │
│ 3 │
│ 3 │
│ 4 │
│ 4 │
└────────┘
jemalloc_collect_profile_samples_in_trace_log
jemalloc_profile_text_collapsed_use_count
jemalloc_profile_text_output_format
jemalloc_profile_text_symbolize_with_inline
grace_hash_join_initial_buckets). Isso é feito de modo a garantir que cada bucket possa ser processado de forma independente. As linhas do primeiro bucket são adicionadas a uma tabela hash em memória, enquanto as demais são salvas em disco. Se a tabela hash crescer além do limite de memória (por exemplo, conforme definido por max_bytes_in_join), o número de buckets será aumentado, assim como o bucket atribuído a cada linha. Quaisquer linhas que não pertençam ao bucket atual são descarregadas e reatribuídas.
Oferece suporte a INNER/LEFT/RIGHT/FULL ALL/ANY JOIN.
Hash join algorithm é usado. É a implementação mais genérica e oferece suporte a todas as combinações de kind e strictness, além de múltiplas chaves de junção combinadas com OR na seção JOIN ON.
Ao usar o algoritmo hash, a parte direita de JOIN é carregada na RAM.
Uma variação de hash join que divide os dados em buckets e cria várias tabelas hash simultaneamente, em vez de apenas uma, para acelerar esse processo.
Ao usar o algoritmo parallel_hash, a parte direita de JOIN é carregada na RAM.
Uma variação do algoritmo sort-merge, em que apenas a tabela da direita é totalmente ordenada.
RIGHT JOIN e FULL JOIN são compatíveis apenas com strictness ALL (SEMI, ANTI, ANY e ASOF não são compatíveis).
Ao usar o algoritmo partial_merge, o ClickHouse ordena os dados e os grava em disco. O algoritmo partial_merge no ClickHouse difere ligeiramente da implementação clássica. Primeiro, o ClickHouse ordena a tabela da direita pelas chaves de junção em blocos e cria um índice min-max para os blocos ordenados. Em seguida, ele ordena partes da tabela da esquerda pela chave de junção e faz a junção com a tabela da direita. O índice min-max também é usado para ignorar blocos desnecessários da tabela da direita.
O algoritmo direct (também conhecido como nested loop) faz uma busca na tabela da direita usando as linhas da tabela da esquerda como chaves.
É compatível com armazenamentos especiais, como Dictionary, EmbeddedRocksDB e tabelas MergeTree.
Para tabelas MergeTree, o algoritmo envia filtros de chave de junção diretamente para a camada de armazenamento. Isso pode ser mais eficiente quando a chave pode usar o índice de chave primária da tabela para buscas; caso contrário, ele executa varreduras completas da tabela da direita para cada bloco da tabela da esquerda.
Oferece suporte a junções INNER e LEFT e apenas a chaves de junção de igualdade com uma única coluna, sem outras condições.
Quando definido como auto, hash join é tentado primeiro, e o algoritmo é alternado dinamicamente para outro algoritmo se o limite de memória for excedido.
Algoritmo sort-merge com ordenação completa das tabelas unidas antes da junção.
O ClickHouse sempre tenta usar partial_merge join, se possível; caso contrário, usa hash. Descontinuado, igual a partial_merge,hash.
Valor legado; não use mais.
Igual a direct,hash, ou seja, tenta usar direct join e hash join (nessa ordem).
Altera o comportamento das operações JOIN com strictness ANY.
Essa configuração se aplica apenas a operações JOIN com tabelas que usam o motor Join.
- 0 — Se a tabela da direita tiver mais de uma linha correspondente, apenas a primeira encontrada será associada.
- 1 — Se a tabela da direita tiver mais de uma linha correspondente, apenas a última encontrada será associada.
Veja também:
Define a strictness padrão para cláusulas JOIN.
Valores possíveis:
ALL — Se a tabela da direita tiver várias linhas correspondentes, o ClickHouse cria um produto cartesiano com as linhas correspondentes. Esse é o comportamento normal de JOIN no SQL padrão.ANY — Se a tabela da direita tiver várias linhas correspondentes, apenas a primeira encontrada será usada na junção. Se a tabela da direita tiver apenas uma linha correspondente, os resultados de ANY e ALL serão os mesmos.ASOF — Para unir sequências com correspondência incerta.Empty string — Se ALL ou ANY não for especificado na consulta, o ClickHouse lança uma exceção.
join_on_disk_max_files_to_merge
- Qualquer inteiro positivo, a partir de 2.
join_output_by_rowlist_perkey_rows_threshold
THROW — o ClickHouse lança uma exceção e interrompe a operação.BREAK — o ClickHouse interrompe a operação e não lança uma exceção.
Valor padrão: THROW.
Veja também
join_runtime_bloom_filter_bytes
join_runtime_bloom_filter_hash_functions
join_runtime_bloom_filter_max_ratio_of_set_bits
join_runtime_filter_blocks_to_skip_before_reenabling
join_runtime_filter_exact_values_limit
join_runtime_filter_pass_ratio_threshold_for_disabling
join_runtime_filter_blocks_to_skip_before_reenabling blocos para reduzir a sobrecarga.
join_to_sort_maximum_table_rows
join_to_sort_minimum_perkey_rows
- 0 — As células vazias são preenchidas com o valor padrão do tipo do campo correspondente.
- 1 —
JOIN se comporta da mesma forma que no SQL padrão. O tipo do campo correspondente é convertido para Nullable, e as células vazias são preenchidas com NULL.
joined_block_split_single_row
max_joined_block_size_rows != 0 é obrigatório para que essa configuração tenha efeito.
O max_joined_block_size_bytes, em combinação com essa configuração, é útil para evitar uso excessivo de memória em caso de dados desbalanceados, com algumas linhas grandes tendo muitas correspondências na tabela à direita.
joined_subquery_requires_alias
kafka_disable_num_consumers_limit
- Inteiro positivo.
- 0 — Sem limite de tempo.
Veja também:
Impõe verificações adicionais durante operações no KeeperMap. Ex.: lança uma exceção ao inserir uma chave que já existe
Máximo de tentativas para operações gerais do Keeper
keeper_retry_initial_backoff_ms
keeper_retry_max_backoff_ms
least_greatest_legacy_null_behavior
legacy_column_name_of_tuple_literal
alter_update - executa a consulta ALTER UPDATE, que cria uma mutação pesada.lightweight_update - executa atualização leve, se possível; caso contrário, executa ALTER UPDATE.lightweight_update_force - executa atualização leve, se possível; caso contrário, gera uma exceção.
O mesmo que mutations_sync, mas controla apenas a execução de exclusões leves.
Valores possíveis:
| Valor | Descrição |
|---|
0 | As mutações são executadas de forma assíncrona. |
1 | A consulta aguarda a conclusão das exclusões leves no servidor atual. |
2 | A consulta aguarda a conclusão das exclusões leves em todas as réplicas (se existirem). |
3 | A consulta aguarda apenas as réplicas ativas. Compatível apenas com SharedMergeTree. Para ReplicatedMergeTree, o comportamento é o mesmo de mutations_sync = 2. |
1.
Define o número máximo de linhas a retornar no resultado da consulta. Ele ajusta o valor definido pela cláusula LIMIT, para que o limite especificado na consulta não possa exceder o limite definido por esta configuração.
Valores possíveis:
- 0 — O número de linhas não é limitado.
- Inteiro positivo.
Especifica o algoritmo de seleção de réplicas usado para o processamento distribuído de consultas.
O ClickHouse oferece suporte aos seguintes algoritmos de seleção de réplicas:
Veja também:
O número de erros é contabilizado para cada réplica. A consulta é enviada para a réplica com menos erros e, se houver várias nessas condições, para qualquer uma delas.
Desvantagens: a proximidade do servidor não é levada em conta; se as réplicas tiverem dados diferentes, você também obterá dados diferentes.
load_balancing = nearest_hostname
Distância de Levenshtein entre hostnames
load_balancing = hostname_levenshtein_distance
nearest_hostname, mas compara o hostname usando a distância de Levenshtein. Por exemplo:
example-clickhouse-0-0 ample-clickhouse-0-0
1
example-clickhouse-0-0 example-clickhouse-1-10
2
example-clickhouse-0-0 example-clickhouse-12-0
3
load_balancing = in_order
load_balancing = first_or_random
first_or_random resolve o problema do algoritmo in_order. Com in_order, se uma réplica ficar indisponível, a próxima recebe o dobro da carga, enquanto as demais réplicas continuam lidando com o volume habitual de tráfego. Ao usar o algoritmo first_or_random, a carga é distribuída de forma uniforme entre as réplicas que ainda estão disponíveis.
É possível definir explicitamente qual é a primeira réplica usando a configuração load_balancing_first_offset. Isso dá mais controle para redistribuir a carga das consultas entre as réplicas.
load_balancing = round_robin
round_robin são levadas em conta).
load_balancing_first_offset
load_marks_asynchronously
1.
local_filesystem_read_method
local_filesystem_read_prefetch
DEADLOCK_AVOIDED.
Valores possíveis:
- Inteiro positivo (em segundos).
- 0 — Sem timeout de bloqueio.
Especifica o valor do campo log_comment da tabela system.query_log e o texto de comentário do log do servidor.
Pode ser usado para melhorar a legibilidade dos logs do servidor. Além disso, ajuda a selecionar consultas relacionadas ao teste em system.query_log após executar clickhouse-test.
Valores possíveis:
- Qualquer string com comprimento máximo de max_query_size. Se
max_query_size for excedido, o servidor gera uma exceção.
Exemplo
Consulta:
SET log_comment = 'log_comment test', log_queries = 1;
SELECT 1;
SYSTEM FLUSH LOGS;
SELECT type, query FROM system.query_log WHERE log_comment = 'log_comment test' AND event_date >= yesterday() ORDER BY event_time DESC LIMIT 2;
┌─type────────┬─query─────┐
│ QueryStart │ SELECT 1; │
│ QueryFinish │ SELECT 1; │
└─────────────┴───────────┘
formatted_query na system.query_log).
Valores possíveis:
- 0 — As consultas formatadas não são registradas na tabela de sistema.
- 1 — As consultas formatadas são registradas na tabela de sistema.
Grava na tabela system.processors_profile_log o tempo que o processador passou em execução/aguardando dados.
Veja também:
Registra estatísticas de desempenho de consultas em query_log, query_thread_log e query_views_log.
Configura o registro de consultas.
As consultas enviadas ao ClickHouse com essa configuração são registradas de acordo com as regras do parâmetro de configuração do servidor query_log.
Exemplo:
log_queries_cut_to_length
log_queries_min_query_duration_ms
long_query_time do MySQL Slow Query Log); isso basicamente significa que você não as encontrará nas tabelas a seguir:
system.query_logsystem.query_thread_log
Somente consultas do seguinte tipo serão registradas no log:
-
QUERY_FINISH
-
EXCEPTION_WHILE_PROCESSING
-
Tipo: milissegundos
-
Valor padrão: 0 (qualquer consulta)
Tipo mínimo de query_log a ser registrado.
Valores possíveis:
QUERY_START (=1)QUERY_FINISH (=2)EXCEPTION_BEFORE_START (=3)EXCEPTION_WHILE_PROCESSING (=4)
Pode ser usado para limitar quais registros irão para query_log; por exemplo, se você estiver interessado apenas em erros, pode usar EXCEPTION_WHILE_PROCESSING:
log_queries_min_type='EXCEPTION_WHILE_PROCESSING'
- 0 — As consultas não são registradas nas tabelas de sistema.
- Número positivo de ponto flutuante no intervalo [0..1]. Por exemplo, se o valor da configuração for
0.5, cerca de metade das consultas será registrada nas tabelas de sistema.
- 1 — Todas as consultas são registradas nas tabelas de sistema.
Registra as configurações da consulta no query_log e no log de span do OpenTelemetry.
Configura o registro em log das threads de consulta.
As threads de consulta são registradas na tabela system.query_thread_log. Essa configuração só tem efeito quando log_queries é true. As threads das consultas executadas pelo ClickHouse com essa configuração são registradas de acordo com as regras definidas no parâmetro de configuração do servidor query_thread_log.
Valores possíveis:
- 0 — Desabilitado.
- 1 — Habilitado.
Exemplo
Configura o registro de visualizações de consultas.
Quando uma consulta executada pelo ClickHouse com essa configuração habilitada tem visualizações associadas (materializadas ou visualizações em tempo real), elas são registradas no parâmetro de configuração do servidor query_views_log.
Exemplo:
Permite ou restringe o uso do tipo de dado LowCardinality com o formato Native.
Se o uso de LowCardinality for restringido, o servidor ClickHouse converte colunas LowCardinality em colunas comuns em consultas SELECT e converte colunas comuns em colunas LowCardinality em consultas INSERT.
Essa configuração é necessária principalmente para clientes de terceiros que não oferecem suporte ao tipo de dado LowCardinality.
Possible values:
- 1 — O uso de
LowCardinality não é restringido.
- 0 — O uso de
LowCardinality é restringido.
low_cardinality_max_dictionary_size
- Qualquer número inteiro positivo.
low_cardinality_use_single_dictionary_for_part
low_cardinality_use_single_dictionary_for_part = 1.
Valores possíveis:
- 1 — A criação de vários dicionários para a data part é proibida.
- 0 — A criação de vários dicionários para a data part não é proibida.
low_priority_query_wait_time_ms
priority), consultas de baixa prioridade aguardam o término das consultas de maior prioridade. Esta configuração define por quanto tempo elas aguardam.
Cria plano de consulta distribuída.
materialize_skip_indexes_on_insert
materialize_statistics_on_insert
materialize_ttl_after_modify
materialized_views_ignore_errors
materialized_views_squash_parallel_inserts
false e parallel_view_processing estiver habilitado, a consulta INSERT gerará uma parte na tabela de destino para cada max_insert_thread.
Número máximo de análises executadas pelo interpretador.
A profundidade máxima de aninhamento da árvore sintática de uma consulta. Se for excedida, uma exceção será lançada.
No momento, isso não é verificado durante o parsing, mas apenas após o parsing da consulta.
Isso significa que uma árvore sintática profunda demais pode ser criada durante o parsing,
mas a consulta falhará.
No momento, isso não é verificado durante o parsing, mas apenas após o parsing da consulta.
Isso significa que uma árvore sintática excessivamente profunda pode ser criada durante o parsing,
mas a consulta falhará.
generateSerialID.
Como cada série representa um nó no Keeper, recomenda-se não ter mais do que alguns milhões delas.
A velocidade máxima de leitura, em bytes por segundo, para um backup específico no servidor. Zero significa sem limite.
No ClickHouse, os dados são processados em blocos, que são conjuntos de partes de colunas. Os ciclos internos de processamento de um único bloco são eficientes, mas há custos perceptíveis no processamento de cada bloco.
A configuração max_block_size indica o número máximo recomendado de linhas a serem incluídas em um único bloco ao carregar dados de tabelas. Blocos com o tamanho de max_block_size nem sempre são carregados da tabela: se o ClickHouse determinar que menos dados precisam ser recuperados, um bloco menor será processado.
O tamanho do bloco não deve ser muito pequeno, para evitar custos perceptíveis no processamento de cada bloco. Também não deve ser muito grande, para garantir que consultas com uma cláusula LIMIT sejam executadas rapidamente após o processamento do primeiro bloco. Ao definir max_block_size, o objetivo deve ser evitar o consumo excessivo de memória ao extrair um grande número de colunas em múltiplas threads e preservar ao menos alguma localidade de cache.
max_bytes_before_external_group_by
GROUP BY na memória externa.
(Consulte GROUP BY na memória externa)
Valores possíveis:
- Volume máximo de RAM (em bytes) que pode ser usado por uma única operação GROUP BY.
0 — GROUP BY na memória externa desabilitado.
Se o uso de memória durante operações de GROUP BY exceder esse limite em bytes,
ative o modo de agregação externa (gravar dados em disco).O valor recomendado é metade da memória disponível do sistema.
max_bytes_before_external_join
join_algorithm for hash, parallel_hash, default ou auto, o hash join será convertido automaticamente em grace hash join para permitir o spilling para disco quando os dados do lado direito excederem essa quantidade de bytes. Quando definido como 0 (padrão), esse limite absoluto em bytes é desabilitado, mas o spilling automático ainda pode ocorrer por meio de max_bytes_ratio_before_external_join (que, por padrão, é 0.5); defina ambos como 0 para desabilitar totalmente o spilling automático. Isso impede a otimização de leitura em ordem por meio de join.
max_bytes_before_external_sort
ORDER BY em memória externa. Consulte Detalhes de implementação de ORDER BY
Se o uso de memória durante a operação ORDER BY exceder esse limite em bytes, o modo de “ordenação externa” (gravar dados em disco) será ativado.
Valores possíveis:
- Volume máximo de RAM (em bytes) que pode ser usado por uma única operação ORDER BY.
O valor recomendado é metade da memória disponível do sistema
0 — ORDER BY em memória externa desabilitado.
max_bytes_before_remerge_sort
- Inteiro positivo.
- 0 — O controle de memória está desabilitado.
O número máximo de bytes (de dados não comprimidos) usado por um conjunto criado a partir de uma subconsulta na cláusula IN.
max_bytes_ratio_before_external_group_by
GROUP BY. Quando esse limite é atingido,
a agregação passa a usar memória externa.
Por exemplo, se definido como 0.6, o GROUP BY permitirá usar 60% da memória disponível
(para servidor/usuário/mesclagens) no início da execução; depois disso, passará
a usar agregação externa.
max_bytes_ratio_before_external_join
JOIN. Quando esse valor é atingido, o hash join será convertido em grace hash join para fazer spill dos dados do lado direito para disco.
Por exemplo, se definido como 0.6, JOIN permitirá usar 60% da memória disponível (para servidor/usuário/mesclagens) para a tabela hash do lado direito no início da execução; depois disso, começa o spill para disco.
Se max_bytes_before_external_join e max_bytes_ratio_before_external_join estiverem definidos, será usado o menor limite resultante. Se a proporção for 0, apenas a configuração absoluta se aplica.
Tem efeito apenas quando join_algorithm é hash, parallel_hash, default ou auto e um caminho de dados temporários está configurado.
max_bytes_ratio_before_external_sort
ORDER BY. Quando esse limite é atingido, a ordenação externa é utilizada.
Por exemplo, se definido como 0.6, ORDER BY permitirá usar 60% da memória disponível (para servidor/usuário/merges) no início da execução; depois disso, começará a usar ordenação externa.
Observe que max_bytes_before_external_sort ainda é respeitado; o spilling para disco só será feito se o bloco de ordenação for maior que max_bytes_before_external_sort.
O número máximo de bytes (de dados não comprimidos) que podem ser lidos de uma tabela ao executar uma consulta.
A restrição é verificada para cada fragmento de dados processado, aplicada apenas à
expressão de tabela mais profunda e, ao ler de um servidor remoto, verificada apenas no
servidor remoto.
O número máximo de bytes (de dados não comprimidos) que pode ser lido de uma
tabela local em um nó folha ao executar uma consulta distribuída. Embora consultas distribuídas
possam emitir várias subconsultas para cada shard (folha), esse limite
será verificado apenas na etapa de leitura nos nós folha e será ignorado na
etapa de mesclagem dos resultados no nó raiz.
Por exemplo, um cluster consiste em 2 shards, e cada shard contém uma tabela com
100 bytes de dados. Uma consulta distribuída que deveria ler todos os dados
de ambas as tabelas com a configuração max_bytes_to_read=150 falhará, pois o total
será de 200 bytes. Uma consulta com max_bytes_to_read_leaf=150 terá êxito, já que
os nós folha lerão no máximo 100 bytes.
A restrição é verificada para cada fragmento de dados processado.
Essa configuração é instável com prefer_localhost_replica=1.
sort_overflow_mode, que por padrão está definido como throw.
O número máximo de bytes (dados não comprimidos) que podem ser enviados a um servidor remoto
ou salvos em uma tabela temporária quando a seção GLOBAL IN/JOIN é executada.
O número máximo de colunas que podem ser lidas de uma tabela em uma única consulta.
Se uma consulta exigir a leitura de mais colunas do que o número especificado, uma exceção
será gerada.
Essa configuração é útil para evitar consultas excessivamente complexas.
0 significa sem limite.
O tamanho máximo dos blocos de dados não comprimidos antes da compressão para gravação em uma tabela. O padrão é 1.048.576 (1 MiB). Especificar um tamanho de bloco menor geralmente resulta em uma taxa de compressão ligeiramente menor; a velocidade de compressão e descompressão aumenta um pouco devido à localidade de cache, e o consumo de memória é reduzido.
Esta é uma configuração de nível avançado, e você não deve alterá-la se estiver apenas começando a usar o ClickHouse.
max_concurrent_queries_for_all_users
max_concurrent_queries_for_all_users pode ser definido como 99 para todos os usuários, e o administrador do banco de dados pode defini-lo como 100 para a própria conta para executar consultas de investigação mesmo quando o servidor estiver sobrecarregado.
Modificar a configuração para uma consulta ou um usuário não afeta outras consultas.
Valores possíveis:
- Inteiro positivo.
- 0 — Sem limite.
Exemplo
<max_concurrent_queries_for_all_users>99</max_concurrent_queries_for_all_users>
1000.
max_concurrent_queries_for_user
- Inteiro positivo.
- 0 — Sem limite.
Exemplo
<max_concurrent_queries_for_user>5</max_concurrent_queries_for_user>
max_distributed_connections
- Inteiro positivo.
- 0 — Profundidade ilimitada.
O tamanho máximo do buffer para download em paralelo por thread (por exemplo, para URL engine).
O número máximo de threads para fazer download de dados (por exemplo, para o URL engine).
max_estimated_execution_time
timeout_before_checking_execution_speed
é atingido.
O número máximo de linhas processadas por segundo. Verificado em cada bloco de dados quando
timeout_before_checking_execution_speed
expira. Se a velocidade de execução estiver alta, ela será reduzida.
max_execution_speed_bytes
timeout_before_checking_execution_speed
expira. Se a velocidade de execução for alta, ela será reduzida.
O tempo máximo de execução da consulta, em segundos.
O parâmetro max_execution_time pode ser um pouco difícil de entender.
Ele funciona com base em interpolação em relação à velocidade atual de execução da consulta
(esse comportamento é controlado por timeout_before_checking_execution_speed).
O ClickHouse interromperá uma consulta se o tempo de execução projetado exceder o
max_execution_time especificado. Por padrão, timeout_before_checking_execution_speed
é definido como 10 segundos. Isso significa que, após 10 segundos de execução da consulta, o ClickHouse
começará a estimar o tempo total de execução. Se, por exemplo, max_execution_time
for definido como 3600 segundos (1 hora), o ClickHouse encerrará a consulta se o tempo estimado
ultrapassar esse limite de 3600 segundos. Se você definir timeout_before_checking_execution_speed
como 0, o ClickHouse usará o tempo de relógio como base para max_execution_time.
Se o tempo de execução da consulta exceder o número especificado de segundos, o comportamento será
determinado por ‘timeout_overflow_mode’, que, por padrão, é definido como throw.
O timeout é verificado, e a consulta só pode ser interrompida em pontos específicos durante o processamento de dados.
Atualmente, ela não pode ser interrompida durante a mesclagem de estados de agregação nem durante a análise da consulta,
e o tempo real de execução será maior que o valor dessa configuração.
max_execution_time, mas aplicado apenas
aos nós folha em consultas distribuídas ou remotas.
Por exemplo, se quisermos limitar o tempo de execução em um nó folha a 10s, mas
não houver limite no nó inicial, em vez de definir max_execution_time nas
configurações da subconsulta aninhada:
SELECT count()
FROM cluster(cluster, view(SELECT * FROM t SETTINGS max_execution_time = 10));
max_execution_time_leaf nas configurações da consulta:
SELECT count()
FROM cluster(cluster, view(SELECT * FROM t)) SETTINGS max_execution_time_leaf = 10;
max_expanded_ast_elements
max_fetch_partition_retries_count
SELECT com o modificador FINAL.
Valores possíveis:
- Inteiro positivo.
- 0 ou 1 — Desativado. As consultas
SELECT são executadas em uma única thread.
Número máximo de saltos de redirecionamento HTTP GET permitidos. Isso garante medidas adicionais de segurança para impedir que um servidor malicioso redirecione suas requisições para serviços inesperados.\n\nIsso pode acontecer quando um servidor externo redireciona para outro endereço, mas esse endereço parece ser interno à infraestrutura da empresa e, ao enviar uma requisição HTTP para um servidor interno, você pode acessar uma API interna pela rede interna, contornando a autenticação, ou até mesmo consultar outros serviços, como Redis ou Memcached. Se você não tem uma infraestrutura interna (incluindo algo em execução no seu localhost) ou confia no servidor, é seguro permitir redirecionamentos. Ainda assim, tenha em mente que, se a URL usar HTTP em vez de HTTPS, você terá de confiar não apenas no servidor remoto, mas também no seu ISP e em todas as redes intermediárias.
Valor padrão no Cloud: 10.
max_hyperscan_regexp_length
- Inteiro positivo.
- 0 - O tamanho não é limitado.
Exemplo
Consulta:
SELECT multiMatchAny('abcd', ['ab','bcd','c','d']) SETTINGS max_hyperscan_regexp_length = 3;
┌─multiMatchAny('abcd', ['ab', 'bcd', 'c', 'd'])─┐
│ 1 │
└────────────────────────────────────────────────┘
SELECT multiMatchAny('abcd', ['ab','bcd','c','d']) SETTINGS max_hyperscan_regexp_length = 2;
Exception: Regexp length too large.
max_hyperscan_regexp_total_length
- Inteiro positivo.
- 0 — O comprimento não é limitado.
Exemplo
Consulta:
SELECT multiMatchAny('abcd', ['a','b','c','d']) SETTINGS max_hyperscan_regexp_total_length = 5;
┌─multiMatchAny('abcd', ['a', 'b', 'c', 'd'])─┐
│ 1 │
└─────────────────────────────────────────────┘
SELECT multiMatchAny('abcd', ['ab','bc','c','d']) SETTINGS max_hyperscan_regexp_total_length = 5;
Exception: Total regexp lengths too large.
max_insert_block_size_rows
O tamanho máximo dos blocos (em número de linhas) a serem formados para inserção em uma tabela.
Essa configuração controla a formação de blocos em dois contextos:
-
Análise de formato: quando o servidor analisa formatos de entrada baseados em linhas (CSV, TSV, JSONEachRow etc.) de qualquer interface (HTTP, clickhouse-client com dados inline, gRPC, PostgreSQL wire protocol), os blocos são emitidos quando:
- min_insert_block_size_rows AND min_insert_block_size_bytes são atingidos, OR
- max_insert_block_size_rows OR max_insert_block_size_bytes é atingido
Observação: ao usar clickhouse-client ou clickhouse-local para ler de um arquivo, o próprio cliente analisa os dados, e essa configuração se aplica no lado do cliente.
-
Operações de INSERT: durante consultas INSERT e quando os dados passam por visões materializadas, o comportamento dessa configuração depende de
use_strict_insert_block_limits:
-
Quando habilitada: os blocos são emitidos quando:
- Limiares mínimos (AND): min_insert_block_size_rows AND min_insert_block_size_bytes são atingidos
- Limiares máximos (OR): max_insert_block_size_rows OR max_insert_block_size_bytes é atingido
-
Quando desabilitada: os blocos são emitidos quando min_insert_block_size_rows OR min_insert_block_size_bytes é atingido. As configurações de max_insert_block_size não são aplicadas.
Valores possíveis:
max_insert_block_size_bytes
- Inteiro positivo.
- 0 — a configuração não participa da formação de blocos.
max_insert_delayed_streams_for_parallel_write
50.
O número máximo de threads para executar a consulta INSERT SELECT.
Valores possíveis:
- 0 (ou 1) —
INSERT SELECT sem execução em paralelo.
- Inteiro positivo, maior que 1.
Valor padrão do Cloud:
1 para nós com 8 GiB de memória2 para nós com 16 GiB de memória4 para nós maiores
O INSERT SELECT em paralelo só tem efeito se a parte SELECT for executada em paralelo. Consulte a configuração max_threads.
Valores mais altos resultarão em maior uso de memória.
max_insert_threads_min_free_memory_per_thread
max_threads_min_free_memory_per_thread, mas aplicada a max_insert_threads em vez de max_threads. O valor padrão é maior porque pipelines de inserção normalmente mantêm buffers por thread maiores (partes do MergeTree, blocos de compressão) do que pipelines de leitura.
Se a quantidade de memória livre for menor que max_insert_threads multiplicado por esse valor, max_insert_threads será reduzido para se adequar, até um mínimo de 1.
Defina como 0 para desativar esse limite.
max_joined_block_size_bytes
max_joined_block_size_rows
max_limit_for_vector_search_queries
max_local_write_bandwidth
0 significa ilimitado.
Essa configuração não considera o volume de memória disponível nem o volume total
de memória da máquina. A restrição se aplica a uma única consulta em um
único servidor.
Você pode usar SHOW PROCESSLIST para ver o consumo de memória atual de cada consulta.
O pico de consumo de memória é rastreado para cada consulta e registrado no log.
O uso de memória não é totalmente rastreado para os estados das seguintes funções de agregação
com argumentos String e Array:
minmaxanyanyLastargMinargMax
O consumo de memória também é limitado pelos parâmetros max_memory_usage_for_user
e max_server_memory_usage.
max_memory_usage_for_user
max_memory_usage_for_user = 0).
Veja também a descrição de max_memory_usage.
Por exemplo, se você quiser definir max_memory_usage_for_user como 1000 bytes para um usuário chamado clickhouse_read, poderá usar a instrução
ALTER USER clickhouse_read SETTINGS max_memory_usage_for_user = 1000;
getSetting:
SELECT getSetting('max_memory_usage_for_user');
- Inteiro positivo.
- 0 — O controle de largura de banda está desativado.
max_network_bandwidth_for_all_users
- Inteiro positivo.
- 0 — O controle da taxa de transferência de dados está desabilitado.
max_network_bandwidth_for_user
- Inteiro positivo.
- 0 — O controle da velocidade de transferência de dados está desabilitado.
Limita o volume de dados (em bytes) recebido ou transmitido pela rede durante a execução de uma consulta. Essa configuração se aplica a cada consulta individual.
Valores possíveis:
- Inteiro positivo.
- 0 — O controle do volume de dados está desativado.
max_number_of_partitions_for_independent_aggregation
max_os_cpu_wait_time_ratio_to_throw
Processamento em paralelo usando a chave SAMPLE
- A posição da chave de amostragem na chave de particionamento não permite varreduras por intervalo eficientes.
- Adicionar uma chave de amostragem à tabela torna menos eficiente a filtragem por outras colunas.
- A chave de amostragem é uma expressão cara de calcular.
- A distribuição de latência do cluster tem uma cauda longa, de modo que consultar mais servidores aumenta a latência geral da consulta.
Essa configuração é útil para qualquer tabela replicada.
Número máximo de retrocessos do analisador sintático (quantas vezes ele tenta alternativas diferentes durante o processo de análise descendente recursiva).
Limita a profundidade máxima de recursão no parser recursivo descendente. Permite controlar o tamanho da pilha.
Valores possíveis:
- Inteiro positivo.
- 0 — A profundidade de recursão é ilimitada.
O número máximo de threads para fazer o parsing de dados em formatos de entrada que suportam parsing em paralelo. Por padrão, ele é determinado automaticamente.
max_partition_size_to_drop
0 significa que você pode remover partições sem restrições.
Valor padrão no Cloud: 1 TB.
max_partitions_per_insert_block
- Inteiro positivo.
0 — Número ilimitado de partições.
Detalhes
Ao inserir dados, o ClickHouse calcula o número de partições no
bloco inserido. Se o número de partições for maior que
max_partitions_per_insert_block, o ClickHouse registra um aviso ou gera uma
exceção com base em throw_on_max_partitions_per_insert_block. As exceções têm
o seguinte texto:
“Partições demais em um único bloco INSERT (partitions_count partições, o limite é ” + toString(max_partitions) + ”).
O limite é controlado pela configuração ‘max_partitions_per_insert_block’.
Um grande número de partições é um equívoco comum. Isso causará um grave
impacto negativo no desempenho, incluindo inicialização lenta do servidor, consultas INSERT lentas
e consultas SELECT lentas. O número total recomendado de partições para uma tabela é
abaixo de 1000..10000. Observe que o particionamento não se destina a acelerar
consultas SELECT (a ORDER BY key é suficiente para tornar consultas de intervalo rápidas).
As partições se destinam à manipulação de dados (DROP PARTITION, etc).”
Essa configuração é um limite de segurança, porque usar um grande número de partições é um equívoco comum.
- Inteiro positivo
-1 - ilimitado (padrão)
Limita o número de partes que podem ser movidas em uma consulta. Zero significa sem limite.
max_projection_rows_to_use_projection_index
max_query_size não pode ser definido dentro de uma consulta SQL (por exemplo, SELECT now() SETTINGS max_query_size=10000) porque o ClickHouse precisa alocar um buffer para analisar a consulta, e o tamanho desse buffer é determinado pela configuração max_query_size, que deve ser definida antes da execução da consulta.
max_rand_distribution_parameter
randChiSquared, randStudentT e randFisherF. Isso evita tempos de computação extremamente longos com valores extremos dos parâmetros.
max_rand_distribution_trials
randBinomial e randNegativeBinomial. Isso evita tempos de processamento excessivamente longos com um grande número de tentativas.
O tamanho máximo do buffer para leitura do filesystem.
max_read_buffer_size_local_fs
max_read_buffer_size será usado.
max_read_buffer_size_remote_fs
max_read_buffer_size será usado.
max_recursive_cte_evaluation_depth
max_remote_read_network_bandwidth
max_remote_write_network_bandwidth
max_replica_delay_for_distributed_queries
- Inteiro positivo.
- 0 — A defasagem das réplicas não é verificada.
Para evitar o uso de qualquer réplica com defasagem diferente de zero, defina este parâmetro como 1.
Usado ao executar SELECT em uma tabela distribuída que aponta para tabelas replicadas.
Limita o tamanho do resultado em bytes (sem compressão). A consulta será interrompida após o processamento de um bloco de dados se o limite for atingido,
mas o último bloco do resultado não será cortado; portanto, o tamanho do resultado pode ser maior que esse limite.
Observações
O tamanho do resultado na memória é considerado para esse limite.
Mesmo que o tamanho do resultado seja pequeno, ele pode fazer referência a estruturas de dados maiores na memória,
como dicionários de colunas LowCardinality e Arenas de colunas AggregateFunction,
portanto o limite pode ser excedido apesar do pequeno tamanho do resultado.
Essa configuração é de baixo nível e deve ser usada com cautela
0.
Limita o número de linhas no resultado. Também é verificado para subconsultas e em servidores remotos ao executar partes de uma consulta Distributed.
Nenhum limite é aplicado quando o valor é 0.
A consulta será interrompida após processar um bloco de dados se o limite for atingido, mas
não cortará o último bloco do resultado; portanto, o tamanho do resultado pode ser
maior que o limite.
max_reverse_dictionary_lookup_cache_size_bytes
dictGetKeys. O cache armazena tuplas de chave serializadas por valor de atributo para evitar varrer o dicionário novamente na mesma consulta. Quando o limite é atingido, as entradas são removidas usando LRU. Defina como 0 para desativar o cache.
Número máximo de linhas no conjunto para a otimização lazy FINAL. Se esse limite for excedido, recorre ao FINAL normal.
O número máximo de linhas distintas ao usar DISTINCT.
Limita o número de linhas na tabela hash usada em junções entre tabelas.
Esta configuração se aplica às operações SELECT … JOIN
e ao motor de tabela Join.
Se uma consulta contiver várias junções, o ClickHouse verificará essa configuração para cada resultado intermediário.
O ClickHouse pode prosseguir com diferentes ações quando o limite for atingido. Use a
configuração join_overflow_mode para escolher a ação.
Valores possíveis:
- Inteiro positivo.
0 — Número ilimitado de linhas.
O número máximo de linhas de um conjunto de dados na cláusula IN criado a partir de uma subconsulta.
max_rows_in_set_to_optimize_join
- 0 — Desativa.
- Qualquer inteiro positivo.
O número máximo de chaves únicas geradas pela agregação. Essa configuração permite
limitar o consumo de memória durante a agregação.
Se a agregação durante o GROUP BY gerar mais do que o número especificado de
linhas (chaves únicas de GROUP BY), o comportamento será determinado por
‘group_by_overflow_mode’, que por padrão é throw, mas também pode ser alterado
para um modo aproximado de GROUP BY.
O número máximo de linhas que podem ser lidas de uma tabela ao executar uma consulta.
A restrição é verificada em cada fragmento de dados processado, aplicada apenas à
expressão de tabela mais interna e, ao ler de um servidor remoto, verificada apenas no
servidor remoto.
O número máximo de linhas que podem ser lidas de uma tabela local em um nó folha ao
executar uma consulta distribuída. Embora as consultas distribuídas possam emitir várias subconsultas
para cada shard (folha), esse limite será verificado apenas na etapa de leitura nos
nós folha e ignorado na etapa de mesclagem de resultados no nó raiz.
Por exemplo, um cluster consiste em 2 shards, e cada shard contém uma tabela com
100 linhas. A consulta distribuída que deve ler todos os dados de ambas as
tabelas com a configuração max_rows_to_read=150 falhará, pois, no total, haverá
200 linhas. Uma consulta com max_rows_to_read_leaf=150 terá êxito, já que os nós folha
lerão no máximo 100 linhas.
A restrição é verificada para cada fragmento de dados processado.
Essa configuração é instável com prefer_localhost_replica=1.
sort_overflow_mode, que por padrão é definido como throw.
Número máximo de linhas que podem ser enviadas a um servidor remoto ou salvas em uma
tabela temporária quando a seção GLOBAL IN/JOIN é executada.
Número máximo de sessões simultâneas por usuário autenticado no servidor ClickHouse.
Exemplo:
<profiles>
<single_session_profile>
<max_sessions_for_user>1</max_sessions_for_user>
</single_session_profile>
<two_sessions_profile>
<max_sessions_for_user>2</max_sessions_for_user>
</two_sessions_profile>
<unlimited_sessions_profile>
<max_sessions_for_user>0</max_sessions_for_user>
</unlimited_sessions_profile>
</profiles>
<users>
<!-- O usuário Alice pode se conectar a um servidor ClickHouse no máximo uma vez por vez. -->
<Alice>
<profile>single_session_user</profile>
</Alice>
<!-- O usuário Bob pode usar 2 sessões simultâneas. -->
<Bob>
<profile>two_sessions_profile</profile>
</Bob>
<!-- O usuário Charles pode usar um número ilimitado de sessões simultâneas. -->
<Charles>
<profile>unlimited_sessions_profile</profile>
</Charles>
</users>
- Inteiro positivo
0 - número infinito de sessões simultâneas (padrão)
max_size_to_preallocate_for_aggregation
max_size_to_preallocate_for_joins
max_skip_unavailable_shards_num
skip_unavailable_shards está ativado, limita o número máximo de shards que podem ser ignorados silenciosamente.
Se o número de shards indisponíveis exceder esse valor, uma exceção é lançada em vez de eles serem ignorados silenciosamente.
Um valor de 0 significa que não há limite (comportamento padrão — todos os shards indisponíveis podem ser ignorados).
max_skip_unavailable_shards_ratio
skip_unavailable_shards está ativado, limita a proporção máxima (de 0 a 1) de shards que podem ser ignorados silenciosamente.
Se a proporção de shards indisponíveis em relação ao total de shards exceder esse valor, uma exceção será lançada em vez de serem ignorados silenciosamente.
Um valor de 0 significa que não há limite (comportamento padrão — todos os shards indisponíveis podem ser ignorados).
max_streams_for_files_processing_in_cluster_functions
max_streams_for_merge_tree_reading
max_streams_for_union_step
UNION (aplica-se tanto a UNION ALL quanto a UNION DISTINCT, porque UNION DISTINCT é implementado por meio de uma etapa UNION ALL seguida de uma etapa DISTINCT). Quando uma consulta UNION tem muitas subconsultas, todas elas abrem seus buffers de leitura ao mesmo tempo, o que faz com que o uso de memória seja proporcional ao número de subconsultas. Essa configuração insere processadores Concat para afunilar o pipeline, de modo que, no máximo, essa quantidade de fluxos fique ativa ao mesmo tempo, reduzindo drasticamente o pico de memória. O limite real é o menor entre este valor e max_threads * max_streams_for_union_step_to_max_threads_ratio (se qualquer um dos dois for 0, ele será ignorado). Quando ambos são 0, nenhum afunilamento é aplicado.
max_streams_for_union_step_to_max_threads_ratio
max_threads, determina um limite para a quantidade de fluxos ativos simultaneamente em uma etapa UNION (aplica-se tanto a UNION ALL quanto a UNION DISTINCT). O limite real é o menor entre esse valor calculado e max_streams_for_union_step (se qualquer um deles for 0, ele é ignorado). Por exemplo, com max_threads = 8 e essa proporção definida como 1, no máximo 8 fluxos ficarão ativos. Defina como 0 para desabilitar esse limite baseado nessa proporção.
max_streams_multiplier_for_merge_tables
max_streams_to_max_threads_ratio
Isso permite fazer uma verificação preventiva para evitar que os usuários do seu
cluster escrevam consultas excessivamente complexas.
0 significa que você pode excluir todas as tabelas sem nenhuma restrição.
Valor padrão no Cloud: 1 TB.
Esta configuração de consulta substitui a configuração equivalente no servidor; consulte max_table_size_to_drop Essa configuração é útil para evitar consultas excessivamente complexas.
0 significa ilimitado.
max_temporary_data_on_disk_size_for_query
- Inteiro positivo.
0 — ilimitado (padrão)
max_temporary_data_on_disk_size_for_user
- Inteiro positivo.
0 — ilimitado (padrão)
max_temporary_non_const_columns
max_temporary_columns, o número máximo de colunas temporárias que devem
ser mantidas na RAM simultaneamente durante a execução de uma consulta, sem contar as
colunas constantes.
Colunas constantes são geradas com bastante frequência durante a execução de uma consulta, mas exigem
praticamente zero recursos computacionais.
WHERE e pré-agregar para GROUP BY em paralelo usando pelo menos o número de threads definido por ‘max_threads’, então ‘max_threads’ será usado.
Para consultas concluídas rapidamente por causa de um LIMIT, você pode definir um valor menor para ‘max_threads’.
Por exemplo, se a quantidade necessária de registros estiver presente em cada bloco e max_threads = 8, então 8 blocos serão recuperados, embora bastasse ler apenas um.
Quanto menor o valor de max_threads, menor o consumo de memória.
A configuração max_threads, por padrão, corresponde ao número de threads de hardware (número de CPU cores) disponíveis para o ClickHouse.
Como caso especial, para processadores x86 com menos de 32 CPU cores e SMT (por exemplo, Intel HyperThreading), o ClickHouse usa por padrão o número de núcleos lógicos (= 2 x número de núcleos físicos).
Sem SMT (por exemplo, Intel HyperThreading), isso corresponde ao número de CPU cores.
Para usuários do ClickHouse Cloud, o valor padrão será exibido como auto(N), em que N corresponde ao tamanho de vCPU do seu serviço, por exemplo, 2vCPU/8GiB, 4vCPU/16GiB etc.
Consulte a aba de configurações no console do Cloud para ver uma lista de todos os tamanhos de serviço.
O número máximo de threads que processam os índices.
max_threads_min_free_memory_per_thread
max_threads quando o servidor está sob pressão de memória, para evitar iniciar consultas com alto paralelismo que provavelmente atingiriam o limite de memória.
A memória livre é calculada como o max_server_memory_usage do servidor menos a memória atualmente rastreada pelo memory tracker global. Se essa memória livre for menor que max_threads multiplicado por esse valor, max_threads será reduzido ao maior N tal que N * value <= free_memory, com mínimo de 1.
Defina como 0 para desabilitar esse limite.
Por exemplo, com o padrão de 1 GiB e 32 GiB de memória livre, max_threads fica limitado a 32; com 1 GiB de memória livre, ele volta para 1.
Essa configuração se aplica ao paralelismo no lado da leitura (SELECT, UNION, INTERSECT/EXCEPT e o lado SELECT de INSERT ... SELECT). Para o lado da escrita, veja max_insert_threads_min_free_memory_per_thread.
Pequenas alocações e desalocações são agrupadas em uma variável local da thread e rastreadas ou analisadas pelo profiler apenas quando um valor (em valor absoluto) se torna maior que o valor especificado. Se o valor for maior que ‘memory_profiler_step’, ele será efetivamente reduzido para ‘memory_profiler_step’.
max_wkb_geometry_elements
readWKB e funções relacionadas. Isso protege contra alocações excessivas de memória causadas por dados WKB malformados. Defina como 0 para usar o limite fixo no código (100 milhões).
memory_overcommit_ratio_denominator
memory_overcommit_ratio_denominator_for_user
memory_profiler_sample_max_allocation_size
memory_profiler_sample_probability. 0 significa desabilitado. Talvez você queira definir ‘max_untracked_memory’ como 0 para que esse limite funcione como esperado.
memory_profiler_sample_min_allocation_size
memory_profiler_sample_probability. 0 significa desabilitado. Talvez seja interessante definir ‘max_untracked_memory’ como 0 para que esse limite funcione como esperado.
memory_profiler_sample_probability
memory_profiler_sample_min_allocation_size e memory_profiler_sample_max_allocation_size). Observe que a amostragem ocorre apenas quando a quantidade de memória não rastreada excede ‘max_untracked_memory’. Talvez você queira definir ‘max_untracked_memory’ como 0 para uma amostragem ainda mais granular.
Define o intervalo do profiler de memória. Sempre que o uso de memória da consulta ultrapassar cada próximo intervalo, em número de bytes, o profiler de memória coletará o stacktrace de alocação e o gravará em trace_log.
Valores possíveis:
-
Um número inteiro positivo de bytes.
-
0 para desativar o profiler de memória.
memory_tracker_fault_probability
exception safety, lance uma exceção sempre que alocar memória, com a probabilidade especificada.
memory_usage_overcommit_max_wait_microseconds
merge_table_max_tables_to_look_for_schema_inference
Merge sem um esquema explícito ou ao usar a função de tabela merge, infira o esquema como a união de, no máximo, o número especificado de tabelas correspondentes.
Se houver mais tabelas do que esse número, o esquema será inferido com base nas primeiras tabelas até o limite especificado.
merge_tree_coarse_index_granularity
merge_tree_coarse_index_granularity subintervalos e busca recursivamente as chaves necessárias neles.
Valores possíveis:
- Qualquer número inteiro par positivo.
merge_tree_compact_parts_min_granules_to_multibuffer_read
merge_tree_determine_task_size_by_prewhere_columns
prewhere para determinar o tamanho da tarefa de leitura.
merge_tree_max_bytes_to_use_cache
merge_tree_max_bytes_to_use_cache bytes em uma consulta, ele não usará o cache de blocos não comprimidos.
O cache de blocos não comprimidos armazena dados extraídos para consultas. O ClickHouse usa esse cache para acelerar as respostas a consultas pequenas e repetidas. Essa configuração protege o cache contra a degradação causada por consultas que leem uma grande quantidade de dados. A configuração do servidor uncompressed_cache_size define o tamanho do cache de blocos não comprimidos.
Valores possíveis:
- Qualquer número inteiro positivo.
merge_tree_max_rows_to_use_cache
merge_tree_max_rows_to_use_cache linhas em uma consulta, ele não usará o cache de blocos descomprimidos.
O cache de blocos descomprimidos armazena dados extraídos para consultas. O ClickHouse usa esse cache para acelerar as respostas a consultas pequenas e repetidas. Essa configuração evita que o cache seja prejudicado por consultas que leem uma grande quantidade de dados. A configuração do servidor uncompressed_cache_size define o tamanho do cache de blocos descomprimidos.
Valores possíveis:
- Qualquer número inteiro positivo.
merge_tree_min_bytes_for_concurrent_read
merge_tree_min_bytes_for_concurrent_read, o ClickHouse tentará ler esse arquivo de forma concorrente usando várias threads.
Valor possível:
merge_tree_min_bytes_for_concurrent_read_for_remote_filesystem
merge_tree_min_bytes_for_seek
merge_tree_min_bytes_for_seek bytes, o ClickHouse lerá sequencialmente uma faixa do arquivo que contém ambos os blocos, evitando assim uma operação de seek adicional.
Valores possíveis:
- Qualquer inteiro positivo.
merge_tree_min_bytes_per_task_for_remote_reading
filesystem_prefetch_min_bytes_for_single_read_task
Número mínimo de bytes lidos por tarefa.
merge_tree_min_read_task_size
merge_tree_min_rows_for_concurrent_read
merge_tree_min_rows_for_concurrent_read, o ClickHouse tentará realizar a leitura concorrente desse arquivo em várias threads.
Valores possíveis:
merge_tree_min_rows_for_concurrent_read_for_remote_filesystem
merge_tree_min_rows_for_seek
merge_tree_min_rows_for_seek linhas, o ClickHouse não faz seek no arquivo, mas lê os dados sequencialmente.
Valores possíveis:
- Qualquer número inteiro positivo.
merge_tree_read_split_ranges_into_intersecting_and_non_intersecting_injection_probability
PartsSplitter - divide os intervalos de leitura em intervalos que se intersectam e que não se intersectam sempre que houver leitura do MergeTree, com a probabilidade especificada.
merge_tree_storage_snapshot_sleep_ms
- 0 - Sem atraso (padrão)
- N - Atraso em milissegundos
merge_tree_use_const_size_tasks_for_remote_reading
merge_tree_use_deserialization_prefixes_cache
merge_tree_use_prefixes_deserialization_thread_pool
max_prefixes_deserialization_thread_pool_size.
merge_tree_use_v1_object_and_dynamic_serialization
metrics_perf_events_enabled
PerfEventInfo no código-fonte para ver os eventos disponíveis.
min_bytes_to_use_direct_io
min_bytes_to_use_direct_io bytes, o ClickHouse lerá os dados do disco de armazenamento com a opção O_DIRECT.
Valores possíveis:
- 0 — A E/S direta está desabilitada.
- Inteiro positivo.
Esta é uma configuração experimental. Define a quantidade mínima de memória para ler arquivos grandes sem copiar dados do kernel para o espaço do usuário. O valor recomendado é de cerca de 64 MB, porque mmap/munmap é lento. Isso só faz sentido para arquivos grandes e só ajuda se os dados estiverem no cache de páginas.
Valores possíveis:
- Inteiro positivo.
- 0 — Arquivos grandes são lidos apenas com cópia de dados do kernel para o espaço do usuário.
min_chunk_bytes_for_parallel_parsing
- Tipo: inteiro sem sinal
- Valor padrão: 1 MiB
O tamanho mínimo do fragmento, em bytes, que cada thread fará o parsing em paralelo.
Para tabelas MergeTree. Para reduzir a latência no processamento de consultas, um bloco é comprimido ao gravar a próxima marca se seu tamanho for de pelo menos min_compress_block_size. Por padrão, 65.536.
O tamanho real do bloco, se os dados descomprimidos forem menores que max_compress_block_size, não fica abaixo desse valor nem do volume de dados de uma marca.
Vejamos um exemplo. Suponha que index_granularity tenha sido definido como 8192 durante a criação da tabela.
Estamos gravando uma coluna do tipo UInt32 (4 bytes por valor). Ao gravar 8192 linhas, o total será de 32 KB de dados. Como min_compress_block_size = 65.536, um bloco comprimido será formado a cada duas marcas.
Estamos gravando uma coluna de URL do tipo String (tamanho médio de 60 bytes por valor). Ao gravar 8192 linhas, o volume médio será de pouco menos de 500 KB de dados. Como isso é mais que 65.536, um bloco comprimido será formado para cada marca. Nesse caso, ao ler dados do disco no intervalo de uma única marca, dados extras não serão descomprimidos.
Esta é uma configuração de nível avançado, e você não deve alterá-la se estiver apenas começando a usar o ClickHouse.
min_count_to_compile_aggregate_expression
- Inteiro positivo.
- 0 — Expressões agregadas idênticas são sempre compiladas por JIT.
min_count_to_compile_expression
min_count_to_compile_sort_description
timeout_before_checking_execution_speed
expira. Se a velocidade de execução for inferior, uma exceção é lançada.
min_execution_speed_bytes
timeout_before_checking_execution_speed
expira. Se a velocidade de execução for menor, uma exceção será lançada.
min_external_table_block_size_bytes
min_external_table_block_size_rows
min_filtered_ratio_for_lazy_final
min_free_disk_space_for_temporary_data
min_hit_rate_to_use_consecutive_keys_optimization
min_insert_block_size_bytes
- Inteiro positivo.
- 0 — a configuração não participa da formação de blocos.
min_insert_block_size_bytes_for_materialized_views
INSERT. Blocos menores são agrupados em blocos maiores. Essa configuração é aplicada apenas a blocos inseridos em visão materializada. Ao ajustar essa configuração, você controla o agrupamento de blocos ao enviar para a visão materializada e evita o uso excessivo de memória.
Valores possíveis:
- Qualquer número inteiro positivo.
- 0 — Agrupamento desativado.
Veja também
min_insert_block_size_rows
-
Análise de formato: Quando o servidor analisa formatos de entrada baseados em linhas (CSV, TSV, JSONEachRow etc.) de qualquer interface (HTTP, clickhouse-client com dados inline, gRPC, PostgreSQL wire protocol), os blocos são emitidos quando:
- Ambos min_insert_block_size_rows AND min_insert_block_size_bytes são atingidos, OR
- max_insert_block_size_rows OR max_insert_block_size_bytes é atingido
Observação: ao usar clickhouse-client ou clickhouse-local para ler de um arquivo, o próprio cliente analisa os dados, e esta configuração se aplica no lado do cliente.
-
Operações de INSERT: Durante consultas INSERT e quando os dados fluem por visões materializadas, o comportamento desta configuração depende de
use_strict_insert_block_limits:
-
Quando habilitado: Os blocos são emitidos quando:
- Limiares mínimos (AND): Ambos min_insert_block_size_rows AND min_insert_block_size_bytes são atingidos
- Limiares máximos (OR): max_insert_block_size_rows OR max_insert_block_size_bytes é atingido
-
Quando desabilitado (padrão): Os blocos são emitidos quando min_insert_block_size_rows OR min_insert_block_size_bytes é atingido. As configurações max_insert_block_size não são aplicadas.
Valores possíveis:
- Inteiro positivo.
- 0 — a configuração não participa da formação de blocos.
min_insert_block_size_rows_for_materialized_views
INSERT. Blocos menores são agrupados em blocos maiores. Essa configuração é aplicada somente aos blocos inseridos em visão materializada. Ao ajustar essa configuração, você controla o agrupamento de blocos durante o envio para a visão materializada e evita uso excessivo de memória.
Valores possíveis:
- Qualquer inteiro positivo.
- 0 — Agrupamento desabilitado.
Veja também
min_joined_block_size_bytes
min_joined_block_size_rows
min_os_cpu_wait_time_ratio_to_throw
min_outstreams_per_resize_after_split
Resize ou StrictResize após a divisão ser realizada durante a geração do pipeline. Se o número resultante de fluxos for menor que esse valor, a operação de divisão não ocorrerá.
Um nó Resize é um processador no pipeline de consulta que ajusta o número de fluxos de dados que passam pelo pipeline. Ele pode aumentar ou diminuir o número de fluxos para equilibrar a carga de trabalho entre vários threads ou processadores. Por exemplo, se uma consulta exigir mais paralelismo, o nó Resize pode dividir um único fluxo em vários fluxos. Por outro lado, ele pode mesclar vários fluxos em menos fluxos para consolidar o processamento de dados.
O nó Resize garante que os dados sejam distribuídos uniformemente entre os fluxos, mantendo a estrutura dos blocos de dados. Isso ajuda a otimizar a utilização de recursos e a melhorar o desempenho da consulta.
Por que o nó Resize precisa ser dividido
ExecutingGraph::Node::status_mutex do nó Resize, que fica no centro do fluxo, enfrenta forte contenção, especialmente em ambientes com muitos núcleos de CPU, e isso leva a:
- Aumento da latência de
ExecutingGraph::updateNode, impactando diretamente o desempenho da consulta.
- Desperdício excessivo de ciclos de CPU com contenção de spin-lock (
native_queued_spin_lock_slowpath), reduzindo a eficiência.
- Redução da utilização da CPU, limitando o paralelismo e o throughput.
Como o nó Resize é dividido
- O número de streams de saída é verificado para garantir que a divisão possa ser feita: os streams de saída de cada processador dividido atingem ou excedem o limiar
min_outstreams_per_resize_after_split.
- O nó
Resize é dividido em nós Resize menores, com a mesma quantidade de portas, cada um lidando com um subconjunto de streams de entrada e saída.
- Cada grupo é processado de forma independente, reduzindo a contenção de lock.
Em alguns casos, quando as entradas/saídas não são divisíveis pelo número de nós Resize resultantes da divisão, algumas entradas são conectadas a NullSources e algumas saídas são conectadas a NullSinks. Isso permite que a divisão ocorra sem afetar o fluxo geral de dados.
Finalidade da configuração
min_outstreams_per_resize_after_split garante que a divisão de nós Resize faça sentido e evita a criação de um número muito pequeno de streams, o que poderia levar a um processamento paralelo ineficiente. Ao impor um número mínimo de streams de saída, essa configuração ajuda a manter o equilíbrio entre paralelismo e sobrecarga, otimizando a execução da consulta em cenários que envolvem divisão e mesclagem de streams.
Desativando a configuração
Resize, defina esta configuração como 0. Isso impedirá o split dos nós Resize durante a geração do pipeline, permitindo que mantenham sua estrutura original, sem serem divididos em nós menores.
min_table_rows_to_use_projection_index
mongodb_throw_on_unsupported_query
move_all_conditions_to_prewhere
move_primary_key_columns_to_end_of_prewhere
multiple_joins_try_to_keep_original_names
mutations_execute_nondeterministic_on_initiator
true, funções constantes não determinísticas (por exemplo, a função now()) serão executadas no iniciador e substituídas por literais em consultas UPDATE e DELETE. Isso ajuda a manter os dados em sincronia entre as réplicas ao executar mutações com funções constantes não determinísticas. Valor padrão: false.
mutations_execute_subqueries_on_initiator
true, as subconsultas escalares são executadas no iniciador e substituídas por valores literais nas consultas UPDATE e DELETE. Valor padrão: false.
mutations_max_literal_size_to_replace
UPDATE e DELETE. Só tem efeito se pelo menos uma das duas configurações acima estiver habilitada. Valor padrão: 16384 (16 KiB).
Permite executar consultas ALTER TABLE ... UPDATE|DELETE|MATERIALIZE INDEX|MATERIALIZE PROJECTION|MATERIALIZE COLUMN|MATERIALIZE STATISTICS (mutações) de forma síncrona.
Valores possíveis:
| Valor | Descrição |
|---|
0 | As mutações são executadas de forma assíncrona. |
1 | A consulta aguarda a conclusão de todas as mutações no servidor atual. |
2 | A consulta aguarda a conclusão de todas as mutações em todas as réplicas (se existirem). |
3 | A consulta aguarda apenas as réplicas ativas. Compatível apenas com SharedMergeTree. Para ReplicatedMergeTree, comporta-se da mesma forma que mutations_sync = 2. |
mysql_datatypes_support_level
decimal, datetime64, date2Date32 ou date2String. Todos os mapeamentos modernos (decimal, datetime64, date2Date32) são ativados por padrão.
decimal: converte os tipos NUMERIC e DECIMAL em Decimal quando a precisão permitir.datetime64: converte os tipos DATETIME e TIMESTAMP em DateTime64 em vez de DateTime quando a precisão não for 0.date2Date32: converte DATE em Date32 em vez de Date. Tem precedência sobre date2String.date2String: converte DATE em String em vez de Date. É substituído por datetime64.
mysql_map_fixed_string_to_text_in_show_columns
TEXT em SHOW COLUMNS.
Só tem efeito quando a conexão é feita por meio do protocolo wire do MySQL.
- 0 - Usar
BLOB.
- 1 - Usar
TEXT.
mysql_map_string_to_text_in_show_columns
TEXT em SHOW COLUMNS.
Só tem efeito quando a conexão é feita pelo MySQL wire protocol.
- 0 - Usar
BLOB.
- 1 - Usar
TEXT.
O número máximo de linhas na inserção em lote do engine MySQL
network_compression_method
NONE — sem compactação.LZ4 — usa o codec LZ4.LZ4HC — usa o codec LZ4HC.ZSTD — usa o codec ZSTD.
Veja também
network_zstd_compression_level
ZSTD.
Valores possíveis:
- Número inteiro positivo de 1 a 15.
Normalizar nomes de funções para seus respectivos nomes canônicos
number_of_mutations_to_delay
number_of_mutations_to_throw
odbc_bridge_connection_pool_size
odbc_bridge_use_connection_pooling
- 0 — Nenhuma linha é ignorada.
- Inteiro positivo.
Exemplo
Tabela de entrada:
CREATE TABLE test (i UInt64) ENGINE = MergeTree() ORDER BY i;
INSERT INTO test SELECT number FROM numbers(500);
SET limit = 5;
SET offset = 7;
SELECT * FROM test LIMIT 10 OFFSET 100;
┌───i─┐
│ 107 │
│ 108 │
│ 109 │
└─────┘
opentelemetry_start_keeper_trace_probability
- ‘auto’ - Equivale à configuração opentelemetry_start_trace_probability
- 0 — O rastreamento está desabilitado
- 0 a 1 — Probabilidade (por exemplo, 1.0 = sempre ativado)
opentelemetry_start_trace_probability
- 0 — O rastreamento de todas as consultas executadas é desabilitado (se nenhum contexto de rastreamento pai for fornecido).
- Número de ponto flutuante positivo no intervalo [0..1]. Por exemplo, se o valor da configuração for
0,5, o ClickHouse poderá iniciar um rastreamento, em média, para metade das consultas.
- 1 — O rastreamento de todas as consultas executadas é habilitado.
opentelemetry_trace_cpu_scheduling
opentelemetry_trace_processors
optimize_aggregation_in_order
- 0 — a otimização de
GROUP BY está desabilitada.
- 1 — a otimização de
GROUP BY está habilitada.
Veja também
optimize_aggregators_of_group_by_keys
optimize_and_compare_chain
<, <=, >, >=, = e combinações entre eles. Por exemplo, (a < b) AND (b < c) AND (c < 5) se tornaria (a < b) AND (b < c) AND (c < 5) AND (b < 5) AND (a < 5).
Use restrições para adicionar a condição do índice. O padrão é false.
Valores possíveis:
optimize_arithmetic_operations_in_aggregate_functions
- inteiro positivo - comprimento máximo do nome,
- 0 — sempre,
- inteiro negativo - nunca.
optimize_count_from_files
file/s3/url/hdfs/azureBlobStorage.
Valores possíveis:
- 0 — Otimização desativada.
- 1 — Otimização ativada.
optimize_dictget_tuple_element
tupleElement(dictGet('dict', ('a', 'b', 'c'), key), 2) como dictGet('dict', 'b', key) para evitar buscar atributos de Dicionário desnecessários. Suporta acesso posicional (.1, .2, …) e nomeado (.b) e também se aplica a dictGetOrDefault quando o argumento padrão é uma tupla constante ou um tuple(...) de constantes.
optimize_distinct_in_order
optimize_distributed_group_by_sharding_key
GROUP BY sharding_key, evitando agregações custosas no servidor iniciador (o que reduz o uso de memória da consulta nesse servidor).
Os seguintes tipos de consultas são suportados (bem como todas as combinações entre eles):
SELECT DISTINCT [..., ]sharding_key[, ...] FROM distSELECT ... FROM dist GROUP BY sharding_key[, ...]SELECT ... FROM dist GROUP BY sharding_key[, ...] ORDER BY xSELECT ... FROM dist GROUP BY sharding_key[, ...] LIMIT 1SELECT ... FROM dist GROUP BY sharding_key[, ...] LIMIT 1 BY x
Os seguintes tipos de consultas não são suportados (o suporte a alguns deles poderá ser adicionado posteriormente):
SELECT ... GROUP BY sharding_key[, ...] WITH TOTALSSELECT ... GROUP BY sharding_key[, ...] WITH ROLLUPSELECT ... GROUP BY sharding_key[, ...] WITH CUBESELECT ... GROUP BY sharding_key[, ...] SETTINGS extremes=1
Valores possíveis:
- 0 — Desativado.
- 1 — Ativado.
Veja também:
No momento, isso exige optimize_skip_unused_shards (o motivo é que, no futuro, isso poderá ser ativado por padrão e só funcionará corretamente se os dados tiverem sido inseridos por meio de uma tabela Distributed, ou seja, se os dados estiverem distribuídos de acordo com sharding_key).
optimize_dry_run_check_part
OPTIMIZE ... DRY RUN valida a parte mesclada resultante com checkDataPart. Se a verificação falhar, uma exceção será gerada.
optimize_empty_string_comparisons
col = '' ou '' = col em empty(col) e col != '' ou '' != col em notEmpty(col),
somente quando col for do tipo String ou FixedString.
Permite extrair expressões comuns de disjunções em expressões WHERE, PREWHERE, ON, HAVING e QUALIFY. Uma expressão lógica como (A AND B) OR (A AND C) pode ser reescrita como A AND (B OR C), o que pode ajudar a aproveitar:
- índices em expressões de filtro simples
- a otimização de CROSS JOIN para INNER JOIN
optimize_functions_to_subcolumns
- 0 — Otimização desativada.
- 1 — Otimização ativada.
optimize_group_by_constant_keys
optimize_group_by_function_keys
optimize_if_chain_to_multiif
optimize_injective_functions_in_group_by
optimize_injective_functions_inside_uniq
optimize_inverse_dictionary_lookup
optimize_min_equality_disjunction_chain_length
expr = x1 OR ... expr = xN para otimizaçã
optimize_min_inequality_conjunction_chain_length
expr <> x1 AND ... expr <> xN para otimizaçã
optimize_move_to_prewhere
- 0 — A otimização automática de
PREWHERE está desativada.
- 1 — A otimização automática de
PREWHERE está ativada.
optimize_move_to_prewhere_if_final
- 0 — A otimização automática de
PREWHERE em consultas SELECT com o modificador FINAL está desabilitada.
- 1 — A otimização automática de
PREWHERE em consultas SELECT com o modificador FINAL está habilitada.
Veja também
Substitui ‘multiIf’ por ‘if’ quando há apenas uma condição.
optimize_normalize_count_variants
- 0 — Desabilitado.
- 1 — Habilitado.
Exemplo
A diferença entre habilitado e desabilitado:
Consulta:
SET optimize_on_insert = 1;
CREATE TABLE test1 (`FirstTable` UInt32) ENGINE = ReplacingMergeTree ORDER BY FirstTable;
INSERT INTO test1 SELECT number % 2 FROM numbers(5);
SELECT * FROM test1;
SET optimize_on_insert = 0;
CREATE TABLE test2 (`SecondTable` UInt32) ENGINE = ReplacingMergeTree ORDER BY SecondTable;
INSERT INTO test2 SELECT number % 2 FROM numbers(5);
SELECT * FROM test2;
┌─FirstTable─┐
│ 0 │
│ 1 │
└────────────┘
┌─SecondTable─┐
│ 0 │
│ 0 │
│ 0 │
│ 1 │
│ 1 │
└─────────────┘
multiMatchAny. Essa otimização não deve ser habilitada por padrão, porque em alguns casos prejudica a análise de índices.
optimize_qbit_distance_function_reads
QBit por equivalentes que leem do armazenamento somente as colunas necessárias para o cálculo.
Habilita a otimização de ORDER BY em consultas SELECT para ler dados de tabelas MergeTree.
Valores possíveis:
- 0 — a otimização de
ORDER BY está desativada.
- 1 — a otimização de
ORDER BY está ativada.
Veja também
optimize_redundant_functions_in_order_by
optimize_rewrite_aggregate_function_with_if
avg(if(cond, col, null)) pode ser reescrita como avgOrNullIf(cond, col). Isso pode melhorar o desempenho.
Suportado apenas com o analisador (enable_analyzer = 1).
optimize_rewrite_array_exists_to_has
arrayExists() para has() quando forem logicamente equivalentes. Por exemplo, arrayExists(x -> x = 1, arr) pode ser reescrita como has(arr, 1)
optimize_rewrite_like_perfect_affix
col LIKE 'ClickHouse%') como funções startsWith ou endsWith (por exemplo, startsWith(col, 'ClickHouse')).
optimize_rewrite_regexp_functions
optimize_rewrite_sum_if_to_count_if
sumIf() e sum(if()) como a função countIf() quando forem logicamente equivalentes
optimize_skip_merged_partitions
OPTIMIZE TABLE ... FINAL SETTINGS optimize_skip_merged_partitions=1
Por padrão, a consulta OPTIMIZE TABLE ... FINAL reescreve a parte mesmo quando há apenas uma única parte.
Valores possíveis:
- 1 - Habilita a otimização.
- 0 - Desabilita a otimização.
optimize_skip_unused_shards
WHERE/PREWHERE, e ativa otimizações relacionadas para consultas distribuídas (por exemplo, agregação pela chave de sharding).
Pressupõe que os dados estejam distribuídos pela chave de sharding; caso contrário, a consulta produzirá um resultado incorreto.
- 0 — Desabilitado.
- 1 — Habilitado.
optimize_skip_unused_shards_limit
optimize_skip_unused_shards quando o limite é atingido.
Valores demais podem exigir um volume significativo de processamento, enquanto o benefício é duvidoso, já que, se você tiver um número muito grande de valores em IN (...), muito provavelmente a consulta será enviada a todos os shards de qualquer maneira.
optimize_skip_unused_shards_nesting
optimize_skip_unused_shards (portanto, ainda requer optimize_skip_unused_shards) e depende do nível de aninhamento da consulta distribuída (no caso em que você tem uma tabela Distributed que consulta outra tabela Distributed).
Valores possíveis:
- 0 — Desabilitado;
optimize_skip_unused_shards sempre funciona.
- 1 — Habilita
optimize_skip_unused_shards apenas no primeiro nível.
- 2 — Habilita
optimize_skip_unused_shards até o segundo nível.
optimize_skip_unused_shards_rewrite_in
IN na consulta para shards remotos a fim de excluir valores que não pertencem ao shard (requer optimize_skip_unused_shards).
Valores possíveis:
- 0 — Desabilitado.
- 1 — Habilitado.
Otimiza a ordenação com base nas propriedades de ordenação do fluxo de entrada
optimize_substitute_columns
false.
Valores possíveis:
optimize_syntax_fuse_functions
- 0 — Funções com o mesmo argumento não são mescladas.
- 1 — Funções com o mesmo argumento são mescladas.
Exemplo
Consulta:
CREATE TABLE fuse_tbl(a Int8, b Int8) Engine = Log;
SET optimize_syntax_fuse_functions = 1;
EXPLAIN SYNTAX run_query_tree_passes = 1 SELECT sum(a), sum(b), count(b), avg(b) from fuse_tbl FORMAT TSV;
SELECT
sum(__table1.a) AS `sum(a)`,
tupleElement(sumCount(__table1.b), 1) AS `sum(b)`,
tupleElement(sumCount(__table1.b), 2) AS `count(b)`,
divide(tupleElement(sumCount(__table1.b), 1), toFloat64(tupleElement(sumCount(__table1.b), 2))) AS `avg(b)`
FROM default.fuse_tbl AS __table1
OPTIMIZE retorna com sucesso mesmo que não faça nada. Essa configuração permite diferenciar essas situações e obter o motivo na mensagem de exceção.
Possible values:
- 1 — O lançamento de uma exceção está ativado.
- 0 — O lançamento de uma exceção está desativado.
optimize_time_filter_with_preimage
toYear(col) = 2023 -> col >= '2023-01-01' AND col <= '2023-12-31')
optimize_trivial_approximate_count_query
- 0 — Otimização desabilitada.
- 1 — Otimização habilitada.
optimize_trivial_count_query
SELECT count() FROM table com base nos metadados do MergeTree. Se precisar usar segurança em nível de linha, desative essa configuração.
Valores possíveis:
- 0 — Otimização desativada.
Veja também:
optimize_trivial_group_by_limit_query
SELECT key_expr FROM table GROUP BY key_expr LIMIT n (sem funções de agregação na projeção, sem cláusulas HAVING/ORDER BY/LIMIT BY/window e sem modificadores GROUP BY) ao definir max_rows_to_group_by = n + offset com group_by_overflow_mode = 'any'. A agregação é interrompida assim que n + offset chaves distintas são produzidas.
A otimização é suprimida quando o usuário definiu explicitamente group_by_overflow_mode como um valor diferente de any (para preservar a escolha explícita de throw/break) e quando o usuário já definiu um max_rows_to_group_by mais restritivo (a otimização seria um no-op).
Valores possíveis:
- 0 — Otimização desabilitada.
- 1 — Otimização habilitada.
optimize_trivial_insert_select
optimize_truncate_order_by_after_group_by_keys
uniq e suas variantes (exceto uniqUpTo) como count se a subconsulta tiver DISTINCT ou cláusula GROUP BY.
optimize_use_implicit_projections
optimize_use_projection_filtering
allow_experimental_projection_optimization
Ativa ou desativa a otimização de projeções ao processar consultas SELECT.
Possible values:
- 0 — Otimização de projeções desativada.
- 1 — Otimização de projeções ativada.
optimize_using_constraints
false.
Valores possíveis:
os_threads_nice_value_materialized_view
os_threads_nice_value_query
os_thread_priority
Valor nice do Linux para threads de processamento de consultas. Valores menores significam maior prioridade de CPU.
Requer a capability CAP_SYS_NICE; caso contrário, não produz efeito.
Possible values: -20 a 19.
Tamanho dos fragmentos de arquivo a serem armazenados no cache de páginas em espaço do usuário, em bytes. Todas as leituras que passarem pelo cache serão arredondadas para cima para um múltiplo desse tamanho.
Esta configuração pode ser ajustada por consulta, mas entradas do cache com tamanhos de bloco diferentes não podem ser reutilizadas. Alterar esta configuração efetivamente invalida as entradas existentes no cache.
Um valor mais alto, como 1 MiB, é bom para consultas de alta vazão, e um valor mais baixo, como 64 KiB, é bom para consultas pontuais de baixa latência.
page_cache_inject_eviction
page_cache_lookahead_blocks
page_cache_max_coalesced_bytes
readBigAt preenche o cache de páginas em espaço de usuário, falhas de cache consecutivas são agrupadas em uma única leitura do armazenamento subjacente. Esta configuração limita, em bytes, o tamanho de uma leitura coalescida; sequências mais longas de falhas são divididas em múltiplas leituras. Ela limita o uso transitório de memória do buffer temporário durante leituras paralelas a frio.
Um valor mais alto reduz o número de requisições HTTP em varreduras a frio no armazenamento de objetos; um valor mais baixo reduz o pico de memória transitória.
paimon_target_snapshot_id
parallel_distributed_insert_select
INSERT ... SELECT em paralelo.
Se executarmos consultas INSERT INTO distributed_table_a SELECT ... FROM distributed_table_b, e ambas as tabelas usarem o mesmo cluster, e ambas forem replicadas ou não replicadas, essa consulta será processada localmente em cada shard.
Valores possíveis:
0 — Desabilitado.1 — SELECT será executado em cada shard a partir da tabela subjacente do motor Distributed.2 — SELECT e INSERT serão executados em cada shard, da/para a tabela subjacente do motor Distributed.
Desde a v25.4, INSERT ... SELECT de uma origem ReplicatedMergeTree ou SharedMergeTree também pode ser paralelizado entre réplicas. Para habilitar:
parallel_distributed_insert_select = 2enable_parallel_replicas = 1
parallel_hash_join_threshold
hash e parallel_hash (somente se a estimativa do tamanho da tabela à direita estiver disponível).
O primeiro é usado quando sabemos que o tamanho da tabela à direita está abaixo do limite.
parallel_non_joined_rows_processing
parallel_hash com tabelas grandes.
Quando desabilitada, as linhas sem correspondência são processadas por uma única thread.
Esta é uma configuração interna que não deve ser usada diretamente e representa um detalhe de implementação do modo de ‘réplicas paralelas’. Essa configuração será definida automaticamente pelo servidor iniciador, em consultas distribuídas, com o índice da réplica que participa do processamento da consulta entre as réplicas paralelas.
parallel_replicas_allow_in_with_subquery
parallel_replicas_allow_materialized_views
parallel_replicas_allow_view_over_mergetree
MergeTree (em vez da consulta interna da view), melhorando a paralelização entre os nós. Também se aplica a views UNION ALL cujos ramos leem de tabelas MergeTree diferentes.
parallel_replicas_connect_timeout_ms
parallel_replicas_custom_key
SAMPLE: usará várias réplicas de cada shard.
parallel_replicas_custom_key_range_lower
range divida o trabalho de forma equilibrada entre as réplicas com base no intervalo personalizado [parallel_replicas_custom_key_range_lower, INT_MAX].
Quando usada em conjunto com parallel_replicas_custom_key_range_upper, essa configuração permite que o filtro divida de forma equilibrada o trabalho entre as réplicas no intervalo [parallel_replicas_custom_key_range_lower, parallel_replicas_custom_key_range_upper].
Observação: essa configuração não faz com que dados adicionais sejam filtrados durante o processamento da consulta; em vez disso, ela altera os pontos em que o filtro de intervalo divide a faixa [0, INT_MAX] para processamento paralelo.
parallel_replicas_custom_key_range_upper
range divida o trabalho uniformemente entre as réplicas com base no intervalo personalizado [0, parallel_replicas_custom_key_range_upper]. Um valor 0 desativa o limite superior, definindo-o como o valor máximo da expressão de chave personalizada.
Quando usado em conjunto com parallel_replicas_custom_key_range_lower, permite que o filtro divida uniformemente o trabalho entre as réplicas no intervalo [parallel_replicas_custom_key_range_lower, parallel_replicas_custom_key_range_upper].
Observação: essa configuração não faz com que dados adicionais sejam filtrados durante o processamento da consulta; em vez disso, ela altera os pontos em que o filtro de intervalo divide o intervalo [0, INT_MAX] para processamento paralelo
parallel_replicas_filter_pushdown
parallel_replicas_for_cluster_engines
parallel_replicas_for_non_replicated_merge_tree
parallel_replicas_index_analysis_only_on_coordinator
parallel_replicas_insert_select_local_pipeline
parallel_replicas_local_plan
parallel_replicas_mark_segment_size
parallel_replicas_min_number_of_rows_per_replica
parallel_replicas_only_with_analyzer
parallel_replicas_prefer_local_join
parallel_replicas_prefer_local_replica
max_parallel_replicas = 1 sejam direcionadas a outro host, o que pode melhorar a localidade de cache quando muitas consultas curtas são distribuídas em um cluster.
parallel_replicas_support_projection
parallelize_output_from_storages
parsedatetime_e_requires_space_padding
parsedatetime_parse_without_leading_zeros
partial_merge_join_left_table_buffer_bytes
partial_merge_join_rows_in_right_blocks
- Divide os dados do lado direito do JOIN em blocos com até o número especificado de linhas.
- Cria um índice para cada bloco com base nos valores mínimo e máximo.
- Descarrega os blocos preparados para o disco, se possível.
Valores possíveis:
- Qualquer inteiro positivo. Faixa de valores recomendada: [1000, 100000].
partial_result_on_first_cancel
postgresql_connection_attempt_timeout
connect_timeout da URL de conexão.
postgresql_connection_pool_auto_close_connection
postgresql_connection_pool_retries
postgresql_connection_pool_size
postgresql_connection_pool_wait_timeout
postgresql_fault_injection_probability
predicate_statistics_sample_rate
system.predicate_statistics_log. Quando definido como N > 0, aproximadamente 1/N das consultas é amostrado (pelo ID da consulta). 0 significa desabilitado.
prefer_column_name_to_alias
- 0 — O nome da coluna é substituído pelo alias.
- 1 — O nome da coluna não é substituído pelo alias.
Exemplo
A diferença entre habilitado e desabilitado:
Consulta:
SET prefer_column_name_to_alias = 0;
SELECT avg(number) AS number, max(number) FROM numbers(10);
Received exception from server (version 21.5.1):
Code: 184. DB::Exception: Received from localhost:9000. DB::Exception: Aggregate function avg(number) is found inside another aggregate function in query: While processing avg(number) AS number.
SET prefer_column_name_to_alias = 1;
SELECT avg(number) AS number, max(number) FROM numbers(10);
┌─number─┬─max(number)─┐
│ 4.5 │ 9 │
└────────┴─────────────┘
prefer_external_sort_block_bytes
prefer_global_in_and_join
IN/JOIN por GLOBAL IN/GLOBAL JOIN.
Valores possíveis:
- 0 — Desabilitado. Os operadores
IN/JOIN não são substituídos por GLOBAL IN/GLOBAL JOIN.
- 1 — Habilitado. Os operadores
IN/JOIN são substituídos por GLOBAL IN/GLOBAL JOIN.
Uso
Embora SET distributed_product_mode=global possa alterar o comportamento das consultas em tabelas distribuídas, ele não é adequado para tabelas locais nem para tabelas de recursos externos. É nesse ponto que a configuração prefer_global_in_and_join se torna útil.
Por exemplo, podemos ter nós de consulta que contêm tabelas locais, que não são adequadas para distribuição. Precisamos distribuir esses dados dinamicamente durante o processamento distribuído com a palavra-chave GLOBAL — GLOBAL IN/GLOBAL JOIN.
Outro caso de uso de prefer_global_in_and_join é o acesso a tabelas criadas por motores externos. Essa configuração ajuda a reduzir o número de chamadas a fontes externas ao fazer join dessas tabelas: apenas uma chamada por consulta.
Veja também:
Habilita/desabilita o uso preferencial da réplica localhost ao processar consultas distribuídas.
Possíveis valores:
- 1 — o ClickHouse sempre envia a consulta para a réplica
localhost, se ela existir.
- 0 — o ClickHouse usa a estratégia de balanceamento especificada pela configuração load_balancing.
prefer_warmed_unmerged_parts_seconds
preferred_block_size_bytes
preferred_max_column_in_block_size_bytes
preferred_optimize_projection_name
- string: nome da projeção preferida
O tamanho máximo do buffer de prefetch para leitura no sistema de arquivos.
Permite exibir nomes de tipos com aninhamento profundo de forma legível, com recuos, na consulta DESCRIBE e na função toTypeName().
Exemplo:
CREATE TABLE test (a Tuple(b String, c Tuple(d Nullable(UInt64), e Array(UInt32), f Array(Tuple(g String, h Map(String, Array(Tuple(i String, j UInt64))))), k Date), l Nullable(String))) ENGINE=Memory;
DESCRIBE TABLE test FORMAT TSVRaw SETTINGS print_pretty_type_names=1;
a Tuple(
b String,
c Tuple(
d Nullable(UInt64),
e Array(UInt32),
f Array(Tuple(
g String,
h Map(
String,
Array(Tuple(
i String,
j UInt64
))
)
)),
k Date
),
l Nullable(String)
)
evaluation_time
Define o horário de avaliação a ser usado com o dialeto promql. ‘auto’ significa o horário atual.
Especifica o nome de uma tabela TimeSeries usada pelo dialeto ‘promql’.
push_external_roles_in_interserver_queries
query_cache_compress_entries
- 0 - Desativado
- 1 - Ativado
query_cache_for_subqueries
use_query_cache para todas as subconsultas.
Valores possíveis:
- 0 - Desativado
- 1 - Ativado
O número máximo de resultados de consultas que o usuário atual pode armazenar no cache de consultas. 0 significa ilimitado.
Valores possíveis:
query_cache_max_size_in_bytes
query_cache_min_query_duration
query_cache_min_query_runs
SELECT precisa ser executada antes que seu resultado seja armazenado no cache de consultas.
Valores possíveis:
- Número inteiro positivo >= 0.
query_cache_nondeterministic_function_handling
SELECT que usam funções não determinísticas, como rand() ou now().
Valores possíveis:
'throw' - Lança uma exceção e não armazena o resultado da consulta em cache.'save' - Armazena o resultado da consulta em cache.'ignore' - Não armazena o resultado da consulta em cache e não lança uma exceção.
query_cache_share_between_users
SELECT armazenadas no cache de consultas pode ser lido por outros usuários.
Não é recomendável habilitar essa configuração por motivos de segurança.
Valores possíveis:
- 0 - Desativado
- 1 - Ativado
query_cache_squash_partial_results
- 0 - Desabilitado
- 1 - Habilitado
query_cache_system_table_handling
SELECT em tabelas do sistema, ou seja, tabelas nos bancos de dados system.* e information_schema.*.
Valores possíveis:
'throw' - Lança uma exceção e não armazena em cache o resultado da consulta.'save' - Armazena em cache o resultado da consulta.'ignore' - Não armazena em cache o resultado da consulta nem lança uma exceção.
Uma string que funciona como rótulo para entradas do cache de consultas.
As mesmas consultas com rótulos diferentes são consideradas diferentes pelo cache de consultas.
Valores possíveis:
Após esse período, em segundos, as entradas no cache de consultas ficam desatualizadas.
Valores possíveis:
query_metric_log_interval
collect_interval_milliseconds da configuração query_metric_log ou, se ela não estiver presente, usará o valor padrão de 1000.
Para desativar a coleta de uma única consulta, defina query_metric_log_interval como 0.
Valor padrão: -1
query_plan_aggregation_in_order
query_plan_enable_optimizations estiver definida como 1.
Esta é uma configuração de nível avançado que deve ser usada apenas para depuração por desenvolvedores. A configuração pode mudar no futuro de formas incompatíveis com versões anteriores ou ser removida.
- 0 - Desabilita
- 1 - Habilita
query_plan_convert_any_join_to_semi_or_anti_join
query_plan_convert_join_to_in
JOIN em subconsulta com IN se as colunas de saída pertencerem apenas à tabela da esquerda. Pode gerar resultados incorretos com JOINs diferentes de ANY (por exemplo, ALL JOINs, que é o padrão).
query_plan_convert_outer_join_to_inner_join
OUTER JOIN em INNER JOIN se o filtro após o JOIN sempre eliminar valores padrão
query_plan_direct_read_from_text_index
query_plan_display_internal_aliases
query_plan_enable_multithreading_after_window_functions
query_plan_enable_optimizations
Esta é uma configuração de nível avançado que deve ser usada apenas por desenvolvedores para depuração. A configuração pode mudar no futuro de formas incompatíveis com versões anteriores ou ser removida.
- 0 - Desabilita todas as otimizações no nível do plano de consulta
- 1 - Habilita as otimizações no nível do plano de consulta (mas otimizações individuais ainda podem ser desabilitadas por meio de suas próprias configurações)
query_plan_execute_functions_after_sorting
query_plan_enable_optimizations for 1.
Esta é uma configuração de nível avançado que deve ser usada apenas para depuração por desenvolvedores. A configuração poderá mudar no futuro de maneiras incompatíveis com versões anteriores ou ser removida.
- 0 - Desabilita
- 1 - Habilita
query_plan_filter_push_down
Esta é uma configuração de nível avançado que deve ser usada apenas para depuração por desenvolvedores. A configuração pode mudar no futuro de formas incompatíveis com versões anteriores ou ser removida.
query_plan_join_shard_by_pk_ranges
query_plan_join_swap_table
ALL com a cláusula JOIN ON. Os valores possíveis são:
- ‘auto’: Permite que o planner decida qual tabela usar como tabela de build.
- ‘false’: Nunca troca as tabelas (a tabela da direita é a tabela de build).
- ‘true’: Sempre troca as tabelas (a tabela da esquerda é a tabela de build).
query_plan_lift_up_array_join
Esta é uma configuração de nível avançado que deve ser usada apenas para depuração por desenvolvedores. A configuração pode mudar no futuro de formas incompatíveis com versões anteriores ou ser removida.
- 0 - Desabilita
- 1 - Habilita
Ativa ou desativa uma otimização em nível de plano de consulta que move subárvores maiores do plano de consulta para o union, permitindo otimizações adicionais.
Só tem efeito se a configuração query_plan_enable_optimizations estiver definida como 1.
Esta é uma configuração de nível avançado que deve ser usada apenas para depuração por desenvolvedores. A configuração pode mudar no futuro de maneiras incompatíveis com versões anteriores ou ser removida.
- 0 - Desabilita
- 1 - Habilita
query_plan_max_limit_for_lazy_materialization
query_plan_max_limit_for_top_k_optimization
query_plan_max_optimizations_to_apply
Esta é uma configuração de nível avançado que deve ser usada apenas para depuração por desenvolvedores. A configuração pode mudar no futuro de formas incompatíveis com versões anteriores ou ser removida.
query_plan_max_step_description_length
query_plan_merge_expressions
Esta é uma configuração de nível avançado que deve ser usada apenas para debugging por desenvolvedores. A configuração pode mudar no futuro de formas incompatíveis com versões anteriores ou ser removida.
- 0 - Desabilita
- 1 - Habilita
query_plan_merge_filter_into_join_condition
JOIN e converter CROSS JOIN em INNER.
Permite mesclar filtros no plano de consulta.
query_plan_optimize_join_order_algorithm
- ‘greedy’ - algoritmo guloso básico - é rápido, mas pode não produzir a melhor ordem de join
- ‘dpsize’ - implementa o algoritmo DPsize, atualmente apenas para junções Inner - considera todas as ordens de join possíveis e encontra a mais otimizada, mas pode ser lento para consultas com muitas tabelas e predicados de join.
É possível especificar vários algoritmos, por exemplo, ‘dpsize,greedy’.
query_plan_optimize_join_order_limit
query_plan_optimize_join_order_randomize
query_plan_optimize_lazy_final
query_plan_optimize_lazy_materialization
query_plan_optimize_prewhere
query_plan_push_down_limit
LIMIT para baixo no plano de execução.
Só tem efeito se a configuração query_plan_enable_optimizations estiver definida como 1.
Esta é uma configuração de nível especialista que só deve ser usada para depuração por desenvolvedores. A configuração poderá mudar no futuro de maneiras incompatíveis com versões anteriores ou ser removida.
query_plan_enable_optimizations estiver definida como 1.
Esta é uma configuração de nível especialista que deve ser usada apenas para depuração por desenvolvedores. A configuração poderá mudar no futuro de formas incompatíveis com versões anteriores ou ser removida.
- 0 - Desabilita
- 1 - Habilita
query_plan_read_in_order_through_join
query_plan_remove_redundant_distinct
query_plan_enable_optimizations for 1.
Esta é uma configuração para especialistas, que deve ser usada apenas para depuração por desenvolvedores. A configuração poderá mudar no futuro de formas incompatíveis com versões anteriores ou ser removida.
query_plan_remove_redundant_sorting
query_plan_enable_optimizations estiver definida como 1.
Esta é uma configuração de nível avançado que deve ser usada apenas para depuração por desenvolvedores. A configuração pode mudar no futuro de maneiras incompatíveis com versões anteriores ou ser removida.
- 0 - Desabilita
- 1 - Habilita
query_plan_remove_unused_columns
Esta é uma configuração de nível avançado que deve ser usada apenas para depuração por desenvolvedores. A configuração pode mudar no futuro de formas incompatíveis com versões anteriores ou ser removida.
- 0 - Desabilita
- 1 - Habilita
query_plan_reuse_storage_ordering_for_window_functions
optimize_read_in_window_order
Ativa ou desativa uma otimização no nível do plano de consulta que usa a ordenação do armazenamento ao ordenar funções de janela.
Só tem efeito se a configuração query_plan_enable_optimizations estiver definida como 1.
Esta é uma configuração de nível avançado que só deve ser usada para depuração por desenvolvedores. A configuração pode mudar no futuro de maneiras incompatíveis com versões anteriores ou ser removida.
- 0 - Desabilita
- 1 - Habilita
Esta é uma configuração de nível avançado que deve ser usada apenas para depuração por desenvolvedores. A configuração pode mudar no futuro de formas incompatíveis com versões anteriores ou ser removida.
- 0 - Desabilita
- 1 - Habilita
query_plan_text_index_add_hint
query_plan_top_k_through_join
ORDER BY ... LIMIT n através de um join quando a chave de ordenação faz referência apenas a colunas do lado preservado pelo join (LEFT/RIGHT). Ela restringe quantas linhas a entrada do lado preservado deve produzir antes do join.
Só tem efeito se a configuração query_plan_enable_optimizations for 1.
Valores possíveis:
query_plan_try_use_vector_search
query_plan_enable_optimizations for 1.
Esta é uma configuração de nível avançado que deve ser usada apenas para depuração por desenvolvedores. A configuração pode mudar no futuro de formas incompatíveis com versões anteriores ou ser removida.
- 0 - Desabilitar
- 1 - Habilitar
query_profiler_cpu_time_period_ns
-
Um número inteiro positivo de nanossegundos.
Valores recomendados:
- 10000000 (100 vezes por segundo) nanossegundos ou mais para consultas individuais.
- 1000000000 (uma vez por segundo) para profiling em todo o cluster.
-
0 para desativar o temporizador.
Veja também:
query_profiler_real_time_period_ns
-
Número inteiro positivo, em nanossegundos.
Valores recomendados:
- 10000000 (100 vezes por segundo) nanossegundos ou menos para consultas individuais.
- 1000000000 (uma vez por segundo) para profiling em todo o cluster.
-
0 para desligar o temporizador.
Veja também:
Valor padrão no Cloud: 3000000000.
O tempo de espera na fila de requisições, caso o número de requisições simultâneas exceda o máximo.
O tempo de espera para ler do RabbitMQ antes de tentar novamente.
read_backoff_max_throughput
read_backoff_min_concurrency
read_backoff_min_interval_between_events_ms
read_backoff_min_latency_ms
read_from_distributed_cache_if_exists_otherwise_bypass_cache
read_from_filesystem_cache_if_exists_otherwise_bypass_cache
read_from_page_cache_if_exists_otherwise_bypass_cache
read_in_order_two_level_merge_threshold
read_in_order_use_buffering
read_in_order_use_virtual_row
read_in_order_use_virtual_row_per_block
read_in_order_use_virtual_row, emite uma linha virtual após cada bloco lido (não apenas no início de cada parte).
Isso permite que MergingSortedTransform repriorize as fontes com mais frequência, o que é útil quando filtros posteriores descartam muitas linhas e os dados estão distribuídos de forma desigual entre as partes.
Observe que isso desativa a otimização read_in_order_use_buffering e a mesclagem preliminar (read_in_order_two_level_merge_threshold) para leitura.
O que fazer quando o limite é excedido.
Define o que acontece quando o volume de dados lidos excede um dos limites no leaf.
Opções possíveis:
throw: gera uma exceção (padrão).break: interrompe a execução da consulta e retorna o resultado parcial.
Prioridade para ler dados do sistema de arquivos local ou do sistema de arquivos remoto. Suportado apenas com o método ‘pread_threadpool’ para sistema de arquivos local e com o método threadpool para sistema de arquivos remoto.
read_through_distributed_cache
recursive_cte_max_steps_in_type_inference
getLeastSupertype aos lados não recursivo e recursivo da UNION ALL até haver convergência. Defina como 0 para desativar o alargamento de tipos e usar apenas os tipos da parte não recursiva.
regexp_dict_allow_hyperscan
regexp_tree use a biblioteca Hyperscan.
regexp_dict_flag_case_insensitive
regexp_max_matches_per_row
reject_expensive_hyperscan_regexps
remerge_sort_lowered_memory_bytes_ratio
remote_filesystem_read_method
remote_filesystem_read_prefetch
remote_fs_read_backoff_max_tries
remote_fs_read_max_backoff_ms
remote_read_min_bytes_for_seek
rename_files_after_processing
-
Tipo: String
-
Valor padrão: String vazia
Esta configuração permite especificar um padrão de renomeação para arquivos processados pela função de tabela file. Quando a opção é definida, todos os arquivos lidos pela função de tabela file serão renomeados de acordo com o padrão especificado com placeholders, somente se o processamento dos arquivos for bem-sucedido.
%a — Nome completo do arquivo original (por exemplo, “sample.csv”).%f — Nome do arquivo original sem extensão (por exemplo, “sample”).%e — Extensão original do arquivo, com ponto (por exemplo, “.csv”).%t — Timestamp (em microssegundos).%% — Sinal de porcentagem (”%”).
-
Opção:
--rename_files_after_processing="processed_%f_%t%e"
-
Consulta:
SELECT * FROM file('sample.csv')
Se a leitura de sample.csv for concluída com sucesso, o arquivo será renomeado para processed_sample_1683473210851438.csv
Ao usar a interface HTTP, o parâmetro ‘query_id’ pode ser informado. Ele pode ser qualquer string que sirva como identificador da consulta.
Se já existir uma consulta do mesmo usuário com o mesmo ‘query_id’, o comportamento dependerá do parâmetro ‘replace_running_query’.
0 (padrão) – Gerar uma exceção (não permitir que a consulta seja executada se já houver uma consulta com o mesmo ‘query_id’ em execução).
1 – Cancelar a consulta antiga e iniciar a nova.
Defina este parâmetro como 1 para implementar sugestões de condições de segmentação. Ao digitar o próximo caractere, se a consulta antiga ainda não tiver terminado, ela deverá ser cancelada.
replace_running_query_max_wait_ms
query_id em execução termine, quando a configuração replace_running_query está ativa.
Valores possíveis:
- Inteiro positivo.
- 0 — Lança uma exceção que não permite executar uma nova consulta se o servidor já estiver executando uma consulta com o mesmo
query_id.
replication_wait_for_inactive_replica_timeout
ALTER, OPTIMIZE ou TRUNCATE.
Valores possíveis:
0 — Não aguardar.- Inteiro negativo — Aguarda por tempo ilimitado.
- Inteiro positivo — Número de segundos de espera.
restore_replace_external_dictionary_source_to_null
restore_replace_external_engines_to_null
restore_replace_external_table_functions_to_null
restore_replicated_merge_tree_to_shared_merge_tree
1.
Valor padrão no Cloud: throw
Define o que fazer se o volume do resultado exceder um dos limites.
Valores possíveis:
throw: lançar uma exceção (padrão).break: interromper a execução da consulta e retornar o resultado parcial, como se os
dados de origem tivessem se esgotado.
Usar ‘break’ é semelhante a usar LIMIT. Break interrompe a execução apenas no
nível do bloco. Isso significa que a quantidade de linhas retornadas será maior que
max_result_rows, será um múltiplo de max_block_size
e dependerá de max_threads.
Exemplo
SET max_threads = 3, max_block_size = 3333;
SET max_result_rows = 3334, result_overflow_mode = 'break';
SELECT *
FROM numbers_mt(100000)
FORMAT Null;
rewrite_count_distinct_if_with_count_distinct_implementation
countDistcintIf usando a configuração count_distinct_implementation.
Valores possíveis:
- true — Permitir.
- false — Não permitir.
Reescreve expressões como ‘x IN subconsulta’ para JOIN. Isso pode ser útil para otimizar toda a consulta com reordenação de JOINs.
Quando ativada, o ClickHouse fornecerá o valor exato da estatística rows_before_aggregation, que representa o número de linhas lidas antes da agregaçã
Permite cópia em múltiplas partes no S3.
s3_allow_parallel_part_upload
s3_check_objects_after_upload
s3_create_new_file_on_insert
data.Parquet.gz -> data.1.Parquet.gz -> data.2.Parquet.gz, etc.
Valores possíveis:
- 0 — a consulta
INSERT cria um novo arquivo ou falha se o arquivo já existir e s3_truncate_on_insert não estiver definido.
- 1 — a consulta
INSERT cria um novo arquivo a cada inserção, usando um sufixo (a partir do segundo), se s3_truncate_on_insert não estiver definido.
Veja mais detalhes aqui.
Não calcule um checksum ao enviar um arquivo para o S3. Isso acelera as gravações ao evitar etapas excessivas de processamento do arquivo. Em geral, isso é seguro, pois os dados das tabelas MergeTree já têm checksum calculado pelo ClickHouse de qualquer forma e, quando o S3 é acessado via HTTPS, a camada TLS já fornece integridade durante a transferência pela rede. Embora checksums adicionais no S3 ofereçam uma defesa em profundidade.
s3_ignore_file_doesnt_exist
- 1 —
SELECT retorna um resultado vazio.
- 0 —
SELECT lança uma exceção.
Número máximo de arquivos que podem ser retornados em um lote pela solicitação ListObject
O número máximo de conexões por servidor.
Número máximo de solicitações que podem ser emitidas simultaneamente antes de atingir o limite de solicitações por segundo. Por padrão, (0) equivale a s3_max_get_rps
Limite da taxa de solicitações GET para o S3 por segundo antes do throttling. Zero significa ilimitado.
s3_max_inflight_parts_for_one_file
s3_max_put_rps
Limite da taxa de requisições PUT no S3 por segundo antes da aplicação de throttling. Zero significa ilimitado.
s3_max_single_operation_copy_size
s3_max_single_part_upload_size
s3_max_single_read_retries
s3_max_unexpected_write_error_retries
_path que podem ser extraídos dos filtros da consulta para serem usados na iteração de arquivos
em vez da listagem com glob. 0 significa desativado.
Tempo limite de inatividade para envio e recebimento de dados de/para o S3. A operação falhará se uma única chamada TCP de leitura ou gravação ficar bloqueada por esse período.
Ativa ou desativa o ignoramento de arquivos vazios em tabelas do motor S3.
Valores possíveis:
- 0 —
SELECT gera uma exceção se o arquivo vazio não for compatível com o formato solicitado.
- 1 —
SELECT retorna um resultado vazio para um arquivo vazio.
s3_slow_all_threads_after_network_error
true, todas as threads que executam requisições ao S3 para o mesmo endpoint de backup ficam mais lentas
depois que qualquer requisição individual ao S3 encontra um erro de rede passível de nova tentativa, como timeout de socket.
Quando definido como false, cada thread lida com o backoff das requisições ao S3 de forma independente das demais.
s3_strict_upload_part_size
s3_throw_on_zero_files_match
- 0 — a consulta
INSERT cria um novo arquivo ou falha se o arquivo já existir e s3_create_new_file_on_insert não estiver definido.
- 1 — a consulta
INSERT substitui o conteúdo existente do arquivo pelos novos dados.
Veja mais detalhes aqui.
s3_upload_part_size_multiply_factor
s3_min_upload_part_size por este fator sempre que s3_multiply_parts_count_threshold partes forem enviadas em uma única gravação no S3.
s3_upload_part_size_multiply_parts_count_threshold
s3_min_upload_part_size será multiplicado por s3_upload_part_size_multiply_factor.
Força o estilo de endpoint do S3. Valores possíveis: auto, virtual_hosted, path.
Quando definido como true, para todas as requisições ao S3, as duas primeiras tentativas são feitas com timeouts de envio e recebimento baixos.
Quando definido como false, todas as tentativas são feitas com os mesmos timeouts.
s3_validate_request_settings
- 1 — validar as configurações.
- 0 — não validar as configurações.
s3queue_default_zookeeper_path
s3queue_enable_logging_to_s3queue_log
s3queue_keeper_fault_injection_probability
schema_inference_cache_require_modification_time_for_url
schema_inference_use_cache_for_azure
schema_inference_use_cache_for_file
schema_inference_use_cache_for_hdfs
schema_inference_use_cache_for_s3
schema_inference_use_cache_for_url
secondary_indices_enable_bulk_filtering
select_sequential_consistency
O comportamento dessa configuração difere entre SharedMergeTree e ReplicatedMergeTree; consulte SharedMergeTree consistency para mais informações sobre o comportamento de select_sequential_consistency no SharedMergeTree. SELECT. Exige que insert_quorum_parallel esteja desativado (embora seja ativado por padrão).
Valores possíveis:
- 0 — Desativado.
- 1 — Ativado.
Uso
Quando a consistência sequencial está ativada, o ClickHouse permite que o cliente execute a consulta SELECT apenas nas réplicas que contêm dados de todas as consultas INSERT anteriores executadas com insert_quorum. Se o cliente acessar uma réplica parcial, o ClickHouse gerará uma exceção. A consulta SELECT não incluirá dados que ainda não tenham sido gravados no quórum de réplicas.
Quando insert_quorum_parallel está ativado (o padrão), select_sequential_consistency não funciona. Isso ocorre porque consultas INSERT paralelas podem ser gravadas em diferentes conjuntos de réplicas de quórum, portanto não há garantia de que uma única réplica tenha recebido todas as gravações.
Veja também:
Envia logs de texto do servidor ao cliente com o nível mínimo especificado. Valores válidos: ‘trace’, ‘debug’, ‘information’, ‘warning’, ‘error’, ‘fatal’, ‘none’
Envia logs de texto do servidor com a regexp especificada para corresponder ao nome da origem do log. Vazio significa todas as origens.
Habilita ou desabilita o envio de pacotes de ProfileEvents para o cliente.
Isso pode ser desabilitado para reduzir o tráfego de rede de clientes que não precisam de eventos de perfil.
Valores possíveis:
- 0 — Desabilitado.
- 1 — Habilitado.
Ativa ou desativa os cabeçalhos de resposta HTTP X-ClickHouse-Progress nas respostas do clickhouse-server.
Para mais informações, leia a descrição da interface HTTP.
Valores possíveis:
- 0 — Desativado.
- 1 — Ativado.
send_table_structure_on_insert_with_inline_data
receive_timeout do socket também será definido na extremidade correspondente da conexão no servidor.
Serializa o plano da consulta para processamento distribuído
serialize_string_in_memory_with_zero_byte
timeZone() e serverTimeZone() para obter o fuso horário da sessão e o do servidor.
Valores possíveis:
- Qualquer nome de fuso horário de
system.time_zones, por exemplo Europe/Berlin, UTC ou Zulu
Exemplos:
SELECT timeZone(), serverTimeZone() FORMAT CSV
"Europe/Berlin","Europe/Berlin"
SELECT timeZone(), serverTimeZone() SETTINGS session_timezone = 'Asia/Novosibirsk' FORMAT CSV
"Asia/Novosibirsk","Europe/Berlin"
SELECT toDateTime64(toDateTime64('1999-12-12 23:23:23.123', 3), 3, 'Europe/Zurich') SETTINGS session_timezone = 'America/Denver' FORMAT TSV
1999-12-13 07:23:23.123
Nem todas as funções que fazem o parse de DateTime/DateTime64 respeitam session_timezone. Isso pode levar a erros sutis.
Veja o exemplo e a explicação a seguir.
CREATE TABLE test_tz (`d` DateTime('UTC')) ENGINE = Memory AS SELECT toDateTime('2000-01-01 00:00:00', 'UTC');
SELECT *, timeZone() FROM test_tz WHERE d = toDateTime('2000-01-01 00:00:00') SETTINGS session_timezone = 'Asia/Novosibirsk'
0 rows in set.
SELECT *, timeZone() FROM test_tz WHERE d = '2000-01-01 00:00:00' SETTINGS session_timezone = 'Asia/Novosibirsk'
┌───────────────────d─┬─timeZone()───────┐
│ 2000-01-01 00:00:00 │ Asia/Novosibirsk │
└─────────────────────┴──────────────────┘
toDateTime() sem um fuso horário explicitamente especificado, usado na primeira consulta SELECT, respeita a configuração session_timezone e o fuso horário global.- Na segunda consulta, um DateTime é parseado de uma String e herda o tipo e o fuso horário da coluna existente
d. Assim, a configuração session_timezone e o fuso horário global não são respeitados.
Veja também
Define o que acontece quando a quantidade de dados excede um dos limites.
Valores possíveis:
throw: gera uma exceção (padrão).break: interrompe a execução da consulta e retorna o resultado parcial, como se os
dados de origem tivessem se esgotado.
shared_merge_tree_sequential_consistency_initial_parts_update_backoff_ms
select_sequential_consistency com SharedMergeTree. Disponível apenas no ClickHouse Cloud.
shared_merge_tree_sequential_consistency_max_parts_update_backoff_ms
select_sequential_consistency com SharedMergeTree. Disponível apenas no ClickHouse Cloud.
shared_merge_tree_sequential_consistency_parts_update_max_retries
select_sequential_consistency com SharedMergeTree. Disponível apenas no ClickHouse Cloud.
shared_merge_tree_sync_parts_on_partition_operations
short_circuit_function_evaluation
enable — Habilita a avaliação de curto-circuito para funções às quais ela se aplica (que podem lançar uma exceção ou ser computacionalmente pesadas).force_enable — Habilita a avaliação de curto-circuito para todas as funções.disable — Desabilita a avaliação de curto-circuito.
short_circuit_function_evaluation_for_nulls
short_circuit_function_evaluation_for_nulls_threshold
show_data_lake_catalogs_in_system_tables
show_processlist_include_internal
SHOW PROCESSLIST.
Os processos internos incluem recarregamentos de dicionários, recarregamentos de views materializadas atualizáveis, SELECTs auxiliares executados em consultas SHOW ..., consultas auxiliares CREATE DATABASE ... executadas internamente para lidar com tabelas corrompidas, entre outros.
show_table_uuid_in_table_create_query_if_not_nil
SHOW TABLE é exibida.
Valores possíveis:
- 0 — A consulta será exibida sem o UUID da tabela.
- 1 — A consulta será exibida com o UUID da tabela.
single_join_prefer_left_table
skip_redundant_aliases_in_udf
- 1 — Os aliases são ignorados (substituídos) em UDFs.
- 0 — Os aliases não são ignorados (substituídos) em UDFs.
Exemplo
A diferença entre ativado e desativado:
Consulta:
SET skip_redundant_aliases_in_udf = 0;
CREATE FUNCTION IF NOT EXISTS test_03274 AS ( x ) -> ((x + 1 as y, y + 2));
EXPLAIN SYNTAX SELECT test_03274(4 + 2);
SELECT ((4 + 2) + 1 AS y, y + 2)
SET skip_redundant_aliases_in_udf = 1;
CREATE FUNCTION IF NOT EXISTS test_03274 AS ( x ) -> ((x + 1 as y, y + 2));
EXPLAIN SYNTAX SELECT test_03274(4 + 2);
SELECT ((4 + 2) + 1, ((4 + 2) + 1) + 2)
-
O ClickHouse não consegue se conectar à réplica por qualquer motivo.
Ao se conectar a uma réplica, o ClickHouse faz várias tentativas. Se todas elas falharem, a réplica será considerada indisponível.
-
A réplica não pode ser resolvida por DNS.
Se o hostname da réplica não puder ser resolvido por DNS, isso pode indicar as seguintes situações:
-
O host da réplica não tem um registro DNS. Isso pode ocorrer em sistemas com DNS dinâmico, por exemplo, Kubernetes, em que os nós podem não ser resolvidos durante períodos de indisponibilidade, e isso não é um erro.
-
Erro de configuração. O arquivo de configuração do ClickHouse contém um hostname incorreto.
Valores possíveis:
-
1 — omissão ativada.
Se um shard estiver indisponível, o ClickHouse retorna um resultado com base em dados parciais e não relata problemas de disponibilidade dos nós.
-
0 — omissão desativada.
Se um shard estiver indisponível, o ClickHouse gera uma exceção.
sleep_after_receiving_query_ms
sleep_in_send_tables_status_ms
throw: lançar uma exceção.break: interromper a execução da consulta e retornar o resultado parcial.
split_intersecting_parts_ranges_into_layers_final
split_parts_ranges_into_intersecting_and_non_intersecting_final
splitby_max_substrings_includes_remaining_string
max_substrings > 0, incluirá a string restante no último elemento do array resultante.
Possible values:
0 - A string restante não será incluída no último elemento do array resultante.1 - A string restante será incluída no último elemento do array resultante. Esse é o comportamento da função split() do Spark e do método ‘string.split()’ do Python.
stop_refreshable_materialized_views_on_startup
SYSTEM STOP VIEWS tivesse sido executado. Depois, você pode iniciá-las manualmente com SYSTEM START VIEWS ou SYSTEM START VIEW <name>. Também se aplica a views criadas posteriormente. Não tem efeito sobre views materializadas não atualizáveis.
Método de leitura de dados do arquivo de armazenamento, entre: read, pread, mmap. O método mmap não se aplica ao clickhouse-server (ele se destina ao clickhouse-local).
storage_system_stack_trace_pipe_read_timeout_ms
system.stack_trace. Essa configuração é usada para fins de teste e não deve ser alterada pelos usuários.
Aplica-se a tabelas com streaming em caso de timeout ou quando uma thread gera max_insert_block_size linhas.
O valor padrão é 7500.
Quanto menor o valor, com mais frequência os dados são descarregados na tabela. Definir um valor muito baixo leva a um desempenho ruim.
stream_like_engine_allow_direct_select
stream_like_engine_insert_queue
system_events_show_zero_values
system.events.
Alguns sistemas de monitoramento exigem que todos os valores das métricas sejam enviados a cada coleta, mesmo que o valor da métrica seja zero.
Valores possíveis:
- 0 — Desabilitado.
- 1 — Habilitado.
Exemplos
Consulta
SELECT * FROM system.events WHERE event='QueryMemoryLimitExceeded';
SET system_events_show_zero_values = 1;
SELECT * FROM system.events WHERE event='QueryMemoryLimitExceeded';
┌─event────────────────────┬─value─┬─description───────────────────────────────────────────┐
│ QueryMemoryLimitExceeded │ 0 │ Number of times when memory limit exceeded for query. │
└──────────────────────────┴───────┴───────────────────────────────────────────────────────┘
system_metric_log_show_zero_values_in_histograms
histograms de system.metric_log.
Por padrão, histogramas cuja count total de observações é zero são ignorados e, dentro de cada histograma emitido, as entradas de bucket sem observações também são omitidas do mapa histogram. Ative esta opção para gravar todos os histogramas e todos os buckets independentemente da contagem — útil para sistemas de monitoramento que exigem que toda métrica apareça em cada coleta.
Valores possíveis:
- 0 — Desativado. Histogramas com
count = 0 não são emitidos; os histogramas emitidos incluem apenas buckets que receberam pelo menos uma observação.
- 1 — Ativado. Todos os histogramas são gravados, e cada limite de bucket aparece em
histogram.
table_engine_read_through_distributed_cache
table_function_remote_max_addresses
temporary_data_in_cache_reserve_space_wait_lock_timeout_milliseconds
temporary_files_buffer_size
- LZ4 — a compressão LZ4 é aplicada.
- NONE — nenhuma compressão é aplicada.
text_index_hint_max_selectivity
text_index_like_max_postings_to_read
use_text_index_like_evaluation_by_dictionary_scan esteja habilitado.
text_index_like_min_pattern_length
use_text_index_like_evaluation_by_dictionary_scan esteja habilitado.
throw_if_no_data_to_insert
clickhouse-client ou a interface gRPC.
throw_on_error_from_cache_on_write_operations
throw_on_max_partitions_per_insert_block
max_partitions_per_insert_block é atingido.
Valores possíveis:
true - Quando um bloco de inserção atinge max_partitions_per_insert_block, uma exceção é lançada.false - Registra um aviso quando max_partitions_per_insert_block é atingido.
throw_on_unsupported_query_inside_transaction
timeout_before_checking_execution_speed
min_execution_speed)
depois de decorrido o tempo especificado em segundos.
Define o que fazer se a consulta demorar mais que max_execution_time para ser executada ou se o
tempo estimado de execução for maior que max_estimated_execution_time.
Valores possíveis:
throw: lançar uma exceção (padrão).break: interromper a execução da consulta e retornar o resultado parcial, como se os
dados de origem tivessem se esgotado.
timeout_overflow_mode_leaf
max_execution_time_leaf.
Valores possíveis:
throw: lança uma exceção (padrão).break: interrompe a execução da consulta e retorna o resultado parcial, como se os
dados de origem tivessem se esgotado.
O limite para totals_mode = 'auto'.
Consulte a seção “modificador WITH TOTALS”.
Como calcular TOTALS quando há HAVING, bem como quando max_rows_to_group_by e group_by_overflow_mode = ‘any’ estão definidos.
Consulte a seção “modificador WITH TOTALS”.
Habilita ou desabilita a coleta de stacktraces a cada atualização dos eventos de perfil, juntamente com o nome do evento de perfil e o valor do incremento, bem como seu envio para trace_log.
Valores possíveis:
- 1 — Rastreamento de eventos de perfil habilitado.
- 0 — Rastreamento de eventos de perfil desabilitado.
trace_profile_events_list
trace_profile_events estiver habilitada, limite os eventos rastreados à lista especificada de nomes separados por vírgula.
Se trace_profile_events_list for uma string vazia (o padrão), rastreie todos os profile events.
Valor de exemplo: ‘DiskS3ReadMicroseconds,DiskS3ReadRequestsCount,SelectQueryTimeMicroseconds,ReadBufferFromS3Bytes’
O uso dessa configuração permite coletar dados com mais precisão para um grande número de consultas, pois, caso contrário, o grande volume de eventos pode causar overflow na fila interna de logs do sistema, e parte deles será descartada.
Define o que acontece quando a quantidade de dados excede um dos limites.
Valores possíveis:
throw: lança uma exceção (padrão).break: interrompe a execução da consulta e retorna o resultado parcial, como se os
dados de origem tivessem acabado.
Habilita a igualdade entre valores NULL para o operador IN.
Por padrão, valores NULL não podem ser comparados, porque NULL significa um valor indefinido. Assim, a comparação expr = NULL deve sempre retornar false. Com essa configuração, NULL = NULL retorna true para o operador IN.
Valores possíveis:
- 0 — A comparação entre valores
NULL no operador IN retorna false.
- 1 — A comparação entre valores
NULL no operador IN retorna true.
Exemplo
Considere a tabela null_in:
┌──idx─┬─────i─┐
│ 1 │ 1 │
│ 2 │ NULL │
│ 3 │ 3 │
└──────┴───────┘
SELECT idx, i FROM null_in WHERE i IN (1, NULL) SETTINGS transform_null_in = 0;
┌──idx─┬────i─┐
│ 1 │ 1 │
└──────┴──────┘
SELECT idx, i FROM null_in WHERE i IN (1, NULL) SETTINGS transform_null_in = 1;
┌──idx─┬─────i─┐
│ 1 │ 1 │
│ 2 │ NULL │
└──────┴───────┘
traverse_shadow_remote_data_paths
SELECT. A configuração é usada apenas com UNION quando UNION ALL ou UNION DISTINCT não são especificados explicitamente.
Valores possíveis:
'DISTINCT' — o ClickHouse retorna linhas como resultado da combinação de consultas, removendo linhas duplicadas.'ALL' — o ClickHouse retorna todas as linhas como resultado da combinação de consultas, incluindo linhas duplicadas.'' — o ClickHouse gera uma exceção quando usado com UNION.
Veja exemplos em UNION.
unknown_packet_in_send_data
UPDATE simultâneas.
Valores possíveis:
sync - executa todas as consultas UPDATE sequencialmente.auto - executa sequencialmente apenas as consultas UPDATE com dependências entre colunas atualizadas em uma consulta e colunas usadas em expressões de outra consulta.async - não sincroniza as consultas UPDATE.
update_sequential_consistency
- URL relativa ao caminho (por exemplo,
data.csv): combinada com o caminho da URL base de acordo com a RFC 3986. Tudo após a última / no caminho base é substituído pela URL relativa, portanto a barra final faz diferença: https://example.com/dir/ + data.csv = https://example.com/dir/data.csv, mas https://example.com/dir + data.csv = https://example.com/data.csv. Se a base não tiver caminho (por exemplo, https://example.com), uma / é inserida: https://example.com/data.csv. Segmentos de ponto (./ e ../) na URL relativa são normalizados: https://example.com/dir/ + ../a.csv = https://example.com/a.csv.
- URL relativa ao host (por exemplo,
/test/data.csv): resolvida com base no esquema e no host da URL base.
- URL relativa ao esquema (por exemplo,
//other.com/test/data.csv): resolvida usando o esquema da URL base.
- Referência apenas de consulta (por exemplo,
?x=1): anexada ao caminho da URL base (substituindo qualquer consulta/fragmento existente).
- Referência apenas de fragmento (por exemplo,
#frag): anexada à URL base, preservando qualquer string de consulta (substituindo qualquer fragmento existente).
- Referência vazia: retorna a URL base sem fragmento.
Por exemplo, se url_base for https://example.com/def/, então:
data.csv é resolvido para https://example.com/def/data.csv/test/data.csv é resolvido para https://example.com/test/data.csv//other.com/test/data.csv é resolvido para https://other.com/test/data.csv
use_async_executor_for_materialized_views
use_cache_for_count_from_files
file/s3/url/hdfs/azureBlobStorage.
Habilitado por padrão.
Use o fuso horário do cliente para interpretar valores DateTime em formato de string, em vez de usar o fuso horário do servidor.
Usa o formato compacto para armazenar blocos para INSERT em segundo plano (distributed_foreground_insert) em tabelas com engine Distributed.
Valores possíveis:
- 0 — Usa o formato de diretório
user[:password]@host:port#default_database.
- 1 — Usa o formato de diretório
[shard{shard_index}[_replica{replica_index}]].
- com
use_compact_format_in_distributed_parts_names=0, alterações na definição do cluster não serão aplicadas ao INSERT em segundo plano.
- com
use_compact_format_in_distributed_parts_names=1, alterar a ordem dos nós na definição do cluster mudará o shard_index/replica_index, portanto tenha isso em mente.
concurrent_threads_soft_limit_num e concurrent_threads_soft_limit_ratio_to_cores do servidor). Se estiver desabilitado, permite usar um número maior de threads mesmo que o servidor esteja sobrecarregado (não é recomendado para uso normal e é necessário principalmente para testes).
Valor padrão no Cloud: 0.
use_hash_table_stats_for_join_reordering
hedged_connection_timeout
ou nenhum dado tenha sido recebido dentro de receive_data_timeout. A consulta usa a primeira conexão que envia um pacote de progresso não vazio (ou um pacote de dados, se allow_changing_replica_until_first_data_packet);
as demais conexões são canceladas. Há suporte para consultas com max_parallel_replicas > 1.
Ativado por padrão.
Valor padrão no Cloud: 0.
Quando habilitada, o ClickHouse detectará o particionamento no estilo Hive no caminho (/name=value/) em motores de tabela semelhantes a arquivos File/S3/URL/HDFS/AzureBlobStorage e permitirá usar colunas de partição como colunas virtuais na consulta. Essas colunas virtuais terão os mesmos nomes do caminho particionado, mas começarão com _.
Se estiver ativada, a função de tabela Iceberg e o armazenamento Iceberg poderão usar o cache de arquivos de metadados do Iceberg.
Valores possíveis:
- 0 - Desabilitado
- 1 - Habilitado
use_iceberg_partition_pruning
use_index_for_in_with_subqueries
use_index_for_in_with_subqueries_max_values
use_join_disjunctions_push_down
use_page_cache_for_disks_without_file_cache
use_page_cache_for_local_disks
use_page_cache_for_object_storage
use_page_cache_with_distributed_cache
use_paimon_partition_pruning
- 0 - Desabilitado
- 1 - Habilitado
Aliases: use_partition_key
Usa a chave de partição para fazer a poda de partições durante a execução de consultas em tabelas MergeTree.
Valores possíveis:
- 0 — Desabilitado.
- 1 — Habilitado.
Usa a chave primária para podar grânulos durante a execução de consultas em tabelas MergeTree.
Valores possíveis:
- 0 — Desabilitado.
- 1 — Habilitado.
Se ativada, consultas SELECT podem usar o cache de consultas. Os parâmetros enable_reads_from_query_cache
e enable_writes_to_query_cache controlam de forma mais detalhada como o cache é usado.
Valores possíveis:
- 0 - Desabilitado
- 1 - Habilitado
use_query_condition_cache
WHERE
e reutiliza essas informações como um índice efêmero para consultas subsequentes.
Valores possíveis:
- 0 - Desativado
- 1 - Ativado
use_roaring_bitmap_iceberg_positional_deletes
- 0 — Desativado.
- 1 — Ativado.
use_skip_indexes_for_disjunctions
WHERE com condições mistas de AND e OR usando skip indexes. Exemplo: WHERE A = 5 AND (B = 5 OR C = 5).
Se desabilitada, os skip indexes ainda são usados para avaliar condições da cláusula WHERE, mas elas devem conter apenas cláusulas combinadas com AND.
Valores possíveis:
- 0 — Desabilitado.
- 1 — Habilitado.
use_skip_indexes_for_top_k
ORDER BY <column> LIMIT n, o otimizador tentará usar o índice minmax para ignorar grânulos que não sejam relevantes para o resultado final. Isso pode reduzir a latência da consulta.
Valores possíveis:
- 0 — Desabilitado.
- 1 — Habilitado.
use_skip_indexes_if_final
- 0 — Desabilitado.
- 1 — Habilitado.
use_skip_indexes_if_final_exact_mode
- 0 — Desativado.
- 1 — Ativado.
use_skip_indexes_on_data_read
- 0 — Desabilitado.
- 1 — Habilitado.
/// preferível a ‘allow_statistics_optimize’ para manter a consistência com ‘use_primary_key’ e ‘use_skip_indexes’
Permite usar estatísticas para otimizar consultas
Use o cache de estatísticas em uma consulta para evitar a sobrecarga de carregar estatísticas de todas as partes
use_statistics_for_part_pruning
- 0 — Desabilitado.
- 1 — Habilitado.
use_strict_insert_block_limits
- Limiares mínimos (AND): Ambos
min_insert_block_size_rows AND min_insert_block_size_bytes são atingidos.
- Limiares máximos (OR):
max_insert_block_size_rows OR max_insert_block_size_bytes é atingido.
Quando desabilitada, um bloco é emitido quando:
- Limiares mínimos (OR):
min_insert_block_size_rows OR min_insert_block_size_bytes é atingido.
Observação: Se as configurações máximas forem menores que as configurações mínimas, os limites máximos terão precedência, e os blocos serão emitidos antes de os limiares mínimos serem atingidos.
Observação: Essa configuração é desabilitada automaticamente para async inserts, porque async inserts anexam tokens de desduplicação por entrada que são incompatíveis com a divisão de blocos necessária para aplicar limites estritos.
Desabilitada por padrão.
use_structure_from_insertion_table_in_table_functions
use_text_index_like_evaluation_by_dictionary_scan
use_text_index_postings_cache
use_text_index_tokens_cache
use_top_k_dynamic_filtering
ORDER BY <column> LIMIT n.
Quando habilitada, o executor da consulta tentará ignorar grânulos e linhas que não farão parte das top N linhas finais no conjunto de resultados. Essa otimização é inerentemente dinâmica, e as melhorias de latência dependem da distribuição dos dados e da presença de outros predicados na consulta.
Valores possíveis:
- 0 — Desabilitado.
- 1 — Habilitado.
use_top_k_dynamic_filtering_for_variable_length_types
use_top_k_dynamic_filtering seja aplicado quando a coluna de ordenação tem um tipo de dados de comprimento variável (por exemplo, String, Array, Map, Tuple contendo elementos de comprimento variável).
Para esses tipos, a comparação de limiar por linha feita pelo filtro dinâmico pode custar mais do que a economia gerada quando o mínimo lexicográfico da coluna predomina (por exemplo, quando há principalmente strings vazias) e poucos grânulos podem ser ignorados. Nesse caso, o filtro dinâmico piora a latência da consulta em vez de melhorá-la.
Quando essa configuração é 0, a filtragem dinâmica fica restrita a colunas cujos valores têm um tamanho máximo fixo na memória (números, Date, DateTime, FixedString, Enum, Nullable desses tipos, Tuple desses tipos). Quando definida como 1, a filtragem dinâmica também se aplica a tipos de comprimento variável.
Valores possíveis:
- 0 — Desabilitado.
- 1 — Habilitado.
Define se deve usar um cache de blocos não comprimidos. Aceita 0 ou 1. Por padrão, 0 (desabilitado).
Usar o cache não comprimido (apenas para tabelas da família MergeTree) pode reduzir significativamente a latência e aumentar a taxa de transferência ao trabalhar com um grande número de consultas curtas. Habilite essa configuração para usuários que enviam solicitações curtas com frequência. Observe também o parâmetro de configuração uncompressed_cache_size (definido apenas no arquivo de configuração) – o tamanho dos blocos do cache não comprimido. Por padrão, ele é 8 GiB. O cache não comprimido é preenchido conforme necessário, e os dados menos usados são excluídos automaticamente.
Para consultas que leem pelo menos um volume de dados relativamente grande (um milhão de linhas ou mais), o cache não comprimido é desabilitado automaticamente para economizar espaço para consultas realmente pequenas. Isso significa que você pode manter a configuração ‘use_uncompressed_cache’ sempre definida como 1.
use_variant_as_common_type
Variant como tipo de resultado das funções if/multiIf/array/map quando não há um tipo comum entre os tipos de argumento.
Exemplo:
SET use_variant_as_common_type = 1;
SELECT toTypeName(if(number % 2, number, range(number))) as variant_type FROM numbers(1);
SELECT if(number % 2, number, range(number)) as variant FROM numbers(5);
┌─variant_type───────────────────┐
│ Variant(Array(UInt64), UInt64) │
└────────────────────────────────┘
┌─variant───┐
│ [] │
│ 1 │
│ [0,1] │
│ 3 │
│ [0,1,2,3] │
└───────────┘
SET use_variant_as_common_type = 1;
SELECT toTypeName(multiIf((number % 4) = 0, 42, (number % 4) = 1, [1, 2, 3], (number % 4) = 2, 'Hello, World!', NULL)) AS variant_type FROM numbers(1);
SELECT multiIf((number % 4) = 0, 42, (number % 4) = 1, [1, 2, 3], (number % 4) = 2, 'Hello, World!', NULL) AS variant FROM numbers(4);
─variant_type─────────────────────────┐
│ Variant(Array(UInt8), String, UInt8) │
└──────────────────────────────────────┘
┌─variant───────┐
│ 42 │
│ [1,2,3] │
│ Hello, World! │
│ ᴺᵁᴸᴸ │
└───────────────┘
SET use_variant_as_common_type = 1;
SELECT toTypeName(array(range(number), number, 'str_' || toString(number))) as array_of_variants_type from numbers(1);
SELECT array(range(number), number, 'str_' || toString(number)) as array_of_variants FROM numbers(3);
┌─array_of_variants_type────────────────────────┐
│ Array(Variant(Array(UInt64), String, UInt64)) │
└───────────────────────────────────────────────┘
┌─array_of_variants─┐
│ [[],0,'str_0'] │
│ [[0],1,'str_1'] │
│ [[0,1],2,'str_2'] │
└───────────────────┘
SET use_variant_as_common_type = 1;
SELECT toTypeName(map('a', range(number), 'b', number, 'c', 'str_' || toString(number))) as map_of_variants_type from numbers(1);
SELECT map('a', range(number), 'b', number, 'c', 'str_' || toString(number)) as map_of_variants FROM numbers(3);
┌─map_of_variants_type────────────────────────────────┐
│ Map(String, Variant(Array(UInt64), String, UInt64)) │
└─────────────────────────────────────────────────────┘
┌─map_of_variants───────────────┐
│ {'a':[],'b':0,'c':'str_0'} │
│ {'a':[0],'b':1,'c':'str_1'} │
│ {'a':[0,1],'b':2,'c':'str_2'} │
└───────────────────────────────┘
use_variant_default_implementation_for_comparisons
use_with_fill_by_sorting_prefix
validate_enum_literals_in_operators
IN, NOT IN, ==, != com base no tipo enum e lança uma exceção caso o literal não seja um valor válido do enum.
Valide as consultas de mutação antes de aceitá-las. As mutações são executadas em segundo plano, e a execução de uma consulta inválida fará com que as mutações fiquem travadas, exigindo intervenção manual.
Altere essa configuração somente se você encontrar um bug de incompatibilidade com versões anteriores.
Ativa ou desativa a geração de uma exceção na função pointInPolygon se o polígono for autointersectante ou autotangente.
Possíveis valores:
- 0 — A geração de uma exceção está desativada.
pointInPolygon aceita polígonos inválidos e pode retornar resultados incorretos para eles.
- 1 — A geração de uma exceção está ativada.
variant_throw_on_type_mismatch
true (padrão) — gera uma exceção.false — retorna NULL para essas linhas.
vector_search_filter_strategy
- ‘auto’ - Pós-filtragem (a semântica exata pode mudar no futuro).
- ‘postfilter’ - Use o índice de similaridade vetorial para identificar os vizinhos mais próximos e, em seguida, aplique outros filtros
- ‘prefilter’ - Avalie primeiro os outros filtros e, em seguida, execute uma busca por força bruta para identificar os vizinhos.
vector_search_index_fetch_multiplier
vector_search_postfilter_multiplier
Multiplica por esse valor o número de vizinhos mais próximos obtidos do vector similarity index. Só se aplica à pós-filtragem com outros predicados ou se a configuração ‘vector_search_with_rescoring = 1’.
vector_search_with_rescoring
wait_changes_become_visible_after_commit_mode
wait_for_async_insert_timeout
wait_for_window_view_fire_signal_timeout
webassembly_udf_max_instances
webassembly_udf_max_memory
window_view_clean_interval
window_view_heartbeat_interval
write_through_distributed_cache
write_through_distributed_cache_buffer_size
