マップ関数と演算子¶

添字演算子: []¶

[] 演算子は、マップから特定のキーに対応する値を取得するために使用されます。

SELECT name_to_age_map['Bob'] AS bob_age;

マップ関数¶

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

マップのすべてのキーが指定された述語に一致するかどうかを返します。すべてのキーが述語に一致する場合はtrueを返し（マップが空の場合も同様）、1つ以上のキーが一致しない場合はfalseを返します。述語関数が1つ以上のキーに対して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()¶

マップのいずれかのキーが指定された述語に一致するかどうかを返します。1つ以上のキーが述語に一致する場合はtrueを返し、キーが一致しない場合はfalseを返します（マップが空の場合も同様）。述語関数が1つ以上のキーに対して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()¶

マップのいずれかの値が指定された述語に一致するかどうかを返します。1つ以上の値が述語に一致する場合はtrueを返し、値が一致しない場合はfalseを返します（マップが空の場合も同様）。述語関数が1つ以上の値に対して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)¶

functionがtrueを返す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); -- {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のキーを降順にソートして、上位n個のキーを返します。nは非負の整数である必要があります。

下位n個のキーについては、ラムダ演算子を使用してカスタムソートを実行する関数を使用してください。

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の上位n個のキーを返します。比較関数は、mapの2つのキーを表す2つのnull許容ではない引数を取ります。最初のキーが2番目のキーより小さい、等しい、または大きい場合に-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の上位n個のキーを返します。2つ以上のキーが同じ値を持つ場合、キーの値が大きい方が優先されます。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)¶

同じキーを持つマップを返しますが、すべてのnull以外の値は比例的にスケールされ、値の合計が1になります。null値を持つマップエントリは変更されません。

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

マップxのすべての値を返します。

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

マップxの上位n個の値を返します。nは正の整数である必要があります。下位n個の値については、ラムダ演算子を使用してカスタムソートを実行する関数を使用してください。

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の上位n個の値を返します。比較関数は、mapの2つの値を表す2つのnull許容引数を取ります。最初の値が2番目の値より小さい、等しい、または大きい場合に-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を適用することで、2つの与えられたマップを1つのマップにマージします。1つのマップのみに存在するキーについては、欠落しているキーの値として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を返します。1つ以上のキーが一致する場合はfalseを返し、述語関数が1つ以上のキーに対して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を返します。1つ以上の値が一致する場合はfalseを返し、述語関数が1つ以上の値に対して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)¶

mapの各エントリにfunctionを適用し、キーを変換するマップを返します。

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

マップの各エントリにfunctionを適用し、値を変換したマップを返します。

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