configurações de formato input_format_*

Configurações de formato do ClickHouse no grupo gerado de input_format_*.

Essas configurações são geradas automaticamente a partir do código-fonte.

​

input_format_allow_errors_num

Define o número máximo de erros aceitáveis ao ler 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 ambos input_format_allow_errors_num e input_format_allow_errors_ratio forem excedidos, o ClickHouse lança uma exceção.

​

input_format_allow_errors_ratio

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 em conjunto com input_format_allow_errors_num.

Se ocorrer um erro durante a leitura de linhas, mas o contador de erros ainda estiver abaixo de input_format_allow_errors_ratio, o ClickHouse ignora a linha e passa para a próxima.

Se tanto input_format_allow_errors_num quanto input_format_allow_errors_ratio forem excedidos, o ClickHouse lança uma exceção.

​

input_format_allow_seeks

Permite reposicionamentos (ou leituras por intervalo) ao ler os formatos de entrada ORC, Parquet e Arrow. Quando habilitado e a origem oferece suporte a isso (por exemplo, arquivo local, S3, 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 desabilitado, ou quando a origem não oferece suporte a reposicionamentos (por exemplo, sem tamanho de arquivo ou com fluxo sem suporte a seek), alguns leitores podem recorrer ao carregamento do arquivo inteiro na memória. Habilitado por padrão.

​

input_format_arrow_allow_missing_columns

Permitir colunas ausentes ao ler formatos de entrada do Arrow

​

input_format_arrow_case_insensitive_column_matching

Ignora maiúsculas e minúsculas ao corresponder colunas Arrow com colunas CH.

​

input_format_arrow_skip_columns_with_unsupported_types_in_schema_inference

Ignorar colunas com tipos não suportados durante a inferência de esquema do formato Arrow

​

input_format_avro_allow_missing_fields

Para o formato Avro/AvroConfluent: quando o campo não for encontrado no esquema, use o valor padrão em vez de gerar um erro

​

input_format_avro_null_as_default

Para o formato Avro/AvroConfluent: insere o valor padrão no caso de null em coluna não Nullable

​

input_format_binary_decode_types_in_binary_format

Ler os tipos de dados em formato binário, em vez de nomes de tipos, no formato de entrada RowBinaryWithNamesAndTypes

​

input_format_binary_max_type_complexity

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.

​

input_format_binary_read_json_as_string

Lê valores do tipo de dado JSON como valores String JSON no formato de entrada RowBinary.

​

input_format_bson_skip_fields_with_unsupported_types_in_schema_inference

Ignora campos com tipos não suportados durante a inferência de esquema do formato BSON.

​

input_format_capn_proto_skip_fields_with_unsupported_types_in_schema_inference

Ignora colunas com tipos não suportados durante a inferência de esquema do formato CapnProto

​

input_format_column_name_matching_mode

Define o modo de correspondência de nomes de colunas ao fazer a ingestão de dados por vários formatos (incluindo, entre outros, JSONEachRow, CSVWithNames, JSONColumns, BSONEachRow e RowBinaryWithNames). Modos compatíveis:

• match_case: faz a correspondência com distinção entre maiúsculas e minúsculas
  • ignore_case: faz a correspondência sem distinção entre maiúsculas e minúsculas
  • auto: primeiro tenta fazer a correspondência com distinção entre maiúsculas e minúsculas; se falhar, tenta fazer a correspondência sem distinção entre maiúsculas e minúsculas.

​

input_format_connection_handling

Quando esta opção está ativada, se a conexão for fechada inesperadamente, quaisquer dados restantes no buffer serão analisados e processados em vez de serem tratados como erro

Ativar esta opção desabilita a análise paralela e torna a desduplicação impossível

​

input_format_csv_allow_cr_end_of_line

Se for definido como true, \r será permitido no final da linha sem ser seguido por \n

​

input_format_csv_allow_variable_number_of_columns

Ignora colunas extras na entrada CSV (se o arquivo tiver mais colunas do que o esperado) e trata campos ausentes na entrada CSV como valores padrão

​

input_format_csv_allow_whitespace_or_tab_as_delimiter

Permite usar espaços e tabulações(\t) como delimitadores de campo em strings CSV

​

input_format_csv_arrays_as_nested_csv

Ao ler Array de CSV, espera-se que seus elementos tenham sido serializados em CSV aninhado e depois colocados em uma string. Exemplo: ”[""Hello"", ""world"", ""42"""" TV""]”. Os colchetes ao redor do array podem ser omitidos.

​

input_format_csv_deserialize_separate_columns_into_tuple

Se definido como true, colunas separadas gravadas no formato CSV podem ser desserializadas para uma coluna Tuple.

Isso se aplica apenas a Tuple puro. Um Nullable(Tuple) sempre é gravado como um único campo CSV (consulte output_format_csv_serialize_tuple_into_separate_columns) e, da mesma forma, sempre é lido de volta de um único campo, nunca de colunas separadas, independentemente desta configuração. A análise em colunas separadas não é suportada para Nullable(Tuple) porque um campo inicial \N é ambíguo (ele pode ser o NULL externo da tupla ou o NULL do primeiro elemento dela).

Como um Tuple puro passa a ocupar um campo por elemento, um \N no campo de um elemento direto de nível superior corresponde a esse elemento, e não à coluna inteira; portanto, input_format_null_as_default se aplica a esse elemento. Uma linha que fornece um único campo para a tupla inteira fica sem os elementos restantes e é rejeitada em vez de usar o valor padrão da coluna. Defina esta configuração como 0 para ler novamente esse campo como a coluna inteira. Um \N no campo de um elemento de um Tuple aninhado ainda é lido como esse elemento aninhado inteiro.

​

input_format_csv_detect_header

Detecta automaticamente o cabeçalho com nomes e tipos no formato CSV

​

input_format_csv_empty_as_default

Considera campos vazios na entrada CSV como valores padrão.

​

input_format_csv_enum_as_number

Trata os valores enum inseridos em formatos CSV como índices do enum

​

input_format_csv_missing_nullable_as_empty_string

Controla como Nullable(String) é lido a partir de um valor ausente no CSV. Um valor ausente é um espaço vazio entre/antes/depois de vírgulas, sem estar entre aspas. Se essa configuração estiver ativada, independentemente do valor de input_format_csv_empty_as_default, o valor ausente de Nullable(String) será interpretado como uma String vazia, não como NULL.

​

input_format_csv_skip_first_lines

Ignora o número especificado de linhas no início dos dados no formato CSV

​

input_format_csv_skip_trailing_empty_lines

Ignora linhas vazias no final no formato CSV

​

input_format_csv_trim_whitespaces

Remove espaços e tabulações (\t) no início e no fim de strings CSV

​

input_format_csv_try_infer_numbers_from_strings

Se estiver habilitada, durante a inferência de esquema, o ClickHouse tentará inferir números a partir de campos do tipo string. Isso pode ser útil se os dados CSV contiverem números UInt64 entre aspas.

Desabilitada por padrão.

​

input_format_csv_try_infer_strings_from_quoted_tuples

Interpreta tuplas entre aspas nos dados de entrada como um valor do tipo String.

​

input_format_csv_use_best_effort_in_schema_inference

Usa alguns ajustes e heurísticas para inferir o esquema no formato CSV

​

input_format_csv_use_default_on_bad_values

Permite definir o valor padrão da coluna quando a desserialização do campo CSV falhar devido a um valor inválido

​

input_format_custom_allow_variable_number_of_columns

Ignora colunas extras na entrada CustomSeparated (se o arquivo tiver mais colunas do que o esperado) e trata campos ausentes na entrada CustomSeparated como valores padrão

​

input_format_custom_detect_header

Detecta automaticamente o cabeçalho com nomes e tipos no formato CustomSeparated

​

input_format_custom_skip_trailing_empty_lines

Ignora linhas vazias no final no formato CustomSeparated

​

input_format_defaults_for_omitted_fields

Ao executar consultas 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 e aos 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.

Valores possíveis:

• 0 — Desabilitado.
• 1 — Habilitado.

​

input_format_force_null_for_omitted_fields

Força a inicialização de campos omitidos com valores NULL

​

input_format_geojson_unsupported_geometry_handling

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) precisa ser armazenado na coluna geometry durante a leitura de dados de 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 para verificar se está bem formada, mas não aciona esse tratamento.

​

input_format_hive_text_allow_variable_number_of_columns

Ignora colunas extras na entrada no formato Hive Text (se o arquivo tiver mais colunas do que o esperado) e trata campos ausentes na entrada no formato Hive Text como valores padrão

​

input_format_hive_text_collection_items_delimiter

Delimitador entre os itens de coleção (array ou map) no Hive Text File

​

input_format_hive_text_fields_delimiter

Delimitador entre os campos em Hive Text File

​

input_format_hive_text_map_keys_delimiter

Delimitador entre um par de chave/valor de map no Hive Text File

​

input_format_import_nested_json

Ativa ou desativa a inserção de dados JSON com objetos aninhados.

Formatos suportados:

• JSONEachRow

Valores possíveis:

• 0 — Desativado.
• 1 — Ativado.

Veja também:

• Uso de estruturas Nested com o formato JSONEachRow.

​

input_format_ipv4_default_on_conversion_error

A desserialização de IPv4 usará valores padrão em vez de gerar uma exceção em caso de erro de conversão.

Desabilitado por padrão.

​

input_format_ipv6_default_on_conversion_error

A desserialização de IPV6 usará valores padrão em vez de gerar uma exceção em caso de erro de conversão.

Desativado por padrão.

​

input_format_json_compact_allow_variable_number_of_columns

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 colunas ausentes como valores padrão.

Desativado por padrão.

​

input_format_json_defaults_for_missing_elements_in_named_tuple

Insere valores padrão para elementos ausentes em objetos JSON ao analisar tuplas nomeadas. Essa configuração funciona somente quando a configuração input_format_json_named_tuples_as_objects está habilitada.

Habilitado por padrão.

​

input_format_json_empty_as_default

Quando habilitada, substitui campos de entrada vazios em JSON por valores padrão. Para expressões padrão complexas, input_format_defaults_for_omitted_fields também deve estar habilitada.

Valores possíveis:

• 0 — Desabilitado.
• 1 — Habilitado.

​

input_format_json_ignore_unknown_keys_in_named_tuple

Ignora chaves desconhecidas em objetos JSON para tuplas nomeadas.

Habilitado por padrão.

​

input_format_json_ignore_unnecessary_fields

Ignora campos desnecessários sem analisá-los. Ao habilitar esta opção, exceções podem não ser geradas para strings JSON com formato inválido ou campos duplicados

​

input_format_json_infer_array_of_dynamic_from_array_of_different_types

Se estiver habilitado, 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))) │
└──────┴──────────────────────────────────────────────────────────────────┘

Habilitado por padrão.

​

input_format_json_infer_incomplete_types_as_strings

Permite usar o tipo String para chaves em JSON que contenham apenas Null/{}/[] na amostra de dados durante a inferência de esquema. Nos 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, usando 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" : []}}');

Resultado:

┌─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,'{}',[]) │
└────────────────────────────────┘

Ativado por padrão.

​

input_format_json_map_as_array_of_tuples

Desserializa colunas do tipo map como arrays JSON de tuplas.

Desativado por padrão.

​

input_format_json_max_depth

Profundidade máxima de um campo em JSON. Não é um limite estrito e não precisa ser aplicado exatamente.

​

input_format_json_max_object_size

Tamanho máximo permitido de um único objeto JSON em bytes. Objetos que excedem esse limite são rejeitados, pois provavelmente estão malformados. Isso protege contra o esgotamento de memória quando um documento JSON malformado é analisado como um único objeto. O mesmo limite é aplicado nos caminhos de análise paralelos e não paralelos. Defina como 0 para desabilitar a verificação.

​

input_format_json_max_string_column_growth_step

Ao criar os buffers internos de String da coluna JSON durante o parsing de JSON a partir de uma string, limite o crescimento em potências de dois a esta quantidade de bytes: quando o tamanho reservado atingir esse valor, o buffer crescerá em incrementos desse tamanho, em vez de dobrar. Isso limita a superalocação em colunas JSON grandes. 0 significa ilimitado (apenas duplicação).

​

input_format_json_named_tuples_as_objects

Interpreta colunas de tuplas nomeadas como objetos JSON.

Ativado por padrão.

​

input_format_json_read_arrays_as_strings

Permite interpretar arrays JSON como strings em formatos de entrada JSON.

Exemplo:

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]]}');

Resultado:

┌─arr───────────────────┬─toTypeName(arr)─┬─arrayElement(JSONExtractArrayRaw(arr), 3)─┐
│ [1, "Hello", [1,2,3]] │ String          │ [1,2,3]                                   │
└───────────────────────┴─────────────────┴───────────────────────────────────────────┘

Ativado por padrão.

​

input_format_json_read_bools_as_numbers

Permite interpretar valores Bool como números em formatos de entrada JSON.

Ativado por padrão.

​

input_format_json_read_bools_as_strings

Permite analisar valores Bool como String em formatos de entrada JSON.

Ativado por padrão.

​

input_format_json_read_numbers_as_strings

Permite interpretar números como strings em formatos de entrada JSON.

Ativado por padrão.

​

input_format_json_read_objects_as_strings

Permite analisar objetos JSON como strings em formatos de entrada JSON.

Exemplo:

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;

Resultado:

┌─id─┬─obj──────────────────────┬───────date─┐
│  1 │ {"a" : 1, "b" : "Hello"} │ 2020-01-01 │
└────┴──────────────────────────┴────────────┘

Habilitado por padrão.

​

input_format_json_throw_on_bad_escape_sequence

Gera uma exceção se a string JSON contiver uma sequência de escape inválida nos formatos de entrada JSON. Se estiver desabilitada, as sequências de escape inválidas permanecerão como estão nos dados.

Ativado por padrão.

​

input_format_json_try_infer_named_tuples_from_objects

Se estiver habilitada, durante a inferência de esquema o ClickHouse tentará inferir uma Tuple nomeada a partir de objetos JSON. A Tuple nomeada resultante conterá todos os elementos de todos os objetos JSON correspondentes nos dados de exemplo.

Exemplo:

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}}}')

Resultado:

┌─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))) │              │                    │         │                  │                │
└──────┴────────────────────────────────────────────────────────────────────────────────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘

Habilitado por padrão.

​

input_format_json_try_infer_numbers_from_strings

Se estiver habilitado, durante a inferência de esquema, o ClickHouse tentará inferir números a partir de campos do tipo string. Isso pode ser útil se os dados JSON contiverem números UInt64 entre aspas.

Desativado por padrão.

​

input_format_json_use_string_type_for_ambiguous_paths_in_named_tuples_inference_from_objects

Use o tipo String em vez de uma exceção no caso de caminhos ambíguos em objetos JSON durante a inferência de tuplas nomeadas

​

input_format_json_validate_types_from_metadata

Para os formatos de entrada JSON/JSONCompact/JSONColumnsWithMetadata, se essa configuração estiver definida como 1, os tipos presentes nos metadados dos dados de entrada serão comparados com os tipos das colunas correspondentes da tabela.

Ativado por padrão.

​

input_format_max_block_size_bytes

Limita, em bytes, o tamanho dos blocos formados durante o parsing de dados em formatos de entrada. Usado em formatos de entrada baseados em linhas quando o bloco é formado no lado do ClickHouse. 0 significa que não há limite em bytes.

​

input_format_max_block_wait_ms

Limita o tempo máximo, em milissegundos, de espera antes da emissão de um bloco durante o parsing em formatos de entrada baseados em linhas. 0 significa que não há limite.

Esta opção só funciona se input_format_connection_handling estiver habilitado. Definir um valor também desabilita o parsing paralelo e impossibilita a desduplicação.

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 analisados ainda podem ser acumulados na memória pelo estágio de squashing de blocos até que esses limites sejam atingidos, impedindo inserções em tempo hábil.

Exemplo: streaming de alterações recentes da Wikipedia para o ClickHouse

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

​

input_format_max_bytes_to_read_for_schema_inference

A quantidade máxima de dados, em bytes, a ser lida para a inferência automática de esquema.

​

input_format_max_rows_to_read_for_schema_inference

O número máximo de linhas de dados lidas para inferência automática de esquema.

​

input_format_msgpack_number_of_columns

O número de colunas nos dados MsgPack inseridos. Usado para a inferência automática de esquema a partir dos dados.

​

input_format_mysql_dump_map_column_names

Faz a correspondência entre as colunas da tabela no MySQL dump e as colunas da tabela do ClickHouse pelos nomes

​

input_format_mysql_dump_table_name

Nome da tabela no MySQL dump de onde ler os dados

​

input_format_native_allow_types_conversion

Permite a conversão de tipos de dados no formato de entrada Native

​

input_format_native_decode_types_in_binary_format

Ler tipos de dados em formato binário em vez de nomes de tipos no formato de entrada Native

​

input_format_null_as_default

Habilita ou desabilita a inicialização de campos NULL com valores padrão, caso o tipo de dados desses campos não seja Nullable. Se o tipo da coluna não for Nullable e essa configuração estiver desabilitada, inserir 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 habilitado.

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.

​

input_format_orc_allow_missing_columns

Permitir colunas ausentes ao ler arquivos ORC no formato de entrada

​

input_format_orc_case_insensitive_column_matching

Ignora diferenças entre maiúsculas e minúsculas ao corresponder colunas ORC com colunas CH.

​

input_format_orc_dictionary_as_low_cardinality

Considera colunas codificadas com dicionário ORC como colunas LowCardinality durante a leitura de arquivos ORC.

​

input_format_orc_filter_push_down

Ao ler arquivos ORC, ignore stripes ou grupos de linhas inteiros com base nas expressões WHERE/PREWHERE, nas estatísticas de mín./máx. ou no filtro de Bloom nos metadados do ORC.

​

input_format_orc_reader_time_zone_name

Nome do fuso horário do leitor de linhas ORC; o fuso horário padrão do leitor de linhas ORC é GMT.

​

input_format_orc_row_batch_size

Tamanho do lote na leitura de stripes do ORC.

​

input_format_orc_skip_columns_with_unsupported_types_in_schema_inference

Ignora colunas com tipos não suportados durante a inferência de esquema do formato ORC

​

input_format_parallel_parsing

Ativa ou desativa o parsing paralelo de formatos de dados, preservando a ordem. Compatível apenas com os formatos TabSeparated (TSV), TSKV, CSV e JSONEachRow.

Valores possíveis:

• 1 — Habilitado.
• 0 — Desabilitado.

​

input_format_parquet_allow_geoparquet_parser

Usar o parser de colunas geo para converter Array(UInt8) nos tipos Point/MultiPoint/Linestring/Polygon/MultiLineString/MultiPolygon

​

input_format_parquet_allow_missing_columns

Permitir colunas ausentes ao ler formatos de entrada em Parquet

​

input_format_parquet_bloom_filter_push_down

Ao ler arquivos Parquet, ignore grupos inteiros de linhas com base nas expressões WHERE e no filtro de Bloom nos metadados do Parquet.

​

input_format_parquet_case_insensitive_column_matching

Ignora a distinção entre maiúsculas e minúsculas ao corresponder colunas do Parquet com colunas CH.

​

input_format_parquet_dictionary_filter_push_down

Ao ler arquivos Parquet (com o leitor v3), ignora grupos de linhas inteiros com base nas expressões WHERE/PREWHERE e no conteúdo das páginas de dicionário quando todas as páginas de dados de um fragmento de coluna são codificadas com dicionário. O valor é o tamanho máximo da página de dicionário (em bytes) ao qual essa otimização se aplica; defina como 0 para desabilitá-la. Essa opção tem precedência sobre o filtro de Bloom quando ambos estão disponíveis.

​

input_format_parquet_enable_json_parsing

Ao ler arquivos Parquet, interpreta colunas JSON como a coluna JSON do ClickHouse.

​

input_format_parquet_enable_row_group_prefetch

Habilita o prefetch de row groups durante o parsing de Parquet. Atualmente, apenas o parsing de thread única pode usar prefetch.

​

input_format_parquet_filter_push_down

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.

​

input_format_parquet_local_file_min_bytes_for_seek

Número mínimo de bytes necessário para que a leitura local (arquivo) faça seek, em vez de ler e ignorar, no formato de entrada Parquet

​

input_format_parquet_local_time_as_utc

Determina o tipo de dado usado pela inferência de esquema para timestamps 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 de relógio. Contraintuitivamente, ‘true’ provavelmente é a opção menos incorreta, porque formatar o timestamp ‘UTC’ como String produzirá a representação do horário local correto.

​

input_format_parquet_max_block_size

Tamanho máximo do bloco do leitor de Parquet.

​

input_format_parquet_memory_high_watermark

Limite aproximado de memória do leitor de Parquet v3. Limita quantos grupos de linhas ou colunas podem ser lidos em paralelo. Ao ler vários arquivos em uma única consulta, o limite se aplica ao uso total de memória desses arquivos.

​

input_format_parquet_memory_low_watermark

Realiza 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

Ignora páginas com base nos valores mín./máx. do índice da coluna.

​

input_format_parquet_prefer_block_bytes

Quantidade média de bytes por bloco gerados pelo leitor de Parquet

​

input_format_parquet_preserve_order

Evite reordenar as linhas ao ler arquivos Parquet. Isso não é recomendado, pois a ordem das linhas em geral não é garantida, e outras partes do pipeline de consulta podem alterá-la. Use ORDER BY _row_number em vez disso.

​

input_format_parquet_skip_columns_with_unsupported_types_in_schema_inference

Ignora colunas com tipos não suportados durante a inferência de esquema do formato Parquet

​

input_format_parquet_spatial_filter_push_down

Ao ler arquivos GeoParquet, pule grupos de linhas inteiros e, em conjunto com input_format_parquet_page_filter_push_down, páginas individuais com base em predicados espaciais na cláusula WHERE e nas estatísticas da caixa delimitadora da geometria (colunas geospatial_statistics.bbox ou covering.bbox) nos metadados do Parquet.

​

input_format_parquet_use_offset_index

Pequeno ajuste na forma de ler páginas de arquivo Parquet quando não há filtragem de páginas.

​

input_format_parquet_verify_checksums

Verifica os checksums das páginas ao ler arquivos Parquet.

​

input_format_protobuf_flatten_google_wrappers

Ativa wrappers do Google para colunas comuns não aninhadas, por exemplo, google.protobuf.StringValue ‘str’ para a coluna do tipo String ‘str’. Para colunas Nullable, wrappers vazios são reconhecidos como valores padrão, e valores ausentes como nulls

​

input_format_protobuf_oneof_presence

Indica qual campo de protobuf oneof foi encontrado por meio da definição de um valor enum em uma coluna especial

​

input_format_protobuf_skip_fields_with_unsupported_types_in_schema_inference

Ignora campos com tipos não suportados durante a inferência de esquema do formato Protobuf

​

input_format_read_datetime_number_as_raw_value

Leia um inteiro sem aspas para uma coluna DateTime/DateTime64 como o valor bruto subjacente — segundos para DateTime, ticks na precisão da coluna para DateTime64 — em vez de como um timestamp Unix em segundos.

Desabilitada por padrão: um número sem aspas é interpretado como um timestamp Unix em segundos (com precisão de subsegundos opcional), em conformidade com o formato Values, CAST e toDateTime64. Habilite-a (ou use SET compatibility = '26.7') para restaurar o comportamento das versões até a 26.7, inclusive, em que um inteiro sem aspas fornecido a uma coluna DateTime64 era interpretado como o valor escalonado bruto (ticks). O caminho legado aceita apenas esse inteiro sem aspas: com a configuração habilitada, um número com parte fracionária ou expoente é rejeitado pelos caminhos de entrada de linhas (como antes da 26.8), enquanto em JSONExtract e no tipo JSON tipado, um número fracionário ainda é lido como segundos para DateTime64 e rejeitado para DateTime (também como antes da 26.8). No próprio formato Values, um número rejeitado pelo parser de streaming recorre à avaliação de expressões SQL e é lido como segundos, tanto antes da 26.8 quanto com esta configuração habilitada — portanto, o comportamento de Values para um número fracionário é o mesmo em todas as configurações.

Esta configuração rege apenas os caminhos JSON, Values/Quoted e JSONExtract/JSON tipado (o caminho Quoted abrange todos os formatos que analisam campos usando a regra de escaping Quoted: Values, MySQLDump e Template/CustomSeparated/Regexp configurados com escaping de campo Quoted). Os formatos separados por tabulação, CSV e outros formatos escapados/de texto completo não são afetados: neles, um número DateTime64 grande sem aspas ainda é lido como ticks.

​

input_format_record_errors_file_path

Caminho do arquivo usado para registrar erros ao ler formatos de texto (CSV, TSV).

​

input_format_skip_unknown_fields

Habilita ou desabilita a omissão 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 habilitada, o ClickHouse não insere os dados extras nem lança uma exceção.

Formatos suportados:

• JSONEachRow (e outros formatos JSON)
• BSONEachRow (e outros formatos JSON)
• TSKV
• Todos os formatos com sufixos WithNames/WithNamesAndTypes
• MySQLDump
• Native

Valores possíveis:

• 0 — Desabilitado.
• 1 — Habilitado.

​

input_format_try_infer_dates

Se habilitado, o ClickHouse tentará inferir o tipo Date a partir 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 convertidos com sucesso em datas, o tipo resultante será Date; se pelo menos um campo não for convertido em data, o tipo resultante será String.

Habilitado por padrão.

​

input_format_try_infer_datetimes

Se estiver habilitado, o ClickHouse tentará inferir o tipo DateTime64 a partir de campo do tipo string na inferência de esquema para formatos de texto. Se todos os campos de uma coluna nos dados de entrada forem convertidos com sucesso como datetimes, o tipo resultante será DateTime64; se pelo menos um campo não for convertido como datetime, o tipo resultante será String.

Habilitado por padrão.

​

input_format_try_infer_datetimes_only_datetime64

Quando input_format_try_infer_datetimes estiver habilitado, infira apenas tipos DateTime64, e não tipos DateTime

​

input_format_try_infer_exponent_floats

Tenta inferir números de ponto flutuante em notação exponencial durante a inferência de esquema em formatos de texto (exceto JSON, em que números com expoente são sempre inferidos)

​

input_format_try_infer_integers

Se estiver habilitado, o ClickHouse tentará inferir inteiros em vez de números de ponto flutuante na inferência de esquema para 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.

​

input_format_try_infer_variants

Se habilitado, o ClickHouse tentará inferir o tipo Variant na inferência de esquema para formatos de texto quando houver mais de um tipo possível para elementos de coluna/array.

Valores possíveis:

• 0 — Habilitado.
• 1 — Habilitado.

​

input_format_tsv_allow_variable_number_of_columns

Ignore colunas extras na entrada TSV (se o arquivo tiver mais colunas do que o esperado) e trate campos ausentes na entrada TSV como valores padrão

​

input_format_tsv_crlf_end_of_line

Se estiver definido como true, a função file lerá o formato TSV usando \r\n em vez de \n.

​

input_format_tsv_detect_header

Detecta automaticamente o cabeçalho com nomes e tipos no formato TSV

​

input_format_tsv_empty_as_default

Trata campos vazios na entrada em TSV como valores padrão.

​

input_format_tsv_enum_as_number

Tratar os valores enum inseridos em formatos TSV como índices de enum.

​

input_format_tsv_skip_first_lines

Ignora o número especificado de linhas no início dos dados no formato TSV

​

input_format_tsv_skip_trailing_empty_lines

Ignora linhas vazias no final no formato TSV

​

input_format_tsv_use_best_effort_in_schema_inference

Usa alguns ajustes e heurísticas para inferir o esquema no formato TSV

​

input_format_values_accurate_types_of_literals

No formato Values: ao fazer o parsing e interpretar expressões usando um modelo, verifique o tipo real do literal para evitar possíveis problemas de overflow e de precisão.

​

input_format_values_deduce_templates_of_expressions

Para o formato Values: se o campo não puder ser analisado pelo parser de streaming, execute o parser SQL, deduza o modelo da expressão SQL, tente analisar todas as linhas usando o modelo e, em seguida, interprete a expressão para todas as linhas.

​

input_format_values_interpret_expressions

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.

​

input_format_with_names_use_header

Habilita ou desabilita a verificação da ordem das colunas ao inserir dados.

Para melhorar o desempenho da inserção, recomendamos desabilitar essa verificação se você tiver certeza de que a ordem das colunas nos dados de entrada é a mesma da tabela de destino.

Formatos compatíveis:

• CSVWithNames
• CSVWithNamesAndTypes
• TabSeparatedWithNames
• TabSeparatedWithNamesAndTypes
• JSONCompactEachRowWithNames
• JSONCompactEachRowWithNamesAndTypes
• JSONCompactStringsEachRowWithNames
• JSONCompactStringsEachRowWithNamesAndTypes
• RowBinaryWithNames
• RowBinaryWithNamesAndTypes
• CustomSeparatedWithNames
• CustomSeparatedWithNamesAndTypes

Valores possíveis:

• 0 — Desabilitado.
• 1 — Habilitado.

​

input_format_with_types_use_header

Controla se o parser de formato deve verificar se os tipos de dados dos dados de entrada correspondem aos tipos de dados da tabela de destino.

Formatos compatíveis:

• CSVWithNamesAndTypes
• TabSeparatedWithNamesAndTypes
• JSONCompactEachRowWithNamesAndTypes
• JSONCompactStringsEachRowWithNamesAndTypes
• RowBinaryWithNamesAndTypes
• CustomSeparatedWithNamesAndTypes

Valores possíveis:

• 0 — Desabilitado.
• 1 — Habilitado.