> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-postgresql-tls-support.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# configurações de formato input_format_*
> Configurações de formato do ClickHouse no grupo gerado de input_format_*.
export const VersionHistory = ({rows = []}) => {
if (rows.length === 0) {
return null;
}
const headers = ["Versão", "Valor padrão", "Comentário"];
const border = "1px solid rgba(128, 128, 128, 0.3)";
const cell = {
border,
padding: "0.25rem 0.5rem",
textAlign: "start",
verticalAlign: "top"
};
return
Histórico de versões
{headers.map(header => |
{header}
| )}
{rows.map((row, row_index) =>
{(row.items ?? []).map((item, item_index) => |
{item?.label}
| )}
)}
;
};
export const SettingsInfoBlock = ({type, default_value, changeable_without_restart}) => {
return
Tipo
{type}
Padrão
{default_value}
{changeable_without_restart &&
Pode ser alterado sem reiniciar
}
{changeable_without_restart &&
{changeable_without_restart}
}
;
};
Essas configurações são geradas automaticamente a partir do [código-fonte](https://github.com/ClickHouse/ClickHouse/blob/master/src/Core/FormatFactorySettings.h).
## 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\_arrow\_use\_native\_reader
Use o leitor nativo do ClickHouse para os formatos Arrow e ArrowStream em vez do baseado na biblioteca Apache 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](/pt-BR/reference/data-types/newjson) como valores [String](/pt-BR/reference/data-types/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
## 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.
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
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](/pt-BR/reference/formats/JSON/JSONEachRow) (e outros formatos JSON), [CSV](/pt-BR/reference/formats/CSV/CSV), [TabSeparated](/pt-BR/reference/formats/TabSeparated/TabSeparated), [TSKV](/pt-BR/reference/formats/TabSeparated/TSKV), [Parquet](/pt-BR/reference/formats/Parquet/Parquet), [Arrow](/pt-BR/reference/formats/Arrow/Arrow), [Avro](/pt-BR/reference/formats/Avro/Avro), [ORC](/pt-BR/reference/formats/ORC), [Native](/pt-BR/reference/formats/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` ou `MultiPoint`) 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](/pt-BR/reference/formats/JSON/JSONEachRow)
Valores possíveis:
* 0 — Desativado.
* 1 — Ativado.
Veja também:
* [Uso de estruturas Nested](/pt-BR/guides/clickhouse/data-formats/json/formats#accessing-nested-json-objects) 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:
```sql theme={null}
SET input_format_json_infer_array_of_dynamic_from_array_of_different_types=1;
DESC format(JSONEachRow, '{"a" : [42, "hello", [1, 2, 3]]}');
```
```response theme={null}
┌─name─┬─type───────────┐
│ a │ Array(Dynamic) │
└──────┴────────────────┘
```
```sql theme={null}
SET input_format_json_infer_array_of_dynamic_from_array_of_different_types=0;
DESC format(JSONEachRow, '{"a" : [42, "hello", [1, 2, 3]]}');
```
```response theme={null}
┌─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:
```sql theme={null}
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\_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:
```sql theme={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]]}');
```
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:
```sql theme={null}
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:
```sql theme={null}
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**
```bash theme={null}
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](/pt-BR/reference/syntax#literals) com [valores padrão](/pt-BR/reference/statements/create/table#default_values), caso o tipo de dados desses campos não seja [Nullable](/pt-BR/reference/data-types/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)](/pt-BR/reference/formats/TabSeparated/TabSeparated), [TSKV](/pt-BR/reference/formats/TabSeparated/TSKV), [CSV](/pt-BR/reference/formats/CSV/CSV) e [JSONEachRow](/pt-BR/reference/formats/JSON/JSONEachRow).
Valores possíveis:
* 1 — Habilitado.
* 0 — Desabilitado.
## input\_format\_parquet\_allow\_geoparquet\_parser
Usar o parser de colunas geo para converter Array(UInt8) em tipos Point/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\_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\_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\_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](/pt-BR/reference/formats/JSON/JSONEachRow) (e outros formatos JSON)
* [BSONEachRow](/pt-BR/reference/formats/BSONEachRow) (e outros formatos JSON)
* [TSKV](/pt-BR/reference/formats/TabSeparated/TSKV)
* Todos os formatos com sufixos WithNames/WithNamesAndTypes
* [MySQLDump](/pt-BR/reference/formats/MySQLDump)
* [Native](/pt-BR/reference/formats/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`](/pt-BR/reference/data-types/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.
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.
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](/pt-BR/reference/formats/CSV/CSVWithNames)
* [CSVWithNamesAndTypes](/pt-BR/reference/formats/CSV/CSVWithNamesAndTypes)
* [TabSeparatedWithNames](/pt-BR/reference/formats/TabSeparated/TabSeparatedWithNames)
* [TabSeparatedWithNamesAndTypes](/pt-BR/reference/formats/TabSeparated/TabSeparatedWithNamesAndTypes)
* [JSONCompactEachRowWithNames](/pt-BR/reference/formats/JSON/JSONCompactEachRowWithNames)
* [JSONCompactEachRowWithNamesAndTypes](/pt-BR/reference/formats/JSON/JSONCompactEachRowWithNamesAndTypes)
* [JSONCompactStringsEachRowWithNames](/pt-BR/reference/formats/JSON/JSONCompactStringsEachRowWithNames)
* [JSONCompactStringsEachRowWithNamesAndTypes](/pt-BR/reference/formats/JSON/JSONCompactStringsEachRowWithNamesAndTypes)
* [RowBinaryWithNames](/pt-BR/reference/formats/RowBinary/RowBinaryWithNames)
* [RowBinaryWithNamesAndTypes](/pt-BR/reference/formats/RowBinary/RowBinaryWithNamesAndTypes)
* [CustomSeparatedWithNames](/pt-BR/reference/formats/CustomSeparated/CustomSeparatedWithNames)
* [CustomSeparatedWithNamesAndTypes](/pt-BR/reference/formats/CustomSeparated/CustomSeparatedWithNamesAndTypes)
Valores possíveis:
* 0 — Desabilitado.
* 1 — Habilitado.
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](/pt-BR/reference/formats/CSV/CSVWithNamesAndTypes)
* [TabSeparatedWithNamesAndTypes](/pt-BR/reference/formats/TabSeparated/TabSeparatedWithNamesAndTypes)
* [JSONCompactEachRowWithNamesAndTypes](/pt-BR/reference/formats/JSON/JSONCompactEachRowWithNamesAndTypes)
* [JSONCompactStringsEachRowWithNamesAndTypes](/pt-BR/reference/formats/JSON/JSONCompactStringsEachRowWithNamesAndTypes)
* [RowBinaryWithNamesAndTypes](/pt-BR/reference/formats/RowBinary/RowBinaryWithNamesAndTypes)
* [CustomSeparatedWithNamesAndTypes](/pt-BR/reference/formats/CustomSeparated/CustomSeparatedWithNamesAndTypes)
Valores possíveis:
* 0 — Desabilitado.
* 1 — Habilitado.