地图函数和运算符¶

下标运算符: []¶

the [] 运算符用于从地图中检索与给定键相对应的值

SELECT name_to_age_map['Bob'] AS bob_age;

地图函数¶

all_keys_match(x(K,V), function(K, boolean)) -> boolean()¶

返回地图的所有键是否与给定的谓词匹配。如果所有键都与谓词匹配，则返回 true（特殊情况是地图为空）；如果一个或多个键不匹配，则返回 false；如果谓词函数对一个或多个键返回 NULL，并且对所有其他键返回 true，则返回 NULL。

SELECT all_keys_match(map(array['a', 'b', 'c'], array[1, 2, 3]), x -> length(x) = 1); -- true

any_keys_match(x(K,V), function(K, boolean)) -> boolean()¶

返回地图的任何键是否与给定的谓词匹配。如果一个或多个键与谓词匹配，则返回 true；如果地图为空，则返回 false（特殊情况是地图为空）；如果谓词函数对一个或多个键返回 NULL，并且对所有其他键返回 false，则返回 NULL。

SELECT any_keys_match(map(array['a', 'b', 'c'], array[1, 2, 3]), x -> x = 'a'); -- true

any_values_match(x(K,V), function(V, boolean)) -> boolean()¶

返回地图的任何值是否与给定的谓词匹配。如果一个或多个值与谓词匹配，则返回 true；如果地图为空，则返回 false（特殊情况是地图为空）；如果谓词函数对一个或多个值返回 NULL，并且对所有其他值返回 false，则返回 NULL。

SELECT ANY_VALUES_MATCH(map(ARRAY['a', 'b', 'c'], ARRAY[1, 2, 3]), x -> x = 1); -- true

cardinality(x) -> bigint()

返回地图 x 的基数（大小）。

element_at(map(K,V), key) -> V()

返回给定 key 的值，如果地图中不包含该键，则返回 NULL。

map() -> map<unknown, unknown>()¶

返回一个空地图。

SELECT map(); -- {}

map(array(K), array(V)) -> map(K, V)¶

返回使用给定的键/值数组创建的地图。

SELECT map(ARRAY[1,3], ARRAY[2,4]); -- {1 -> 2, 3 -> 4}

另请参阅 map_agg() 和 multimap_agg() 以了解如何创建地图作为聚合。

map_from_entries(array(row(K, V))) -> map(K, V)¶

返回从给定的条目数组创建的地图。

SELECT map_from_entries(ARRAY[(1, 'x'), (2, 'y')]); -- {1 -> 'x', 2 -> 'y'}

multimap_from_entries(array(row(K, V))) -> map(K, array(V))¶

返回从给定的条目数组创建的多重地图。每个键可以与多个值关联。

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))¶

返回给定地图中的所有条目的数组。

SELECT map_entries(MAP(ARRAY[1, 2], ARRAY['x', 'y'])); -- [ROW(1, 'x'), ROW(2, 'y')]

map_concat(map1(K, V), map2(K, V), ..., mapN(K, V)) -> map(K, V)¶

返回所有给定地图的并集。如果在一个或多个给定地图中找到了一个键，则结果地图中该键的值来自那些地图中的最后一个。

map_filter(map(K, V), function(K, V, boolean)) -> map(K, V)¶

从 map 的那些条目中构建一个地图，对于这些条目，function 返回 true

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); -- {k1 -> 20, k3 -> 15}

map_remove_null_values(x(K, V)) -> map(K, V)¶

从映射 x 中删除所有值为 null 的条目。

map_subset(map(K, V), array(k)) -> map(K, V)¶

从 map 中构建一个映射，其中键存在于给定的数组中。

SELECT map_subset(MAP(ARRAY[1,2], ARRAY['a','b']), ARRAY[10]); -- {}
SELECT map_subset(MAP(ARRAY[1,2], ARRAY['a','b']), ARRAY[1]); -- {1->'a'}
SELECT map_subset(MAP(ARRAY[1,2], ARRAY['a','b']), ARRAY[1,3]); -- {1->'a'}
SELECT map_subset(MAP(ARRAY[1,2], ARRAY['a','b']), ARRAY[]); -- {}
SELECT map_subset(MAP(ARRAY[], ARRAY[]), ARRAY[1,2]); -- {}

map_key_exists(x(K, V), k) -> boolean()¶

返回给定键是否在映射中。如果键存在于输入映射中，则返回 true，否则返回 false。

SELECT map_key_exists(MAP(ARRAY['x','y'], ARRAY[100,200]), 'x'); -- TRUE

map_keys(x(K, V)) -> array(K)¶

返回映射 x 中的所有键。

map_top_n_keys(x(K, V), n) -> array(K)¶

通过按降序排序其键，返回映射 x 中的 top n 个键。 n 必须是非负整数。

对于 bottom n 个键，使用带 lambda 运算符的函数执行自定义排序。

SELECT map_top_n_keys(map(ARRAY['a', 'b', 'c'], ARRAY[3, 2, 1]), 2) --- ['c', 'b']

map_top_n_keys(x(K, V), n, function(K, K, int)) -> array(K)¶

通过使用给定的比较器 function 对键进行排序，返回映射 x 中的 top n 个键。 比较器接受两个不可为空的参数，分别表示 map 的两个键。 如果第一个键小于、等于或大于第二个键，则返回 -1、0 或 1。 如果比较器函数返回其他值（包括 NULL），则查询将失败并引发错误。

SELECT map_top_n_keys(map(ARRAY['a', 'b', 'c'], ARRAY[3, 2, 1]), 2, (x, y) -> IF(x < y, -1, IF(x = y, 0, 1))) --- ['c', 'b']

map_keys_by_top_n_values(x(K, V), n) -> array(K)¶

通过按降序排序其值，返回映射 x 中的 top n 个键。 如果两个或多个键具有相同的值，则更高的键优先。 n 必须是非负整数。

SELECT map_top_n_keys_by_value(map(ARRAY['a', 'b', 'c'], ARRAY[2, 1, 3]), 2) --- ['c', 'a']

map_top_n(x(K, V), n) -> map(K, V)¶

截断映射项。 按值保留前 n 个元素。 键用于打破与最大键相匹配的平局。 键和值都应该是可排序的。 n 必须是非负整数。

SELECT map_top_n(map(ARRAY['a', 'b', 'c'], ARRAY[2, 3, 1]), 2) --- {'b' -> 3, 'a' -> 2}

map_normalize(x(varchar, double)) -> map(varchar, double)¶

返回具有相同键的映射，但所有非空值按比例缩放，使值的总和变为 1。 具有 null 值的映射条目保持不变。

map_values(x(K, V)) -> array(V)¶

返回映射 x 中的所有值。

map_top_n_values(x(K, V), n) -> array(K)¶

返回映射 x 中的 top n 个值。 n 必须是正整数。 对于 bottom n 个值，使用带 lambda 运算符的函数执行自定义排序。

SELECT map_top_n_values(map(ARRAY['a', 'b', 'c'], ARRAY[1, 2, 3]), 2) --- [3, 2]

map_top_n_values(x(K, V), n, function(V, V, int)) -> array(V)¶

根据给定的比较器 function 返回映射 x 中的 top n 个值。 比较器将接受两个可为空的参数，分别表示 map 的两个值。 如果第一个值小于、等于或大于第二个值，则返回 -1、0 或 1。 如果比较器函数返回其他值（包括 NULL），则查询将失败并引发错误。

SELECT map_top_n_values(map(ARRAY['a', 'b', 'c'], ARRAY[1, 2, 3]), 2, (x, y) -> IF(x < y, -1, IF(x = y, 0, 1))) --- [3, 2]

map_zip_with(map(K, V1), map(K, V2), function(K, V1, V2, V3)) -> map(K, V3)¶

通过将 function 应用于具有相同键的成对值，将两个给定的映射合并为一个映射。 对于仅在一个映射中出现的键，将 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));
SELECT map_zip_with(MAP(ARRAY['k1', 'k2'], ARRAY[1, 2]), -- {k1 -> ROW(1, null), k2 -> ROW(2, 4), k3 -> ROW(null, 9)}
                    MAP(ARRAY['k2', 'k3'], ARRAY[4, 9]),
                    (k, v1, v2) -> (v1, v2));
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));

no_keys_match(x(K,V), function(K, boolean)) -> boolean()¶

返回映射中是否没有键与给定的谓词匹配。 如果没有键与谓词匹配（特殊情况是映射为空），则返回 true； 如果一个或多个键匹配，则返回 false； 如果谓词函数对一个或多个键返回 NULL，而对所有其他键返回 false，则返回 NULL。

SELECT no_keys_match(map(array['a', 'b', 'c'], array[1, 2, 3]), x -> x = 'd'); -- true

no_values_match(x(K,V), function(V, boolean)) -> boolean()¶

返回映射中是否没有值与给定的谓词匹配。 如果没有值与谓词匹配（特殊情况是映射为空），则返回 true； 如果一个或多个值匹配，则返回 false； 如果谓词函数对一个或多个值返回 NULL，而对所有其他值返回 false，则返回 NULL。

SELECT no_values_match(map(array['a', 'b', 'c'], array[1, 2, 3]), x -> x = 'd'); -- true

transform_keys(map(K1, V), function(K1, V, K2)) -> map(K2, V)¶

返回一个映射，该映射将 function 应用于 map 的每个条目并转换键。

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, 4 -> 2, 9 -> 3}
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]), -- {one -> 1.0, two -> 1.4}
                      (k, v) -> MAP(ARRAY[1, 2], ARRAY['one', 'two'])[k]);

transform_values(map(K, V1), function(K, V1, V2)) -> map(K, V2)¶

返回一个 map，它将 function 应用于 map 中的每个条目，并转换值。

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]), -- {1 -> one_1.0, 2 -> two_1.4}
                        (k, v) -> MAP(ARRAY[1, 2], ARRAY['one', 'two'])[k] || '_' || CAST(v AS VARCHAR));