> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-8a08bda2.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# Configurações de formato
> Configurações que controlam os formatos de entrada e saída.
export const SettingsInfoBlock = ({type, default_value, changeable_without_restart}) => {
const cells = [["Type", {type}], ["Default value", {default_value}]];
if (changeable_without_restart) {
const isYes = String(changeable_without_restart).trim().toLowerCase() === "yes";
const badge = isYes ? Yes : No;
cells.push(["Changeable without restart", badge]);
}
return
{cells.map(([h]) => | {h} | )}
{cells.map(([h, v]) => | {v} | )}
;
};
export const galaxyOnClick = eventName => () => {
try {
if (typeof window !== "undefined" && window.galaxy && eventName) {
window.galaxy.track(eventName, {
interaction: "click"
});
}
} catch (e) {}
};
export const BetaBadge = ({link, galaxyTrack, galaxyEvent}) => {
if (link) {
return
Beta
;
}
return ;
};
export const ExperimentalBadge = () => {
return ;
};
Essas configurações são geradas automaticamente a partir do [código-fonte](https://github.com/ClickHouse/ClickHouse/blob/master/src/Core/FormatFactorySettings.h).
## allow\_special\_bool\_values\_inside\_variant
Permite interpretar valores Bool dentro do tipo Variant a partir de valores booleanos textuais especiais, como "on", "off", "enable", "disable" etc.
## bool\_false\_representation
Texto usado para representar o valor bool falso nos formatos TSV/CSV/Vertical/Pretty.
## bool\_true\_representation
Texto usado para representar o valor bool true nos formatos TSV/CSV/Vertical/Pretty.
## check\_conversion\_from\_numbers\_to\_enum
Lança uma exceção durante a conversão de números para Enum se o valor não existir no Enum.
Valores possíveis:
* 0 — Desativado.
* 1 — Ativado.
**Exemplo**
```text theme={null}
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
A lista de nomes de colunas a ser usada na inferência de esquema para formatos sem nomes de colunas. O formato é: 'column1,column2,column3,...'
## date\_time\_64\_output\_format\_cut\_trailing\_zeros\_align\_to\_groups\_of\_thousands
Remove dinamicamente os zeros à direita dos valores de `datetime64` para ajustar a escala de saída para \[0, 3, 6],
correspondendo a 'segundos', 'milissegundos' e 'microssegundos'
## date\_time\_input\_format
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](/pt-BR/reference/functions/regular-functions/date-time-functions).
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](https://en.wikipedia.org/wiki/ISO_8601). Por exemplo, `'2018-06-08T01:02:03.000Z'`.
* `'best_effort_us'` — Semelhante a `best_effort` (veja a diferença em [parseDateTimeBestEffortUS](/pt-BR/reference/functions/regular-functions/type-conversion-functions#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:
* [Tipo de dado DateTime.](/pt-BR/reference/data-types/datetime)
* [Funções para trabalhar com datas e horas.](/pt-BR/reference/functions/regular-functions/date-time-functions)
## date\_time\_output\_format
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](https://en.wikipedia.org/wiki/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](https://en.wikipedia.org/wiki/Unix_time). Por exemplo, `1566285536`.
Veja também:
* [Tipo de dado DateTime.](/pt-BR/reference/data-types/datetime)
* [Funções para trabalhar com datas e horas.](/pt-BR/reference/functions/regular-functions/date-time-functions)
## date\_time\_overflow\_behavior
Define o comportamento quando [Date](/pt-BR/reference/data-types/date), [Date32](/pt-BR/reference/data-types/date32), [DateTime](/pt-BR/reference/data-types/datetime), [DateTime64](/pt-BR/reference/data-types/datetime64) ou inteiros são convertidos em Date, Date32, DateTime ou DateTime64, mas o valor não pode ser representado no tipo de resultado.
Valores possíveis:
* `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`.
## errors\_output\_format
Método para escrever erros na saída de texto.
## format\_avro\_schema\_registry\_connection\_timeout
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).
## format\_avro\_schema\_registry\_receive\_timeout
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).
## format\_avro\_schema\_registry\_send\_timeout
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).
## format\_avro\_schema\_registry\_url
Para o formato AvroConfluent: URL do Confluent Schema Registry.
## format\_binary\_max\_array\_size
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
## format\_binary\_max\_object\_size
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
## format\_binary\_max\_string\_size
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
## format\_capn\_proto\_enum\_comparising\_mode
Como fazer o mapeamento entre o Enum do ClickHouse e o Enum do CapnProto
## format\_capn\_proto\_max\_message\_size
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.
## format\_capn\_proto\_use\_autogenerated\_schema
Usa o esquema CapnProto gerado automaticamente quando format\_schema não está definido
## format\_csv\_allow\_double\_quotes
Se estiver definido como true, permite strings com aspas duplas.
## format\_csv\_allow\_single\_quotes
Se estiver definido como true, permite strings entre aspas simples.
## format\_csv\_delimiter
O caractere considerado como delimitador em dados CSV. Se a configuração for definida com uma string, ela deverá ter comprimento de 1.
## format\_csv\_null\_representation
Representação personalizada de NULL no formato CSV
## format\_custom\_escaping\_rule
Regra de escape para campos (no formato CustomSeparated)
## format\_custom\_field\_delimiter
Delimitador entre campos (no formato CustomSeparated)
## format\_custom\_result\_after\_delimiter
Sufixo após o conjunto de resultados (para o formato CustomSeparated)
## format\_custom\_result\_before\_delimiter
Prefixo antes do conjunto de resultados (para o formato CustomSeparated)
## format\_custom\_row\_after\_delimiter
Delimitador após o campo da última coluna (no formato CustomSeparated)
## format\_custom\_row\_before\_delimiter
Delimitador antes do campo da primeira coluna (no formato CustomSeparated)
## format\_custom\_row\_between\_delimiter
Delimitador entre linhas (para o formato CustomSeparated)
## format\_display\_secrets\_in\_show\_and\_select
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](/pt-BR/reference/settings/server-settings/settings#display_secrets_in_show_and_select)
habilitada e o
[`displaySecretsInShowAndSelect`](/pt-BR/reference/statements/grant#displaysecretsinshowandselect) privilégio.
Valores possíveis:
* 0 — Desabilitado.
* 1 — Habilitado.
## format\_json\_object\_each\_row\_column\_for\_object\_name
O nome da coluna que será usada para armazenar/gravar nomes de objetos no formato [JSONObjectEachRow](/pt-BR/reference/formats/JSON/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.
## format\_protobuf\_use\_autogenerated\_schema
Use o Protobuf gerado automaticamente quando format\_schema não estiver definido
## format\_regexp
Expressão regular (do formato Regexp)
## format\_regexp\_escaping\_rule
Regra de escape do campo (para o formato Regexp)
## format\_regexp\_skip\_unmatched
Ignora linhas que não correspondem à expressão regular (para o formato Regexp)
## format\_schema
Este parâmetro é útil quando você usa formatos que exigem uma definição de esquema, como [Cap'n Proto](https://capnproto.org/) ou [Protobuf](https://developers.google.com/protocol-buffers/). O valor depende do formato.
## format\_schema\_message\_name
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.
## format\_schema\_source
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.
## format\_template\_resultset
Caminho para o arquivo que contém a string de formato do conjunto de resultados (para o formato Template)
## format\_template\_resultset\_format
String de formato do conjunto de resultados (para o formato Template)
## format\_template\_row
Caminho para o arquivo que contém a string de formato das linhas (para o formato Template)
## format\_template\_row\_format
String de formato para linhas (para o formato Template)
## format\_template\_rows\_between\_delimiter
Delimitador entre linhas (no formato Template)
## format\_tsv\_null\_representation
Representação personalizada para NULL no formato TSV
## input\_format\_allow\_errors\_num
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.
## 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 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.
## input\_format\_allow\_seeks
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.
## 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 fazer a correspondência entre colunas Arrow e colunas CH.
## input\_format\_arrow\_skip\_columns\_with\_unsupported\_types\_in\_schema\_inference
Ignora 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 um campo não for encontrado no esquema, use o valor padrão em vez de retornar erro
## input\_format\_avro\_null\_as\_default
Para o formato Avro/AvroConfluent: insere o valor padrão em caso de NULL em colunas não Nullable
## input\_format\_binary\_decode\_types\_in\_binary\_format
Ler 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 JSON em [String](/pt-BR/reference/data-types/string) 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 para o formato CapnProto
## input\_format\_column\_name\_matching\_mode
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.
## input\_format\_connection\_handling
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
## input\_format\_csv\_allow\_cr\_end\_of\_line
Se estiver definido como true, \r será permitido no fim da linha sem ser seguido de
## 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 considera 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 um Array em CSV, espera-se que seus elementos tenham sido serializados como CSV aninhado e, em seguida, inseridos 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 estiver definido como true, colunas separadas escritas no formato CSV poderão ser desserializadas para uma coluna Tuple.
Detecta automaticamente o cabeçalho com nomes e tipos no formato CSV
## input\_format\_csv\_empty\_as\_default
Trata campos vazios na entrada CSV como valores padrão.
## input\_format\_csv\_enum\_as\_number
Tratar valores enum inseridos em formatos CSV como índices de enum
## 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 finais no formato CSV
## input\_format\_csv\_trim\_whitespaces
Remove caracteres de espaço e tabulação (\t) do início e do fim de Strings CSV
## input\_format\_csv\_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 CSV contiverem números UInt64 entre aspas.
Desabilitado 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 de um 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 cabeçalhos 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), 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.
Valores possíveis:
* 0 — Desabilitado.
* 1 — Habilitado.
## input\_format\_force\_null\_for\_omitted\_fields
Força a inicialização dos campos omitidos com valores NULL
## input\_format\_hive\_text\_allow\_variable\_number\_of\_columns
Ignora colunas extras na entrada Hive Text (se o arquivo tiver mais colunas do que o esperado) e trata campos ausentes na entrada Hive Text como os valores padrão
## input\_format\_hive\_text\_collection\_items\_delimiter
Delimitador entre itens de coleções (array ou map) no Hive Text File
## input\_format\_hive\_text\_fields\_delimiter
Delimitador entre os campos no Hive Text File
## input\_format\_hive\_text\_map\_keys\_delimiter
Delimitador entre um par de chave/valor em um map no Hive Text File
## input\_format\_import\_nested\_json
Habilita ou desabilita a inserção de dados JSON com objetos aninhados.
Formatos suportados:
* [JSONEachRow](/pt-BR/reference/formats/JSON/JSONEachRow)
Valores possíveis:
* 0 — Desabilitado.
* 1 — Habilitado.
Veja também:
* [Uso de estruturas aninhadas](/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.
Desativado 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.
Desabilitado 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 as 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 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.
## input\_format\_json\_empty\_as\_default
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.
## input\_format\_json\_ignore\_unknown\_keys\_in\_named\_tuple
Ignora chaves desconhecidas no objeto JSON de tuplas nomeadas.
Ativado por padrão.
## input\_format\_json\_ignore\_unnecessary\_fields
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
## input\_format\_json\_infer\_array\_of\_dynamic\_from\_array\_of\_different\_types
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:
```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 de JSON que contêm apenas `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:
```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,'{}',[]) │
└────────────────────────────────┘
```
Habilitado por padrão.
## input\_format\_json\_map\_as\_array\_of\_tuples
Desserializa colunas do tipo map como arrays JSON de tuplas.
Desabilitado por padrão.
## input\_format\_json\_max\_depth
Profundidade máxima de um campo no JSON. Não é um limite rígido e não precisa ser aplicado com exatidão.
## input\_format\_json\_named\_tuples\_as\_objects
Interpreta colunas de tuplas nomeadas como objetos JSON.
Habilitado por padrão.
## input\_format\_json\_read\_arrays\_as\_strings
Permite parsing de 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] │
└───────────────────────┴─────────────────┴───────────────────────────────────────────┘
```
Habilitado por padrão.
## input\_format\_json\_read\_bools\_as\_numbers
Permite parsing de valores booleanos como números em formatos de entrada JSON.
Ativado por padrão.
## input\_format\_json\_read\_bools\_as\_strings
Permite fazer parsing de valores Bool como Strings em formatos de entrada JSON.
Habilitado por padrão.
## input\_format\_json\_read\_numbers\_as\_strings
Permite fazer parsing de números como strings nos formatos de entrada JSON.
Habilitado por padrão.
## input\_format\_json\_read\_objects\_as\_strings
Permite parsing de 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 │
└────┴──────────────────────────┴────────────┘
```
Ativado por padrão.
## input\_format\_json\_throw\_on\_bad\_escape\_sequence
Gera uma exceção se uma string JSON contiver uma sequência de escape inválida em formatos de entrada JSON. Se estiver desabilitada, as sequências de escape inválidas permanecerão nos dados como estão.
Ativado por padrão.
## input\_format\_json\_try\_infer\_named\_tuples\_from\_objects
Se estiver habilitado, durante a inferência de esquema, o ClickHouse tentará inferir uma tupla nomeada a partir de objetos JSON.
A tupla nomeada resultante conterá todos os elementos de todos os objetos JSON correspondentes nos dados de amostra.
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))) │ │ │ │ │ │
└──────┴────────────────────────────────────────────────────────────────────────────────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Ativado 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.
Desabilitado por padrão.
## input\_format\_json\_use\_string\_type\_for\_ambiguous\_paths\_in\_named\_tuples\_inference\_from\_objects
Usa o tipo String em vez de gerar uma exceção em 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 esta configuração estiver definida como 1,
os tipos dos metadados nos dados de entrada serão comparados com os tipos das respectivas colunas da tabela.
Ativada 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 de espera, em milissegundos, antes da emissão de um bloco durante o parsing em formatos de entrada baseados em linha. 0 significa sem limite.
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.
**Exemplo: streaming de mudanças 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 a serem lidas para a 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 com base nos dados.
## input\_format\_mysql\_dump\_map\_column\_names
Faz a correspondência entre as colunas da tabela no dump do MySQL e as colunas da tabela do ClickHouse pelos nomes
## input\_format\_mysql\_dump\_table\_name
Nome da tabela no dump do MySQL da qual os dados serão lidos
## 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
Lê tipos de dados em formato binário em vez de nomes de tipos no formato de entrada Native
## input\_format\_null\_as\_default
Ativa ou desativa a inicialização de campos [NULL](/pt-BR/reference/syntax#literals) com [valores padrão](/pt-BR/reference/statements/create/table#default_values), se o tipo de dado desses campos não for [nullable](/pt-BR/reference/data-types/nullable).
Se o tipo da coluna não for nullable e essa configuração estiver desativada, 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 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.
## input\_format\_orc\_allow\_missing\_columns
Permitir colunas ausentes na leitura de formatos de entrada ORC
## input\_format\_orc\_case\_insensitive\_column\_matching
Ignora diferenças entre maiúsculas e minúsculas ao corresponder colunas ORC com colunas do CH.
## input\_format\_orc\_dictionary\_as\_low\_cardinality
Trata colunas codificadas por dicionário ORC como colunas LowCardinality ao ler 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 mín./máx. ou no filtro de Bloom nos metadados do ORC.
## input\_format\_orc\_reader\_time\_zone\_name
O nome do fuso horário do leitor de linhas ORC; por padrão, o fuso horário do leitor de linhas ORC é GMT.
## input\_format\_orc\_row\_batch\_size
Tamanho do batch ao ler stripes de 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\_orc\_use\_fast\_decoder
Usa uma implementação mais rápida do decodificador ORC.
## input\_format\_parallel\_parsing
Ativa ou desativa o parsing paralelo de formatos de dados com preservação da 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
Use o parser de colunas geo para converter Array(UInt8) em tipos Point/Linestring/Polygon/MultiLineString/MultiPolygon
## input\_format\_parquet\_allow\_missing\_columns
Permite colunas ausentes ao ler formatos de entrada Parquet
## input\_format\_parquet\_bloom\_filter\_push\_down
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.
## input\_format\_parquet\_case\_insensitive\_column\_matching
Ignora diferenças entre maiúsculas e minúsculas ao corresponder colunas do Parquet com colunas do CH.
## input\_format\_parquet\_enable\_json\_parsing
Ao ler arquivos Parquet, fazer o parsing de colunas JSON como colunas JSON do ClickHouse.
## input\_format\_parquet\_enable\_row\_group\_prefetch
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.
## 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
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
## input\_format\_parquet\_local\_time\_as\_utc
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.
## input\_format\_parquet\_max\_block\_size
Tamanho máximo do bloco para o leitor de Parquet.
## input\_format\_parquet\_memory\_high\_watermark
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.
## input\_format\_parquet\_memory\_low\_watermark
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
Ignora páginas com base nos valores mín./máx. do índice de coluna.
## input\_format\_parquet\_prefer\_block\_bytes
Quantidade média de bytes por bloco produzidos 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 da consulta podem alterá-la. Em vez disso, use `ORDER BY _row_number`.
## 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 em como as páginas são lidas de arquivo Parquet quando não é usada 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
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
## input\_format\_protobuf\_oneof\_presence
Indica qual campo de oneof do Protobuf foi encontrado, definindo o valor do enum em uma coluna especial
## input\_format\_protobuf\_skip\_fields\_with\_unsupported\_types\_in\_schema\_inference
Ignora campos com tipos não suportados na 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
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:
* [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 — Desativado.
* 1 — Ativado.
## input\_format\_try\_infer\_dates
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.
## input\_format\_try\_infer\_datetimes
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.
## input\_format\_try\_infer\_datetimes\_only\_datetime64
Quando input\_format\_try\_infer\_datetimes estiver habilitado, infira apenas 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, no qual 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 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.
## input\_format\_try\_infer\_variants
Quando habilitado, o ClickHouse tentará inferir o tipo [`Variant`](/pt-BR/reference/data-types/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.
## input\_format\_tsv\_allow\_variable\_number\_of\_columns
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
## input\_format\_tsv\_crlf\_end\_of\_line
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
## input\_format\_tsv\_empty\_as\_default
Considera campos vazios na entrada TSV como valores padrão.
## input\_format\_tsv\_enum\_as\_number
Trata os valores `enum` inseridos em formatos TSV como índices de `enum`.
## input\_format\_tsv\_skip\_first\_lines
Ignora a quantidade especificada de linhas no início dos dados no formato TSV
## input\_format\_tsv\_skip\_trailing\_empty\_lines
Ignora linhas vazias finais no formato TSV
## input\_format\_tsv\_use\_best\_effort\_in\_schema\_inference
Utiliza alguns ajustes e heurísticas para inferir o esquema no formato TSV
## input\_format\_values\_accurate\_types\_of\_literals
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.
## input\_format\_values\_deduce\_templates\_of\_expressions
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.
## 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.
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:
* [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 — 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:
* [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.
## insert\_distributed\_one\_random\_shard
Habilita ou desabilita a inserção em um shard aleatório em uma tabela [Distributed](/pt-BR/reference/engines/table-engines/special/distributed) quando não há chave de distribuição.
Por padrão, ao inserir dados em uma tabela `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.
## interval\_output\_format
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](https://learn.microsoft.com/en-us/dotnet/standard/base-types/standard-timespan-format-strings#the-constant-c-format-specifier). 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:
* [Interval](/pt-BR/reference/data-types/special-data-types/interval)
## into\_outfile\_create\_parent\_directories
Cria automaticamente os diretórios pai ao usar INTO OUTFILE, caso eles ainda não existam.
## json\_type\_escape\_dots\_in\_keys
Quando ativado, os pontos nas chaves do JSON serão escapados durante o parsing.
## max\_dynamic\_subcolumns\_in\_json\_type\_parsing
O número máximo de subcolunas dinâmicas que podem ser criadas em cada coluna durante a análise de uma coluna JSON.
Isso permite controlar o número de subcolunas dinâmicas durante a análise, independentemente dos parâmetros dinâmicos especificados no tipo de dado.
## output\_format\_arrow\_compression\_method
Método de compressão para o formato de saída Arrow. Codecs compatíveis: lz4\_frame, zstd, none (sem compressão)
## output\_format\_arrow\_date\_as\_uint16
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).
## output\_format\_arrow\_fixed\_string\_as\_fixed\_byte\_array
Usa o tipo Arrow FIXED\_SIZE\_BINARY em vez de Binary para colunas FixedString.
## output\_format\_arrow\_low\_cardinality\_as\_dictionary
Habilita a saída do tipo LowCardinality como tipo Dicionário do Arrow
## output\_format\_arrow\_string\_as\_string
Use o tipo Arrow String em vez de Binary para colunas String
## output\_format\_arrow\_unsupported\_types\_as\_binary
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.
## output\_format\_arrow\_use\_64\_bit\_indexes\_for\_dictionary
Sempre use inteiros de 64 bits para índices de dicionário no formato Arrow
## output\_format\_arrow\_use\_signed\_indexes\_for\_dictionary
Usar inteiros com sinal para índices de dicionário no formato Arrow
## output\_format\_avro\_codec
Codec de compressão usado na saída. Valores possíveis: 'null', 'deflate', 'snappy', 'zstd'.
## output\_format\_avro\_confluent\_subject
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.
## output\_format\_avro\_rows\_in\_file
Número máximo de linhas em um arquivo (se permitido pelo armazenamento)
## output\_format\_avro\_string\_column\_pattern
Para o formato Avro: expressão regular das colunas String a serem selecionadas como string do AVRO.
## output\_format\_avro\_sync\_interval
Intervalo de sincronização, em bytes.
## output\_format\_binary\_encode\_types\_in\_binary\_format
Grava tipos de dados em formato binário em vez de nomes de tipos no formato de saída RowBinaryWithNamesAndTypes
## output\_format\_binary\_write\_json\_as\_string
Grava valores do tipo de dado [JSON](/pt-BR/reference/data-types/newjson) como strings JSON [String](/pt-BR/reference/data-types/string) no formato de saída RowBinary.
## output\_format\_bson\_string\_as\_string
Usa o tipo String do BSON em vez de Binary para colunas String.
## output\_format\_compression\_level
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`
## output\_format\_compression\_zstd\_window\_log
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`).
## output\_format\_csv\_crlf\_end\_of\_line
Se estiver definido como true, o fim de linha no formato CSV será \r\n em vez de \n.
## output\_format\_csv\_serialize\_tuple\_into\_separate\_columns
Se definido como true, as Tuples no formato CSV são serializadas como colunas separadas (isto é, o aninhamento na tupla é perdido)
## output\_format\_decimal\_trailing\_zeros
Exibe zeros à direita ao imprimir valores Decimal. Ex.: 1.230000 em vez de 1.23.
Desativado por padrão.
## output\_format\_json\_array\_of\_rows
Permite gerar todas as linhas como um array JSON no formato [JSONEachRow](/pt-BR/reference/formats/JSON/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:
```sql theme={null}
SET output_format_json_array_of_rows = 1;
SELECT number FROM numbers(3) FORMAT JSONEachRow;
```
Resultado:
```text theme={null}
[
{"number":"0"},
{"number":"1"},
{"number":"2"}
]
```
**Exemplo de consulta com a configuração desativada**
Consulta:
```sql theme={null}
SET output_format_json_array_of_rows = 0;
SELECT number FROM numbers(3) FORMAT JSONEachRow;
```
Resultado:
```text theme={null}
{"number":"0"}
{"number":"1"}
{"number":"2"}
```
## output\_format\_json\_escape\_forward\_slashes
Controla o escape de barras normais em saídas de string no formato de saída JSON. Isso é destinado à compatibilidade com JavaScript. Não confunda com barras invertidas, que são sempre escapadas.
Habilitado por padrão.
## output\_format\_json\_map\_as\_array\_of\_tuples
Serializa colunas do tipo map como arrays JSON de tuplas.
Desativado por padrão.
## output\_format\_json\_named\_tuples\_as\_objects
Serializa colunas de tuplas nomeadas como objetos JSON.
Ativado por padrão.
## output\_format\_json\_pretty\_print
Essa configuração determina como estruturas aninhadas, como Tuples, Maps e Arrays, são exibidas no array `data` ao usar o formato de saída JSON.
Por exemplo, em vez de gerar:
```json theme={null}
"data":
[
{
"tuple": {"a":1,"b":2,"c":3},
"array": [1,2,3],
"map": {"a":1,"b":2,"c":3}
}
],
```
A saída será formatada da seguinte forma:
```json theme={null}
"data":
[
{
"tuple": {
"a": 1,
"b": 2,
"c": 3
},
"array": [
1,
2,
3
],
"map": {
"a": 1,
"b": 2,
"c": 3
}
}
],
```
Habilitado por padrão.
## output\_format\_json\_quote\_64bit\_floats
Controla o uso de aspas em [números de ponto flutuante](/pt-BR/reference/data-types/float) de 64 bits quando são gerados em formatos JSON\*.
Desativado por padrão.
## output\_format\_json\_quote\_64bit\_integers
Controla o uso de aspas em [inteiros](/pt-BR/reference/data-types/int-uint) de 64 bits ou maiores (como `UInt64` ou `Int128`) quando são gerados no formato [JSON](/pt-BR/reference/formats/JSON/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.
## output\_format\_json\_quote\_decimals
Controla se valores decimais são colocados entre aspas nos formatos de saída JSON.
Desativado por padrão.
## output\_format\_json\_quote\_denormals
Habilita a saída de `+nan`, `-nan`, `+inf` e `-inf` no formato de saída [JSON](/pt-BR/reference/formats/JSON/JSON).
Valores possíveis:
* 0 — Desabilitado.
* 1 — Habilitado.
**Exemplo**
Considere a seguinte tabela `account_orders`:
```text theme={null}
┌─id─┬─name───┬─duration─┬─period─┬─area─┐
│ 1 │ Andrew │ 20 │ 0 │ 400 │
│ 2 │ John │ 40 │ 0 │ 0 │
│ 3 │ Bob │ 15 │ 0 │ -100 │
└────┴────────┴──────────┴────────┴──────┘
```
Quando `output_format_json_quote_denormals = 0`, a consulta retorna valores `null` na saída:
```sql theme={null}
SELECT area/period FROM account_orders FORMAT JSON;
```
```json theme={null}
{
"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
}
}
```
Quando `output_format_json_quote_denormals = 1`, a consulta retorna:
```json theme={null}
{
"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
}
}
```
## output\_format\_json\_skip\_null\_value\_in\_named\_tuples
Ignora pares chave-valor com valor nulo ao serializar colunas de tuplas nomeadas como objetos JSON. Isso só é válido quando output\_format\_json\_named\_tuples\_as\_objects é true.
## output\_format\_json\_validate\_utf8
Controla a validação de sequências UTF-8 nos formatos de saída JSON; não afeta os formatos JSON/JSONCompact/JSONColumnsWithMetadata, que sempre validam UTF-8.
Desativado por padrão.
## output\_format\_markdown\_escape\_special\_characters
Quando ativado, escapa caracteres especiais em Markdown.
[Common Mark](https://spec.commonmark.org/0.30/#example-12) define os seguintes caracteres especiais que podem ser escapados por :
```
! " # $ % & ' ( ) * + , - . / : ; < = > ? @ [ \ ] ^ _ ` { | } ~
```
Valores possíveis:
* 0 — Desativado.
* 1 — Ativado.
## output\_format\_msgpack\_uuid\_representation
A forma como o UUID é exibido no formato MsgPack.
## output\_format\_native\_encode\_types\_in\_binary\_format
Escreve tipos de dados em formato binário em vez de nomes de tipos no formato de saída Native
## output\_format\_native\_use\_flattened\_dynamic\_and\_json\_serialization
Grava os dados das colunas [JSON](/pt-BR/reference/data-types/newjson) e [Dynamic](/pt-BR/reference/data-types/dynamic) em formato achatado (todos os tipos/caminhos como subcolunas separadas).
## output\_format\_native\_write\_json\_as\_string
Grava os dados da coluna [JSON](/pt-BR/reference/data-types/newjson) como uma coluna [String](/pt-BR/reference/data-types/string) contendo strings JSON, em vez da serialização JSON nativa padrão.
## output\_format\_orc\_compression\_block\_size
Tamanho do bloco de compressão, em bytes, para o formato de saída ORC.
## output\_format\_orc\_compression\_method
Método de compressão para o formato de saída ORC. Codecs compatíveis: lz4, snappy, zlib, zstd, none (sem compressão)
## output\_format\_orc\_dictionary\_key\_size\_threshold
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
## output\_format\_orc\_row\_index\_stride
Passo alvo do índice de linhas no formato de saída ORC
## output\_format\_orc\_string\_as\_string
Usa o tipo String do ORC em vez de Binary para colunas String
## output\_format\_orc\_writer\_time\_zone\_name
O nome do fuso horário do gravador ORC; o fuso horário padrão do gravador ORC é GMT.
## output\_format\_parallel\_formatting
Ativa ou desativa a formatação paralela para formatos de dados. Compatível apenas com os formatos [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.
## output\_format\_parquet\_batch\_size
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.
## output\_format\_parquet\_bloom\_filter\_bits\_per\_value
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%
## output\_format\_parquet\_bloom\_filter\_flush\_threshold\_bytes
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.
## output\_format\_parquet\_compression\_method
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
Tamanho alvo da página em bytes, antes da compressão.
## output\_format\_parquet\_date\_as\_uint16
Grava valores de Date como números simples de 16 bits (lidos de volta como UInt16), em vez de convertê-los para um tipo DATE de 32 bits do Parquet (lido de volta como Date32).
## output\_format\_parquet\_datetime\_as\_uint32
Grava valores DateTime como timestamp Unix bruto (lido de volta como UInt32), em vez de convertê-los para milissegundos (lido de volta como DateTime64(3)).
## output\_format\_parquet\_enum\_as\_byte\_array
Grava enum usando o tipo físico do Parquet: BYTE\_ARRAY e o tipo lógico: ENUM
## output\_format\_parquet\_fixed\_string\_as\_fixed\_byte\_array
Use o tipo Parquet FIXED\_LEN\_BYTE\_ARRAY em vez de Binary para colunas do tipo FixedString.
## output\_format\_parquet\_geometadata
Permite gravar informações sobre colunas geoespaciais nos metadados do Parquet e codificá-las no formato WKB.
## output\_format\_parquet\_max\_dictionary\_size
Se o tamanho do dicionário exceder esse número de bytes, alterne para a codificação sem dicionário. Defina 0 para desativar a codificação por dicionário.
## output\_format\_parquet\_parallel\_encoding
Executa a codificação Parquet em várias threads.
## output\_format\_parquet\_row\_group\_size
Tamanho alvo do grupo de linhas em linhas.
## output\_format\_parquet\_row\_group\_size\_bytes
Tamanho desejado do grupo de linhas, em bytes, antes da compressão.
## output\_format\_parquet\_string\_as\_string
Use o tipo String do Parquet em vez de Binary para colunas String.
## output\_format\_parquet\_write\_bloom\_filter
Grava filtros de Bloom em arquivos Parquet.
## output\_format\_parquet\_write\_checksums
Adiciona checksums crc32 aos cabeçalhos de página do Parquet.
## output\_format\_parquet\_write\_page\_index
Grava o índice de coluna e o índice de deslocamento (ou seja, estatísticas sobre cada página de dados, que podem ser usadas para pushdown de filtros durante a leitura) em arquivos Parquet.
## output\_format\_pretty\_color
Usa sequências de escape ANSI em formatos Pretty. 0 - desabilitado, 1 - habilitado, 'auto' - habilitado se a saída for um terminal.
## output\_format\_pretty\_display\_footer\_column\_names
Exibe os nomes das colunas no rodapé quando houver muitas linhas na tabela.
Valores possíveis:
* 0 — Nenhum nome de coluna é exibido no rodapé.
* 1 — Os nomes das colunas são exibidos no rodapé se a contagem de linhas for maior ou igual ao valor limite definido por [output\_format\_pretty\_display\_footer\_column\_names\_min\_rows](#output_format_pretty_display_footer_column_names_min_rows) (50 por padrão).
**Exemplo**
Consulta:
```sql theme={null}
SELECT *, toTypeName(*) FROM (SELECT * FROM system.numbers LIMIT 1000);
```
Resultado:
```response theme={null}
┌─number─┬─toTypeName(number)─┐
1. │ 0 │ UInt64 │
2. │ 1 │ UInt64 │
3. │ 2 │ UInt64 │
...
999. │ 998 │ UInt64 │
1000. │ 999 │ UInt64 │
└─number─┴─toTypeName(number)─┘
```
## output\_format\_pretty\_display\_footer\_column\_names\_min\_rows
Define o número mínimo de linhas a partir do qual um rodapé com nomes de colunas será exibido se a configuração [output\_format\_pretty\_display\_footer\_column\_names](#output_format_pretty_display_footer_column_names) estiver habilitada.
## output\_format\_pretty\_fallback\_to\_vertical
Se estiver habilitada e a tabela for larga, mas com poucas linhas, o formato Pretty a exibirá como o formato Vertical.
Consulte `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.
## output\_format\_pretty\_fallback\_to\_vertical\_max\_rows\_per\_chunk
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.
## output\_format\_pretty\_fallback\_to\_vertical\_min\_columns
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.
## output\_format\_pretty\_fallback\_to\_vertical\_min\_table\_width
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.
## output\_format\_pretty\_glue\_chunks
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.
## output\_format\_pretty\_grid\_charset
Conjunto de caracteres usado para imprimir as bordas da grade. Conjuntos de caracteres disponíveis: ASCII, UTF-8 (padrão).
## output\_format\_pretty\_highlight\_digit\_groups
Se estiver habilitado e a saída for um terminal, destaque com sublinhado cada dígito correspondente às casas de milhar, milhão etc.
## output\_format\_pretty\_highlight\_trailing\_spaces
Se estiver habilitada e a saída for um terminal, os espaços à direita serão destacados em cinza e sublinhados.
## output\_format\_pretty\_max\_column\_name\_width\_cut\_to
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`.
## 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`.
## output\_format\_pretty\_max\_column\_pad\_width
Largura máxima de preenchimento para todos os valores de uma coluna nos formatos Pretty.
## output\_format\_pretty\_max\_rows
Limite de linhas para os formatos Pretty.
## output\_format\_pretty\_max\_value\_width
Largura máxima do valor a ser exibido nos formatos Pretty. Se for maior, ele será truncado.
O valor 0 significa: nunca truncar.
## output\_format\_pretty\_max\_value\_width\_apply\_for\_single\_value
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`.
## output\_format\_pretty\_multiline\_fields
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).
## output\_format\_pretty\_named\_tuples\_as\_json
Controla se tuplas nomeadas no formato Pretty são exibidas como objetos JSON com formatação legível.
## output\_format\_pretty\_row\_numbers
Adiciona números de linha antes de cada linha no formato de saída Pretty
## output\_format\_pretty\_single\_large\_number\_tip\_threshold
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)
## output\_format\_pretty\_squash\_consecutive\_ms
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.
## output\_format\_pretty\_squash\_max\_wait\_ms
Emite o bloco pendente em formatos Pretty se tiver decorrido mais do que o número especificado de milissegundos desde a saída anterior.
## output\_format\_protobuf\_nullables\_with\_google\_wrappers
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
## output\_format\_schema
O caminho para o arquivo em que o esquema gerado automaticamente será salvo nos formatos [Cap'n Proto](/pt-BR/reference/formats/CapnProto) ou [Protobuf](/pt-BR/reference/formats/Protobuf/Protobuf).
## output\_format\_sql\_insert\_include\_column\_names
Inclui os nomes das colunas na consulta INSERT
## output\_format\_sql\_insert\_max\_batch\_size
O número máximo de linhas em uma única instrução INSERT.
## output\_format\_sql\_insert\_quote\_names
Coloca os nomes das colunas entre caracteres '\`'
## output\_format\_sql\_insert\_table\_name
O nome da tabela na consulta INSERT gerada na saída
## output\_format\_sql\_insert\_use\_replace
Usar a instrução REPLACE em vez de INSERT
## output\_format\_trim\_fixed\_string
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`.
## output\_format\_tsv\_crlf\_end\_of\_line
Se estiver definido como true, a quebra de linha no formato TSV será \r\n em vez de \n.
## output\_format\_values\_escape\_quote\_with\_quote
Se true, escapa ' como '', caso contrário, usa aspas com \\'
## output\_format\_write\_statistics
Grava estatísticas sobre linhas lidas, bytes e tempo decorrido em formatos de saída apropriados.
Ativado por padrão
## precise\_float\_parsing
Prefira um algoritmo de parsing de números de ponto flutuante mais preciso (porém mais lento)
## schema\_inference\_hints
A lista de nomes e tipos de colunas a ser usada como dica na inferência de esquema para formatos sem esquema.
Exemplo:
Consulta:
```sql theme={null}
desc format(JSONEachRow, '{"x" : 1, "y" : "String", "z" : "0.0.0.0" }') settings schema_inference_hints='x UInt8, z IPv4';
```
Resultado:
```sql theme={null}
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
Controla se os tipos inferidos serão definidos como `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
Controla se os tipos JSON inferidos serão definidos como `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`.
## schema\_inference\_mode
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
Defina a regra de aspas para identificadores na consulta SHOW CREATE
## show\_create\_query\_identifier\_quoting\_style
Define o estilo de aspas dos identificadores na consulta SHOW CREATE
## type\_json\_allow\_duplicated\_key\_with\_literal\_and\_nested\_object
Quando ativado, permite fazer o parse de JSONs como `{"a" : 42, "a" : {"b" : 42}}`, em que uma chave está duplicada, mas uma das ocorrências é um objeto aninhado.
## type\_json\_skip\_duplicated\_paths
Quando ativado, durante o parsing de um objeto JSON para o tipo JSON, caminhos duplicados serão ignorados e apenas o primeiro será inserido em vez de uma exceçã
## type\_json\_skip\_invalid\_typed\_paths
Quando ativada, os campos com valores que não podem ser convertidos para o tipo declarado em colunas do tipo JSON com caminhos tipados são ignorados em vez de gerar erro. Os campos ignorados são tratados como ausentes e usarão valores padrão/null com base na definição do caminho tipado.
Essa configuração se aplica apenas a colunas do tipo JSON (por exemplo, JSON(a Int64, b String)) em que caminhos específicos têm tipos declarados. Ela não se aplica a formatos de entrada JSON comuns, como JSONEachRow, ao inserir em colunas tipadas comuns.
Valores possíveis:
* 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
Quando ativado, durante a análise de um objeto JSON no tipo JSON, as expressões regulares especificadas com SKIP REGEXP exigirão uma correspondência parcial para ignorar um caminho. Quando desativado, será exigida uma correspondência completa.
## validate\_experimental\_and\_suspicious\_types\_inside\_nested\_types
Valida o uso de tipos experimentais e suspeitos em tipos aninhados, como Array/Map/Tuple