Essas configurações são geradas automaticamente a partir do código-fonte.
allow_special_bool_values_inside_variant
bool_false_representation
check_conversion_from_numbers_to_enum
- 0 — Desativado.
- 1 — Ativado.
Exemplo
CREATE TABLE tab (
val Enum('first' = 1, 'second' = 2, 'third' = 3)
) ENGINE = Memory;
INSERT INTO tab SETTINGS check_conversion_from_numbers_to_enum = 1 VALUES (4); -- retorna um erro
column_names_for_schema_inference
datetime64 para ajustar a escala de saída para [0, 3, 6],
correspondendo a ‘segundos’, ‘milissegundos’ e ‘microssegundos’
Permite escolher um parser para a representação textual de data e hora.
A configuração não se aplica a funções de data e hora.
Valores possíveis:
-
'best_effort' — Habilita parsing estendido.
O ClickHouse pode interpretar 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 interpretar 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:
Permite escolher diferentes formatos de saída para a representação textual de data e hora.
Valores possíveis:
-
simple - Formato de saída simples.
O ClickHouse exibe a data e a hora no formato YYYY-MM-DD hh:mm:ss. Por exemplo, 2019-08-20 10:18:56. O cálculo é realizado de acordo com o fuso horário do tipo de dado (se presente) ou com o fuso horário do servidor.
-
iso - Formato de saída ISO.
O ClickHouse exibe a data e a hora no formato ISO 8601 YYYY-MM-DDThh:mm:ssZ. Por exemplo, 2019-08-20T10:18:56Z. Observe que a saída é em UTC (Z significa UTC).
-
unix_timestamp - Formato de saída Unix timestamp.
O ClickHouse exibe a data e a hora no formato Unix timestamp. Por exemplo, 1566285536.
Veja também:
date_time_overflow_behavior
ignore — Ignora silenciosamente os estouros. O resultado é indefinido.throw — Lança uma exceção em caso de estouro.saturate — Satura o resultado. Se o valor for menor que o menor valor que pode ser representado pelo tipo de destino, o resultado será o menor valor representável. Se o valor for maior que o maior valor que pode ser representado pelo tipo de destino, o resultado será o maior valor representável.
Valor padrão: ignore.
Método para escrever erros na saída de texto.
Para o formato AvroConfluent: tempo limite de conexão, em segundos, do cliente HTTP do Confluent Schema Registry. Usado tanto na obtenção do esquema quanto no registro do esquema. Deve ser maior que 0 e menor que 600 (10 minutos).
Para o formato AvroConfluent: número máximo de tentativas em caso de falhas transitórias ao se comunicar com o Confluent Schema Registry (timeouts de transporte, conexão recusada, erros de DNS, HTTP 5xx/408/429). Defina como 0 para desativar as tentativas. O valor máximo permitido é 20. Erros de validação de esquema (HTTP 409, Avro JSON malformado) não geram novas tentativas.
Para o formato AvroConfluent: tempo limite de recebimento, em segundos, para o cliente HTTP do Confluent Schema Registry. Usado tanto para a busca do esquema quanto para o registro do esquema. Deve ser maior que 0 e menor que 600 (10 minutos).
Para o formato AvroConfluent: backoff inicial em milissegundos antes de repetir uma solicitação com falha para o Confluent Schema Registry. O backoff dobra a cada tentativa subsequente, limitado a 10 segundos. Deve ser maior que 0 e menor ou igual a 60000.
Para o formato AvroConfluent: tempo limite de envio, em segundos, do cliente HTTP do Confluent Schema Registry. Usado tanto na busca de esquema quanto no registro de esquema. Deve ser maior que 0 e menor que 600 (10 minutos).
Para o formato AvroConfluent: URL do Confluent Schema Registry.
O tamanho máximo permitido para Array no formato RowBinary. Isso evita a alocação de grandes quantidades de memória em caso de dados corrompidos. 0 significa que não há limite
Número máximo de caminhos permitido em um único Object no formato RowBinary para o tipo JSON. Isso evita a alocação de grandes quantidades de memória em caso de dados corrompidos. 0 significa que não há limite
O tamanho máximo permitido para String no formato RowBinary. Isso evita a alocação de uma grande quantidade de memória em caso de dados corrompidos. 0 significa que não há limite
Como fazer o mapeamento entre o Enum do ClickHouse e o Enum do CapnProto
Tamanho máximo de uma única mensagem CapnProto, em bytes. Isso protege contra dados malformados ou corrompidos que provoquem alocação excessiva de memória. O padrão é 1 GiB.
Usa o esquema CapnProto gerado automaticamente quando format_schema não está definido
Se estiver definido como true, permite strings com aspas duplas.
Se estiver definido como true, permite strings entre aspas simples.
O caractere considerado como delimitador em dados CSV. Se a configuração for definida com uma string, ela deverá ter comprimento de 1.
Representação personalizada de NULL no formato CSV
Regra de escape para campos (no formato CustomSeparated)
Delimitador entre campos (no formato CustomSeparated)
Sufixo após o conjunto de resultados (para o formato CustomSeparated)
Prefixo antes do conjunto de resultados (para o formato CustomSeparated)
Delimitador após o campo da última coluna (no formato CustomSeparated)
Delimitador antes do campo da primeira coluna (no formato CustomSeparated)
Delimitador entre linhas (para o formato CustomSeparated)
Habilita ou desabilita a exibição de secrets em consultas SHOW e SELECT para tabelas, bancos de dados,
funções de tabela e dicionários.
O usuário que quiser ver secrets também precisa ter a
display_secrets_in_show_and_select configuração do servidor
habilitada e o
displaySecretsInShowAndSelect privilégio.
Valores possíveis:
- 0 — Desabilitado.
- 1 — Habilitado.
O nome da coluna que será usada para armazenar/gravar nomes de objetos no formato JSONObjectEachRow.
O tipo da coluna deve ser String. Se o valor estiver vazio, os nomes padrão row_{i} serão usados como nomes dos objetos.
Use o Protobuf gerado automaticamente quando format_schema não estiver definido
Expressão regular (do formato Regexp)
Regra de escape do campo (para o formato Regexp)
Ignora linhas que não correspondem à expressão regular (para o formato Regexp)
Este parâmetro é útil quando você usa formatos que exigem uma definição de esquema, como Cap’n Proto ou Protobuf. O valor depende do formato.
Define o nome da mensagem necessária no esquema definido em format_schema.
Para manter a compatibilidade com o formato legado de format_schema (file_name:message_name):
- Se
format_schema_message_name não for especificado, o nome da mensagem será inferido com base na parte message_name do valor legado de format_schema.
- Se
format_schema_message_name for especificado ao usar o formato legado, será gerado um erro.
Define a origem do format_schema.
Valores possíveis:
- ‘file’ (padrão):
format_schema é o nome de um arquivo de esquema localizado no diretório format_schemas.
- ‘string’:
format_schema é o conteúdo literal do esquema.
- ‘query’:
format_schema é uma consulta para obter o esquema.
Quando format_schema_source é definido como ‘query’, as seguintes condições se aplicam:
- A consulta deve retornar exatamente um valor: uma única linha com uma única coluna do tipo string.
- O resultado da consulta é tratado como o conteúdo do esquema.
- Esse resultado é armazenado em cache localmente no diretório
format_schemas.
- Você pode limpar o cache local usando o comando:
SYSTEM DROP FORMAT SCHEMA CACHE FOR Files.
- Depois de serem armazenadas em cache, consultas idênticas não são executadas novamente para buscar o esquema até que o cache seja explicitamente limpo
- Além dos arquivos de cache local, mensagens Protobuf também são armazenadas em cache na memória. Mesmo após limpar os arquivos de cache local, o cache em memória deve ser limpo usando
SYSTEM DROP FORMAT SCHEMA CACHE [FOR Protobuf] para atualizar completamente o esquema.
- Execute a consulta
SYSTEM DROP FORMAT SCHEMA CACHE para limpar de uma só vez o cache dos arquivos locais e das mensagens Protobuf.
Caminho para o arquivo que contém a string de formato do conjunto de resultados (para o formato Template)
String de formato do conjunto de resultados (para o formato Template)
Caminho para o arquivo que contém a string de formato das linhas (para o formato Template)
String de formato para linhas (para o formato Template)
Delimitador entre linhas (no formato Template)
Representação personalizada para NULL no formato TSV
Define o número máximo de erros aceitáveis durante a leitura de formatos de texto (CSV, TSV etc.).
O valor padrão é 0.
Sempre use em conjunto com input_format_allow_errors_ratio.
Se ocorrer um erro durante a leitura de linhas, mas o contador de erros ainda estiver abaixo de input_format_allow_errors_num, o ClickHouse ignora a linha e passa para a próxima.
Se input_format_allow_errors_num e input_format_allow_errors_ratio forem excedidos, o ClickHouse gera uma exceção.
Define a porcentagem máxima de erros permitida ao ler formatos de texto (CSV, TSV etc.).
A porcentagem de erros é definida como um número de ponto flutuante entre 0 e 1.
O valor padrão é 0.
Sempre use esta configuração em conjunto com input_format_allow_errors_num.
Se ocorrer um erro durante a leitura das linhas, mas o contador de erros ainda for menor que input_format_allow_errors_ratio, o ClickHouse ignora a linha e passa para a próxima.
Se input_format_allow_errors_num e input_format_allow_errors_ratio forem excedidos, o ClickHouse lança uma exceção.
Permite seeks (ou leituras por intervalo) ao ler os formatos de entrada ORC, Parquet e Arrow.
Quando habilitada e a origem oferece esse suporte (por exemplo, arquivo local, S3 ou HTTP com suporte a intervalos e tamanho conhecido),
o ClickHouse pode ler apenas os intervalos de bytes necessários e usar menos memória.
Quando desabilitada, ou quando a origem não oferece suporte a seeks (por exemplo, sem tamanho de arquivo ou com stream que não permite seek),
alguns leitores podem recorrer ao carregamento do arquivo inteiro na memória.
Habilitado por padrão.
Permitir colunas ausentes ao ler formatos de entrada do Arrow
Ignora maiúsculas e minúsculas ao fazer a correspondência entre colunas Arrow e colunas CH.
Ignora colunas com tipos não suportados durante a inferência de esquema do formato Arrow
Para o formato Avro/AvroConfluent: quando um campo não for encontrado no esquema, use o valor padrão em vez de retornar erro
Para o formato Avro/AvroConfluent: insere o valor padrão em caso de NULL em colunas não Nullable
Ler tipos de dados em formato binário em vez de nomes de tipos no formato de entrada RowBinaryWithNamesAndTypes
Número máximo de nós de tipo ao decodificar tipos binários (não a profundidade, mas a contagem total). Map(String, UInt32) = 3 nós. Protege contra entradas maliciosas. 0 = ilimitado.
Lê valores do tipo de dado JSON como valores JSON em String no formato de entrada RowBinary.
Ignora campos com tipos não suportados durante a inferência de esquema do formato BSON.
Ignora colunas com tipos não suportados durante a inferência de esquema para o formato CapnProto
Define o modo de correspondência dos nomes de colunas ao fazer a ingestão de dados em vários formatos (incluindo, entre outros, JSONEachRow, CSVWithNames, JSONColumns, BSONEachRow, RowBinaryWithNames).
Modos compatíveis:
- match_case: faz a correspondência considerando maiúsculas e minúsculas
- ignore_case: faz a correspondência sem considerar maiúsculas e minúsculas
- auto: primeiro tenta fazer a correspondência considerando maiúsculas e minúsculas; se falhar, tenta sem considerar maiúsculas e minúsculas.
Quando esta opção está habilitada, se a conexão for encerrada inesperadamente, os dados restantes no buffer serão analisados e processados em vez de serem tratados como erro
Habilitar esta opção desativa a análise paralela e impossibilita a desduplicação
INSERT, substitua os valores omitidos das colunas de entrada pelos valores padrão das respectivas colunas. Esta opção se aplica aos formatos JSONEachRow (e outros formatos JSON), CSV, TabSeparated, TSKV, Parquet, Arrow, Avro, ORC, Native, além de formatos com os sufixos WithNames/WithNamesAndTypes.
Quando esta opção está habilitada, metadados estendidos da tabela são enviados do servidor para o cliente. Isso consome recursos computacionais adicionais no servidor e pode reduzir o desempenho.
- 0 — Desabilitado.
- 1 — Habilitado.
Força a inicialização dos campos omitidos com valores NULL
Controla o que acontece quando um tipo de geometria GeoJSON válido que não pode ser representado no tipo Geometry do ClickHouse (como GeometryCollection ou MultiPoint) precisa ser armazenado na coluna geometry durante a leitura da entrada GeoJSON.
Valores possíveis:
'throw' (padrão) — gera uma exceção.'null' — insere um valor NULL na coluna geometry e continua o parsing.
Isso se aplica somente quando a coluna geometry é materializada. Quando ela não é uma coluna de saída solicitada, essa geometria é validada quanto à sua estrutura, mas não aciona esse tratamento.
input_format_hive_text_allow_variable_number_of_columns
input_format_hive_text_collection_items_delimiter
input_format_hive_text_fields_delimiter
input_format_hive_text_map_keys_delimiter
- 0 — Desabilitado.
- 1 — Habilitado.
Veja também:
A desserialização de IPv4 usará valores padrão em vez de gerar uma exceção em caso de erro de conversão.
Desativado por padrão.
A desserialização de IPV6 usará valores padrão em vez de gerar uma exceção em caso de erro de conversão.
Desabilitado por padrão.
Permite um número variável de colunas por linha nos formatos de entrada JSONCompact/JSONCompactEachRow.
Ignora colunas extras em linhas com mais colunas do que o esperado e trata as colunas ausentes como valores padrão.
Desativado por padrão.
Insere valores padrão para elementos ausentes no objeto JSON ao processar uma tupla nomeada.
Essa configuração só funciona quando a configuração input_format_json_named_tuples_as_objects está habilitada.
Habilitado por padrão.
Quando habilitada, substitui campos de entrada vazios em JSON por valores padrão. Para expressões de valor padrão complexas, input_format_defaults_for_omitted_fields também deve estar habilitada.
Possíveis valores:
- 0 — Desabilitado.
- 1 — Habilitado.
Ignora chaves desconhecidas no objeto JSON de tuplas nomeadas.
Ativado por padrão.
Ignora campos desnecessários e não faz o parsing deles. Ao habilitar esta opção, exceções podem não ser geradas para strings JSON com formato inválido ou com campos duplicados
Se estiver habilitada, durante a inferência de esquema, o ClickHouse usará o tipo Array(Dynamic) para arrays JSON com valores de diferentes tipos de dados.
Exemplo:
SET input_format_json_infer_array_of_dynamic_from_array_of_different_types=1;
DESC format(JSONEachRow, '{"a" : [42, "hello", [1, 2, 3]]}');
┌─name─┬─type───────────┐
│ a │ Array(Dynamic) │
└──────┴────────────────┘
SET input_format_json_infer_array_of_dynamic_from_array_of_different_types=0;
DESC format(JSONEachRow, '{"a" : [42, "hello", [1, 2, 3]]}');
┌─name─┬─type─────────────────────────────────────────────────────────────┐
│ a │ Tuple(Nullable(Int64), Nullable(String), Array(Nullable(Int64))) │
└──────┴──────────────────────────────────────────────────────────────────┘
Null/{}/[] na amostra de dados durante a inferência de esquema.
Em formatos JSON, qualquer valor pode ser lido como String, e isso permite evitar erros como Cannot determine type for column 'column_name' by first 25000 rows of data, most likely this column contains only Nulls or empty Arrays/Maps durante a inferência de esquema
ao usar o tipo String para chaves com tipos desconhecidos.
Exemplo:
SET input_format_json_infer_incomplete_types_as_strings = 1, input_format_json_try_infer_named_tuples_from_objects = 1;
DESCRIBE format(JSONEachRow, '{"obj" : {"a" : [1,2,3], "b" : "hello", "c" : null, "d" : {}, "e" : []}}');
SELECT * FROM format(JSONEachRow, '{"obj" : {"a" : [1,2,3], "b" : "hello", "c" : null, "d" : {}, "e" : []}}');
┌─name─┬─type───────────────────────────────────────────────────────────────────────────────────────────────────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ obj │ Tuple(a Array(Nullable(Int64)), b Nullable(String), c Nullable(String), d Nullable(String), e Array(Nullable(String))) │ │ │ │ │ │
└──────┴────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
┌─obj────────────────────────────┐
│ ([1,2,3],'hello',NULL,'{}',[]) │
└────────────────────────────────┘
SET input_format_json_read_arrays_as_strings = 1;
SELECT arr, toTypeName(arr), JSONExtractArrayRaw(arr)[3] from format(JSONEachRow, 'arr String', '{"arr" : [1, "Hello", [1,2,3]]}');
┌─arr───────────────────┬─toTypeName(arr)─┬─arrayElement(JSONExtractArrayRaw(arr), 3)─┐
│ [1, "Hello", [1,2,3]] │ String │ [1,2,3] │
└───────────────────────┴─────────────────┴───────────────────────────────────────────┘
SET input_format_json_read_objects_as_strings = 1;
CREATE TABLE test (id UInt64, obj String, date Date) ENGINE=Memory();
INSERT INTO test FORMAT JSONEachRow {"id" : 1, "obj" : {"a" : 1, "b" : "Hello"}, "date" : "2020-01-01"};
SELECT * FROM test;
┌─id─┬─obj──────────────────────┬───────date─┐
│ 1 │ {"a" : 1, "b" : "Hello"} │ 2020-01-01 │
└────┴──────────────────────────┴────────────┘
SET input_format_json_try_infer_named_tuples_from_objects = 1;
DESC format(JSONEachRow, '{"obj" : {"a" : 42, "b" : "Hello"}}, {"obj" : {"a" : 43, "c" : [1, 2, 3]}}, {"obj" : {"d" : {"e" : 42}}}')
┌─name─┬─type───────────────────────────────────────────────────────────────────────────────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ obj │ Tuple(a Nullable(Int64), b Nullable(String), c Array(Nullable(Int64)), d Tuple(e Nullable(Int64))) │ │ │ │ │ │
└──────┴────────────────────────────────────────────────────────────────────────────────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
Esta opção só funciona se input_format_connection_handling estiver habilitado. Definir um valor também desabilita o parsing paralelo e torna a desduplicação impossível.
Para inserções em streaming, você também deve definir min_insert_block_size_rows=0 e min_insert_block_size_bytes=0. Caso contrário, os blocos processados ainda podem ser acumulados na memória pela etapa de squashing de blocos até que esses limites sejam atingidos, impedindo inserções em tempo hábil.
clickhouse-client --query 'CREATE TABLE wikipedia_edits (data JSON)'
curl -sS --globoff -H 'Accept: application/json' --no-buffer \
'https://stream.wikimedia.org/v2/stream/recentchange' \
| clickhouse-client \
--query 'INSERT INTO wikipedia_edits FORMAT JSONAsObject' \
--input_format_max_block_wait_ms 1000 \
--input_format_connection_handling 1 \
--min_insert_block_size_rows 0 \
--min_insert_block_size_bytes 0
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 à maioria dos formatos de entrada.
Para expressões padrão complexas, input_format_defaults_for_omitted_fields também deve estar ativado.
Valores possíveis:
- 0 — Inserir
NULL em uma coluna não nullable causa uma exceção.
- 1 — Os campos
NULL são inicializados com os valores padrão da coluna.
Permitir colunas ausentes na leitura de formatos de entrada ORC
Ignora diferenças entre maiúsculas e minúsculas ao corresponder colunas ORC com colunas do CH.
Trata colunas codificadas por dicionário ORC como colunas LowCardinality ao ler arquivos ORC.
Ao ler arquivos ORC, ignore stripes ou grupos de linhas inteiros com base nas expressões WHERE/PREWHERE, nas estatísticas mín./máx. ou no filtro de Bloom nos metadados do ORC.
O nome do fuso horário do leitor de linhas ORC; por padrão, o fuso horário do leitor de linhas ORC é GMT.
Tamanho do batch ao ler stripes de ORC.
Ignora colunas com tipos não suportados durante a inferência de esquema do formato ORC
Usa uma implementação mais rápida do decodificador ORC.
Ativa ou desativa o parsing paralelo de formatos de dados com preservação da ordem. Compatível apenas com os formatos TabSeparated (TSV), TSKV, CSV e JSONEachRow.
Valores possíveis:
- 1 — Habilitado.
- 0 — Desabilitado.
Use o parser de colunas geo para converter Array(UInt8) em tipos Point/Linestring/Polygon/MultiLineString/MultiPolygon
Permite colunas ausentes ao ler formatos de entrada Parquet
Ao ler arquivos Parquet, pule grupos de linhas inteiros com base nas expressões WHERE e no filtro de Bloom presente nos metadados do Parquet.
Ignora diferenças entre maiúsculas e minúsculas ao corresponder colunas do Parquet com colunas do CH.
Ao ler arquivos Parquet, fazer o parsing de colunas JSON como colunas JSON do ClickHouse.
Habilita o pré-carregamento de grupos de linhas durante o parsing de Parquet. No momento, apenas o parsing em thread única pode fazer pré-carregamento.
Ao ler arquivos Parquet, ignore grupos de linhas inteiros com base nas expressões WHERE/PREWHERE e nas estatísticas mín./máx. dos metadados do Parquet.
Quantidade mínima de bytes necessária para que a leitura local (arquivo) realize seek, em vez de ler com ignore, no formato de entrada Parquet
Determina o tipo de dado usado pela inferência de esquema para timestamps do Parquet com isAdjustedToUTC=false. Se true: DateTime64(…, ‘UTC’); se false: DateTime64(…). Nenhum dos comportamentos está totalmente correto, pois o ClickHouse não tem um tipo de dado para horário local exibido no relógio. Contraintuitivamente, ‘true’ provavelmente é a opção menos incorreta, porque formatar o timestamp em ‘UTC’ como String produzirá a representação do horário local correto.
Tamanho máximo do bloco para o leitor de Parquet.
Limite aproximado de memória para o leitor de Parquet v3. Limita quantos grupos de linhas ou colunas podem ser lidos em paralelo. Ao ler vários arquivos em uma consulta, o limite se aplica ao uso total de memória desses arquivos.
Programa prefetches de forma mais agressiva se o uso de memória estiver abaixo do limite. Pode ser útil, por exemplo, se houver muitos filtros de Bloom pequenos para ler pela rede.
input_format_parquet_page_filter_push_down
ORDER BY _row_number.
Ignora colunas com tipos não suportados durante a inferência de esquema do formato Parquet
Pequeno ajuste em como as páginas são lidas de arquivo Parquet quando não é usada filtragem de páginas.
Verifica os checksums das páginas ao ler arquivos Parquet.
Habilita wrappers do Google para colunas regulares não aninhadas, por exemplo, google.protobuf.StringValue ‘str’ para a coluna String ‘str’. Para colunas Nullable, wrappers vazios são reconhecidos como valores padrão, e wrappers ausentes como nulls
Indica qual campo de oneof do Protobuf foi encontrado, definindo o valor do enum em uma coluna especial
Ignora campos com tipos não suportados na inferência de esquema do formato Protobuf
Caminho do arquivo usado para registrar erros ao ler formatos de texto (CSV, TSV).
Ativa ou desativa o descarte de dados extras durante a inserção.
Ao gravar dados, o ClickHouse lança uma exceção se os dados de entrada contiverem colunas que não existem na tabela de destino. Se essa opção estiver ativada, o ClickHouse não insere os dados extras nem lança uma exceção.
Formatos suportados:
Valores possíveis:
- 0 — Desativado.
- 1 — Ativado.
Se estiver habilitado, o ClickHouse tentará inferir o tipo Date a partir de campos do tipo string na inferência de esquema de formatos de texto. Se todos os campos de uma coluna nos dados de entrada forem interpretados com sucesso como datas, o tipo resultante será Date; se pelo menos um campo não for interpretado como data, o tipo resultante será String.
Habilitado por padrão.
Se estiver habilitado, o ClickHouse tentará inferir o tipo DateTime64 de campos do tipo string na inferência de esquema para formatos de texto. Se todos os campos de uma coluna nos dados de entrada forem analisados com sucesso como datetimes, o tipo resultante será DateTime64; se pelo menos um campo não for analisado como datetime, o tipo resultante será String.
Habilitado por padrão.
Quando input_format_try_infer_datetimes estiver habilitado, infira apenas DateTime64, e não tipos DateTime
Tenta inferir números de ponto flutuante em notação exponencial durante a inferência de esquema em formatos de texto (exceto JSON, no qual números com expoente são sempre inferidos)
Se estiver habilitado, o ClickHouse tentará inferir inteiros em vez de números de ponto flutuante na inferência de esquema de formatos de texto. Se todos os números na coluna dos dados de entrada forem inteiros, o tipo resultante será Int64; se pelo menos um número for de ponto flutuante, o tipo resultante será Float64.
Habilitado por padrão.
Quando habilitado, o ClickHouse tentará inferir o tipo Variant na inferência de esquema de formatos de texto quando houver mais de um tipo possível para elementos de colunas/arrays.
Valores possíveis:
- 0 — Desabilitado.
- 1 — Habilitado.
Ignora colunas extras na entrada em TSV (se o arquivo tiver mais colunas do que o esperado) e trata campos ausentes na entrada em TSV como valores padrão
Se estiver definido como true, a função file lerá o formato TSV com \r\n em vez de \n.
Detecta automaticamente o cabeçalho com nomes e tipos no formato TSV
Considera campos vazios na entrada TSV como valores padrão.
Trata os valores enum inseridos em formatos TSV como índices de enum.
Ignora a quantidade especificada de linhas no início dos dados no formato TSV
Ignora linhas vazias finais no formato TSV
Utiliza alguns ajustes e heurísticas para inferir o esquema no formato TSV
Para o formato Values: ao fazer o parsing e interpretar expressões usando um template, verifique o tipo real do literal para evitar possíveis problemas de overflow e precisão.
Para o formato Values: se o campo não puder ser analisado pelo parser de streaming, executa o parser SQL, infere o template da expressão SQL, tenta analisar todas as linhas usando o template e, em seguida, interpreta a expressão para todas as linhas.
Para o formato Values: se o campo não puder ser analisado pelo parser de streaming, execute o parser SQL e tente interpretá-lo como uma expressão SQL.
Ativa ou desativa a verificação da ordem das colunas ao inserir dados.
Para melhorar o desempenho das inserções, recomendamos desativar essa verificação se você tiver certeza de que a ordem das colunas nos dados de entrada é a mesma da tabela de destino.
Formatos suportados:
Valores possíveis:
- 0 — Desativado.
- 1 — Ativado.
Controla se o parser de formato deve verificar se os tipos de dados na entrada correspondem aos tipos de dados da tabela de destino.
Formatos compatíveis:
Valores possíveis:
- 0 — Desabilitado.
- 1 — Habilitado.
insert_distributed_one_random_shard
Distributed com mais de um shard, o servidor ClickHouse rejeita qualquer solicitação de inserção se não houver chave de distribuição. Quando insert_distributed_one_random_shard = 1, as inserções são permitidas, e os dados são encaminhados aleatoriamente entre todos os shards.
Valores possíveis:
- 0 — A inserção é rejeitada se houver vários shards e nenhuma chave de distribuição for fornecida.
- 1 — A inserção é feita aleatoriamente entre todos os shards disponíveis quando nenhuma chave de distribuição é fornecida.
Permite escolher diferentes formatos de saída para a representação textual dos tipos interval.
Valores possíveis:
-
kusto - Formato de saída no estilo KQL.
O ClickHouse gera intervalos no formato KQL. Por exemplo, toIntervalDay(2) seria formatado como 2.00:00:00. Observe que, para tipos interval de duração variável (ou seja, IntervalMonth e IntervalYear), o número médio de segundos por interval é levado em consideração.
-
numeric - Formato de saída numérico.
O ClickHouse gera intervalos usando sua representação numérica subjacente. Por exemplo, toIntervalDay(2) seria formatado como 2.
Veja também:
into_outfile_create_parent_directories
json_type_escape_dots_in_keys
max_dynamic_subcolumns_in_json_type_parsing
1. em vez de 1.
Desativado por padrão.
Método de compressão para o formato de saída Arrow. Codecs compatíveis: lz4_frame, zstd, none (sem compressão)
Grave valores do tipo Date como números simples de 16 bits (lidos de volta como UInt16), em vez de convertê-los para o tipo Arrow DATE32 de 32 bits (lido de volta como Date32).
Usa o tipo Arrow FIXED_SIZE_BINARY em vez de Binary para colunas FixedString.
Habilita a saída do tipo LowCardinality como tipo Dicionário do Arrow
Use o tipo Arrow String em vez de Binary para colunas String
Produz, como dados binários brutos, tipos que não têm conversão. Se for false - esses tipos gerarão a exceção UNKNOWN_TYPE.
Sempre use inteiros de 64 bits para índices de dicionário no formato Arrow
Usar inteiros com sinal para índices de dicionário no formato Arrow
Codec de compressão usado na saída. Valores possíveis: ‘null’, ‘deflate’, ‘snappy’, ‘zstd’.
Para o formato de saída AvroConfluent: o nome do subject sob o qual o esquema é registrado no Confluent Schema Registry. Obrigatório ao gravar a saída AvroConfluent.
Número máximo de linhas em um arquivo (se permitido pelo armazenamento)
Para o formato Avro: expressão regular das colunas String a serem selecionadas como string do AVRO.
Intervalo de sincronização, em bytes.
Grava tipos de dados em formato binário em vez de nomes de tipos no formato de saída RowBinaryWithNamesAndTypes
Grava valores do tipo de dado JSON como strings JSON String no formato de saída RowBinary.
Usa o tipo String do BSON em vez de Binary para colunas String.
Nível de compressão padrão se a saída da consulta for comprimida. A configuração é aplicada quando a consulta SELECT usa INTO OUTFILE ou ao gravar em funções de tabela file, url, hdfs, s3 ou azureBlobStorage.
Valores possíveis: de 1 a 22
Pode ser usado quando o método de compressão de saída é zstd. Se for maior que 0, essa configuração define explicitamente o tamanho da janela de compressão (potência de 2) e habilita o modo de longo alcance para a compressão zstd. Isso pode ajudar a obter uma taxa de compressão melhor.
Valores possíveis: números não negativos. Observe que, se o valor for muito pequeno ou muito grande, zstdlib lançará uma exceção. Os valores típicos variam de 20 (tamanho da janela = 1MB) a 30 (tamanho da janela = 1GB).
Se estiver definido como true, o fim de linha no formato CSV será \r\n em vez de \n.
Se definido como true, as Tuples no formato CSV são serializadas como colunas separadas (isto é, o aninhamento na tupla é perdido)
Exibe zeros à direita ao imprimir valores Decimal. Ex.: 1.230000 em vez de 1.23.
Desativado por padrão.
Quando diferente de zero, formata a saída de números de ponto flutuante (Float32, Float64, BFloat16) com no máximo esse número de dígitos após o separador decimal (os zeros à direita são removidos).
Quando 0 (o padrão), usa a menor representação que preserva o round-trip.
Valores grandes demais para notação fixa e valores cuja magnitude é tão pequena que o arredondamento para a precisão solicitada faria perder todos os dígitos significativos (a mantissa se tornaria ±0) são emitidos em notação científica. Nesses casos de fallback, a mantissa pode ter mais dígitos fracionários do que o número solicitado.
Intervalo válido: 0 a 100.
A altura, em pixels, da imagem de saída em formatos de saída de imagem, como PNG.
Valor padrão: 1024.
Para formatos de saída de imagem, como PNG, envie a imagem diretamente para o terminal usando um protocolo de imagem em linha, em vez de gravar os bytes brutos da imagem.
Valores possíveis:
- “ (vazio) — grava os bytes brutos da imagem (padrão).
iterm — usa o protocolo de imagem em linha do iTerm2.kitty — usa o protocolo gráfico do Kitty.sixel — usa o protocolo Sixel.auto — se a saída for um terminal, detecta as capacidades dele e usa iterm, kitty ou sixel (nesta ordem); caso contrário, grava os bytes brutos da imagem.
Valor padrão: “ (vazio).
A largura, em pixels, da imagem de saída para formatos de saída de imagem, como PNG.
Valor padrão: 1024.
Permite gerar todas as linhas como um array JSON no formato JSONEachRow.
Valores possíveis:
- 1 — o ClickHouse gera todas as linhas como um array, com cada linha no formato
JSONEachRow.
- 0 — o ClickHouse gera cada linha separadamente no formato
JSONEachRow.
Exemplo de uma consulta com a configuração ativada
Consulta:
SET output_format_json_array_of_rows = 1;
SELECT number FROM numbers(3) FORMAT JSONEachRow;
[
{"number":"0"},
{"number":"1"},
{"number":"2"}
]
SET output_format_json_array_of_rows = 0;
SELECT number FROM numbers(3) FORMAT JSONEachRow;
{"number":"0"}
{"number":"1"}
{"number":"2"}
data ao usar o formato de saída JSON.
Por exemplo, em vez de gerar:
"data":
[
{
"tuple": {"a":1,"b":2,"c":3},
"array": [1,2,3],
"map": {"a":1,"b":2,"c":3}
}
],
"data":
[
{
"tuple": {
"a": 1,
"b": 2,
"c": 3
},
"array": [
1,
2,
3
],
"map": {
"a": 1,
"b": 2,
"c": 3
}
}
],
UInt64 ou Int128) quando são gerados no formato JSON.
Por padrão, esses inteiros são colocados entre aspas. Esse comportamento é compatível com a maioria das implementações de JavaScript.
Valores possíveis:
- 0 — Os inteiros são gerados sem aspas.
- 1 — Os inteiros são colocados entre aspas.
Controla se valores decimais são colocados entre aspas nos formatos de saída JSON.
Desativado por padrão.
Habilita a saída de +nan, -nan, +inf e -inf no formato de saída JSON.
Valores possíveis:
- 0 — Desabilitado.
- 1 — Habilitado.
Exemplo
Considere a seguinte tabela account_orders:
┌─id─┬─name───┬─duration─┬─period─┬─area─┐
│ 1 │ Andrew │ 20 │ 0 │ 400 │
│ 2 │ John │ 40 │ 0 │ 0 │
│ 3 │ Bob │ 15 │ 0 │ -100 │
└────┴────────┴──────────┴────────┴──────┘
output_format_json_quote_denormals = 0, a consulta retorna valores null na saída:
SELECT area/period FROM account_orders FORMAT JSON;
{
"meta":
[
{
"name": "divide(area, period)",
"type": "Float64"
}
],
"data":
[
{
"divide(area, period)": null
},
{
"divide(area, period)": null
},
{
"divide(area, period)": null
}
],
"rows": 3,
"statistics":
{
"elapsed": 0.003648093,
"rows_read": 3,
"bytes_read": 24
}
}
output_format_json_quote_denormals = 1, a consulta retorna:
{
"meta":
[
{
"name": "divide(area, period)",
"type": "Float64"
}
],
"data":
[
{
"divide(area, period)": "inf"
},
{
"divide(area, period)": "-nan"
},
{
"divide(area, period)": "-inf"
}
],
"rows": 3,
"statistics":
{
"elapsed": 0.000070241,
"rows_read": 3,
"bytes_read": 24
}
}
! " # $ % & ' ( ) * + , - . / : ; < = > ? @ [ \ ] ^ _ ` { | } ~
- 0 — Desativado.
- 1 — Ativado.
A forma como o UUID é exibido no formato MsgPack.
Escreve tipos de dados em formato binário em vez de nomes de tipos no formato de saída Native
Grava os dados das colunas JSON e Dynamic em formato achatado (todos os tipos/caminhos como subcolunas separadas).
Grava os dados da coluna JSON como uma coluna String contendo strings JSON, em vez da serialização JSON nativa padrão.
Tamanho do bloco de compressão, em bytes, para o formato de saída ORC.
Método de compressão para o formato de saída ORC. Codecs compatíveis: lz4, snappy, zlib, zstd, none (sem compressão)
Para uma coluna String no formato de saída ORC, se o número de valores distintos for maior que esta fração do número total de linhas não nulas, desative a codificação por dicionário. Caso contrário, a codificação por dicionário fica ativada
Passo alvo do índice de linhas no formato de saída ORC
Usa o tipo String do ORC em vez de Binary para colunas String
O nome do fuso horário do gravador ORC; o fuso horário padrão do gravador ORC é GMT.
Ativa ou desativa a formatação paralela para formatos de dados. Compatível apenas com os formatos TSV, TSKV, CSV e JSONEachRow.
Valores possíveis:
- 1 — Habilitado.
- 0 — Desabilitado.
Verifique o tamanho da página a cada esta quantidade de linhas. Considere reduzir esse valor se você tiver colunas com tamanho médio dos valores acima de alguns KBs.
Número aproximado de bits a serem usados para cada valor distinto em filtros de Bloom do Parquet. Taxas estimadas de falso positivo:
- 6 bits - 10%
- 10.5 bits - 1%
- 16.9 bits - 0.1%
- 26.4 bits - 0.01%
- 41 bits - 0.001%
Em que ponto do arquivo Parquet os filtros de Bloom devem ser colocados. Os filtros de Bloom serão gravados em grupos de aproximadamente esse tamanho. Em particular:
- se for 0, os filtros de Bloom de cada grupo de linhas serão gravados imediatamente após o grupo de linhas,
- se for maior que o tamanho total de todos os filtros de Bloom, os filtros de Bloom de todos os grupos de linhas serão acumulados na memória e depois gravados juntos perto do fim do arquivo,
- caso contrário, os filtros de Bloom serão acumulados na memória e gravados sempre que o tamanho total deles ultrapassar esse valor.
Método de compressão do formato de saída Parquet. Codecs compatíveis: snappy, lz4, brotli, zstd, gzip, none (não comprimido)
output_format_parquet_data_page_size
output_format_parquet_write_page_index
SELECT *, toTypeName(*) FROM (SELECT * FROM system.numbers LIMIT 1000);
┌─number─┬─toTypeName(number)─┐
1. │ 0 │ UInt64 │
2. │ 1 │ UInt64 │
3. │ 2 │ UInt64 │
...
999. │ 998 │ UInt64 │
1000. │ 999 │ UInt64 │
└─number─┴─toTypeName(number)─┘
output_format_pretty_fallback_to_vertical_max_rows_per_chunk e output_format_pretty_fallback_to_vertical_min_table_width para ajustar esse comportamento em detalhes.
O fallback para o formato Vertical (consulte output_format_pretty_fallback_to_vertical) será ativado somente se o número de registros em um fragmento não exceder o valor especificado.
O fallback para o formato Vertical (consulte output_format_pretty_fallback_to_vertical) só será ativado se o número de colunas for maior que o valor especificado.
O fallback para o formato Vertical (consulte output_format_pretty_fallback_to_vertical) será ativado apenas se a soma dos comprimentos das colunas da tabela for, no mínimo, o valor especificado, ou se pelo menos um valor contiver um caractere de quebra de linha.
Se os dados exibidos nos formatos Pretty vierem em vários fragmentos, mesmo com algum atraso, mas o próximo fragmento tiver as mesmas larguras de coluna do anterior, use sequências de escape ANSI para retornar à linha anterior e sobrescrever o rodapé do fragmento anterior, continuando-o com os dados do novo fragmento. Isso torna o resultado visualmente mais agradável.
0 - desabilitado, 1 - habilitado, ‘auto’ - habilitado se estiver em um terminal.
Conjunto de caracteres usado para imprimir as bordas da grade. Conjuntos de caracteres disponíveis: ASCII, UTF-8 (padrão).
No modo interativo, o clickhouse-client muda automaticamente para ASCII quando o terminal não oferece suporte a UTF-8 (conforme determinado pelas variáveis de ambiente LC_ALL, LC_CTYPE e LANG), a menos que essa configuração seja especificada explicitamente.
Se estiver habilitado e a saída for um terminal, destaque com sublinhado cada dígito correspondente às casas de milhar, milhão etc.
Se estiver habilitada e a saída for um terminal, os espaços à direita serão destacados em cinza e sublinhados.
Se o nome da coluna for muito longo, ele será truncado para esse comprimento.
A coluna será truncada se exceder output_format_pretty_max_column_name_width_cut_to mais output_format_pretty_max_column_name_width_min_chars_to_cut.
Número mínimo de caracteres a cortar se o nome da coluna for muito longo.
A coluna será cortada se tiver comprimento maior que output_format_pretty_max_column_name_width_cut_to mais output_format_pretty_max_column_name_width_min_chars_to_cut.
Largura máxima de preenchimento para todos os valores de uma coluna nos formatos Pretty.
Limite de linhas para os formatos Pretty.
Largura máxima do valor a ser exibido nos formatos Pretty. Se for maior, ele será truncado.
O valor 0 significa: nunca truncar.
Corte os valores (consulte a configuração output_format_pretty_max_value_width) somente quando não se tratar de um único valor em um bloco. Caso contrário, exiba-o por completo, o que é útil para a consulta SHOW CREATE TABLE.
Se estiver habilitado, os formatos Pretty renderizarão campos de várias linhas dentro da célula da tabela, de modo que o contorno da tabela seja preservado.
Caso contrário, eles serão renderizados como estão, o que pode deformar a tabela (uma vantagem de mantê-lo desativado é que será mais fácil copiar e colar valores com várias linhas).
Controla se tuplas nomeadas no formato Pretty são exibidas como objetos JSON com formatação legível.
Adiciona números de linha antes de cada linha no formato de saída Pretty
Exibe um indicador numérico legível no lado direito da tabela se o bloco consistir em um único número que exceder este valor (exceto 0)
Aguarde o próximo bloco por até o número especificado de milissegundos e consolide-o com o anterior antes de gravar.
Isso evita a saída frequente de blocos muito pequenos, mas ainda permite exibir os dados de forma contínua.
Emite o bloco pendente em formatos Pretty se tiver decorrido mais do que o número especificado de milissegundos desde a saída anterior.
Se habilitado, o preenchimento nos formatos de saída Pretty é renderizado com U+00A0 em vez de um espaço ASCII.
A saída permanece visualmente idêntica em fonte monoespaçada, mas o preenchimento é preservado em ferramentas que comprimem ou removem sequências de espaços comuns.
Só tem efeito quando output_format_pretty_grid_charset é UTF-8.
Ao serializar colunas Nullable com wrappers do Google, serializa os valores padrão como wrappers vazios. Se estiver desativado, os valores padrão e NULL não serão serializados
O caminho para o arquivo em que o esquema gerado automaticamente será salvo nos formatos Cap’n Proto ou Protobuf.
Inclui os nomes das colunas na consulta INSERT
O número máximo de linhas em uma única instrução INSERT.
Coloca os nomes das colunas entre caracteres ’`‘
O nome da tabela na consulta INSERT gerada na saída
Usar a instrução REPLACE em vez de INSERT
Remove bytes nulos no final de valores FixedString em formatos de saída de texto. Por exemplo, toFixedString('John', 8) é exibido como John em vez de John\0\0\0\0.
Se estiver definido como true, a quebra de linha no formato TSV será \r\n em vez de \n.
Se true, escapa ’ como ”, caso contrário, usa aspas com \‘
Grava estatísticas sobre linhas lidas, bytes e tempo decorrido em formatos de saída apropriados.
Ativado por padrão
Prefira um algoritmo de parsing de números de ponto flutuante mais preciso (porém mais lento)
A lista de nomes e tipos de colunas a ser usada como dica na inferência de esquema para formatos sem esquema.
Exemplo:
Consulta:
desc format(JSONEachRow, '{"x" : 1, "y" : "String", "z" : "0.0.0.0" }') settings schema_inference_hints='x UInt8, z IPv4';
x UInt8
y Nullable(String)
z IPv4
Se schema_inference_hints não estiver formatado corretamente, ou se houver um erro de digitação, um tipo de dado incorreto etc… todo o schema_inference_hints será ignorado.
schema_inference_make_columns_nullable
Nullable na inferência de esquema.
Valores possíveis:
- 0 - o tipo inferido nunca será
Nullable (use input_format_null_as_default para controlar o que fazer com valores NULL neste caso),
- 1 - todos os tipos inferidos serão
Nullable,
- 2 ou
auto - o tipo inferido será Nullable somente se a coluna contiver NULL em uma amostra analisada durante a inferência de esquema ou se os metadados do arquivo contiverem informações sobre a nulabilidade da coluna,
- 3 - a nulabilidade do tipo inferido corresponderá aos metadados do arquivo, se o formato os fornecer (por exemplo, Parquet); caso contrário, será sempre
Nullable (por exemplo, CSV).
schema_inference_make_json_columns_nullable
Nullable na inferência de esquema.
Se esta configuração estiver habilitada junto com schema_inference_make_columns_nullable, o tipo JSON inferido será Nullable.
Modo de inferência de esquema. ‘default’ - pressupõe que todos os arquivos têm o mesmo esquema e que o esquema pode ser inferido a partir de qualquer arquivo; ‘union’ - os arquivos podem ter esquemas diferentes, e o esquema resultante deve ser a união dos esquemas de todos os arquivos
show_create_query_identifier_quoting_rule
show_create_query_identifier_quoting_style
type_json_allow_duplicated_key_with_literal_and_nested_object
{"a" : 42, "a" : {"b" : 42}}, em que uma chave está duplicada, mas uma das ocorrências é um objeto aninhado.
type_json_skip_duplicated_paths
type_json_skip_invalid_typed_paths
- 0 — Desativado (gerar erro em caso de incompatibilidade de tipo).
- 1 — Ativado (ignorar campo em caso de incompatibilidade de tipo).
type_json_use_partial_match_to_skip_paths_by_regexp
validate_experimental_and_suspicious_types_inside_nested_types
