> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-8c05c8a2.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
> Documentação do formato JSONObjectEachRow
# JSONObjectEachRow
| Entrada | Saída | Alias |
| ------- | ----- | ----- |
| ✔ | ✔ | |
## Descrição
Neste formato, todos os dados são representados como um único objeto JSON, com cada linha representada como um campo separado desse objeto, de maneira semelhante ao formato [`JSONEachRow`](/pt-BR/reference/formats/JSON/JSONEachRow).
## Exemplo de uso
### Exemplo básico
Dado o seguinte JSON:
```json theme={null}
{
"row_1": {"num": 42, "str": "hello", "arr": [0,1]},
"row_2": {"num": 43, "str": "hello", "arr": [0,1,2]},
"row_3": {"num": 44, "str": "hello", "arr": [0,1,2,3]}
}
```
Para usar um nome de objeto como valor de uma coluna, você pode usar a configuração especial [`format_json_object_each_row_column_for_object_name`](/pt-BR/reference/settings/formats#format_json_object_each_row_column_for_object_name).
O valor dessa configuração é definido como o nome de uma coluna, usada como chave JSON de uma linha no objeto resultante.
#### Saída
Digamos que temos a tabela `test` com duas colunas:
```text theme={null}
┌─object_name─┬─number─┐
│ first_obj │ 1 │
│ second_obj │ 2 │
│ third_obj │ 3 │
└─────────────┴────────┘
```
Vamos gerar a saída no formato `JSONObjectEachRow` e usar a configuração `format_json_object_each_row_column_for_object_name`:
```sql title="Query" theme={null}
SELECT * FROM test SETTINGS format_json_object_each_row_column_for_object_name='object_name'
```
```json title="Response" theme={null}
{
"first_obj": {"number": 1},
"second_obj": {"number": 2},
"third_obj": {"number": 3}
}
```
#### Entrada
Digamos que armazenamos a saída do exemplo anterior em um arquivo chamado `data.json`:
```sql title="Query" theme={null}
SELECT * FROM file('data.json', JSONObjectEachRow, 'object_name String, number UInt64') SETTINGS format_json_object_each_row_column_for_object_name='object_name'
```
```response title="Response" theme={null}
┌─object_name─┬─number─┐
│ first_obj │ 1 │
│ second_obj │ 2 │
│ third_obj │ 3 │
└─────────────┴────────┘
```
Também funciona para inferência de esquema:
```sql title="Query" theme={null}
DESCRIBE file('data.json', JSONObjectEachRow) SETTING format_json_object_each_row_column_for_object_name='object_name'
```
```response title="Response" theme={null}
┌─name────────┬─type────────────┐
│ object_name │ String │
│ number │ Nullable(Int64) │
└─────────────┴─────────────────┘
```
### Inserção de dados
```sql title="Query" theme={null}
INSERT INTO UserActivity FORMAT JSONEachRow {"PageViews":5, "UserID":"4324182021466249494", "Duration":146,"Sign":-1} {"UserID":"4324182021466249494","PageViews":6,"Duration":185,"Sign":1}
```
O ClickHouse permite:
* Qualquer ordem dos pares chave-valor no objeto.
* Omitir alguns valores.
O ClickHouse ignora os espaços entre os elementos e as vírgulas após os objetos. Você pode passar todos os objetos em uma única linha. Não é necessário separá-los com quebras de linha.
#### Processamento de valores omitidos
O ClickHouse substitui os valores omitidos pelos valores padrão dos [tipos de dados](/pt-BR/reference/data-types/index) correspondentes.
Se `DEFAULT expr` for especificado, o ClickHouse usará regras de substituição diferentes, dependendo da configuração [input\_format\_defaults\_for\_omitted\_fields](/pt-BR/reference/settings/formats#input_format_defaults_for_omitted_fields).
Considere a tabela a seguir:
```sql title="Query" theme={null}
CREATE TABLE IF NOT EXISTS example_table
(
x UInt32,
a DEFAULT x * 2
) ENGINE = Memory;
```
* Se `input_format_defaults_for_omitted_fields = 0`, o valor padrão de `x` e `a` é `0` (o valor padrão do tipo de dado `UInt32`).
* Se `input_format_defaults_for_omitted_fields = 1`, o valor padrão de `x` é `0`, mas o valor padrão de `a` é `x * 2`.
Ao inserir dados com `input_format_defaults_for_omitted_fields = 1`, o ClickHouse consome mais recursos computacionais do que na inserção com `input_format_defaults_for_omitted_fields = 0`.
### Selecionando dados
Considere a tabela `UserActivity` como um exemplo:
```response theme={null}
┌──────────────UserID─┬─PageViews─┬─Duration─┬─Sign─┐
│ 4324182021466249494 │ 5 │ 146 │ -1 │
│ 4324182021466249494 │ 6 │ 185 │ 1 │
└─────────────────────┴───────────┴──────────┴──────┘
```
A consulta `SELECT * FROM UserActivity FORMAT JSONEachRow` retorna:
```response theme={null}
{"UserID":"4324182021466249494","PageViews":5,"Duration":146,"Sign":-1}
{"UserID":"4324182021466249494","PageViews":6,"Duration":185,"Sign":1}
```
Ao contrário do formato [JSON](/pt-BR/reference/formats/JSON/JSON), não há substituição de sequências UTF-8 inválidas. Os valores são escapados da mesma forma que no `JSON`.
Qualquer conjunto de bytes pode ser emitido nas strings. Use o formato [`JSONEachRow`](/pt-BR/reference/formats/JSON/JSONEachRow) se tiver certeza de que os dados da tabela podem ser formatados como JSON sem perda de informação.
### Uso de estruturas aninhadas
Se você tiver uma tabela com colunas do tipo de dado [`Nested`](/pt-BR/reference/data-types/nested-data-structures/index), poderá inserir dados JSON com a mesma estrutura. Ative esse recurso com a configuração [input\_format\_import\_nested\_json](/pt-BR/reference/settings/formats#input_format_import_nested_json).
Por exemplo, considere a seguinte tabela:
```sql title="Query" theme={null}
CREATE TABLE json_each_row_nested (n Nested (s String, i Int32) ) ENGINE = Memory
```
Como você pode ver na descrição do tipo de dado `Nested`, o ClickHouse trata cada componente da estrutura aninhada como uma coluna separada (`n.s` e `n.i` na nossa tabela). Você pode inserir os dados da seguinte forma:
```sql title="Query" theme={null}
INSERT INTO json_each_row_nested FORMAT JSONEachRow {"n.s": ["abc", "def"], "n.i": [1, 23]}
```
Para inserir dados como um objeto JSON hierárquico, defina [`input_format_import_nested_json=1`](/pt-BR/reference/settings/formats#input_format_import_nested_json).
```json theme={null}
{
"n": {
"s": ["abc", "def"],
"i": [1, 23]
}
}
```
Sem essa configuração, ClickHouse lança uma exceção.
```sql title="Query" theme={null}
SELECT name, value FROM system.settings WHERE name = 'input_format_import_nested_json'
```
```response title="Response" theme={null}
┌─name────────────────────────────┬─value─┐
│ input_format_import_nested_json │ 0 │
└─────────────────────────────────┴───────┘
```
```sql title="Query" theme={null}
INSERT INTO json_each_row_nested FORMAT JSONEachRow {"n": {"s": ["abc", "def"], "i": [1, 23]}}
```
```response title="Response" theme={null}
Code: 117. DB::Exception: Unknown field found while parsing JSONEachRow format: n: (at row 1)
```
```sql title="Query" theme={null}
SET input_format_import_nested_json=1
INSERT INTO json_each_row_nested FORMAT JSONEachRow {"n": {"s": ["abc", "def"], "i": [1, 23]}}
SELECT * FROM json_each_row_nested
```
```response title="Response" theme={null}
┌─n.s───────────┬─n.i────┐
│ ['abc','def'] │ [1,23] │
└───────────────┴────────┘
```
## Configurações de formato
| Configuração | Descrição | Padrão | Observações |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [`input_format_import_nested_json`](/pt-BR/reference/settings/formats#input_format_import_nested_json) | mapeia dados JSON aninhados para tabelas aninhadas (funciona com o formato JSONEachRow). | `false` | |
| [`input_format_json_read_bools_as_numbers`](/pt-BR/reference/settings/formats#input_format_json_read_bools_as_numbers) | permite analisar valores booleanos como números em formatos de entrada JSON. | `true` | |
| [`input_format_json_read_bools_as_strings`](/pt-BR/reference/settings/formats#input_format_json_read_bools_as_strings) | permite interpretar bools como strings em formatos de entrada JSON. | `true` | |
| [`input_format_json_read_numbers_as_strings`](/pt-BR/reference/settings/formats#input_format_json_read_numbers_as_strings) | permite interpretar números como strings em formatos de entrada JSON. | `true` | |
| [`input_format_json_read_arrays_as_strings`](/pt-BR/reference/settings/formats#input_format_json_read_arrays_as_strings) | permite interpretar arrays JSON como strings em formatos de entrada JSON. | `true` | |
| [`input_format_json_read_objects_as_strings`](/pt-BR/reference/settings/formats#input_format_json_read_objects_as_strings) | permite interpretar objetos JSON como strings em formatos de entrada JSON. | `true` | |
| [`input_format_json_named_tuples_as_objects`](/pt-BR/reference/settings/formats#input_format_json_named_tuples_as_objects) | analisa colunas de tupla nomeada como objetos JSON. | `true` | |
| [`input_format_json_try_infer_numbers_from_strings`](/pt-BR/reference/settings/formats#input_format_json_try_infer_numbers_from_strings) | tenta inferir números a partir de campos string durante a inferência de esquema. | `false` | |
| [`input_format_json_try_infer_named_tuples_from_objects`](/pt-BR/reference/settings/formats#input_format_json_try_infer_named_tuples_from_objects) | tenta inferir tuplas nomeadas a partir de objetos JSON durante a inferência de esquema. | `true` | |
| [`input_format_json_infer_incomplete_types_as_strings`](/pt-BR/reference/settings/formats#input_format_json_infer_incomplete_types_as_strings) | usar o tipo String para chaves que contêm apenas NULLs ou objetos/arrays vazios durante a inferência de esquema em formatos de entrada JSON. | `true` | |
| [`input_format_json_defaults_for_missing_elements_in_named_tuple`](/pt-BR/reference/settings/formats#input_format_json_defaults_for_missing_elements_in_named_tuple) | inserir valores padrão para elementos ausentes em objeto JSON durante a análise de tupla nomeada. | `true` | |
| [`input_format_json_ignore_unknown_keys_in_named_tuple`](/pt-BR/reference/settings/formats#input_format_json_ignore_unknown_keys_in_named_tuple) | ignorar chaves desconhecidas em objeto JSON para tuplas nomeadas. | `false` | |
| [`input_format_json_compact_allow_variable_number_of_columns`](/pt-BR/reference/settings/formats#input_format_json_compact_allow_variable_number_of_columns) | permite um número variável de colunas no formato JSONCompact/JSONCompactEachRow, ignora colunas extras e usa valores padrão para colunas ausentes. | `false` | |
| [`input_format_json_throw_on_bad_escape_sequence`](/pt-BR/reference/settings/formats#input_format_json_throw_on_bad_escape_sequence) | gera uma exceção se a string JSON contiver uma sequência de escape inválida. Se desabilitado, as sequências de escape inválidas permanecerão como estão nos dados. | `true` | |
| [`input_format_json_empty_as_default`](/pt-BR/reference/settings/formats#input_format_json_empty_as_default) | trata campos vazios na entrada JSON como valores padrão. | `false`. | Para expressões padrão complexas, [`input_format_defaults_for_omitted_fields`](/pt-BR/reference/settings/formats#input_format_defaults_for_omitted_fields) também precisa estar habilitado. |
| [`output_format_json_quote_64bit_integers`](/pt-BR/reference/settings/formats#output_format_json_quote_64bit_integers) | controla o uso de aspas em inteiros de 64 bits no formato de saída JSON. | `true` | |
| [`output_format_json_quote_64bit_floats`](/pt-BR/reference/settings/formats#output_format_json_quote_64bit_floats) | controla o uso de aspas em números de ponto flutuante de 64 bits no formato de saída JSON. | `false` | |
| [`output_format_json_quote_denormals`](/pt-BR/reference/settings/formats#output_format_json_quote_denormals) | habilita as saídas '+nan', '-nan', '+inf' e '-inf' no formato de saída JSON. | `false` | |
| [`output_format_json_quote_decimals`](/pt-BR/reference/settings/formats#output_format_json_quote_decimals) | controla o uso de aspas em valores decimais no formato de saída JSON. | `false` | |
| [`output_format_json_escape_forward_slashes`](/pt-BR/reference/settings/formats#output_format_json_escape_forward_slashes) | controla o escape de barras normais em saídas de String no formato de saída JSON. | `true` | |
| [`output_format_json_named_tuples_as_objects`](/pt-BR/reference/settings/formats#output_format_json_named_tuples_as_objects) | serializa colunas de named tuple como objetos JSON. | `true` | |
| [`output_format_json_array_of_rows`](/pt-BR/reference/settings/formats#output_format_json_array_of_rows) | gera um array JSON de todas as linhas no formato JSONEachRow(Compact). | `false` | |
| [`output_format_json_validate_utf8`](/pt-BR/reference/settings/formats#output_format_json_validate_utf8) | habilita a validação de sequências UTF-8 nos formatos de saída JSON (observe que isso não afeta os formatos JSON/JSONCompact/JSONColumnsWithMetadata, que sempre validam UTF-8). | `false` | |