> ## Documentation Index > Fetch the complete documentation index at: https://private-7c7dfe99-postgresql-tls-support.mintlify.site/llms.txt > Use this file to discover all available pages before exploring further. # Обработка других форматов JSON > Обработка других форматов JSON В предыдущих примерах загрузки данных в формате JSON предполагается использование [`JSONEachRow`](/ru/reference/formats/JSON/JSONEachRow) (`NDJSON`). Этот формат интерпретирует ключи в каждой строке JSON как столбцы. Например: ```sql theme={null} SELECT * FROM s3('https://datasets-documentation.s3.eu-west-3.amazonaws.com/pypi/json/*.json.gz', JSONEachRow) LIMIT 5 ``` ```response theme={null} ┌───────date─┬─country_code─┬─project────────────┬─type────────┬─installer────┬─python_minor─┬─system─┬─version─┐ │ 2022-11-15 │ CN │ clickhouse-connect │ bdist_wheel │ bandersnatch │ │ │ 0.2.8 │ │ 2022-11-15 │ CN │ clickhouse-connect │ bdist_wheel │ bandersnatch │ │ │ 0.2.8 │ │ 2022-11-15 │ CN │ clickhouse-connect │ bdist_wheel │ bandersnatch │ │ │ 0.2.8 │ │ 2022-11-15 │ CN │ clickhouse-connect │ bdist_wheel │ bandersnatch │ │ │ 0.2.8 │ │ 2022-11-15 │ CN │ clickhouse-connect │ bdist_wheel │ bandersnatch │ │ │ 0.2.8 │ └────────────┴──────────────┴────────────────────┴─────────────┴──────────────┴──────────────┴────────┴─────────┘ 5 rows in set. Elapsed: 0.449 sec. ``` Хотя обычно используется именно этот формат JSON, вы также можете столкнуться с другими форматами или вам может понадобиться считать JSON как единый объект. Ниже приведены примеры чтения и загрузки JSON в других распространённых форматах.
## Чтение JSON как объекта
В предыдущих примерах показано, как `JSONEachRow` читает JSON, разделённый символами новой строки: каждая строка интерпретируется как отдельный объект, сопоставляется со строкой таблицы, а каждый ключ — со столбцом. Это идеально подходит для случаев, когда структура JSON предсказуема и для каждого столбца используется только один тип. В отличие от этого, `JSONAsObject` рассматривает каждую строку как отдельный объект JSON и сохраняет его в одном столбце типа [`JSON`](/ru/reference/data-types/newjson), поэтому этот формат лучше подходит для вложенной полезной нагрузки JSON и случаев, когда ключи являются динамическими и потенциально могут иметь более одного типа. Используйте `JSONEachRow` для построчной вставки, а [`JSONAsObject`](/ru/reference/formats/JSON/JSONAsObject) — для хранения гибких или динамических данных JSON. Сравните приведённый выше пример со следующим запросом, который читает те же данные как объект JSON в каждой строке: ```sql theme={null} SELECT * FROM s3('https://datasets-documentation.s3.eu-west-3.amazonaws.com/pypi/json/*.json.gz', JSONAsObject) LIMIT 5 ``` ```response theme={null} ┌─json─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐ │ {"country_code":"CN","date":"2022-11-15","installer":"bandersnatch","project":"clickhouse-connect","python_minor":"","system":"","type":"bdist_wheel","version":"0.2.8"} │ │ {"country_code":"CN","date":"2022-11-15","installer":"bandersnatch","project":"clickhouse-connect","python_minor":"","system":"","type":"bdist_wheel","version":"0.2.8"} │ │ {"country_code":"CN","date":"2022-11-15","installer":"bandersnatch","project":"clickhouse-connect","python_minor":"","system":"","type":"bdist_wheel","version":"0.2.8"} │ │ {"country_code":"CN","date":"2022-11-15","installer":"bandersnatch","project":"clickhouse-connect","python_minor":"","system":"","type":"bdist_wheel","version":"0.2.8"} │ │ {"country_code":"CN","date":"2022-11-15","installer":"bandersnatch","project":"clickhouse-connect","python_minor":"","system":"","type":"bdist_wheel","version":"0.2.8"} │ └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘ 5 rows in set. Elapsed: 0.338 sec. ``` `JSONAsObject` полезен для вставки строк в таблицу с помощью одного столбца с объектом JSON, например. ```sql theme={null} CREATE TABLE pypi ( `json` JSON ) ENGINE = MergeTree ORDER BY tuple(); INSERT INTO pypi SELECT * FROM s3('https://datasets-documentation.s3.eu-west-3.amazonaws.com/pypi/json/*.json.gz', JSONAsObject) LIMIT 5; SELECT * FROM pypi LIMIT 2; ``` ```response theme={null} ┌─json─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐ │ {"country_code":"CN","date":"2022-11-15","installer":"bandersnatch","project":"clickhouse-connect","python_minor":"","system":"","type":"bdist_wheel","version":"0.2.8"} │ │ {"country_code":"CN","date":"2022-11-15","installer":"bandersnatch","project":"clickhouse-connect","python_minor":"","system":"","type":"bdist_wheel","version":"0.2.8"} │ └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘ 2 rows in set. Elapsed: 0.003 sec. ``` Формат `JSONAsObject` также может быть полезен для чтения JSON, разделённого символами новой строки, в случаях, когда структура объектов непоследовательна. Например, если тип значения по одному и тому же ключу различается от строки к строке (иногда это строка, а в других случаях — объект). В таких случаях ClickHouse не может вывести стабильную схему с помощью `JSONEachRow`, а `JSONAsObject` позволяет выполнять приём данных без строгой типизации, сохраняя каждую JSON-строку целиком в одном столбце. Например, обратите внимание, как `JSONEachRow` выдаёт ошибку в следующем примере: ```sql theme={null} SELECT count() FROM s3('https://clickhouse-public-datasets.s3.amazonaws.com/bluesky/file_0001.json.gz', 'JSONEachRow') ``` ```response theme={null} Elapsed: 1.198 sec. Received exception from server (version 24.12.1): Code: 636. DB::Exception: Received from sql-clickhouse.clickhouse.com:9440. DB::Exception: The table structure cannot be extracted from a JSONEachRow format file. Error: Code: 117. DB::Exception: JSON objects have ambiguous data: in some objects path 'record.subject' has type 'String' and in some - 'Tuple(`$type` String, cid String, uri String)'. You can enable setting input_format_json_use_string_type_for_ambiguous_paths_in_named_tuples_inference_from_objects to use String type for path 'record.subject'. (INCORRECT_DATA) (version 24.12.1.18239 (official build)) To increase the maximum number of rows/bytes to read for structure determination, use setting input_format_max_rows_to_read_for_schema_inference/input_format_max_bytes_to_read_for_schema_inference. You can specify the structure manually: (in file/uri bluesky/file_0001.json.gz). (CANNOT_EXTRACT_TABLE_STRUCTURE) ``` Напротив, в этом случае можно использовать `JSONAsObject`, поскольку тип `JSON` поддерживает несколько типов для одного и того же подстолбца. ```sql theme={null} SELECT count() FROM s3('https://clickhouse-public-datasets.s3.amazonaws.com/bluesky/file_0001.json.gz', 'JSONAsObject') ``` ```response theme={null} ┌─count()─┐ │ 1000000 │ └─────────┘ 1 row in set. Elapsed: 0.480 sec. Processed 1.00 million rows, 256.00 B (2.08 million rows/s., 533.76 B/s.) ```
## Массив объектов JSON
Один из самых распространённых форматов JSON-данных — список объектов JSON в JSON-массиве, как в [этом примере](https://clickhouse-docs-assets.s3.us-east-1.amazonaws.com/list.json): ```bash theme={null} > cat list.json [ { "path": "Akiba_Hebrew_Academy", "month": "2017-08-01", "hits": 241 }, { "path": "Aegithina_tiphia", "month": "2018-02-01", "hits": 34 }, ... ] ``` Давайте создадим таблицу для таких данных: ```sql theme={null} CREATE TABLE sometable ( `path` String, `month` Date, `hits` UInt32 ) ENGINE = MergeTree ORDER BY tuple(month, path) ``` Чтобы импортировать список объектов JSON, можно использовать формат [`JSONEachRow`](/ru/reference/formats/JSON/JSONEachRow) (для вставки данных из файла [list.json](https://clickhouse-docs-assets.s3.us-east-1.amazonaws.com/list.json)): ```sql theme={null} INSERT INTO sometable FROM INFILE 'list.json' FORMAT JSONEachRow ``` Мы использовали конструкцию [FROM INFILE](/ru/reference/statements/insert-into#inserting-data-from-a-file), чтобы загрузить данные из локального файла, и видим, что импорт прошёл успешно: ```sql theme={null} SELECT * FROM sometable ``` ```response theme={null} ┌─path──────────────────────┬──────month─┬─hits─┐ │ 1971-72_Utah_Stars_season │ 2016-10-01 │ 1 │ │ Akiba_Hebrew_Academy │ 2017-08-01 │ 241 │ │ Aegithina_tiphia │ 2018-02-01 │ 34 │ └───────────────────────────┴────────────┴──────┘ ```
## Ключи объектов JSON
В некоторых случаях список объектов JSON может быть представлен как свойства объекта, а не как элементы массива (см. пример в [objects.json](https://clickhouse-docs-assets.s3.us-east-1.amazonaws.com/objects.json)): ```bash theme={null} cat objects.json ``` ```response theme={null} { "a": { "path":"April_25,_2017", "month":"2018-01-01", "hits":2 }, "b": { "path":"Akahori_Station", "month":"2016-06-01", "hits":11 }, ... } ``` ClickHouse может загружать данные такого типа с помощью формата [`JSONObjectEachRow`](/ru/reference/formats/JSON/JSONObjectEachRow): ```sql theme={null} INSERT INTO sometable FROM INFILE 'objects.json' FORMAT JSONObjectEachRow; SELECT * FROM sometable; ``` ```response theme={null} ┌─path────────────┬──────month─┬─hits─┐ │ Abducens_palsy │ 2016-05-01 │ 28 │ │ Akahori_Station │ 2016-06-01 │ 11 │ │ April_25,_2017 │ 2018-01-01 │ 2 │ └─────────────────┴────────────┴──────┘ ```
### Указание значений ключей родительского объекта
Допустим, мы также хотим сохранять в таблице значения из ключей родительского объекта. В этом случае можно использовать [следующую настройку](/ru/reference/settings/formats#format_json_object_each_row_column_for_object_name), чтобы указать имя столбца, в который будут сохраняться значения ключей: ```sql theme={null} SET format_json_object_each_row_column_for_object_name = 'id' ``` Теперь мы можем проверить, какие данные будут загружены из исходного JSON‑файла с помощью функции [`file()`](/ru/reference/functions/regular-functions/files#file): ```sql theme={null} SELECT * FROM file('objects.json', JSONObjectEachRow) ``` ```response theme={null} ┌─id─┬─path────────────┬──────month─┬─hits─┐ │ a │ April_25,_2017 │ 2018-01-01 │ 2 │ │ b │ Akahori_Station │ 2016-06-01 │ 11 │ │ c │ Abducens_palsy │ 2016-05-01 │ 28 │ └────┴─────────────────┴────────────┴──────┘ ``` Обратите внимание, что столбец `id` корректно заполнился значениями ключей.
## JSON-массивы
Иногда для экономии места JSON‑файлы кодируют в виде массивов, а не объектов. В этом случае мы имеем дело со [списком JSON-массивов](https://clickhouse-docs-assets.s3.us-east-1.amazonaws.com/arrays.jsonl): ```bash theme={null} cat arrays.json ``` ```response theme={null} ["Akiba_Hebrew_Academy", "2017-08-01", 241], ["Aegithina_tiphia", "2018-02-01", 34], ["1971-72_Utah_Stars_season", "2016-10-01", 1] ``` В этом случае ClickHouse загрузит эти данные и сопоставит каждое значение с соответствующим столбцом по его порядку в массиве. Для этого мы используем формат [`JSONCompactEachRow`](/ru/reference/formats/JSON/JSONCompactEachRow): ```sql theme={null} SELECT * FROM sometable ``` ```response theme={null} ┌─c1────────────────────────┬─────────c2─┬──c3─┐ │ Akiba_Hebrew_Academy │ 2017-08-01 │ 241 │ │ Aegithina_tiphia │ 2018-02-01 │ 34 │ │ 1971-72_Utah_Stars_season │ 2016-10-01 │ 1 │ └───────────────────────────┴────────────┴─────┘ ```
### Импорт отдельных столбцов из JSON-массивов
В некоторых случаях данные могут быть представлены по столбцам, а не по строкам. В этом случае родительский объект JSON содержит столбцы со значениями. См. [следующий файл](https://clickhouse-docs-assets.s3.us-east-1.amazonaws.com/columns.json): ```bash theme={null} cat columns.json ``` ```response theme={null} { "path": ["2007_Copa_America", "Car_dealerships_in_the_USA", "Dihydromyricetin_reductase"], "month": ["2016-07-01", "2015-07-01", "2015-07-01"], "hits": [178, 11, 1] } ``` ClickHouse использует формат [`JSONColumns`](/ru/reference/formats/JSON/JSONColumns) для разбора данных, представленных в таком виде: ```sql theme={null} SELECT * FROM file('columns.json', JSONColumns) ``` ```response theme={null} ┌─path───────────────────────┬──────month─┬─hits─┐ │ 2007_Copa_America │ 2016-07-01 │ 178 │ │ Car_dealerships_in_the_USA │ 2015-07-01 │ 11 │ │ Dihydromyricetin_reductase │ 2015-07-01 │ 1 │ └────────────────────────────┴────────────┴──────┘ ``` Также поддерживается более компактный формат для работы с [массивом столбцов](https://clickhouse-docs-assets.s3.us-east-1.amazonaws.com/columns-array.json) вместо объекта с использованием формата [`JSONCompactColumns`](/ru/reference/formats/JSON/JSONCompactColumns): ```sql theme={null} SELECT * FROM file('columns-array.json', JSONCompactColumns) ``` ```response theme={null} ┌─c1──────────────┬─────────c2─┬─c3─┐ │ Heidenrod │ 2017-01-01 │ 10 │ │ Arthur_Henrique │ 2016-11-01 │ 12 │ │ Alan_Ebnother │ 2015-11-01 │ 66 │ └─────────────────┴────────────┴────┘ ```
## Сохранение объектов JSON вместо парсинга
В некоторых случаях объекты JSON удобнее сохранять в одном столбце `String` (или `JSON`), а не разбирать. Это может быть полезно при работе со списком объектов JSON с разной структурой. Возьмем для примера [этот файл](https://clickhouse-docs-assets.s3.us-east-1.amazonaws.com/custom.json), где внутри родительского списка содержится несколько разных объектов JSON: ```bash theme={null} cat custom.json ``` ```response theme={null} [ {"name": "Joe", "age": 99, "type": "person"}, {"url": "/my.post.MD", "hits": 1263, "type": "post"}, {"message": "Warning on disk usage", "type": "log"} ] ``` Мы хотим сохранить исходные объекты JSON в следующей таблице: ```sql theme={null} CREATE TABLE events ( `data` String ) ENGINE = MergeTree ORDER BY () ``` Теперь мы можем загрузить данные из файла в эту таблицу, используя формат [`JSONAsString`](/ru/reference/formats/JSON/JSONAsString), чтобы сохранить объекты JSON вместо их парсинга: ```sql theme={null} INSERT INTO events (data) FROM INFILE 'custom.json' FORMAT JSONAsString ``` Также можно использовать [JSON-функции](/ru/reference/functions/regular-functions/json-functions) для запросов к сохранённым объектам: ```sql theme={null} SELECT JSONExtractString(data, 'type') AS type, data FROM events ``` ```response theme={null} ┌─type───┬─data─────────────────────────────────────────────────┐ │ person │ {"name": "Joe", "age": 99, "type": "person"} │ │ post │ {"url": "/my.post.MD", "hits": 1263, "type": "post"} │ │ log │ {"message": "Warning on disk usage", "type": "log"} │ └────────┴──────────────────────────────────────────────────────┘ ``` Обратите внимание, что `JSONAsString` отлично подходит для файлов в формате «один объект JSON на строку» (обычно используется с форматом `JSONEachRow`).
## Схема для вложенных объектов
Когда мы имеем дело с [вложенными JSON-объектами](https://clickhouse-docs-assets.s3.us-east-1.amazonaws.com/list-nested.json), можно дополнительно определить явную схему и использовать сложные типы ([`Array`](/ru/reference/data-types/array), [`JSON`](/ru/guides/clickhouse/data-formats/json/intro) или [`Tuple`](/ru/reference/data-types/tuple)) для загрузки данных: ```sql theme={null} SELECT * FROM file('list-nested.json', JSONEachRow, 'page Tuple(path String, title String, owner_id UInt16), month Date, hits UInt32') LIMIT 1 ``` ```response theme={null} ┌─page───────────────────────────────────────────────┬──────month─┬─hits─┐ │ ('Akiba_Hebrew_Academy','Akiba Hebrew Academy',12) │ 2017-08-01 │ 241 │ └────────────────────────────────────────────────────┴────────────┴──────┘ ```
## Доступ к вложенным JSON-объектам
Мы можем обращаться к [ключам вложенных JSON-объектов](https://clickhouse-docs-assets.s3.us-east-1.amazonaws.com/list-nested.json), включив [следующий параметр настройки](/ru/reference/settings/formats#input_format_import_nested_json): ```sql theme={null} SET input_format_import_nested_json = 1 ``` Это позволяет обращаться к ключам вложенных объектов JSON с помощью точечной нотации (не забудьте заключить их в обратные кавычки, чтобы это работало): ```sql theme={null} SELECT * FROM file('list-nested.json', JSONEachRow, '`page.owner_id` UInt32, `page.title` String, month Date, hits UInt32') LIMIT 1 ``` ```results theme={null} ┌─page.owner_id─┬─page.title───────────┬──────month─┬─hits─┐ │ 12 │ Akiba Hebrew Academy │ 2017-08-01 │ 241 │ └───────────────┴──────────────────────┴────────────┴──────┘ ``` Таким образом можно развернуть вложенные JSON-объекты или взять некоторые вложенные значения и сохранить их в отдельных столбцах.
## Игнорирование неизвестных столбцов
По умолчанию ClickHouse игнорирует неизвестные столбцы при импорте JSON-данных. Попробуем импортировать исходный файл в таблицу без столбца `month`: ```sql theme={null} CREATE TABLE shorttable ( `path` String, `hits` UInt32 ) ENGINE = MergeTree ORDER BY path ``` Мы по-прежнему можем вставить в эту таблицу [исходные данные в формате JSON](https://clickhouse-docs-assets.s3.us-east-1.amazonaws.com/list.json) с 3 столбцами: ```sql theme={null} INSERT INTO shorttable FROM INFILE 'list.json' FORMAT JSONEachRow; SELECT * FROM shorttable ``` ```response theme={null} ┌─path──────────────────────┬─hits─┐ │ 1971-72_Utah_Stars_season │ 1 │ │ Aegithina_tiphia │ 34 │ │ Akiba_Hebrew_Academy │ 241 │ └───────────────────────────┴──────┘ ``` ClickHouse будет игнорировать неизвестные столбцы при импорте. Это поведение можно отключить с помощью параметра [input\_format\_skip\_unknown\_fields](/ru/reference/settings/formats#input_format_skip_unknown_fields): ```sql theme={null} SET input_format_skip_unknown_fields = 0; INSERT INTO shorttable FROM INFILE 'list.json' FORMAT JSONEachRow; ``` ```response theme={null} Ok. Exception on client: Code: 117. DB::Exception: Unknown field found while parsing JSONEachRow format: month: (in file/uri /data/clickhouse/user_files/list.json): (at row 1) ``` ClickHouse будет генерировать исключения, если структура JSON не соответствует структуре столбцов таблицы.
## BSON
ClickHouse позволяет экспортировать данные в файлы в формате [BSON](https://bsonspec.org/) и импортировать данные из них. Этот формат используется некоторыми СУБД, например [MongoDB](https://github.com/mongodb/mongo). Для импорта данных BSON используется формат [BSONEachRow](/ru/reference/formats/BSONEachRow). Давайте импортируем данные из [этого BSON-файла](https://clickhouse-docs-assets.s3.us-east-1.amazonaws.com/data.bson): ```sql theme={null} SELECT * FROM file('data.bson', BSONEachRow) ``` ```response theme={null} ┌─path──────────────────────┬─month─┬─hits─┐ │ Bob_Dolman │ 17106 │ 245 │ │ 1-krona │ 17167 │ 4 │ │ Ahmadabad-e_Kalij-e_Sofla │ 17167 │ 3 │ └───────────────────────────┴───────┴──────┘ ``` Мы также можем экспортировать данные в файлы BSON, используя тот же формат: ```sql theme={null} SELECT * FROM sometable INTO OUTFILE 'out.bson' FORMAT BSONEachRow ``` После этого наши данные будут записаны в файл `out.bson`.