如何在MaxComputeSQL中使用复杂类型函数_云原生大数据计算服务 MaxCompute(MaxCompute)-阿里云帮助中心

您可以在MaxCompute SQL中使用复杂类型函数处理复杂数据类型，例如ARRAY、MAP、STRUCT、JSON。本文为您提供MaxCompute SQL支持的复杂类型函数的命令格式、参数说明及示例，指导您使用复杂类型函数完成开发。

MaxCompute SQL支持的复杂类型函数如下。其中JSON函数的使用限制请参见使用限制。

函数类别	函数	功能
ARRAY函数	ALL_MATCH	判断ARRAY数组中是否所有元素都满足指定条件。
	ANY_MATCH	判断ARRAY数组中是否存在满足指定条件的元素。
	ARRAY	使用给定的值构造ARRAY。
	ARRAY_CONTAINS	检测指定的ARRAY中是否包含指定的值。
	ARRAY_DISTINCT	去除ARRAY数组中的重复元素。
	ARRAY_EXCEPT	找出在ARRAY A中，但不在ARRAY B中的元素，并去掉重复的元素后，以ARRAY形式返回结果。
	ARRAY_INTERSECT	计算两个ARRAY数组的交集。
	ARRAY_JOIN	将ARRAY数组中的元素按照指定字符串进行拼接。
	ARRAY_MAX	计算ARRAY数组中的最大值。
	ARRAY_MIN	计算ARRAY数组中的最小值。
	ARRAY_NORMALIZE	返回根据指定p范数（p Norm）对数组元素规范化后的数组。
	ARRAY_POSITION	计算指定元素在ARRAY数组中第一次出现的位置。
	ARRAY_REDUCE	将ARRAY数组的元素进行聚合。
	ARRAY_REMOVE	在ARRAY数组中删除指定元素。
	ARRAY_REPEAT	返回将指定元素重复指定次数后的ARRAY数组。
	ARRAY_SORT	将ARRAY数组的元素进行排序。
	ARRAY_UNION	计算两个ARRAY数组的并集并去掉重复元素。
	ARRAYS_OVERLAP	判断两个ARRAY数组中是否包含相同元素。
	ARRAYS_ZIP	合并多个ARRAY数组。
	COMBINATIONS	返回输入数组元素的N元组合组成的数组。
	CONCAT	将ARRAY数组或字符串连接在一起。
	EXPLODE	将一行数据转为多行的UDTF。
	FILTER	将ARRAY数组中的元素进行过滤。
	FLATTEN	将数组类型的数组转换为单个数组。
	INDEX	返回ARRAY数组指定位置的元素值。
	NGRAMS	返回指定数组元素的N元语法（ n-gram ）数组。
	POSEXPLODE	将指定的ARRAY展开，每个Value一行，每行两列分别对应数组从0开始的下标和数组元素。
	REVERSE	返回指定数组的元素倒序数组。
	SEQUENCE	根据表达式生成包含指定元素的数组。
	SHUFFLE	返回指定数组的元素随机排列数组。
	SIZE	返回指定ARRAY中的元素数目。
	SLICE	对ARRAY数据切片，返回从指定位置开始、指定长度的数组。
	SORT_ARRAY	为指定的数组中的元素排序。
	SPLIT	将字符串按照指定的分隔符分割后返回数组。
	TRANSFORM	将ARRAY数组中的元素进行转换。
	ZIP_WITH	将2个ARRAY数组按照位置进行元素级别的合并。
MAP函数	EXPLODE	将一行数据转为多行的UDTF。
	INDEX	返回MAP类型参数中满足指定条件的Value。
	MAP	使用指定的Key-Value对建立MAP。
	MAP_CONCAT	返回多个MAP的并集。
	MAP_ENTRIES	将MAP中的Key、Value键值映射转换为STRUCT结构数组。
	MAP_FILTER	将MAP中的元素进行过滤。
	MAP_FROM_ARRAYS	通过给定的ARRAY数组构造MAP。
	MAP_FROM_ENTRIES	通过给定的结构体数组构造MAP。
	MAP_KEYS	将参数MAP中的所有Key作为数组返回。
	MAP_VALUES	将参数MAP中的所有Value作为数组返回。
	MAP_ZIP_WITH	对输入的两个MAP进行合并得到一个新MAP。
	MULTIMAP_FROM_ENTRIES	结构体数组中返回一个MAP。
	SIZE	返回指定MAP中的K/V对数。
	TRANSFORM_KEYS	对MAP进行变换，保持Value不变，根据指定函数计算新的Key。
	TRANSFORM_VALUES	对MAP进行变换，保持Key不变，根据指定函数计算新的Value。
STRUCT函数	FIELD	获取STRUCT中的成员变量的取值。
	INLINE	将指定的STRUCT数组展开。每个数组元素对应一行，每行每个STRUCT元素对应一列。
	NAMED_STRUCT	使用给定的Name、Value列表建立STRUCT。
	STRUCT	使用给定Value列表建立STRUCT。
JSON函数	FROM_JSON	根据给定的JSON字符串和输出格式信息，返回ARRAY、MAP或STRUCT类型。
	GET_JSON_OBJECT	在一个标准JSON字符串中，按照指定方式抽取指定的字符串。
	JSON_TUPLE	在一个标准的JSON字符串中，按照输入的一组键抽取各个键指定的字符串。
	TO_JSON	将指定的复杂类型输出为JSON字符串。
	JSON_OBJECT	生成JSON OBJECT，要求key和value成对出现。
	JSON_ARRAY	生成JSON ARRAY。将一个可能为空的JSON类型对象，转换为包含这些类型的数组。
	JSON_EXTRACT	解析JSON表达式中对应json_path的数据，注意json_path非法时会报错。
	JSON_EXISTS	查看json_path对应的JSON值是否存在。
	JSON_PRETTY	美化JSON，增加换行及空格。
	JSON_TYPE	返回JSON数据所属的数据类型名称。
	JSON_FORMAT	将JSON数据转换成STRING类型，默认不自动进行美化。
	JSON_PARSE	将STRING类型转成JSON类型，非JSON格式转换为字符串会报错。
	JSON_VALID	检查字符串是否为合法的JSON格式。
	CAST	支持基本类型与JSON类型的转换。

boolean all_match(array<T> <a>, function<T, boolean> <predicate>)

- ```
--返回true。
select all_match(array(4, 5, 6), x -> x>3);
```
- ```
--返回true。
select all_match(array(), x -> x>3);
```
- ```
--返回false。
select all_match(array(1, 2, -10, 100, -30), x -> x>3);
```
- ```
--返回NULL。
select all_match(array(10, 100, 30, null), x -> x>3);
```

boolean any_match(array<T> <a>, function<T, boolean> <predicate>)

- ```
--返回true。
select any_match(array(1, 2, -10, 100, -30), x-> x > 3);
```
- ```
--返回false。
select any_match(array(), x-> x > 3);
```
- ```
--返回false。
select any_match(array(1, 2, -10, -20, -30), x-> x > 3);
```
- ```
--返回NULL。
select any_match(array(1, 2, null, -10), x-> x > 3);
```

```
array array(<value>,<value>[, ...])
```

+------------+----+----+------------+------------+
| c1         | c2 | c3 | c4         | c5         |
+------------+----+----+------------+------------+
| 1000       | k11 | k21 | 86         | 15         |
| 1001       | k12 | k22 | 97         | 2          |
| 1002       | k13 | k23 | 99         | 1          |
+------------+----+----+------------+------------+

--根据c2、c4、c3、c5列的数据构造ARRAY数组。
select array(c2,c4,c3,c5) from t_table;
--返回结果如下。
+------+
| _c0  |
+------+
| [k11, 86, k21, 15] |
| [k12, 97, k22, 2] |
| [k13, 99, k23, 1] |
+------+

boolean array_contains(array<T> <a>, value <v>)

+------------+---------+
| c1         | t_array |
+------------+---------+
| 1000       | [k11, 86, k21, 15] |
| 1001       | [k12, 97, k22, 2] |
| 1002       | [k13, 99, k23, 1] |
+------------+---------+

--检测t_array列是否包含1。
select c1, array_contains(t_array,'1') from t_table_array;
--返回结果如下。
+------------+------+
| c1         | _c1  |
+------------+------+
| 1000       | false |
| 1001       | false |
| 1002       | true |
+------------+------+

```
array<T> array_distinct(array<T> <a>)
```
- ```
--返回[10,20,30]。
select array_distinct(array(10, 20, 30, 30, 20, 10));
```
- ```
--返回[10,20,null,30]。
select array_distinct(array(10, 20, 20, null, null, 30, 20, null)); 
```
- ```
--返回[]。
select array_distinct(array());
```

array<T> array_except(array<T> <a>, array<T> <b>)

- ```
--返回[5]。
select array_except(array(1, 1, 3, 3, 5, 5), array(1, 1, 2, 2, 3, 3));
```
- ```
--返回[5,null]。
select array_except(array(1, 1, 3, 3, 5, 5, null, null), array(1, 1, 2, 2, 3, 3));
```
- ```
--返回[2,1]。
select array_except(array(2, 1, 1, 2), cast(array() as array<int>)); 
```
- ```
--返回[]。
select array_except(cast(array() as array<int>), cast(array() as array<int>));
```

array<T> array_intersect(array<T> <a>, array<T> <b>)

- ```
--返回[1,3]。
select array_intersect(array(1, 2, 3), array(1, 3, 5));
```
- ```
--返回[20,30,null]。
select array_intersect(array(10, 20, 20, 30, 30, null, null), array(30, 30, 20, 20, 40, null, null)); 
```

array_join(array<T> <a>, <delimiter>[, <nullreplacement>])

--返回10,20,20,30。
select array_join(array(10, 20, 20, null, null, 30), ",");
--返回10##20##20##null##null##30。
select array_join(array(10, 20, 20, null, null, 30), "##", "null");

```
T array_max(array<T> <a>) 
```

--返回20。
select array_max(array(1, 20, null, 3));

```
T array_min(array<T> <a>) 
```

--返回1。
select array_min(array(1, 20, null, 3));

```
array_normalize(array, p)
```

SELECT  array_normalize(array(10.0, 20.0, 50.0), 1.0);

[0.125, 0.25, 0.625]

bigint array_position(array<T> <a>, T <element>)

- ```
--返回3。
select array_position(array(3, 2, 1), 1);
```
- ```
--返回NULL。
select array_position(array(3, 1, null), null);
```

R array_reduce(array<T> <a>, buf <init>, function<buf, T, buf> <merge>, function<buf, R> <final>)

--返回6。
select array_reduce(array(1, 2, 3), 0, (buf, e)->buf + e, buf->buf);
--返回2.5。
select array_reduce(array(1, 2, 3, 4), named_struct('sum', 0, 'count', 0), (buf, e)->named_struct('sum', buf.sum + e, 'count', buf.count + 1), buf -> buf.sum / buf.count);

array<T> array_remove(array<T> <a>, T <element>)

- ```
--返回[3,2]。
select array_remove(array(3, 2, 1), 1);
```
- ```
--返回NULL。
select array_remove(array(3, 1, null), null);
```
- ```
--返回[3,1,null]。
select array_remove(array(3, 1, null), 2);
```

array<T> array_repeat(T <element>, int <count>)

- ```
--返回[123, 123]。
select array_repeat('123', 2);
```
- ```
--返回NULL。
select array_repeat('123', null);
```
- ```
--返回[]。
select array_repeat('123', -1);
```

array<T> array_sort(array<T> <a>, function<T, T, bigint> <comparator>)

SELECTarray_sort(array(5,6,1),(left,right)->CASEWHENleft<rightTHEN-1LWHENleft>rightTHEN1LELSE0LEND);
--返回结果
+------------+
| _c0        |
+------------+
| [1,5,6]    |
+------------+

--返回[{"a":1,"b":10},{"a":2,"b":12},{"a":3,"b":11}]。
select array_sort(a, (a,b)->case when a.a> b.a then 1L when a.a=b.a then 0L else -1L end)
from values (
  array(named_struct('a', 1, 'b', 10),
        named_struct('a', 3, 'b', 11),
        named_struct('a', 2, 'b', 12)))
  as t(a);

array<T> array_union(array<T> <a>,  array<T> <b>)

- ```
--返回[1,2,3,5]。
select array_union(array(1, 2, 3), array(1, 3, 5));
```
- ```
--返回NULL。
select array_union(array(1, 2, 3), null);
```

boolean arrays_overlap(array<T> <a>,  array<T> <b>)

- ```
--返回true。
select arrays_overlap(array(1, 2, 3), array(3, 4, 5));
```
- ```
--返回false。
select arrays_overlap(array(1, 2, 3), array(6, 4, 5));
```
- ```
--返回NULL。
select arrays_overlap(array(1, 2, 3), array(5, 4, null));
```

array<struct<T, U, ...>> arrays_zip(array<T> <a>, array<U> <b>[, ...])

- ```
--返回[{0:1, 1:2}, {0:2, 1:3}, {0:3, 1:4}]。
select arrays_zip(array(1, 2, 3), array(2, 3, 4));
```
- ```
--返回[{0:1, 1:4}, {0:2, 1:5}, {0:3, 1:NULL}]。
select arrays_zip(array(1, 2, 3), array(4, 5));
```

```
combinations(array(T), n)
```

SELECT combinations(array('foo', 'bar', 'boo'),2);

[['foo', 'bar'], ['foo', 'boo']['bar', 'boo']]

SELECT combinations(array(1,2,3,4,5),3);

[[1, 2, 3], [1, 2, 4], [1, 3, 4], [2, 3, 4], [1, 2, 5], [1, 3, 5], [2, 3, 5], [1, 4, 5], [2, 4, 5], [3, 4, 5]]

SELECT combinations(array(1,2,2),2);

[[1,2], [1,2], [2,2]]

array<T> concat(array<T> <a>, array<T> <b>[,...])
string concat(string <str1>, string <str2>[,...])

- ```
--返回[10, 20, 20, -20]。
select concat(array(10, 20), array(20, -20));
```
- ```
--返回[10, NULL, 20, -20]。
select concat(array(10, null), array(20, -20));
```
- ```
--返回NULL。
select concat(array(10, 20), null);
```
- ```
--返回aabcabcde。
select concat('aabc','abcde');
```
- ```
--返回NULL。
select concat();
```
- ```
--返回NULL。
select concat('aabc', 'abcde', null);
```

```
explode (<var>)
```

  +------------+-------+
| c1         | t_map |
+------------+-------+
| 1000       | {k11:86, k21:15} |
| 1001       | {k12:97, k22:2} |
| 1002       | {k13:99, k23:1} |
+------------+-------+

select explode(t_map) from t_table_map;
--返回结果如下。
+-----+------------+
| key | value      |
+-----+------------+
| k11 | 86         |
| k21 | 15         |
| k12 | 97         |
| k22 | 2          |
| k13 | 99         |
| k23 | 1          |
+-----+------------+

```
T field(struct <s>, string <fieldName>)
```

--返回hello。
select field(named_struct('f1', 'hello', 'f2', 3), 'f1');

array<T> filter(array<T> <a>, function<T,boolean> <func>)

--返回[2, 3]。
select filter(array(1, 2, 3), x -> x > 1);

```
flatten(arrayOfArray)
```

SELECT flatten(array(array(1, 2), array(3, 4)));

[1,2,3,4]

```
from_json(<jsonStr>, <schema>)
```

JSON数据类型	MaxCompute数据类型
OBJECT	STRUCT、MAP、STRING
ARRAY	ARRAY、STRING
NUMBER	TINYINT、SMALLINT、INT、BIGINT、FLOAT、DOUBLE、DECIMAL、STRING
BOOLEAN	BOOLEAN、STRING
STRING	STRING、CHAR、VARCHAR、BINARY、DATE、DATETIME
NULL	所有类型

--返回{"a":1,"b":0.8}。
select from_json('{"a":1, "b":0.8}', 'a int, b double');
--返回{"time":"26/08/2015"}。
select from_json('{"time":"26/08/2015"}', 'time string');
--返回{"a":1,"b":0.8}。
select from_json('{"a":1, "b":0.8}', 'a int, b double, c string');
--返回[1,2,3]。
select from_json('[1, 2, 3, "a"]', 'array<bigint>');
--返回{"d":"v","a":"1","b":"[1,2,3]","c":"{}"}。
select from_json('{"a":1,"b":[1,2,3],"c":{},"d":"v"}', 'map<string, string>');

```
--返回["a","b"]。
select map_keys(from_json('{"a":1,"b":2}','map<string,string>'));
```

json get_json_object(json <json>, string <json_path>)

select get_json_object(json '{"a":1, "b":2}', '$.a');

+-----+
| _c0 |
+-----+
| 1   |
+-----+

select get_json_object(json '{"a":1, "b":2}', '$.c');

+-----+
| _c0 |
+-----+
| NULL |
+-----+

select get_json_object(json '{"a":1, "b":2}', '$invalid_json_path');

+-----+
| _c0 |
+-----+
| NULL |
+-----+

```
string get_json_object(string <json>, string <path>)
```
- - - ```
    --返回NULL。
    select get_json_object('{"a":"1","a":"2"}', '$.a');
```
- ```
--返回NULL。
select get_json_object('{"a":"<Emoji符号>"}', '$.a');
```
    - ```
    --返回{"a":"2","b":"1"}。
    select get_json_object('{"b":"1","a":"2"}', '$');
```

--JSON对象src_json.json的内容。
+----+
+----+
{"store":
{"fruit":[{"weight":8,"type":"apple"},{"weight":9,"type":"pear"}],
"bicycle":{"price":19.95,"color":"red"}
"email":"amy@only_for_json_udf_test.net",
"owner":"amy"
--提取owner字段信息，返回amy。
select get_json_object(src_json.json, '$.owner') from src_json;
--提取store.fruit字段第一个数组信息，返回{"weight":8,"type":"apple"}。
select get_json_object(src_json.json, '$.store.fruit[0]') from src_json;
--提取不存在的字段信息，返回NULL。
select get_json_object(src_json.json, '$.non_exist_key') from src_json;

--返回2222。
select get_json_object('{"array":[["aaaa",1111],["bbbb",2222],["cccc",3333]]}','$.array[1][1]');
--返回["h0","h1","h2"]。
set odps.sql.udf.getjsonobj.new=true;
select get_json_object('{"aaa":"bbb","ccc":{"ddd":"eee","fff":"ggg","hhh":["h0","h1","h2"]},"iii":"jjj"}','$.ccc.hhh[*]');
--返回["h0","h1","h2"]。
set odps.sql.udf.getjsonobj.new=false;
select get_json_object('{"aaa":"bbb","ccc":{"ddd":"eee","fff":"ggg","hhh":["h0","h1","h2"]},"iii":"jjj"}','$.ccc.hhh');
--返回h1。
select get_json_object('{"aaa":"bbb","ccc":{"ddd":"eee","fff":"ggg","hhh":["h0","h1","h2"]},"iii":"jjj"}','$.ccc.hhh[1]');

--创建一张表。
create table mf_json (id string, json string);
--向表中插入数据，Key带.。
insert into table mf_json (id, json) values ("1", "{
\"China.beijing\":{\"school\":{\"id\":0,\"book\":[{\"title\": \"A\",
\"price\": 8.95},{\"title\": \"B\",\"price\": 10.2}]}}}");
--向表中插入数据，Key不带.。
insert into table mf_json (id, json) values ("2", "{
\"China_beijing\":{\"school\":{\"id\":0,\"book\":[{\"title\": \"A\",
\"price\": 8.95},{\"title\": \"B\",\"price\": 10.2}]}}}");
--取id的值，查询key为China.beijing，返回0。由于包含.，只能用['']来解析。
select get_json_object(json, "$['China.beijing'].school['id']") from mf_json where id =1;
--取id的值，查询key为China_beijing，返回0。查询方法有如下两种。
select get_json_object(json, "$['China_beijing'].school['id']") from mf_json where id =2;
select get_json_object(json, "$.China_beijing.school['id']") from mf_json where id =2;

--返回NULL。
select get_json_object('','$.array[1][1]');
--返回NULL。
select get_json_object('"array":["aaaa",1111],"bbbb":["cccc",3333]','$.array[1][1]');

set odps.sql.udf.getjsonobj.new=true;
--返回"1"。
select get_json_object('{"a":"\\"1\\"","b":"2"}', '$.a'); 
--返回'1'。
select get_json_object('{"a":"\'1\'","b":"2"}', '$.a');

```
index(<var1>[<var2>])
```
- ```
--返回c。
select array('a','b','c')[2];
```
- ```
--返回1。
select str_to_map("test1=1,test2=2")["test1"];
```

inline(array<struct<f1:T1, f2:T2[, ...]>>)

+----------+
| t_struct |
+----------+
| {user_id:10001, user_name:LiLei, married:N, weight:63.5} |
| {user_id:10002, user_name:HanMeiMei, married:Y, weight:43.5} |
+----------+

--将t_struct列展开。
select inline(array(t_struct)) from t_table;
--返回结果如下。
+------------+-----------+---------+------------+
| user_id    | user_name | married | weight     |
+------------+-----------+---------+------------+
| 10001      | LiLei     | N       | 63.5       |
| 10002      | HanMeiMei | Y       | 43.5       |
+------------+-----------+---------+------------+

string json_tuple(string <json>, string <key1>, string <key2>,...)

--创建一张表school。
create table school (id string, json string);
--向表中插入数据。
insert into school (id, json) values ("1", "{
\"school\": \"湖畔大学\", \"地址\":\"杭州\", \"SchoolRank\": \"00\", 
\"Class1\":{\"Student\":[{\"studentId\":1,\"scoreRankIn3Year\":[1,2,[3,2,6]]}, 
{\"studentId\":2,\"scoreRankIn3Year\":[2,3,[4,3,1]]}]}}");

select json_tuple(school.json,"SchoolRank","Class1") as (item0, item1) from school;
--等效于如下语句。
select get_json_object(school.json,"$.SchoolRank") item0,get_json_object(school.json,"$.Class1") item1 from school;
--返回结果如下。
+-------+-------+
| item0 | item1 |
+-------+-------+
| 00    | {"Student":[{"studentId":1,"scoreRankIn3Year":[1,2,[3,2,6]]},{"studentId":2,"scoreRankIn3Year":[2,3,[4,3,1]]}]} |
+-------+-------+

select json_tuple(school.json,"school","['Class1'].Student") as (item0, item2) from school where id=1;
--返回结果如下。
+-------+-------+
| item0 | item2 |
+-------+-------+
| 湖畔大学 | [{"studentId":1,"scoreRankIn3Year":[1,2,[3,2,6]]},{"studentId":2,"scoreRankIn3Year":[2,3,[4,3,1]]}] |

select json_tuple(school.json,"校名","地址") as (item0,item1) from school;
--返回结果如下。
+-------+-------+
| item0 | item1 |
+-------+-------+
| 湖畔大学 | 杭州 |
+-------+-------+

select sc.Id, q.item0, q.item1 
from school sc lateral view json_tuple(sc.json,"Class1.Student[*].studentId","Class1.Student[0].scoreRankIn3Year") q as item0,item1;
--返回结果如下。
+------------+-------+-------+
| id         | item0 | item1 |
+------------+-------+-------+
| 1          | [1,2] | [1,2,[3,2,6]] |
+------------+-------+-------+

select sc.Id, q.item0, q.item1
from school sc lateral view json_tuple(sc.json,"Class1.Student[0].scoreRankIn3Year[2]","Class1.Student[0].scoreRankIn3Year[2][1]") q as item0,item1;
--返回结果如下。
+------------+-------+-------+
| id         | item0 | item1 |
+------------+-------+-------+
| 1          | [3,2,6] | 2     |
+------------+-------+-------+

json json_object(<key1>,<value1>[,<keyn>,<valuen>])

--生成json对象
select json_object('a', 123);

+-----+
| _c0 |
+-----+
| {"a":123} |
+-----+

--生成json对象
select json_object('a', 123,'b','hello');

+-----+
| _c0 |
+-----+
| {"a":123,"b":"hello"} |
+-----+

```
json json_array(<element>)
```

--生成json array
select json_array('a', 45, true, 13, json '{"a":456}');

+-----+
| _c0 |
+-----+
| ["a",45,true,13,{"a":456}] |
+-----+

```
json json_extract(<json>, <json_path>)
```

select json_extract(json '{"a":1, "b":2}', '$.a');

+-----+
| _c0 |
+-----+
| 1   |
+-----+

select json_extract(json '{"a":1, "b":2}', 'strict $.c');

+-----+
| _c0 |
+-----+
| NULL |
+-----+

```
select json_extract(json '{"a":1, "b":2}', '$a');
```
```
--返回报错信息
Invalid argument - Param json path $invalid_json_path is invalid
```

boolean json_exists(<json>, <json_path>)

select json_exists(json '{"a":1, "b":2}', '$.a');

+------+
| _c0  |
+------+
| true |
+------+

select json_exists(json '[1,2, {"a":34}]', '$[2].a');

+------+
| _c0  |
+------+
| true |
+------+

select json_exists(json '{"a":1, "b":2}', 'strict $.c');

+------+
| _c0  |
+------+
| false |
+------+

```
string json_pretty(<json>)
```

--美化json
select json_pretty(json '{"a":1, "b":2}');

+-----+
| _c0 |
+-----+
    "a":1,
    "b":2
+-----+

string|number|boolean|null|object|array json_type(<json>)

- ```
select json_type(json '[{"a":1}, 23]');
```
```
+-----+
| _c0 |
+-----+
| array |
+-----+
```
- ```
select json_type(json '123');
```
```
+-----+
| _c0 |
+-----+
| number |
+-----+
```
- ```
select json_type(json '"123"');
```
```
+-----+
| _c0 |
+-----+
| string |
+-----+
```

```
string json_format(<json>)
```
- ```
select json_format(json '123');
```
```
+-----+
| _c0 |
+-----+
| 123 |
+-----+
```
- ```
select json_format(json '"123"');
```
```
+-----+
| _c0 |
+-----+
| "123" |
+-----+
```

```
json json_parse(<string>)
```

select json_parse('{"a":1, "b":2}');

+-----+
| _c0 |
+-----+
| {"a":1,"b":2} |
+-----+

```
select json_parse('"abc"');
```
```
+-----+
| _c0 |
+-----+
| "abc" |
+-----+
```

select json_parse('abc');

Invalid input syntax for type json, detail:Token "abc" is invalid.

```
boolean json_valid(<json>)
```
- ```
select json_valid('"abc"');
```
```
+------+
| _c0  |
+------+
| true |
+------+
```
- ```
select json_valid('abc');
```
```
+------+
| _c0  |
+------+
| false |
+------+
```

json/string/bigint/int/tinyint/smallint/double/float/boolean/sql-type 
cast(json as string/
     string as json/
     json as bigint/
     bigint as json/
     json as int/
     int as json/
     json as tinyint/
     tinyint as json/
     json as smallint/
     smallint as json/
     json as double/
     double as json/
     json as float/
     float as json/
     boolean as json/
     json as boolean/
     null as json/
     json 'null' as ...
     )

--json转成string
select cast(json '123' as string);
--返回：
+-----+
| _c0 |
+-----+
| 123 |
+-----+
--json转成string
select cast(json '"abc"' as string);
--返回：
+-----+
| _c0 |
+-----+
| abc |
+-----+
--json转成string
select cast(json 'true' as string); 
--返回：
+-----+
| _c0 |
+-----+
| TRUE |
+-----+
--json转成string
select cast(json 'null' as string);
--返回：
+-----+
| _c0 |
+-----+
| NULL |
+-----+
--string转成json
select cast('{"a":2}' as json); 
--返回：
+-----+
| _c0 |
+-----+
| "{\"a\":2}" |
+-----+
--json转成string的错误示例，不支持array/object类型的JSON表达式转换为string。
select cast(json '{"a":2}' as string);
--返回报错：
FAILED: ODPS-0123091:Illegal type cast - Unsupported cast from json array/object to string

--json转成bigint
select cast(json '123' as bigint);
--返回：
+------------+
| _c0        |
+------------+
| 123        |
+------------+
--json转成float
select cast(json '"1.23"' as float);
--返回：
+------+
| _c0  |
+------+
| 1.23 |
+------+
--json转成double
select cast(json '1.23' as double);
--返回：
+------------+
| _c0        |
+------------+
| 1.23       |
+------------+
--int转成json
select cast(123 as json);
--返回：
+-----+
| _c0 |
+-----+
| 123 |
+-----+
--float转成json
select cast(1.23 as json);
--返回：
+-----+
| _c0 |
+-----+
| 1.23 |
+-----+

--boolean转成bigint
select cast(true as json);
--返回：
+-----+
| _c0 |
+-----+
| true |
+-----+
--json转成boolean
select cast(json 'false' as boolean);
--返回：
+------+
| _c0  |
+------+
| false |
+------+
--json转成boolean
select cast(json '"abc"' as boolean);
--返回：
+------+
| _c0  |
+------+
| true |
+------+
--array/object不能转成boolean
select cast(json '[1,2]' as boolean);
--返回报错：
Unsupported cast from json array/object to boolean

--null转成string
select json_type(cast(null as json));
--返回：
+-----+
| _c0 |
+-----+
| NULL |
+-----+

map(K, V) map(K <key1>, V <value1>, K <key2>, V <value2>[, ...])

+------------+----+----+------------+------------+
| c1         | c2 | c3 | c4         | c5         |
+------------+----+----+------------+------------+
| 1000       | k11 | k21 | 86         | 15         |
| 1001       | k12 | k22 | 97         | 2          |
| 1002       | k13 | k23 | 99         | 1          |
+------------+----+----+------------+------------+

--将c2、c4，c3、c5组成MAP。
select map(c2,c4,c3,c5) from t_table;
--返回结果如下。
+------+
| _c0  |
+------+
| {k11:86, k21:15} |
| {k12:97, k22:2} |
| {k13:99, k23:1} |
+------+

1000,'k11','k11',86,15
1001,'k12','k22',97,2
1002,'k13','k23',99,1
1003,'k13','k24',100,1
1004,'k12','k25',95,1

--将c2、c4，c3、c5组成MAP。
select map(c2,c4,c3,c5) from t_table;
--返回结果如下。
+------+
| _c0  |
+------+
| {'k11':15} |
| {'k12':97, 'k22':2} |
| {'k13':99, 'k23':1} |
| {'k13':100, 'k24':1} |
| {'k12':95, 'k25':1} |
+------+

map<K, V> map_concat([string <mapDupKeyPolicy>,] map<K, V> <a>, map<K, V> <b>[,...])

--返回{1:a, 2:b, 3:c}。
select map_concat(map(1, 'a', 2, 'b'), map(3, 'c'));
--返回{1:a, 2:d, 3:c}。
select map_concat('last_win', map(1, 'a', 2, 'b'), map(3, 'c'), map(2, 'd'));

array<struct<K, V>> map_entries(map<K, V> <a>):

--返回[{key:1, value:a}, {key:2, value:b}]。
select map_entries(map(1,  'a',  2,  'b'));

map<K, V> map_filter(map<K, V> <input>, function <K, V, boolean> <predicate>)

--返回{-30:100, 20:50}。
select map_filter(map(10, -20, 20, 50, -30, 100, 21, null), (k, v) -> (k+v) > 10);

map<K, V> map_from_arrays([string <mapDupKeyPolicy>,] array<K> <a>, array<V> <b>))

--返回{1:2, 3:4}。
select map_from_arrays(array(1.0, 3.0), array('2', '4'));
--返回{1:2, 3:6}。
select map_from_arrays('last_win', array(1.0, 3.0, 3), array('2', '4', '6'));

map<K, V> map_from_entries([string <mapDupKeyPolicy>,] array <struct<K, V> , struct<K, V>[,...]>)

--返回{1:a, 2:b}。
select map_from_entries(array(struct(1, 'a'), struct(2, 'b')));
--返回{1:a, 2:c}。
select map_from_entries(array(struct(1, 'a'), struct(2, 'b'), struct(2, 'c')));

```
array<K> map_keys(map<K, V> <a>)
```

+------------+-------+
| c1         | t_map |
+------------+-------+
| 1000       | {k11:86, k21:15} |
| 1001       | {k12:97, k22:2} |
| 1002       | {k13:99, k23:1} |
+------------+-------+

--将t_map中的Key作为数组返回。
select c1, map_keys(t_map) from t_table_map;
--返回结果如下。
+------------+------+
| c1         | _c1  |
+------------+------+
| 1000       | [k11, k21] |
| 1001       | [k12, k22] |
| 1002       | [k13, k23] |
+------------+------+

```
array<V> map_values(map<K, V> <a>)
```

+------------+-------+
| c1         | t_map |
+------------+-------+
| 1000       | {k11:86, k21:15} |
| 1001       | {k12:97, k22:2} |
| 1002       | {k13:99, k23:1} |
+------------+-------+

--将t_map中的Key作为数组返回。
select c1,map_values(t_map) from t_table_map;
--返回结果如下。
+------------+------+
| c1         | _c1  |
+------------+------+
| 1000       | [86, 15] |
| 1001       | [97, 2] |
| 1002       | [99, 1] |
+------------+------+

<K, V1, V2, V3> map<K, V3> map_zip_with(map<K, V1> <input1>, map<K, V2> <input2>, function<K, V1, V2, V3> <func>)

--返回{1:[1, 1, 4], 2:[2, 2, 5], 3:[3, NULL, NULL], 4:[4, NULL, 7]}。
select map_zip_with(map(1, 1, 2, 2, 3, null), map(1, 4, 2, 5, 4, 7), (k, v1, v2) -> array(k, v1, v2));

	multimap_from_entries(array<struct<K, V>>)

SELECT multimap_from_entries(array(struct(1, 'a'), 
                                     struct(2, 'b'), 
                                     struct(1, 'c')));

{1 : ['a', 'c'],  2: ['b']}

struct named_struct(string <name1>, T1 <value1>, string <name2>, T2 <value2>[, ...])

--返回{user_id:10001, user_name:LiLei, married:F, weight:63.5}。
select named_struct('user_id',10001,'user_name','LiLei','married','F','weight',63.50);

```
ngrams(array(T), n)
```

SELECT ngrams(array('foo', 'bar', 'baz', 'foo'), 2);

[['foo', 'bar'], ['bar', 'baz'], ['baz', 'foo']]

SELECT ngrams(array('foo', 'bar', 'baz', 'foo'), 3);

[['foo', 'bar', 'baz'], ['bar', 'baz', 'foo']]

SELECT ngrams(array('foo', 'bar', 'baz', 'foo'), 4);

[['foo', 'bar', 'baz', 'foo']]

SELECT ngrams(array('foo', 'bar', 'baz', 'foo'), 5);

[['foo', 'bar', 'baz', 'foo']]

SELECT ngrams(array(1, 2, 3, 4), 2);

[[1, 2], [2, 3], [3, 4]]

```
posexplode(array<T> <a>)
```

select posexplode(array('a','c','f','b'));
--返回结果如下。
+------------+------------+
| pos        | val        |
+------------+------------+
| 0          | a          |
| 1          | c          |
| 2          | f          |
| 3          | b          |
+------------+------------+

```
array reverse(array <value>)
```

--返回[3, 4, 1, 2]
SELECT reverse(array(2, 1, 4, 3));

```
sequence(start, stop, [step]) -> array
```

```
SELECT sequence(1, 5);
```
```
[1, 2, 3, 4, 5]
```
```
SELECT sequence(5, 1);
```
```
[5, 4, 3, 2, 1] 
```

SELECT sequence(to_date('2018-01-01'), to_date('2018-03-01'), interval 1 month);

[2018-01-01,  2018-02-01,  2018-03-01]

```
shuffle(array)
```

SELECT shuffle(array(1, 20, 3, 5));

[3,1,5,20]

SELECT shuffle(array(1, 20, null, 3));

[20,null,3,1]

```
int size(array<T> <a>)
int size(map<K, V> <b> )
```
- ```
--返回2。
select size(array('a','b'));
```
- ```
--返回2。
select size(map('a',123,'b',456)); 
```

```
array<T> slice(array<T> <a>, <start>, <length>)
```
- ```
--返回[10, 20, 20]。
select slice(array(10, 20, 20, null, null, 30), 1, 3);
```
- ```
--返回[NULL, 30]。
select slice(array(10, 20, 20, null, null, 30), -2, 2);  
```
- ```
--返回[20, NULL, NULL, 30]。
select slice(array(10, 20, 20, null, null, 30), 3, 10); 
```
- ```
--返回[]。
select slice(array(10, 20, 20, null, null, 30), 3, 0);
```

array<T> sort_array(array<T> <a>[, <isasc>])

+------------+---------+--------------+
| c1         | c2      | c3           |
+------------+---------+--------------+
| [a, c, f, b]  | [4, 5, 7, 2, 5, 8]  |  [你, 我, 他] |
+------------+---------+--------------+

--返回[a, b, c, f] [2, 4, 5, 5, 7, 8] [他, 你, 我]。
select sort_array(c1),sort_array(c2),sort_array(c3) from t_array;

```
--返回[50, 40, 30, 30, 20, 10, NULL]。
select sort_array(array(10, 20, 40, 30, 30, null, 50), false);
```

```
split(<str>, <pat>)
```

--返回[a,  b,  c]。
select split("a, b, c", ",");

```
struct struct(<value1>,<value2>[, ...])
```

--返回{col1:a, col2:123, col3:true, col4:56.9}。
select struct('a',123,'true',56.90);

```
string to_json(<expr>)
```

--返回{"a":1,"b":2}。
select to_json(named_struct('a', 1, 'b', 2));
--返回{"time":"26/08/2015"}。
select to_json(named_struct('time', "26/08/2015"));
--返回[{"a":1,"b":2}]。
select to_json(array(named_struct('a', 1, 'b', 2)));
--返回{"a":{"b":1}}。
select to_json(map('a', named_struct('b', 1)));
--返回{"a":1}。
select to_json(map('a', 1));
--返回[{"a":1}]。
select to_json(array((map('a', 1))));

--返回{"a":"B"}。STRUCT类型转换为JSON字符串时，key会全部转为小写。
select to_json(named_struct("A", "B"));
--返回{"k2":"v2"}。NULL值所在组的数据，不会输出到JSON字符串。
select to_json(named_struct("k1", cast(null as string), "k2", "v2"));

array<R> transform(array<T> <a>, function<T, R> <func>)

--返回[2, 3, 4]。
select transform(array(1, 2, 3), x -> x + 1);

map<K2, V> transform_keys([string <mapDupKeyPolicy>,] map<K1, V> <input>, function<K1, V, K2> <func>)

--返回{-10:-20, 70:50, 71:101}。
select transform_keys(map(10, -20, 20, 50, -30, 101), (k, v) -> k + v);
--不报错，返回的结果依赖于输入map中元素的顺序。
select transform_keys("last_win", map(10, -20, 20, 50, -30, 100), (k, v) -> k + v);
--因出现重复Key，返回报错。
select transform_keys("exception", map(10, -20, 20, 50, -30, 100), (k, v) -> k + v);

map<K, V2> transform_values(map<K, V1> <input>, function<K, V1, V2> <func>)

--返回{-30:71, 10:-10, 20:NULL}。
select transform_values(map(10, -20, 20, null, -30, 101), (k, v) -> k + v);

array<R> zip_with(array<T> <a>, array<S> <b>, function<T, S, R> <combiner>)

--返回[2, 4, 6, NULL]。
select zip_with(array(1,2,3), array(1,2,3,4), (x,y) -> x + y);

ALL_MATCH

ANY_MATCH

ARRAY

ARRAY_CONTAINS

ARRAY_DISTINCT

ARRAY_EXCEPT

ARRAY_INTERSECT

ARRAY_JOIN

ARRAY_MAX

ARRAY_MIN

ARRAY_NORMALIZE

ARRAY_POSITION

ARRAY_REDUCE

ARRAY_REMOVE

ARRAY_REPEAT

ARRAY_SORT

ARRAY_UNION

ARRAYS_OVERLAP

ARRAYS_ZIP

COMBINATIONS

CONCAT

EXPLODE

FIELD

FILTER

FLATTEN

FROM_JSON

GET_JSON_OBJECT

使用说明

入参为JSON类型

入参为STRING类型

INDEX

INLINE

JSON_TUPLE

JSON_OBJECT

JSON_ARRAY

JSON_EXTRACT

JSON_EXISTS

JSON_PRETTY

JSON_TYPE

JSON_FORMAT

JSON_PARSE

JSON_VALID

CAST

MAP

MAP_CONCAT

MAP_ENTRIES

MAP_FILTER

MAP_FROM_ARRAYS

MAP_FROM_ENTRIES

MAP_KEYS

MAP_VALUES

MAP_ZIP_WITH

MULTIMAP_FROM_ENTRIES

NAMED_STRUCT

NGRAMS

POSEXPLODE

REVERSE

SEQUENCE

SHUFFLE

SIZE

SLICE

SORT_ARRAY

SPLIT

STRUCT

TO_JSON

TRANSFORM

TRANSFORM_KEYS

TRANSFORM_VALUES

ZIP_WITH