configurações de formato input_format_*

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

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.

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.

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.

Permitir colunas ausentes ao ler formatos de entrada do Arrow

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

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

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

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

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

Número máximo de nós de tipo ao decodificar tipos binários (não a profundidade, mas a contagem total). Map(String, UInt32) = 3 nós. Protege contra entradas maliciosas. 0 = ilimitado.

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

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

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

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.

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

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

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

Permite usar espaços e tabulações(\t) como delimitadores de campo em strings 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.

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

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

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

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

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

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

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.

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

Ignora linhas vazias no final no formato CSV

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

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.

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

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

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

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

Ignora linhas vazias no final no formato CustomSeparated

Ao executar consultas INSERT, substitua os valores omitidos das colunas de entrada pelos valores padrão das respectivas colunas. Esta opção se aplica aos formatos JSONEachRow (e outros formatos JSON), CSV, TabSeparated, TSKV, Parquet, Arrow, Avro, ORC, Native e aos formatos com os sufixos WithNames/WithNamesAndTypes.

Valores possíveis:

• 0 — Desabilitado.
• 1 — Habilitado.

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

Controla o que acontece quando um tipo de geometria GeoJSON válido que não pode ser representado no tipo Geometry do ClickHouse (como GeometryCollection) 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.

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

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

Delimitador entre os campos em Hive Text File

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

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

Formatos suportados:

• JSONEachRow

Valores possíveis:

• 0 — Desativado.
• 1 — Ativado.

Veja também:

• Uso de estruturas Nested com o formato JSONEachRow.

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.

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.

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.

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.

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.

Ignora chaves desconhecidas em objetos JSON para tuplas nomeadas.

Habilitado por padrão.

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

Se estiver habilitado, durante a inferência de esquema o ClickHouse usará o tipo Array(Dynamic) para arrays JSON com valores de diferentes tipos de dados.

Exemplo:

SET input_format_json_infer_array_of_dynamic_from_array_of_different_types=1;
DESC format(JSONEachRow, '{"a" : [42, "hello", [1, 2, 3]]}');

┌─name─┬─type───────────┐
│ a    │ Array(Dynamic) │
└──────┴────────────────┘

SET input_format_json_infer_array_of_dynamic_from_array_of_different_types=0;
DESC format(JSONEachRow, '{"a" : [42, "hello", [1, 2, 3]]}');

┌─name─┬─type─────────────────────────────────────────────────────────────┐
│ a    │ Tuple(Nullable(Int64), Nullable(String), Array(Nullable(Int64))) │
└──────┴──────────────────────────────────────────────────────────────────┘

Habilitado por padrão.

Permite usar o tipo String para chaves em JSON que contenham apenas Null/{}/[] na amostra de dados durante a inferência de esquema. Nos formatos JSON, qualquer valor pode ser lido como String, e isso permite evitar erros como Cannot determine type for column 'column_name' by first 25000 rows of data, most likely this column contains only Nulls or empty Arrays/Maps durante a inferência de esquema, usando o tipo String para chaves com tipos desconhecidos.

Exemplo:

SET input_format_json_infer_incomplete_types_as_strings = 1, input_format_json_try_infer_named_tuples_from_objects = 1;
DESCRIBE format(JSONEachRow, '{"obj" : {"a" : [1,2,3], "b" : "hello", "c" : null, "d" : {}, "e" : []}}');
SELECT * FROM format(JSONEachRow, '{"obj" : {"a" : [1,2,3], "b" : "hello", "c" : null, "d" : {}, "e" : []}}');

Resultado:

┌─name─┬─type───────────────────────────────────────────────────────────────────────────────────────────────────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ obj  │ Tuple(a Array(Nullable(Int64)), b Nullable(String), c Nullable(String), d Nullable(String), e Array(Nullable(String))) │              │                    │         │                  │                │
└──────┴────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘

┌─obj────────────────────────────┐
│ ([1,2,3],'hello',NULL,'{}',[]) │
└────────────────────────────────┘

Ativado por padrão.

Desserializa colunas do tipo map como arrays JSON de tuplas.

Desativado por padrão.

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

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

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

Interpreta colunas de tuplas nomeadas como objetos JSON.

Ativado por padrão.

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

Exemplo:

SET input_format_json_read_arrays_as_strings = 1;
SELECT arr, toTypeName(arr), JSONExtractArrayRaw(arr)[3] from format(JSONEachRow, 'arr String', '{"arr" : [1, "Hello", [1,2,3]]}');

Resultado:

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

Ativado por padrão.

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

Ativado por padrão.

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

Ativado por padrão.

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

Ativado por padrão.

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

Exemplo:

SET input_format_json_read_objects_as_strings = 1;
CREATE TABLE test (id UInt64, obj String, date Date) ENGINE=Memory();
INSERT INTO test FORMAT JSONEachRow {"id" : 1, "obj" : {"a" : 1, "b" : "Hello"}, "date" : "2020-01-01"};
SELECT * FROM test;

Resultado:

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

Habilitado por padrão.

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.

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

Exemplo:

SET input_format_json_try_infer_named_tuples_from_objects = 1;
DESC format(JSONEachRow, '{"obj" : {"a" : 42, "b" : "Hello"}}, {"obj" : {"a" : 43, "c" : [1, 2, 3]}}, {"obj" : {"d" : {"e" : 42}}}')

Resultado:

┌─name─┬─type───────────────────────────────────────────────────────────────────────────────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ obj  │ Tuple(a Nullable(Int64), b Nullable(String), c Array(Nullable(Int64)), d Tuple(e Nullable(Int64))) │              │                    │         │                  │                │
└──────┴────────────────────────────────────────────────────────────────────────────────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘

Habilitado por padrão.

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.

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

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.

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.

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.

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

clickhouse-client --query 'CREATE TABLE wikipedia_edits (data JSON)'

curl -sS --globoff -H 'Accept: application/json' --no-buffer \
  'https://stream.wikimedia.org/v2/stream/recentchange' \
  | clickhouse-client \
      --query 'INSERT INTO wikipedia_edits FORMAT JSONAsObject' \
      --input_format_max_block_wait_ms 1000 \
      --input_format_connection_handling 1 \
      --min_insert_block_size_rows 0 \
      --min_insert_block_size_bytes 0

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

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

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

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

Nome da tabela no MySQL dump de onde ler os dados

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

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

Habilita ou desabilita a inicialização de campos NULL com valores padrão, caso o tipo de dados desses campos não seja Nullable. Se o tipo da coluna não for Nullable e essa configuração estiver desabilitada, inserir NULL causará uma exceção. Se o tipo da coluna for Nullable, os valores NULL serão inseridos como estão, independentemente dessa configuração.

Essa configuração se aplica à maioria dos formatos de entrada.

Para expressões padrão complexas, input_format_defaults_for_omitted_fields também deve estar habilitado.

Valores possíveis:

• 0 — Inserir NULL em uma coluna não Nullable causa uma exceção.
• 1 — Os campos NULL são inicializados com os valores padrão da coluna.

Permitir colunas ausentes ao ler arquivos ORC no formato de entrada

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

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

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.

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

Tamanho do lote na leitura de stripes do ORC.

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

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

Valores possíveis:

• 1 — Habilitado.
• 0 — Desabilitado.

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

Permitir colunas ausentes ao ler formatos de entrada em Parquet

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

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

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

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

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

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.

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

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.

Tamanho máximo do bloco do leitor de Parquet.

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.

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.

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

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

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.

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

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

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

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

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

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

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

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

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

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

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

Habilita ou desabilita a omissão de dados extras durante a inserção.

Ao gravar dados, o ClickHouse lança uma exceção se os dados de entrada contiverem colunas que não existem na tabela de destino. Se essa opção estiver habilitada, o ClickHouse não insere os dados extras nem lança uma exceção.

Formatos suportados:

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

Valores possíveis:

• 0 — Desabilitado.
• 1 — Habilitado.

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.

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.

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

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

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

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

Valores possíveis:

• 0 — Habilitado.
• 1 — Habilitado.

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

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

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

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

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

Ignora linhas vazias no final no formato TSV

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

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.

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.

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
• CSVWithNamesAndTypes
• TabSeparatedWithNames
• TabSeparatedWithNamesAndTypes
• JSONCompactEachRowWithNames
• JSONCompactEachRowWithNamesAndTypes
• JSONCompactStringsEachRowWithNames
• JSONCompactStringsEachRowWithNamesAndTypes
• RowBinaryWithNames
• RowBinaryWithNamesAndTypes
• CustomSeparatedWithNames
• 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
• TabSeparatedWithNamesAndTypes
• JSONCompactEachRowWithNamesAndTypes
• JSONCompactStringsEachRowWithNamesAndTypes
• RowBinaryWithNamesAndTypes
• CustomSeparatedWithNamesAndTypes

Valores possíveis:

• 0 — Desabilitado.
• 1 — Habilitado.