7、Map函数

原创于 2025-08-31 09:00:00 发布 · 1w 阅读

11 ·

CC 4.0 BY-SA版权

文章标签：

#服务器 #运维 #MaxCompute #ALiyun #linux #DataWorks #SQL

MaxCompute 专栏收录该内容

12 篇文章

订阅专栏

文章目录

- 7、Map函数

7、Map函数

0、概述

分类	函数	功能
map处理	`MAP`	使用指定的Key-Value对建立MAP。
map处理	`MAP_CONCAT`	返回多个MAP的并集。
map处理	`MAP_ENTRIES`	将MAP中的Key、Value键值映射转换为STRUCT结构数组。
map处理	`MAP_FILTER`	将MAP中的元素进行过滤。
map处理	`MAP_FROM_ARRAYS`	通过给定的ARRAY数组构造MAP。
map处理	`MAP_FROM_ENTRIES`	通过给定的结构体数组构造MAP。
map处理	`MAP_KEYS`	将参数MAP中的所有Key作为数组返回。
map处理	`MAP_VALUES`	将参数MAP中的所有Value作为数组返回。
map处理	`MAP_ZIP_WITH`	对输入的两个MAP进行合并得到一个新MAP。
map处理	`MULTIMAP_FROM_ENTRIES`	结构体数组中返回一个MAP。

转换	`TRANSFORM_KEYS`	对MAP进行变换，保持Value不变，根据指定函数计算新的Key。
转换	`TRANSFORM_VALUES`	对MAP进行变换，保持Key不变，根据指定函数计算新的Value。

其它	`SIZE`	返回指定MAP中的K/V对数。
其它	`INDEX`	返回MAP类型参数中满足指定条件的Value。
其它	`EXPLODE`	将一行数据转为多行的UDTF。

1、Map处理

MAP：使用指定的Key-Value对建立MAP。

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

-- {"b":2,"a":1}
SELECT map('a',1,'b',2);

-- 将c2、c4，c3、c5组成MAP。
select map(c2,c4,c3,c5) from t_table;

MAP_CONCAT：返回多个MAP的并集。

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

入参
- mapDupKeyPolicy：可选。STRING类型。指定出现重复Key时的处理方式。取值范围如下：
  - exception：如果出现重复的Key，返回报错。
  - last_win：如果出现重复的Key，后边的值将覆盖前边的值。

-- {"d":4,"a":1,"b":2}
SELECT map_concat(map('a',1,'b',2),map('d',4));
-- {"b":2,"a":5}
SELECT map_concat('last_win',map('a',1) ,map('a',5,'b',2));

MAP_ENTRIES：将MAP中的Key、Value键值映射转换为STRUCT结构数组。

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

-- [{key:a, value:1}, {key:b, value:2}]
SELECT map_entries(map('a',1,'b',2));

MAP_FILTER：将MAP中的元素进行过滤。

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

入参
- input：必填。MAP类型。
  predicate：必填。用于对输入MAP对象中的元素进行过滤的函数（内建函数或自定义函数）或表达式。

-- {"3":4,"5":6}
SELECT map_filter(map(1,2,3,4,5,6) ,(x,y)-> (x+y)>5);

MAP_FROM_ARRAYS：通过给定的ARRAY数组构造MAP。

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

入参
- mapDupKeyPolicy：可选。STRING类型。指定出现重复Key时的处理方式。取值范围如下：
  - exception：如果出现重复的Key，返回报错。
  - last_win：如果出现重复的Key，后边的值将覆盖前边的值。

-- {"a":1,"b":2,"c":3}
SELECT map_from_arrays(array('a','b','c') ,array(1,2,3));
-- {"b":3,"a":1}
SELECT map_from_arrays('last_win' ,array('a','b','b') ,array(1,2,3));

MAP_FROM_ENTRIES：通过给定的结构体数组构造MAP。

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

入参
- mapDupKeyPolicy：可选。STRING类型。指定出现重复Key时的处理方式。取值范围如下：
  - exception：如果出现重复的Key，返回报错。
  - last_win：如果出现重复的Key，后边的值将覆盖前边的值。

-- [{col1:a, col2:1}, {col1:b, col2:2}]
SELECT array(struct('a',1),struct('b',2));
-- {"b":2,"a":1}
SELECT map_from_entries(array(struct('a',1),struct('b',2)));

MAP_KEYS：将参数MAP中的所有Key作为数组返回。

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

select c1, map_keys(t_map) from t_table_map;

MAP_VALUES：将参数MAP中的所有Value作为数组返回。

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

select c1,map_values(t_map) from t_table_map;

MAP_ZIP_WITH：对输入的两个MAP进行合并得到一个新MAP。
- 先2个map取并集，然后再传入后面Lambda函数进行计算
- k为键、v1、v2为值。

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

-- {"b":["b","2","4"],"a":["a","1","3"]}
SELECT map_zip_with(map('a',1,'b',2), map('a',3,'b',4)
            , (k, v1, v2) -> array(k, v1, v2));

-- {"a":["a","1","3"],"b":["b","2","2"],"c":["c",null,"4"]}
select map_zip_with(map('a',1,'b',2), map('a',3,'b',2,'c',4)
            , (k, v1, v2) -> array(k, v1, v2));

MULTIMAP_FROM_ENTRIES：结构体数组中返回一个MAP。

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

-- {"2":["b"],"1":["a","c"]}
SELECT multimap_from_entries(array(
                                struct(1, 'a'), 
                                struct(2, 'b'), 
                                struct(1, 'c')));

2、转换

TRANSFORM_KEYS：对MAP进行变换，保持Value不变，根据指定函数计算新的Key。

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

入参
- mapDupKeyPolicy：可选。STRING类型。指定出现重复Key时的处理方式。取值范围如下：
  - exception：如果出现重复的Key，返回报错。
  - last_win：如果出现重复的Key，后边的值将覆盖前边的值。

-- {"a1":1,"b2":2}
SELECT transform_keys(map('a',1,'b',2), (k,v)->concat(k,v));
-- {"b2":2,"a3":3}
SELECT transform_keys('last_win' ,map('a',1,'b',2,'a',3) ,(k,v)->concat(k,v));

TRANSFORM_VALUES：对MAP进行变换，保持Key不变，根据指定函数计算新的Value。

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

-- {"b":"b2","a":"a1"}
SELECT transform_values(map('a',1,'b',2),(k,v)->concat(k,v));

3、其它

SIZE：返回指定ARRAY中的元素数目。

int size(array<T> <a>)
int size(map<K, V> <b> )

入参
- a：必填。ARRAY数组。
- b：必填。MAP对象。

-- 3
SELECT size(array(1,2,3));
-- 2
SELECT size(map('a',1,'b',2));

INDEX：返回ARRAY数组指定位置的元素值。

INDEX (<var1>[<var2>])

入参
- var1：必填。array<T>类型或map<K, V>类型。
- var2：必填。
  - array<T>类型，为BIGINT类型且大于等于0。
  - map<K, V>类型，与K的类型保持一致。

-- 3
SELECT array(1,2,3,4)[2];
-- 2
SELECT map('a',1,'b',2,'c',3)['b'];

EXPLODE：将一行数据转为多行的UDTF。

explode (<var>)

入参
- 如果参数是array<T>类型，则将列中存储的ARRAY转为多行。
- 如果参数是map<K, V>类型，则将列中存储的MAP的每个Key-Value对转换为包含两列的行，其中一列存储Key，另一列存储Value。
- 如果表中存在NULL数据，不会单独返回。

-- 源数据
+------------+-------+
| 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          |
+-----+------------+