Parquet
更新时间：2025-08-21
本文介绍如何在 PALO 中导入 JSON 格式的数据文件。PALO 支持导入标准 JSON 格式数据，通过配置相关参数，可以灵活地处理不同的 JSON 数据结构，并支持从 JSON 数据中抽取字段、处理嵌套结构等场景。
导入方式
以下导入方式支持 JSON 格式的数据导入：
- Stream Load
- Broker Load
- Routine Load
- INSERT INTO FROM S3 TVF
- INSERT INTO FROM HDFS TVF
支持的 JSON 格式
PALO 支持以下三种 JSON 格式：
以 Array 表示的多行数据
适用于批量导入多行数据，要求：
- 根节点必须是数组
- 数组中每个元素是一个对象，表示一行数据
- 必须设置
strip_outer_array=true
示例数据：
JSON
1[
2 {"id": 123, "city": "beijing"},
3 {"id": 456, "city": "shanghai"}
4]
5
6// 支持嵌套结构
7[
8 {"id": 123, "city": {"name": "beijing", "region": "haidian"}},
9 {"id": 456, "city": {"name": "beijing", "region": "chaoyang"}}
10]以 Object 表示的单行数据
适用于单行数据导入，要求：
- 根节点必须是对象
- 整个对象表示一行数据
示例数据：
JSON
1{"id": 123, "city": "beijing"}
2
3// 支持嵌套结构
4{"id": 123, "city": {"name": "beijing", "region": "haidian"}}注意： 通常用于 Routine Load 导入方式，如 Kafka 中的单条消息。
以固定分隔符分隔的多行 Object 数据
适用于批量导入多行数据，要求：
- 每行是一个完整的 JSON 对象
- 必须设置
read_json_by_line=true - 可通过
line_delimiter参数指定行分隔符，默认为\n
示例数据：
JSON
1{"id": 123, "city": "beijing"}
2{"id": 456, "city": "shanghai"}参数配置
参数支持情况
下表列出了各种导入方式支持的 JSON 格式参数：
| 参数 | 默认值 | Stream Load | Broker Load | Routine Load | TVF |
|---|---|---|---|---|---|
| json paths | 无 | jsonpaths | properties.jsonpaths | properties.jsonpaths | jsonpaths |
| json root | 无 | json_root | properties.json_root | properties.json_root | json_root |
| strip outer array | false | strip_outer_array | properties.strip_outer_array | properties.strip_outer_array | strip_outer_array |
| read json by line | false | read_json_by_line | 不支持配置，都为 true | 不支持 | read_json_by_line, 默认为 true |
| fuzzy parse | false | fuzzy_parse | properties.fuzzy_parse | 不支持 | fuzzy_parse |
| num as string | false | num_as_string | properties.num_as_string | properties.num_as_string | num_as_string |
| 压缩格式 | plain | 不支持 | PROPERTIES.compress_type | 不支持 | compress_type |
注意：
- Stream Load：参数直接通过 HTTP Header 指定，如：
-H "jsonpaths: $.data" - Broker Load：参数通过
PROPERTIES指定，如：PROPERTIES("jsonpaths"="$.data") - Routine Load：参数通过
PROPERTIES指定，如：PROPERTIES("jsonpaths"="$.data") - TVF：参数通过 TVF 语句指定，如：
S3("jsonpaths"="$.data") - 如果需要将 JSON 文件中根节点的 JSON 对象导入，jsonpaths 需要指定为$.，如：
PROPERTIES("jsonpaths"="$.")
参数说明
JSON Path
- 作用：指定如何从 JSON 数据中抽取字段
- 类型：字符串数组
- 默认值：无，默认使用列名匹配
-
使用示例：
JSON1-- 基本用法 2["$.id", "$.city"] 3 4-- 嵌套结构 5["$.id", "$.info.city", "$.data[0].name"]
JSON Root
- 作用：指定 JSON 数据的解析起点
- 类型：字符串
- 默认值：无，默认从根节点开始解析
-
使用示例：
JSON1-- 原始数据 2{ 3 "data": { 4 "id": 123, 5 "city": "beijing" 6 } 7} 8 9-- 设置 json_root 10json_root = $.data
Strip Outer Array
- 作用：指定是否去除最外层的数组结构
- 类型：布尔值
- 默认值：false
-
使用示例：
JSON1-- 原始数据 2[ 3 {"id": 1, "city": "beijing"}, 4 {"id": 2, "city": "shanghai"} 5] 6 7-- 设置 strip_outer_array=true
Read JSON By Line
- 作用：指定是否按行读取 JSON 数据
- 类型：布尔值
- 默认值：false
-
使用示例：
JSON1-- 原始数据（每行一个完整的 JSON 对象） 2{"id": 1, "city": "beijing"} 3{"id": 2, "city": "shanghai"} 4 5-- 设置 read_json_by_line=true
Fuzzy Parse
- 作用：加速 JSON 数据的导入效率
- 类型：布尔值
- 默认值：false
-
限制：
- Array 中每行数据的字段顺序必须完全一致
- 通常与 strip_outer_array 配合使用
- 性能：可提升 3-5 倍导入效率
Num As String
- 作用：指定是否将 JSON 中的数值类型以字符串形式解析
- 类型：布尔值
- 默认值：false
-
使用场景：
- 处理超出数值范围的大数
- 避免数值精度损失
-
使用示例：
JSON1-- 原始数据 2{ 3 "id": "12345678901234567890", 4 "price": "99999999.999999" 5} 6-- 设置 num_as_string=true，price 字段将以字符串形式解析
JSON Path 和 Columns 的关系
在数据导入过程中，JSON Path 和 Columns 各自承担不同的职责：
JSON Path：定义数据抽取规则
- 从 JSON 数据中按指定路径抽取字段
- 抽取的字段按 JSON Path 中定义的顺序进行重排列
Columns：定义数据映射规则
- 将抽取的字段映射到目标表的列
- 可以进行列的重排和转换
这两个参数的处理过程是串行的：首先 JSON Path 从源数据中抽取字段并形成有序的数据集，然后 Columns 将这些数据映射到表的列中。如果不指定 Columns，抽取的字段将按照表的列顺序直接映射。
使用示例
仅使用 JSON Path
表结构和数据：
SQL
1-- 表结构
2CREATE TABLE example_table (
3 k2 int,
4 k1 int
5);
6
7-- JSON 数据
8{"k1": 1, "k2": 2}导入命令：
Shell
1curl -v ... -H "format: json" \
2 -H "jsonpaths: [\"$.k2\", \"$.k1\"]" \
3 -T example.json \
4 http://<fe_host>:<fe_http_port>/api/db_name/table_name/_stream_load导入结果：
Text
1+------+------+
2| k1 | k2 |
3+------+------+
4| 2 | 1 |
5+------+------+使用 JSON Path + Columns
使用相同的表结构和数据，添加 columns 参数：
导入命令：
Shell
1curl -v ... -H "format: json" \
2 -H "jsonpaths: [\"$.k2\", \"$.k1\"]" \
3 -H "columns: k2, k1" \
4 -T example.json \
5 http://<fe_host>:<fe_http_port>/api/db_name/table_name/_stream_load导入结果：
Text
1+------+------+
2| k1 | k2 |
3+------+------+
4| 1 | 2 |
5+------+------+字段重复使用
表结构和数据：
SQL
1-- 表结构
2CREATE TABLE example_table (
3 k2 int,
4 k1 int,
5 k1_copy int
6);
7
8-- JSON 数据
9{"k1": 1, "k2": 2}导入命令：
Shell
1curl -v ... -H "format: json" \
2 -H "jsonpaths: [\"$.k2\", \"$.k1\", \"$.k1\"]" \
3 -H "columns: k2, k1, k1_copy" \
4 -T example.json \
5 http://<fe_host>:<fe_http_port>/api/db_name/table_name/_stream_load导入结果：
Text
1+------+------+---------+
2| k2 | k1 | k1_copy |
3+------+------+---------+
4| 2 | 1 | 1 |
5+------+------+---------+嵌套字段映射
表结构和数据：
SQL
1-- 表结构
2CREATE TABLE example_table (
3 k2 int,
4 k1 int,
5 k1_nested1 int,
6 k1_nested2 int
7);
8
9-- JSON 数据
10{
11 "k1": 1,
12 "k2": 2,
13 "k3": {
14 "k1": 31,
15 "k1_nested": {
16 "k1": 32
17 }
18 }
19}导入命令：
Shell
1curl -v ... -H "format: json" \
2 -H "jsonpaths: [\"$.k2\", \"$.k1\", \"$.k3.k1\", \"$.k3.k1_nested.k1\"]" \
3 -H "columns: k2, k1, k1_nested1, k1_nested2" \
4 -T example.json \
5 http://<fe_host>:<fe_http_port>/api/db_name/table_name/_stream_load导入结果：
Text
1+------+------+------------+------------+
2| k2 | k1 | k1_nested1 | k1_nested2 |
3+------+------+------------+------------+
4| 2 | 1 | 31 | 32 |
5+------+------+------------+------------+使用示例
本节展示了不同导入方式下的 JSON 格式使用方法。
Stream Load 导入
Bash
1# 使用 JSON Path
2curl --location-trusted -u <user>:<passwd> \
3 -H "format: json" \
4 -H "jsonpaths: [\"$.id\", \"$.city\"]" \
5 -T example.json \
6 http://<fe_host>:<fe_http_port>/api/example_db/example_table/_stream_load
7
8# 指定 JSON root
9curl --location-trusted -u <user>:<passwd> \
10 -H "format: json" \
11 -H "json_root: $.events" \
12 -T example.json \
13 http://<fe_host>:<fe_http_port>/api/example_db/example_table/_stream_load
14
15# 按行读取 JSON
16curl --location-trusted -u <user>:<passwd> \
17 -H "format: json" \
18 -H "read_json_by_line: true" \
19 -T example.json \
20 http://<fe_host>:<fe_http_port>/api/example_db/example_table/_stream_loadBroker Load 导入
SQL
1-- 使用 JSON Path
2LOAD LABEL example_db.example_label
3(
4 DATA INFILE("s3://bucket/path/example.json")
5 INTO TABLE example_table
6 FORMAT AS "json"
7 PROPERTIES
8 (
9 "jsonpaths" = "[\"$.id\", \"$.city\"]"
10 )
11)
12WITH S3
13(
14 ...
15);
16
17-- 指定 JSON root
18LOAD LABEL example_db.example_label
19(
20 DATA INFILE("s3://bucket/path/example.json")
21 INTO TABLE example_table
22 FORMAT AS "json"
23 PROPERTIES
24 (
25 "json_root" = "$.events"
26 )
27)
28WITH S3
29(
30 ...
31);Routine Load 导入
SQL
1-- 使用 JSON Path
2CREATE ROUTINE LOAD example_db.example_job ON example_table
3PROPERTIES
4(
5 "format" = "json",
6 "jsonpaths" = "[\"$.id\", \"$.city\"]"
7)
8FROM KAFKA
9(
10 ...
11);TVF 导入
SQL
1-- 使用 JSON Path
2INSERT INTO example_table
3SELECT *
4FROM S3
5(
6 "uri" = "s3://bucket/example.json",
7 "format" = "json",
8 "jsonpaths" = "[\"$.id\", \"$.city\"]",
9 ...
10);
11
12-- 指定 JSON root
13INSERT INTO example_table
14SELECT *
15FROM S3
16(
17 "uri" = "s3://bucket/example.json",
18 "format" = "json",
19 "json_root" = "$.events",
20 ...
21);