# Map函数和运算符
#### 下标操作符: \[\]
描述：\[\]运算符用于从映射中检索与给定键对应的值。
```
select age_map['li'] from (values (map(array['li','wang'],array[15,27]))) as table_age(age_map);-- 15
```
#### Map函数
- cardinality(*x* )
  描述：返回map x的基数大小。
  ```
  select cardinality(map(array['num1','num2'],array[11,12]));-- 2
  ```
  
- element_at(*map(K* , *V)* , *key* )
  描述：返回map中key对应值，如果map中不包含这个key，则返回NULL。
  ```
  select element_at(map(array['num1','num2'],array[11,12]),'num1'); --11
  select element_at(map(array['num1','num2'],array[11,12]),'num3');-- NULL
  ```
  
- map() 描述：返回一个空的map。
  ```
  select map();-- {}
  ```
  
- map(*array(K)* , *array(V)) -\> map(K* , *V* )
  描述：根据给定的键值对数组，返回map。聚合函数中的map_agg()和multimap_agg()也同样能用于生成map。
  ```
  SELECT map(ARRAY[1,3],ARRAY[2,4]);-- {1=2, 3=4}
  ```
  
- map_from_entries(*array(row(K* , *V))) -\> map(K* , *V* )
  描述：使用给定数组生成map。
  ```
  SELECT map_from_entries(ARRAY[(1, 'x'), (2, 'y')]); --  {1=x, 2=y}
  ```
  
- multimap_from_entries(*array(row(K* , *V))) -\> map(K* , *array(V)* )
  描述：根据给定的row数组返回复合map，每个键可以对应多个值。
  ```
  SELECT multimap_from_entries(ARRAY[(1, 'x'), (2, 'y'), (1, 'z')]); -- {1=[x, z], 2=[y]}
  ```
  
- map_entries(*map(K* , *V)) -\> array(row(K* , *V)* )
  描述：使用给定map生成一个row数组。
  ```
  SELECT map_entries(MAP(ARRAY[1, 2], ARRAY['x', 'y'])); --  [{1, x}, {2, y}]
  ```
  
- map_concat(*map1(K* , *V)* , *map2(K* , *V)* , *...* , *mapN(K* , *V))*
  描述：合并多个map，当key值一样时，取最后一个map的value来构造键值对。如下示例中，a就使用了最后一个map的value值10。
  ```
  select map_concat(map(ARRAY['a','b'],ARRAY[1,2]),map(ARRAY['a', 'c'], ARRAY[10, 20]));
         _col0       
  -------------------
   {a=10, b=2, c=20} 
  (1 row)
  ```
  
- map_filter(*map(K* , *V)* , *function(K* , *V* , *boolean)) -\> map(K* , *V* )
  描述：使用map中仅给定函数映射为true的entry去构造一个新的map。
  ```
  SELECT map_filter(MAP(ARRAY[], ARRAY[]), (k, v) -> true); -- {}
  SELECT map_filter(MAP(ARRAY[10, 20, 30], ARRAY['a', NULL, 'c']), (k, v) -> v IS NOT NULL); -- {10=a, 30=c}
  SELECT map_filter(MAP(ARRAY['k1', 'k2', 'k3'], ARRAY[20, 3, 15]), (k, v) -> v > 10); -- {k3=15, k1=20}
  ```
  
- map_keys(*x(K* , *V)) -\> array(K* )
  描述：返回map中所有的key构造的数组。
  ```
  select map_keys(map(array['num1','num2'],array[11,12])); -- [num1, num2]
  ```
  
- map_values(*x(K* , *V)) -\> array(V* )
  描述：返回map中所有的value构造的数组。
  ```
  select map_values(map(array['num1','num2'],array[11,12]));-- [11, 12]
  ```
  
- map_zip_with(*map(K* , *V1)* , *map(K* , *V2)* , *function(K* , *V1* , *V2* , *V3))*
  描述：通过将函数应用于具有相同键的一对值，将两个给定的map合并为一个map。对于仅在一个map中显示的键，将传递NULL作为缺少键的值。
  ```
  SELECT map_zip_with(MAP(ARRAY[1, 2, 3], ARRAY['a', 'b', 'c']), -- {1 -> ad, 2 -> be, 3 -> cf} 
                       MAP(ARRAY[1, 2, 3], ARRAY['d', 'e', 'f']), 
                       (k, v1, v2) -> concat(v1, v2)); 
         _col0        
  --------------------
   {1=ad, 2=be, 3=cf} 
  (1 row)
    
  SELECT map_zip_with(MAP(ARRAY['k1','k2'],ARRAY[1,2]),Map(ARRAY['K2','k3'],ARRAY[4,9]),(k,v1,v2)->(v1,v2));  -- {k3={NULL, 9}, k1={1, NULL}, k2={2, NULL}, K2={NULL, 4}}
                                         _col0                                       
  -------------------------------------------------------------------------------
  {k3={NULL, 9}, k1={1, NULL}, k2={2, NULL}, K2={NULL, 4}}
  (1 row)
    
   SELECT map_zip_with(MAP(ARRAY['a', 'b', 'c'], ARRAY[1, 8, 27]), -- {a -> a1, b -> b4, c -> c9} 
                       MAP(ARRAY['a', 'b', 'c'], ARRAY[1, 2, 3]), 
                       (k, v1, v2) -> k || CAST(v1/v2 AS VARCHAR));
         _col0        
  --------------------
   {a=a1, b=b4, c=c9} 
  (1 row)
  ```
  
- transform_keys(*map(K1* , *V)* , *function(K1* , *V* , *K2)) -\> map(K2* , *V* )
  描述：对map中的每个entry，将key值K1映射为新的key值K2，保持对应的value不变。
  ```
  SELECT transform_keys(MAP(ARRAY[], ARRAY[]), (k, v) -> k + 1); -- {}
  SELECT transform_keys(MAP(ARRAY [1, 2, 3], ARRAY ['a', 'b', 'c']), (k, v) -> k + 1); -- {2=a, 3=b, 4=c} 
  SELECT transform_keys(MAP(ARRAY ['a', 'b', 'c'], ARRAY [1, 2, 3]), (k, v) -> v * v); -- {1=1, 9=3, 4=2}
  SELECT transform_keys(MAP(ARRAY ['a', 'b'], ARRAY [1, 2]), (k, v) -> k || CAST(v as VARCHAR)); --  {a1=1, b2=2}
  SELECT transform_keys(MAP(ARRAY [1, 2], ARRAY [1.0, 1.4]), (k, v) -> MAP(ARRAY[1, 2], ARRAY['one', 'two'])[k]); -- {two=1.4, one=1.0}
  ```
  
- size(*x* ) → bigint
  描述：返回Map(x) 的容量。
  ```
  select size(map(array['num1','num2'],array[11,12])); --2
  ```
  
- transform_values(*map(K,* *V1)* , *function(K* , *V2* , *V2)) -\> map(K* , *V2* )
  描述：对map中的每个entry，将value值V1映射为新的value值V2，保持对应的key不变。
  ```
  SELECT transform_values(MAP(ARRAY[], ARRAY[]), (k, v) -> v + 1); -- {}
  SELECT transform_values(MAP(ARRAY [1, 2, 3], ARRAY [10, 20, 30]), (k, v) -> v + k); -- {1=11, 2=22, 3=33}
  SELECT transform_values(MAP(ARRAY [1, 2, 3], ARRAY ['a', 'b', 'c']), (k, v) -> k * k); -- {1=1, 2=4, 3=9}
  SELECT transform_values(MAP(ARRAY ['a', 'b'], ARRAY [1, 2]), (k, v) -> k || CAST(v as VARCHAR)); --  {a=a1, b=b2}
  SELECT transform_values(MAP(ARRAY [1, 2], ARRAY [1.0, 1.4]),(k, v) -> MAP(ARRAY[1, 2], ARRAY['one', 'two'])[k] || '_' || CAST(v AS VARCHAR)); -- {1=one_1.0, 2=two_1.4}
  ```