JSON 函数 | ClickHouse Docs

JSON 函数的类型

有两类用于解析 JSON 的函数：

simpleJSON* (visitParam*)，用于以极高速度解析受限的 JSON 子集。
JSONExtract*，用于解析常规 JSON。

simpleJSON (visitParam) 函数

ClickHouse 提供了一组用于处理简化 JSON 的特殊函数。所有这些 JSON 函数都建立在对 JSON 形式的严格假设之上。它们会尽量少做处理，以便尽可能快地完成任务。

具体假设如下：

字段名 (函数参数) 必须是常量。
字段名在 JSON 中必须采用某种规范编码形式。例如：simpleJSONHas('{"abc":"def"}', 'abc') = 1，但 simpleJSONHas('{"\\u0061\\u0062\\u0063":"def"}', 'abc') = 0
会在任意嵌套层级中搜索字段，不区分层级。如果存在多个匹配字段，则使用第一次出现的字段。
JSON 在字符串字面量之外不能包含空格字符。

JSONExtract 函数

这些函数基于 simdjson 实现，适用于更复杂的 JSON 解析场景。

不区分大小写的 JSONExtract 函数

这些函数在从 JSON 对象中提取值时执行 ASCII 不区分大小写的键名匹配。它们的行为与对应的区分大小写版本完全一致，唯一的区别是匹配对象键名时不考虑大小写。当多个仅大小写不同的键都能匹配时，将返回第一个匹配项。

JSONPath 语法

JSON_EXISTS、JSON_VALUE 和 JSON_QUERY 函数的第二个参数接受 JSONPath 表达式。ClickHouse 实现了 JSONPath 的一个小型子集，该子集大致基于 SQL/JSON 标准 (ISO/IEC TR 19075-6) ，且其支持范围有意比 RFC 9535 和其他常见实现更窄。支持的运算符如下。

权威实现位于 src/Functions/JSONPath/Parsers。

支持的运算符

语法	描述	示例
`$`	根元素。所有路径都必须以它开头。	`$`
`.key`	不带引号的点表示法成员访问。键可以以数字开头，也可以仅由数字组成。	`$.store.book`, `$.1key`, `$.123`
`."key"`	带引号的点表示法成员访问。用于包含空格或特殊字符的键。可使用双引号或反引号。	`$."foo bar"`
`[key]`	不带引号的方括号表示法成员访问。	`$[hello]`
`['key']`	带引号的方括号表示法成员访问。可使用单引号、双引号或反引号。	`$['foo bar']`
`[n]`	按索引访问数组元素 (索引从 0 开始) 。	`$.items[0]`
`[n, m, ...]`	访问多个数组元素。	`$.items[0, 2, 4]`
`[n to m]`	数组元素范围。结束索引 `m` 不包含在内。	`$.items[0 to 3]`
`[*]`	通配符，匹配数组中的所有元素。	`$.items[*]`

注意：

可以在同一对方括号内组合使用索引和范围 (例如 [0 to 2, 4]) 。
不能在同一对方括号内组合使用索引范围和通配符 (例如，[* , 0] 无效) 。
在范围 [n to m] 中，起始索引 n 必须严格小于结束索引 m，否则会引发异常。
单个索引 [n] 等同于范围 [n to n+1]。

不支持的运算符

以下 JSONPath 运算符在 RFC 9535 或其他实现中可用，但 ClickHouse 不支持：

语法	描述
`..`	递归下降。
`?(@.expr)`	过滤表达式。
`[start:end:step]`	切片表示法。请改用 `[n to m]`。
`@`	当前节点引用。
`[-n]`	负数 (从末尾开始) 数组索引。
脚本表达式	路径中的算术表达式或函数表达式。
`ON ERROR` / `ON EMPTY`	用于控制错误和空结果行为的标准 SQL/JSON 子句。

JSONAllPaths

引入版本：v24.8.0

返回 JSON 列每一行中存储的所有路径列表。

语法

JSONAllPaths(json)

参数

json — JSON 列。JSON

返回值

返回由 JSON 列中所有路径组成的数组。Array(String)

示例

用法示例

CREATE TABLE test (json JSON(max_dynamic_paths=1)) ENGINE = Memory;
INSERT INTO test FORMAT JSONEachRow {"json" : {"a" : 42}}, {"json" : {"b" : "Hello"}}, {"json" : {"a" : [1, 2, 3], "c" : "2020-01-01"}};
SELECT json, JSONAllPaths(json) FROM test;

┌─json───────────────────────────┬─JSONAllPaths(json)─┐
│ {"a":42}                       │ ['a']              │
│ {"b":"Hello"}                  │ ['b']              │
│ {"a":[1,2,3],"c":"2020-01-01"} │ ['a','c']          │
└────────────────────────────────┴────────────────────┘

JSONAllPathsWithTypes

引入版本：v24.8.0

返回 JSON 列中每一行存储的所有路径及其数据类型列表。

语法

JSONAllPathsWithTypes(json)

参数

json — JSON 列。JSON

返回值

返回 JSON 列中所有路径及其数据类型的映射。Map(String, String)

示例

使用示例

CREATE TABLE test (json JSON(max_dynamic_paths=1)) ENGINE = Memory;
INSERT INTO test FORMAT JSONEachRow {"json" : {"a" : 42}}, {"json" : {"b" : "Hello"}}, {"json" : {"a" : [1, 2, 3], "c" : "2020-01-01"}};
SELECT json, JSONAllPathsWithTypes(json) FROM test;

┌─json───────────────────────────┬─JSONAllPathsWithTypes(json)───────────────┐
│ {"a":42}                       │ {'a':'Int64'}                             │
│ {"b":"Hello"}                  │ {'b':'String'}                            │
│ {"a":[1,2,3],"c":"2020-01-01"} │ {'a':'Array(Nullable(Int64))','c':'Date'} │
└────────────────────────────────┴───────────────────────────────────────────┘

JSONAllValues

首次引入于：v26.4.0

以字符串数组的形式返回 JSON 列中每一行的所有值。这些值会按其文本表示形式进行序列化，并按路径名称排序。

语法

JSONAllValues(json)

参数

json — JSON 列。JSON

返回值

返回 JSON 列中所有值组成的 String 数组。Array(String)

示例

用法示例

CREATE TABLE test (json JSON(max_dynamic_paths=1)) ENGINE = Memory;
INSERT INTO test FORMAT JSONEachRow {"json": {"a": 42}}, {"json": {"b": "Hello"}}, {"json": {"a": [1, 2, 3], "c": "2020-01-01"}};
SELECT json, JSONAllValues(json) FROM test;

┌─json───────────────────────────┬─JSONAllValues(json)──────┐
│ {"a":42}                       │ ['42']                   │
│ {"b":"Hello"}                  │ ['Hello']                │
│ {"a":[1,2,3],"c":"2020-01-01"} │ ['[1,2,3]','2020-01-01'] │
└────────────────────────────────┴──────────────────────────┘

JSONArrayLength

引入版本：v23.2.0

返回最外层 JSON 数组中的元素数量。如果输入的 JSON 字符串无效，该函数将返回 NULL。

语法

JSONArrayLength(json)

别名: JSON_ARRAY_LENGTH

参数

json — 有效 JSON 的 String。String

返回值

如果 json 是有效的 JSON 数组字符串，则返回数组元素个数；否则返回 NULL。Nullable(UInt64)

示例

使用示例

SELECT
    JSONArrayLength(''),
    JSONArrayLength('[1,2,3]');

┌─JSONArrayLength('')─┬─JSONArrayLength('[1,2,3]')─┐
│                ᴺᵁᴸᴸ │                          3 │
└─────────────────────┴────────────────────────────┘

JSONDynamicPaths

引入版本：v24.8.0

返回以独立子列形式存储在 JSON 列中的动态路径列表。

语法

JSONDynamicPaths(json)

参数

json — JSON 列。JSON

返回值

返回由 JSON 列中的动态路径组成的数组。Array(String)

示例

使用示例

CREATE TABLE test (json JSON(max_dynamic_paths=1)) ENGINE = Memory;
INSERT INTO test FORMAT JSONEachRow {"json" : {"a" : 42}}, {"json" : {"b" : "Hello"}}, {"json" : {"a" : [1, 2, 3], "c" : "2020-01-01"}};
SELECT json, JSONDynamicPaths(json) FROM test;

┌─json───────────────────────────┬─JSONDynamicPaths(json)─┐
│ {"a":42}                       │ ['a']                  │
│ {"b":"Hello"}                  │ []                     │
│ {"a":[1,2,3],"c":"2020-01-01"} │ ['a']                  │
└────────────────────────────────┴────────────────────────┘

JSONDynamicPathsWithTypes

引入版本：v24.8.0

返回 JSON 列中以独立子列形式存储的动态路径列表，以及它们在每一行中的类型。

语法

JSONDynamicPathsWithTypes(json)

参数

json — JSON 列。JSON

返回值

返回 JSON 列中动态路径及其数据类型的映射。Map(String, String)

示例

使用示例

CREATE TABLE test (json JSON(max_dynamic_paths=1)) ENGINE = Memory;
INSERT INTO test FORMAT JSONEachRow {"json" : {"a" : 42}}, {"json" : {"b" : "Hello"}}, {"json" : {"a" : [1, 2, 3], "c" : "2020-01-01"}};
SELECT json, JSONDynamicPathsWithTypes(json) FROM test;

┌─json───────────────────────────┬─JSONDynamicPathsWithTypes(json)─┐
│ {"a":42}                       │ {'a':'Int64'}                   │
│ {"b":"Hello"}                  │ {}                              │
│ {"a":[1,2,3],"c":"2020-01-01"} │ {'a':'Array(Nullable(Int64))'}  │
└────────────────────────────────┴─────────────────────────────────┘

JSONExtract

引入版本：v19.14.0

解析 JSON，并提取指定 ClickHouse 数据类型的值。

语法

JSONExtract(json[, indices_or_keys, ...], return_type)

参数

json — 要解析的 JSON 字符串。String
indices_or_keys — 由零个或多个参数组成的列表，其中每个参数都可以是字符串或整数。String 或 (U)Int*
return_type — 要返回的 ClickHouse 数据类型。String

返回值

如果可以，返回指定的 ClickHouse 数据类型的值；否则返回该类型的默认值。

示例

用法示例

SELECT JSONExtract('{"a": "hello", "b": [-100, 200.0, 300]}', 'Tuple(String, Array(Float64))') AS res;

┌─res──────────────────────┐
│ ('hello',[-100,200,300]) │
└──────────────────────────┘

JSONExtractArrayRaw

引入于：v20.1.0

返回一个数组，其中包含 JSON 数组的各个元素，每个元素都表示为未解析字符串。

语法

JSONExtractArrayRaw(json[, indices_or_keys, ...])

参数

json — 要解析的 JSON 字符串。String
indices_or_keys — 由零个或多个参数构成的列表，其中每个参数都可以是字符串或整数。String 或 (U)Int*

返回值

返回由 JSON 数组元素组成的字符串数组。如果对应部分不是数组或不存在，则返回空数组。Array(String)

示例

用法示例

SELECT JSONExtractArrayRaw('{"a": "hello", "b": [-100, 200.0, "hello"]}', 'b') AS res;

┌─res──────────────────────┐
│ ['-100','200','"hello"'] │
└──────────────────────────┘

JSONExtractArrayRawCaseInsensitive

引入版本：v25.8.0

使用不区分大小写的键名匹配，返回一个 JSON 数组，其中每个元素都表示为未解析的字符串。此函数与 JSONExtractArrayRaw 类似。

语法

JSONExtractArrayRawCaseInsensitive(json [, indices_or_keys]...)

参数

json — 要解析的 JSON 字符串 String
indices_or_keys — 可选。用于定位数组中的索引或键。键匹配不区分大小写 String 或 (U)Int*

返回值

返回由原始 JSON 字符串组成的数组。Array(String)

示例

基本

SELECT JSONExtractArrayRawCaseInsensitive('{"Items": [1, 2, 3]}', 'ITEMS')

['1','2','3']

JSONExtractBool

自 v20.1.0 起引入

解析 JSON 并提取 Bool 类型的值。

语法

JSONExtractBool(json[, indices_or_keys, ...])

参数

json — 要解析的 JSON 字符串。String
indices_or_keys — 由零个或多个参数组成的列表，其中每个参数都可以是字符串或整数。String 或 (U)Int*

返回值

如果存在，则返回 Bool 值；否则返回 0。Bool

示例

用法示例

SELECT JSONExtractBool('{"passed": true}', 'passed') AS res;

┌─res─┐
│   1 │
└─────┘

JSONExtractBoolCaseInsensitive

引入版本：v25.8.0

解析 JSON，并通过不区分大小写的键名匹配提取布尔值。该函数与 JSONExtractBool 类似。

语法

JSONExtractBoolCaseInsensitive(json [, indices_or_keys]...)

参数

json — 要解析的 JSON 字符串 String
indices_or_keys — 可选。用于定位字段的索引或键。键按不区分大小写的方式匹配 String 或 (U)Int*

返回值

返回提取出的布尔值 (true 为 1，false 为 0) ；如果未找到，则返回 0。UInt8

示例

基本用法

SELECT JSONExtractBoolCaseInsensitive('{"IsActive": true}', 'isactive')

JSONExtractCaseInsensitive

引入版本：v25.8.0

解析 JSON，并通过不区分大小写的键名匹配提取指定 ClickHouse 数据类型的值。该函数类似于 JSONExtract。

语法

JSONExtractCaseInsensitive(json [, indices_or_keys...], return_type)

参数

json — 要解析的 JSON 字符串 String
indices_or_keys — 可选。用于定位到该字段的索引或键。键采用不区分大小写的匹配方式 String 或 (U)Int*
return_type — 要提取的 ClickHouse 数据类型 String

返回值

返回以指定数据类型表示的提取值。Any

示例

int_type

SELECT JSONExtractCaseInsensitive('{"Number": 123}', 'number', 'Int32')

array_type

SELECT JSONExtractCaseInsensitive('{"List": [1, 2, 3]}', 'list', 'Array(Int32)')

[1,2,3]

JSONExtractFloat

引入版本：v20.1.0

解析 JSON 并提取 Float 类型的值。

语法

JSONExtractFloat(json[, indices_or_keys, ...])

参数

json — 要解析的 JSON 字符串。String
indices_or_keys — 由零个或多个参数组成的列表，其中每个参数都可以是字符串或整数。String 或 (U)Int*

返回值

如果存在，则返回 Float 值；否则返回 0。Float64

示例

使用示例

SELECT JSONExtractFloat('{"a": "hello", "b": [-100, 200.0, 300]}', 'b', 2) AS res;

┌─res─┐
│ 200 │
└─────┘

JSONExtractFloatCaseInsensitive

引入版本：v25.8.0

解析 JSON，并通过不区分大小写的键名匹配提取 Float 类型的值。该函数与 JSONExtractFloat 类似。

语法

JSONExtractFloatCaseInsensitive(json [, indices_or_keys]...)

参数

json — 要解析的 JSON 字符串 String
indices_or_keys — 可选。用于定位到该字段的索引或键。键名匹配时不区分大小写 String 或 (U)Int*

返回值

返回提取出的浮点值；如果未找到或无法转换，则返回 0。 Float64

示例

基本用法

SELECT JSONExtractFloatCaseInsensitive('{"Price": 12.34}', 'PRICE')

12.34

JSONExtractInt

引入版本：v20.1.0

解析 JSON 并提取 Int 类型的值。

语法

JSONExtractInt(json[, indices_or_keys, ...])

参数

json — 要解析的 JSON 字符串。String
indices_or_keys — 由零个或多个参数组成的列表，其中每个参数都可以是字符串或整数。String 或 (U)Int*

返回值

如果该值存在，则返回 Int 值；否则返回 0。Int64

示例

用法示例

SELECT JSONExtractInt('{"a": "hello", "b": [-100, 200.0, 300]}', 'b', 1) AS res;

┌──res─┐
│ -100 │
└──────┘

JSONExtractIntCaseInsensitive

引入版本：v25.8.0

解析 JSON，并通过不区分大小写的键名匹配提取 Int 类型的值。此函数与 JSONExtractInt 类似。

语法

JSONExtractIntCaseInsensitive(json [, indices_or_keys]...)

参数

json — 要解析的 JSON 字符串 String
indices_or_keys — 可选。用于定位到该字段的索引或键。键按不区分大小写的方式匹配 String 或 (U)Int*

返回值

返回提取出的 Int 值；如果未找到或无法转换，则返回 0。Int64

示例

基本用法

SELECT JSONExtractIntCaseInsensitive('{"Value": 123}', 'value')

嵌套

SELECT JSONExtractIntCaseInsensitive('{"DATA": {"COUNT": 42}}', 'data', 'Count')

JSONExtractKeys

自 v21.11.0 引入

解析 JSON 字符串并提取键名。

语法

JSONExtractKeys(json[, indices_or_keys, ...])

参数

json — 要解析的 JSON 字符串。String
indices_or_keys — 由零个或多个参数组成的列表，每个参数都可以是字符串或整数。String 或 (U)Int*

返回值

返回一个包含 JSON 对象键的数组。Array(String)

示例

使用示例

SELECT JSONExtractKeys('{"a": "hello", "b": [-100, 200.0, 300]}') AS res;

┌─res───────┐
│ ['a','b'] │
└───────────┘

JSONExtractKeysAndValues

引入版本：v20.1.0

从 JSON 中解析键值对，其中值的类型为指定的 ClickHouse 数据类型。

语法

JSONExtractKeysAndValues(json[, indices_or_keys, ...], value_type)

参数

json — 要解析的 JSON 字符串。String
indices_or_keys — 由零个或多个参数组成的列表，其中每个参数都可以是字符串或整数。String 或 (U)Int*
value_type — 值的 ClickHouse 数据类型。String

返回值

返回由已解析键值对组成的Tuple数组。Array(Tuple(String, value_type))

示例

用法示例

SELECT JSONExtractKeysAndValues('{"x": {"a": 5, "b": 7, "c": 11}}', 'x', 'Int8') AS res

┌─res────────────────────────┐
│ [('a',5),('b',7),('c',11)] │
└────────────────────────────┘

JSONExtractKeysAndValuesCaseInsensitive

引入版本：v25.8.0

通过不区分大小写的键名匹配从 JSON 中解析键值对。此函数与 JSONExtractKeysAndValues 类似。

语法

JSONExtractKeysAndValuesCaseInsensitive(json [, indices_or_keys...], value_type)

参数

json — 要解析的 JSON 字符串 String
indices_or_keys — 可选。用于定位到对象的索引或键。键按不区分大小写的方式匹配 String 或 (U)Int*
value_type — 值的 ClickHouse 数据类型 String

返回值

返回一个包含键值对的 Tuple 数组。Array(Tuple(String, T))

示例

基本用法

SELECT JSONExtractKeysAndValuesCaseInsensitive('{"Name": "Alice", "AGE": 30}', 'String')

[('Name','Alice'),('AGE','30')]

JSONExtractKeysAndValuesRaw

引入版本：v20.4.0

返回一个数组，其中包含 JSON 对象中的键和值组成的元组。所有值都以未解析的字符串形式表示。

语法

JSONExtractKeysAndValuesRaw(json[, indices_or_keys, ...])

参数

json — 要解析的 JSON 字符串。String
indices_or_keys — 由零个或多个参数组成的列表，其中每个参数都可以是字符串或整数。String 或 (U)Int*

返回值

返回一个包含已解析键值对的 Tuple 数组，其中值为未解析的字符串。Array(Tuple(String, String))

示例

用法示例

SELECT JSONExtractKeysAndValuesRaw('{"a": [-100, 200.0], "b": "hello"}') AS res;

┌─res──────────────────────────────────┐
│ [('a','[-100,200]'),('b','"hello"')] │
└──────────────────────────────────────┘

JSONExtractKeysAndValuesRawCaseInsensitive

引入版本：v25.8.0

使用不区分大小写的键名匹配，从 JSON 中提取原始键值对。此函数与 JSONExtractKeysAndValuesRaw 类似。

语法

JSONExtractKeysAndValuesRawCaseInsensitive(json [, indices_or_keys]...)

参数

json — 要解析的 JSON 字符串 String
indices_or_keys — 可选。用于定位到该对象的索引或键。键采用不区分大小写的匹配方式 String 或 (U)Int*

返回值

返回一个 Tuple 数组，其中包含以原始字符串形式表示的键值对。Array(Tuple(String, String))

示例

基本用法

SELECT JSONExtractKeysAndValuesRawCaseInsensitive('{"Name": "Alice", "AGE": 30}')

[('Name','"Alice"'),('AGE','30')]

JSONExtractKeysCaseInsensitive

引入版本：v25.8.0

解析 JSON 字符串，并通过不区分大小写的键名匹配访问嵌套对象并提取键。此函数类似于 JSONExtractKeys。

语法

JSONExtractKeysCaseInsensitive(json [, indices_or_keys]...)

参数

json — 要解析的 JSON 字符串 String
indices_or_keys — 可选。用于定位到该对象的索引或键。键按不区分大小写的方式匹配 String 或 (U)Int*

返回值

返回 JSON 对象中键组成的数组。Array(String)

示例

基本用法

SELECT JSONExtractKeysCaseInsensitive('{"Name": "Alice", "AGE": 30}')

['Name','AGE']

嵌套

SELECT JSONExtractKeysCaseInsensitive('{"User": {"name": "John", "AGE": 25}}', 'user')

['name','AGE']

JSONExtractRaw

引入版本：v20.1.0

以未解析字符串的形式返回 JSON 的一部分。

语法

JSONExtractRaw(json[, indices_or_keys, ...])

参数

json — 要解析的 JSON 字符串。String
indices_or_keys — 由零个或多个参数组成的列表，其中每个参数都可以是字符串或整数。String 或 (U)Int*

返回值

返回 JSON 中指定部分的未解析字符串。如果该部分不存在或类型不正确，则返回空字符串。String

示例

使用示例

SELECT JSONExtractRaw('{"a": "hello", "b": [-100, 200.0, 300]}', 'b') AS res;

┌─res────────────┐
│ [-100,200,300] │
└────────────────┘

JSONExtractRawCaseInsensitive

发布于：v25.8.0

使用不区分大小写的键名匹配，将 JSON 的一部分以未解析字符串的形式返回。此函数与 JSONExtractRaw 类似。

语法

JSONExtractRawCaseInsensitive(json [, indices_or_keys]...)

参数

json — 要解析的 JSON 字符串 String
indices_or_keys — 可选。用于定位到该字段的索引或键。键采用不区分大小写的匹配方式 String 或 (U)Int*

返回值

返回提取出的元素的原始 JSON 字符串。String

示例

object

SELECT JSONExtractRawCaseInsensitive('{"Object": {"key": "value"}}', 'OBJECT')

{"key":"value"}

JSONExtractString

引入版本：v20.1.0

解析 JSON 并提取 String 类型的值。

语法

JSONExtractString(json[, indices_or_keys, ...])

参数

json — 要解析的 JSON 字符串。String
indices_or_keys — 由零个或多个参数组成的列表，其中每个参数都可以是字符串或整数。String 或 (U)Int*

返回值

如果该值存在，则返回 String 值；否则返回空字符串。String

示例

使用示例

SELECT JSONExtractString('{"a": "hello", "b": [-100, 200.0, 300]}', 'a') AS res;

┌─res───┐
│ hello │
└───────┘

JSONExtractStringCaseInsensitive

引入版本：v25.8.0

解析 JSON，并通过不区分大小写的键名匹配提取字符串。此函数与 JSONExtractString 类似。

语法

JSONExtractStringCaseInsensitive(json [, indices_or_keys]...)

参数

json — 要解析的 JSON 字符串 String
indices_or_keys — 可选。用于定位到该字段的索引或键。键按不区分大小写的方式匹配 String 或 (U)Int*

返回值

返回提取出的字符串值；如果未找到，则返回空字符串。String

示例

基本用法

SELECT JSONExtractStringCaseInsensitive('{"ABC": "def"}', 'abc')

def

嵌套

SELECT JSONExtractStringCaseInsensitive('{"User": {"Name": "John"}}', 'user', 'name')

John

JSONExtractUInt

引入版本：v20.1.0

解析 JSON，并提取 UInt 类型的值。

语法

JSONExtractUInt(json [, indices_or_keys, ...])

参数

json — 要解析的 JSON 字符串。String
indices_or_keys — 由零个或多个参数组成的列表，其中每个参数都可以是字符串或整数。String 或 (U)Int*

返回值

如果存在，则返回一个 UInt 值；否则返回 0。UInt64

示例

用法示例

SELECT JSONExtractUInt('{"a": "hello", "b": [-100, 200.0, 300]}', 'b', -1) AS res;

┌─res─┐
│ 300 │
└─────┘

JSONExtractUIntCaseInsensitive

引入版本：v25.8.0

解析 JSON，并通过不区分大小写的键名匹配提取 UInt 类型的值。该函数与 JSONExtractUInt 类似。

语法

JSONExtractUIntCaseInsensitive(json [, indices_or_keys]...)

参数

json — 要解析的 JSON 字符串 String
indices_or_keys — 可选。用于定位到该字段的索引或键。键按不区分大小写的方式匹配 String 或 (U)Int*

返回值

返回提取出的 UInt 值；如果未找到或无法转换，则返回 0。UInt64

示例

基本用法

SELECT JSONExtractUIntCaseInsensitive('{"COUNT": 789}', 'count')

JSONHas

引入于版本：v20.1.0

检查 JSON 文档中是否存在给定的值。

语法

JSONHas(json[ ,indices_or_keys, ...])

参数

json — 要解析的 JSON 字符串 String
[ ,indices_or_keys, ...] — 由零个或多个参数组成的列表。String 或 (U)Int*

返回值

如果值存在于 json 中，则返回 1；否则返回 0 UInt8

示例

用法示例

SELECT JSONHas('{"a": "hello", "b": [-100, 200.0, 300]}', 'b') = 1;
SELECT JSONHas('{"a": "hello", "b": [-100, 200.0, 300]}', 'b', 4) = 0;

1
1

JSONKey

引入版本：v20.1.0

返回 JSON 对象中指定索引 (从 1 开始) 处字段的键。如果 JSON 以字符串形式传入，则会先进行解析。第二个参数是用于访问嵌套对象的 JSON path。该函数返回指定位置的键名。

语法

JSONKey(json[, indices_or_keys, ...])

参数

json — 要解析的 JSON 字符串。String
indices_or_keys — 可选的索引或键列表，用于指定嵌套元素的路径。每个参数都可以是字符串 (通过键访问) 或整数 (通过从 1 开始的索引访问) 。String 或 Int*

返回值

返回 JSON 对象中指定位置的键名。String

示例

使用示例

SELECT JSONKey('{"a": "hello", "b": [-100, 200.0, 300]}', 1);

JSONLength

引入版本：v20.1.0

返回 JSON 数组或 JSON 对象的长度。如果该值不存在或类型不正确，则返回 0。

语法

JSONLength(json [, indices_or_keys, ...])

参数

json — 要解析的 JSON 字符串 String
[, indices_or_keys, ...] — 可选。由零个或多个参数组成的列表。String 或 (U)Int8/16/32/64

返回值

返回 JSON 数组或 JSON 对象的长度；如果该值不存在或类型不正确，则返回 0。UInt64

示例

使用示例

SELECT JSONLength('{"a": "hello", "b": [-100, 200.0, 300]}', 'b') = 3;
SELECT JSONLength('{"a": "hello", "b": [-100, 200.0, 300]}') = 2;

1
1

JSONMergePatch

引入版本：v23.10.0

返回通过合并多个 JSON 对象生成的合并后 JSON 对象字符串。

语法

JSONMergePatch(json1[, json2, ...])

别名: jsonMergePatch

参数

json1[, json2, ...] — 一个或多个有效的 JSON 字符串。String

返回值

如果 JSON 对象字符串有效，则返回合并后的 JSON 对象字符串。String

示例

使用示例

SELECT JSONMergePatch('{"a":1}', '{"name": "joey"}', '{"name": "tom"}', '{"name": "zoey"}') AS res;

┌─res───────────────────┐
│ {"a":1,"name":"zoey"} │
└───────────────────────┘

JSONSharedDataPaths

引入版本：v24.8.0

返回存储在 JSON 列共享数据结构中的路径列表。

语法

JSONSharedDataPaths(json)

参数

json — JSON 列。JSON

返回值

返回 JSON 列中存储在共享数据结构中的路径数组。Array(String)

示例

用法示例

CREATE TABLE test (json JSON(max_dynamic_paths=1)) ENGINE = Memory;
INSERT INTO test FORMAT JSONEachRow {"json" : {"a" : 42}}, {"json" : {"b" : "Hello"}}, {"json" : {"a" : [1, 2, 3], "c" : "2020-01-01"}};
SELECT json, JSONSharedDataPaths(json) FROM test;

┌─json───────────────────────────┬─JSONSharedDataPaths(json)─┐
│ {"a":42}                       │ []                        │
│ {"b":"Hello"}                  │ ['b']                     │
│ {"a":[1,2,3],"c":"2020-01-01"} │ ['c']                     │
└────────────────────────────────┴───────────────────────────┘

JSONSharedDataPathsWithTypes

引入版本：v24.8.0

返回 JSON 列中每一行存储在共享数据结构中的路径及其类型列表。

语法

JSONSharedDataPathsWithTypes(json)

参数

json — JSON 列。JSON

返回值

返回一个映射，包含存储在共享数据结构中的路径及其在 JSON 列中的数据类型。Map(String, String)

示例

使用示例

CREATE TABLE test (json JSON(max_dynamic_paths=1)) ENGINE = Memory;
INSERT INTO test FORMAT JSONEachRow {"json" : {"a" : 42}}, {"json" : {"b" : "Hello"}}, {"json" : {"a" : [1, 2, 3], "c" : "2020-01-01"}};
SELECT json, JSONSharedDataPathsWithTypes(json) FROM test;

┌─json───────────────────────────┬─JSONSharedDataPathsWithTypes(json)─┐
│ {"a":42}                       │ {}                                 │
│ {"b":"Hello"}                  │ {'b':'String'}                     │
│ {"a":[1,2,3],"c":"2020-01-01"} │ {'c':'Date'}                       │
└────────────────────────────────┴────────────────────────────────────┘

JSONType

引入版本：v20.1.0

返回 JSON 值的类型。如果该值不存在，则返回 Null=0。

语法

JSONType(json[, indices_or_keys, ...])

参数

json — 待解析的 JSON 字符串 String
json[, indices_or_keys, ...] — 由零个或多个参数组成的列表，其中每个参数都可以是字符串或整数。String 或 (U)Int8/16/32/64

返回值

返回 JSON 值的类型 (以字符串形式表示) ；如果该值不存在，则返回 Null=0 枚举

示例

使用示例

SELECT JSONType('{"a": "hello", "b": [-100, 200.0, 300]}') = 'Object';
SELECT JSONType('{"a": "hello", "b": [-100, 200.0, 300]}', 'a') = 'String';
SELECT JSONType('{"a": "hello", "b": [-100, 200.0, 300]}', 'b') = 'Array';

1
1
1

JSON_EXISTS

引入版本：v21.8.0

如果该值存在于 JSON 文档中，则返回 1。如果该值不存在，则返回 0。

语法

JSON_EXISTS(json, path)

参数

json — 包含有效 JSON 的字符串。String
path — 表示路径的字符串。String

返回值

如果该值在 JSON 文档中存在，则返回 1；否则返回 0。UInt8

示例

使用示例

SELECT JSON_EXISTS('{"hello":1}', '$.hello');
SELECT JSON_EXISTS('{"hello":{"world":1}}', '$.hello.world');
SELECT JSON_EXISTS('{"hello":["world"]}', '$.hello[*]');
SELECT JSON_EXISTS('{"hello":["world"]}', '$.hello[0]');

┌─JSON_EXISTS('{"hello":1}', '$.hello')─┐
│                                     1 │
└───────────────────────────────────────┘
┌─JSON_EXISTS('{"hello":{"world":1}}', '$.hello.world')─┐
│                                                     1 │
└───────────────────────────────────────────────────────┘
┌─JSON_EXISTS('{"hello":["world"]}', '$.hello[*]')─┐
│                                                1 │
└──────────────────────────────────────────────────┘
┌─JSON_EXISTS('{"hello":["world"]}', '$.hello[0]')─┐
│                                                1 │
└──────────────────────────────────────────────────┘

JSON_QUERY

引入版本：v21.8.0

解析 JSON，并将某个值提取为 JSON 数组或 JSON 对象。如果该值不存在，则返回空字符串。

语法

JSON_QUERY(json, path)

参数

json — 包含有效 JSON 的字符串。String
path — 表示路径的字符串。String

返回值

返回提取出的 JSON 数组或 JSON 对象字符串；如果该值不存在，则返回空字符串。String

示例

用法示例

SELECT JSON_QUERY('{"hello":"world"}', '$.hello');
SELECT JSON_QUERY('{"array":[[0, 1, 2, 3, 4, 5], [0, -1, -2, -3, -4, -5]]}', '$.array[*][0 to 2, 4]');
SELECT JSON_QUERY('{"hello":2}', '$.hello');
SELECT toTypeName(JSON_QUERY('{"hello":2}', '$.hello'));

["world"]
[0, 1, 4, 0, -1, -4]
[2]
String

JSON_VALUE

引入版本：v21.11.0

解析 JSON，并提取其中的一个值作为 JSON 标量。如果该值不存在，默认返回空字符串。

此函数的行为由以下设置控制：

通过 SET function_json_value_return_type_allow_nullable = true，将返回 NULL。如果该值为复杂类型 (例如：struct、array、map) ，默认将返回空字符串。
通过 SET function_json_value_return_type_allow_complex = true，将返回该复杂值。

语法

JSON_VALUE(json, path)

参数

json — 包含有效 JSON 的字符串。String
path — 表示路径的字符串。String

返回值

返回提取出的 JSON 标量字符串；如果该值不存在，则返回空字符串。String

示例

用法示例

SELECT JSON_VALUE('{"hello":"world"}', '$.hello');
SELECT JSON_VALUE('{"array":[[0, 1, 2, 3, 4, 5], [0, -1, -2, -3, -4, -5]]}', '$.array[*][0 to 2, 4]');
SELECT JSON_VALUE('{"hello":2}', '$.hello');
SELECT JSON_VALUE('{"hello":"world"}', '$.b') settings function_json_value_return_type_allow_nullable=true;

world
0
2
\N

dynamicElement

引入版本：v24.1.0

从 Dynamic 列中提取指定类型的数据列。

此函数可从 Dynamic 列中提取特定类型的值。如果某一行包含所请求类型的值，则返回该值。如果该行包含其他类型的值或 NULL，则对于标量类型返回 NULL，对于数组类型返回空数组。

语法

dynamicElement(dynamic, type_name)

参数

dynamic — 要从中提取值的 Dynamic 列。Dynamic
type_name — 要提取的 Variant 类型名称 (例如 'String'、'Int64'、'Array(Int64)') 。

返回值

返回 Dynamic 列中指定类型的值。对于类型不匹配的情况，返回 NULL (数组类型则返回空数组) 。Any

示例

从 Dynamic 列提取不同类型

CREATE TABLE test (d Dynamic) ENGINE = Memory;
INSERT INTO test VALUES (NULL), (42), ('Hello, World!'), ([1, 2, 3]);
SELECT d, dynamicType(d), dynamicElement(d, 'String'), dynamicElement(d, 'Int64'), dynamicElement(d, 'Array(Int64)'), dynamicElement(d, 'Date'), dynamicElement(d, 'Array(String)') FROM test

┌─d─────────────┬─dynamicType(d)─┬─dynamicElement(d, 'String')─┬─dynamicElement(d, 'Int64')─┬─dynamicElement(d, 'Array(Int64)')─┬─dynamicElement(d, 'Date')─┬─dynamicElement(d, 'Array(String)')─┐
│ ᴺᵁᴸᴸ          │ None           │ ᴺᵁᴸᴸ                        │                       ᴺᵁᴸᴸ │ []                                │                      ᴺᵁᴸᴸ │ []                                 │
│ 42            │ Int64          │ ᴺᵁᴸᴸ                        │                         42 │ []                                │                      ᴺᵁᴸᴸ │ []                                 │
│ Hello, World! │ String         │ Hello, World!               │                       ᴺᵁᴸᴸ │ []                                │                      ᴺᵁᴸᴸ │ []                                 │
│ [1,2,3]       │ Array(Int64)   │ ᴺᵁᴸᴸ                        │                       ᴺᵁᴸᴸ │ [1,2,3]                           │                      ᴺᵁᴸᴸ │ []                                 │
└───────────────┴────────────────┴─────────────────────────────┴────────────────────────────┴───────────────────────────────────┴───────────────────────────┴────────────────────────────────────┘

dynamicType

Introduced in: v24.1.0

返回 Dynamic 列中每一行对应的 Variant 类型名称。

对于包含 NULL 的行，该函数返回 'None'。对于其他所有行，它返回存储在该行 Dynamic 列中的实际数据类型 (例如 'Int64'、'String'、'Array(Int64)') 。

Syntax

dynamicType(dynamic)

参数

dynamic — 要检查的 Dynamic 列。Dynamic

返回值

返回每一行中存储的值的类型名称；对于 NULL 值，返回 'None'。String

示例

检查 Dynamic 列中的类型

CREATE TABLE test (d Dynamic) ENGINE = Memory;
INSERT INTO test VALUES (NULL), (42), ('Hello, World!'), ([1, 2, 3]);
SELECT d, dynamicType(d) FROM test;

┌─d─────────────┬─dynamicType(d)─┐
│ ᴺᵁᴸᴸ          │ None           │
│ 42            │ Int64          │
│ Hello, World! │ String         │
│ [1,2,3]       │ Array(Int64)   │
└───────────────┴────────────────┘

isDynamicElementInSharedData

引入版本：v24.1.0

对于存储为共享 Variant 格式而非单独子列的 Dynamic 列中的行，返回 true。

当 Dynamic 列设置了 max_types 限制时，超出该限制的值会以共享二进制格式存储，而不会拆分为各个独立的类型化子列。此函数可用于识别哪些行是以这种共享格式存储的。

语法

isDynamicElementInSharedData(dynamic)

参数

dynamic — 要检查的 Dynamic 列。Dynamic

返回值

如果值以共享 Variant 格式存储，则返回 true；如果值存储为独立子列或为 NULL，则返回 false。Bool

示例

检查带有 max_types 限制的 Dynamic 列的存储格式

CREATE TABLE test (d Dynamic(max_types=2)) ENGINE = Memory;
INSERT INTO test VALUES (NULL), (42), ('Hello, World!'), ([1, 2, 3]);
SELECT d, isDynamicElementInSharedData(d) FROM test;

┌─d─────────────┬─isDynamicElementInSharedData(d)─┐
│ ᴺᵁᴸᴸ          │ false                           │
│ 42            │ false                           │
│ Hello, World! │ false                           │
│ [1,2,3]       │ true                            │
└───────────────┴─────────────────────────────────┘

isValidJSON

自 v20.1.0 引入

检查传入的字符串是否为有效的 JSON。

语法

isValidJSON(json)

参数

json — 待验证的 JSON 字符串 String

返回值

如果该字符串是有效的 JSON，则返回 1；否则返回 0。UInt8

示例

用法示例

SELECT isValidJSON('{"a": "hello", "b": [-100, 200.0, 300]}') = 1;
SELECT isValidJSON('not JSON') = 0;

1
1

使用整数访问 JSON 数组和 JSON 对象

SELECT JSONHas('{"a": "hello", "b": [-100, 200.0, 300]}', 0);
SELECT JSONHas('{"a": "hello", "b": [-100, 200.0, 300]}', 1);
SELECT JSONHas('{"a": "hello", "b": [-100, 200.0, 300]}', 2);
SELECT JSONHas('{"a": "hello", "b": [-100, 200.0, 300]}', -1);
SELECT JSONHas('{"a": "hello", "b": [-100, 200.0, 300]}', -2);
SELECT JSONHas('{"a": "hello", "b": [-100, 200.0, 300]}', 3);

prettyPrintJSON

引入于：v26.4.0

返回经过美化格式化的 JSON 字符串，带有换行和空格缩进。

语法

prettyPrintJSON(json [, indent])

参数

json — 要格式化的有效 JSON 字符串。String
indent — 每级缩进的空格数。默认值：4。最大值：32 UInt*

返回值

经过美化格式化的 JSON 字符串。String

示例

简单对象

SELECT prettyPrintJSON('{"a":1,"b":"hello"}');

{\n    "a": 1,\n    "b": "hello"\n}

自定义缩进

SELECT prettyPrintJSON('{"a":1}', 8);

{\n        "a": 1\n}

simpleJSONExtractBool

引入版本：v21.4.0

从名为 field_name 的字段值中解析出一个 true/false 值。结果为 UInt8。

语法

simpleJSONExtractBool(json, field_name)

别名: visitParamExtractBool

参数

json — 要在其中查找字段的 JSON。String
field_name — 要查找的字段名称。const String

返回值

如果字段的值为 true，则返回 1；否则返回 0。这意味着在以下情况 (包括但不限于) 下，此函数也会返回 0：

如果字段不存在。
如果字段包含字符串形式的 true，例如：{"field":"true"}。
如果字段包含数值 1。UInt8

示例

使用示例

CREATE TABLE jsons
(
    `json` String
)
ENGINE = MergeTree
ORDER BY tuple();

INSERT INTO jsons VALUES ('{"foo":false,"bar":true}');
INSERT INTO jsons VALUES ('{"foo":"true","qux":1}');

SELECT simpleJSONExtractBool(json, 'bar') FROM jsons ORDER BY json;
SELECT simpleJSONExtractBool(json, 'foo') FROM jsons ORDER BY json;

simpleJSONExtractFloat

引入版本：v21.4.0

从名为 field_name 的字段值中解析 Float64。如果 field_name 是字符串字段，会尝试从字符串开头解析出数值。如果该字段不存在，或虽存在但不包含数值，则返回 0。

语法

simpleJSONExtractFloat(json, field_name)

别名: visitParamExtractFloat

参数

json — 要在其中查找字段的 JSON。String
field_name — 要查找的字段名称。const String

返回值

如果字段存在且包含数字，则返回从该字段中解析出的数值；否则返回 0。Float64

示例

用法示例

CREATE TABLE jsons
(
    `json` String
)
ENGINE = MergeTree
ORDER BY tuple();

INSERT INTO jsons VALUES ('{"foo":"-4e3"}');
INSERT INTO jsons VALUES ('{"foo":-3.4}');
INSERT INTO jsons VALUES ('{"foo":5}');
INSERT INTO jsons VALUES ('{"foo":"not1number"}');
INSERT INTO jsons VALUES ('{"baz":2}');

SELECT simpleJSONExtractFloat(json, 'foo') FROM jsons ORDER BY json;

simpleJSONExtractInt

引入版本：v21.4.0

从名为 field_name 的字段值中解析 Int64。如果 field_name 是字符串字段，则会尝试从字符串开头解析数字。如果该字段不存在，或者虽存在但不包含数字，则返回 0。

语法

simpleJSONExtractInt(json, field_name)

别名: visitParamExtractInt

参数

json — 用于查找字段的 JSON。String
field_name — 要查找的字段名称。const String

返回值

如果该字段存在且其值为数值，则返回从该字段中解析出的数值；否则返回 0。Int64

示例

使用示例

CREATE TABLE jsons
(
    `json` String
)
ENGINE = MergeTree
ORDER BY tuple();

INSERT INTO jsons VALUES ('{"foo":"-4e3"}');
INSERT INTO jsons VALUES ('{"foo":-3.4}');
INSERT INTO jsons VALUES ('{"foo":5}');
INSERT INTO jsons VALUES ('{"foo":"not1number"}');
INSERT INTO jsons VALUES ('{"baz":2}');

SELECT simpleJSONExtractInt(json, 'foo') FROM jsons ORDER BY json;

simpleJSONExtractRaw

引入版本：v21.4.0

返回名为 field_name 的字段值，类型为 String，并保留分隔符。

语法

simpleJSONExtractRaw(json, field_name)

别名: visitParamExtractRaw

参数

json — 要在其中查找字段的 JSON。String
field_name — 要查找的字段名称。const String

返回值

如果字段存在，则返回该字段的字符串值 (包括分隔符) ；否则返回空字符串。String

示例

用法示例

CREATE TABLE jsons
(
    `json` String
)
ENGINE = MergeTree
ORDER BY tuple();

INSERT INTO jsons VALUES ('{"foo":"-4e3"}');
INSERT INTO jsons VALUES ('{"foo":-3.4}');
INSERT INTO jsons VALUES ('{"foo":5}');
INSERT INTO jsons VALUES ('{"foo":{"def":[1,2,3]}}');
INSERT INTO jsons VALUES ('{"baz":2}');

SELECT simpleJSONExtractRaw(json, 'foo') FROM jsons ORDER BY json;

"-4e3"
-3.4
5
{"def":[1,2,3]}

simpleJSONExtractString

引入版本：v21.4.0

从名为 field_name 的字段的值中解析出双引号括起来的 String。

实现细节

目前不支持处理不属于基本多文种平面的 \uXXXX\uYYYY 格式码点 (它们会被转换为 CESU-8，而不是 UTF-8) 。

语法

simpleJSONExtractString(json, field_name)

别名: visitParamExtractString

参数

json — 要在其中查找字段的 JSON。String
field_name — 要查找的字段名。const String

返回值

返回字段未经转义的字符串值，包括分隔符。如果该字段不包含双引号括起来的字符串、转义还原失败，或字段不存在，则返回空字符串。String

示例

使用示例

CREATE TABLE jsons
(
    `json` String
)
ENGINE = MergeTree
ORDER BY tuple();

INSERT INTO jsons VALUES ('{"foo":"\\n\\u0000"}');
INSERT INTO jsons VALUES ('{"foo":"\\u263"}');
INSERT INTO jsons VALUES ('{"foo":"\\u263a"}');
INSERT INTO jsons VALUES ('{"foo":"hello}');

SELECT simpleJSONExtractString(json, 'foo') FROM jsons ORDER BY json;

\n\0

☺

simpleJSONExtractUInt

引入版本：v21.4.0

从名为 field_name 的字段值中解析 UInt64。如果 field_name 是 String 类型的字段，则会尝试从字符串开头解析数值。如果该字段不存在，或虽存在但不包含数值，则返回 0。

语法

simpleJSONExtractUInt(json, field_name)

别名: visitParamExtractUInt

参数

json — 要搜索字段的 JSON。String
field_name — 要搜索的字段名。const String

返回值

如果字段存在且包含数值，则返回从该字段中解析出的数值；否则返回 0。UInt64

示例

用法示例

CREATE TABLE jsons
(
    `json` String
)
ENGINE = MergeTree
ORDER BY tuple();

INSERT INTO jsons VALUES ('{"foo":"4e3"}');
INSERT INTO jsons VALUES ('{"foo":3.4}');
INSERT INTO jsons VALUES ('{"foo":5}');
INSERT INTO jsons VALUES ('{"foo":"not1number"}');
INSERT INTO jsons VALUES ('{"baz":2}');

SELECT simpleJSONExtractUInt(json, 'foo') FROM jsons ORDER BY json;

simpleJSONHas

引入版本：v21.4.0

检查是否存在名为 field_name 的字段。

语法

simpleJSONHas(json, field_name)

别名: visitParamHas

参数

json — 要在其中查找字段的 JSON。 String
field_name — 要查找的字段名称。 const String

返回值

如果字段存在，则返回 1；否则返回 0。 UInt8

示例

使用示例

CREATE TABLE jsons
(
    `json` String
)
ENGINE = MergeTree
ORDER BY tuple();

INSERT INTO jsons VALUES ('{"foo":"true","qux":1}');

SELECT simpleJSONHas(json, 'foo') FROM jsons;
SELECT simpleJSONHas(json, 'bar') FROM jsons;

1
0

toJSONString

引入版本：v21.7.0

将一个值序列化为其 JSON 表示形式。支持多种数据类型和嵌套结构。默认情况下，64 位整数或更大的整数 (例如 UInt64 或 Int128) 会以引号括起来。output_format_json_quote_64bit_integers 控制此行为。特殊值 NaN 和 inf 会被替换为 null。启用 output_format_json_quote_denormals 设置可显示它们。序列化枚举值时，该函数会输出其名称。

另请参见：

语法

toJSONString(value)

参数

value — 要序列化的值。该值可以是任意数据类型。Any

返回值

返回该值的 JSON 表示。String

示例

Map 的序列化

SELECT toJSONString(map('key1', 1, 'key2', 2));

┌─toJSONString(map('key1', 1, 'key2', 2))─┐
│ {"key1":1,"key2":2}                     │
└─────────────────────────────────────────┘

特殊值

SELECT toJSONString(tuple(1.25, NULL, NaN, +inf, -inf, [])) SETTINGS output_format_json_quote_denormals = 1;

┌─toJSONString((1.25, NULL, nan, inf, -inf, []))─┐
│ [1.25,null,"nan","inf","-inf",[]]              │
└────────────────────────────────────────────────┘