配列関数と演算子¶

添字演算子: []¶

[] 演算子は、配列の要素にアクセスするために使用され、1 からインデックス付けされます。

SELECT my_array[1] AS first_element

連結演算子: ||¶

|| 演算子は、配列を同じ型の配列または要素と連結するために使用されます。

SELECT ARRAY [1] || ARRAY [2]; -- [1, 2]
SELECT ARRAY [1] || 2; -- [1, 2]
SELECT 2 || ARRAY [1]; -- [2, 1]

配列関数¶

all_match(array(T), function(T,boolean)) -> boolean()¶

配列のすべての要素が指定された述語と一致するかどうかを返します。すべての要素が述語と一致する場合trueを返します（配列が空の場合も特殊ケースです）。1つ以上の要素が一致しない場合falseを返します。述語関数が1つ以上の要素に対してNULLを返し、他のすべての要素に対してtrueを返す場合、NULLを返します。

any_match(array(T), function(T,boolean)) -> boolean()¶

配列のいずれかの要素が指定された述語と一致するかどうかを返します。1つ以上の要素が述語と一致する場合trueを返します。いずれの要素も一致しない場合falseを返します（配列が空の場合も特殊ケースです）。述語関数が1つ以上の要素に対してNULLを返し、他のすべての要素に対してfalseを返す場合、NULLを返します。

array_average(array(double)) -> double()¶

arrayのすべてのNULL以外の要素の平均を返します。NULL以外の要素がない場合はnullを返します。

array_cum_sum(array(T)) -> array(T)¶

要素が入力配列の累積和である配列を返します。つまり、result[i] = input[1]+input[2]+…+input[i]です。配列にNULL要素がある場合、その要素以降の累積和はNULLになります。

SELECT array_cum_sum(ARRAY [1, 2, null, 3]) -- array[1, 3, null, null]

array_distinct(x) -> array()¶

配列xから重複値を削除します。この関数は、重複要素を判断するためにIS DISTINCT FROMを使用します。

SELECT array_distinct(ARRAY [1, 2, null, null, 2]) -- ARRAY[1, 2, null]
SELECT array_distinct(ARRAY [ROW(1, null), ROW (1, null)] -- ARRAY[ROW(1, null)

array_duplicates(array(T)) -> array(bigint/varchar)¶

arrayで2回以上出現する要素の集合を返します。要素のいずれかがNULLを含む行または配列の場合、例外をスローします。

SELECT array_duplicates(ARRAY[1, 2, null, 1, null, 3]) -- ARRAY[1, null]
SELECT array_duplicates(ARRAY[ROW(1, null), ROW(1, null)]) -- "map key cannot be null or contain nulls"

array_except(x, y) -> array()¶

x に存在するが y に存在しない要素の配列を、重複なしで返します。この関数は、IS NOT DISTINCT FROM を使用して、どの要素が同じであるかを判断します。

SELECT array_except(ARRAY[1, 3, 3, 2, null], ARRAY[1,2, 2, 4]) -- ARRAY[3, null]

array_frequency(array(E)) -> map(E, int)¶

マップを返します。キーは配列内の固有の要素であり、値はキーが出現する回数です。NULL要素は無視されます。空の配列は空のマップを返します。

array_has_duplicates(array(T)) -> boolean()¶

ブール値を返します。array に2回以上出現する要素があるかどうかを示します。要素のいずれかがNULLを含む行または配列の場合、例外をスローします。

SELECT array_has_duplicates(ARRAY[1, 2, null, 1, null, 3]) – true SELECT array_has_duplicates(ARRAY[ROW(1, null), ROW(1, null)]) – “map key cannot be null or contain nulls”

array_intersect(x, y) -> array()¶

x と y の共通部分にある要素の配列を、重複なしで返します。この関数は、IS NOT DISTINCT FROM を使用して、どの要素が同じであるかを判断します。

SELECT array_intersect(ARRAY[1, 2, 3, 2, null], ARRAY[1,2, 2, 4, null]) -- ARRAY[1, 2, null]

array_intersect(array(array(E))) -> array(E)¶

与えられた配列内のすべての配列の共通部分にある要素の配列を、重複なしで返します。この関数は、IS NOT DISTINCT FROM を使用して、どの要素が同じであるかを判断します。

SELECT array_intersect(ARRAY[ARRAY[1, 2, 3, 2, null], ARRAY[1,2,2, 4, null], ARRAY [1, 2, 3, 4 null]])  -- ARRAY[1, 2, null]

array_join(x, delimiter, null_replacement) -> varchar()¶

デリミタと、NULLを置き換えるためのオプションの文字列を使用して、与えられた配列の要素を連結します。

array_least_frequent(array(T)) -> array(T)¶

配列の最も頻度の低い非NULL要素を返します。同じ頻度の要素が複数ある場合、関数は最小の要素を返します。配列に複数の要素があり、要素のいずれかがNULLフィールドを持つROWSまたはNULL要素を持つARRAYSである場合、例外が返されます。

SELECT array_least_frequent(ARRAY[1, 0 , 5])  -- ARRAY[0]
select array_least_frequent(ARRAY[1, null, 1]) -- ARRAY[1]
select array_least_frequent(ARRAY[ROW(1,null), ROW(1, null)]) -- "map key cannot be null or contain nulls"

array_least_frequent(array(T), n) -> array(T)¶

配列の頻度の低い非NULL要素をn個返します。要素は、頻度の昇順に並べられています。2つの要素が同じ頻度を持つ場合、小さい要素が先に表示されます。配列に複数の要素があり、要素のいずれかがNULLフィールドを持つROWSまたはNULL要素を持つARRAYSである場合、例外が返されます。

SELECT array_least_frequent(ARRAY[3, 2, 2, 6, 6, 1, 1], 3) -- ARRAY[3, 1, 2]
select array_least_frequent(ARRAY[1, null, 1], 2) -- ARRAY[1]
select array_least_frequent(ARRAY[ROW(1,null), ROW(1, null)], 2) -- "map key cannot be null or contain nulls"

array_max(x) -> x()¶

入力配列の最大値を返します。

array_min(x) -> x()¶

入力配列の最小値を返します。

array_max_by(array(T), function(T, U)) -> T()¶

各要素に指定された関数を適用し、最大値を与える要素を返します。U は、任意の順序付け可能な型です。

SELECT array_max_by(ARRAY ['a', 'bbb', 'cc'], x -> LENGTH(x)) -- 'bbb'

array_min_by(array(T), function(T, U)) -> T()¶

各要素に指定された関数を適用し、最小値を与える要素を返します。U は、任意の順序付け可能な型です。

SELECT array_min_by(ARRAY ['a', 'bbb', 'cc'], x -> LENGTH(x)) -- 'a'

array_normalize(x, p) -> array()¶

配列xを、配列のpノルムで各要素を割ることで正規化します。これはTRANSFORM(array, v -> v / REDUCE(array, 0, (a, v) -> a + POW(ABS(v), p), a -> POW(a, 1 / p))と等価ですが、reduceの部分は一度だけ実行されます。配列がNULLの場合、またはNULLの配列要素がある場合はNULLを返します。

array_position(x, element) -> bigint()¶

配列xにおけるelementの最初の出現位置を返します（見つからない場合は0）。

array_position(x, element, instance) -> bigint()¶

instance > 0の場合、配列xにおけるelementのinstance番目の出現位置を返します。instance < 0の場合、配列xにおけるelementの最後からinstance番目の出現位置を返します。一致する要素が見つからない場合は0を返します。

array_remove(x, element) -> array()¶

配列xからelementと等しいすべての要素を削除します。

array_sort(x) -> array()¶

配列xをソートして返します。xの要素は順序付け可能でなければなりません。NULL要素は返された配列の最後に配置されます。

array_sort(array(T), function(T, T, int)) -> array(T)¶

指定された比較関数functionに基づいてarrayをソートし、返します。比較関数は、arrayの2つのnull許容要素を表す、2つのnull許容引数を取得します。最初のnull許容要素が2番目のnull許容要素より小さい、等しい、または大きい場合に、それぞれ-1、0、または1を返します。比較関数が他の値（NULLを含む）を返す場合、クエリは失敗し、エラーが発生します。

SELECT array_sort(ARRAY [3, 2, 5, 1, 2], (x, y) -> IF(x < y, 1, IF(x = y, 0, -1))); -- [5, 3, 2, 2, 1]
SELECT array_sort(ARRAY ['bc', 'ab', 'dc'], (x, y) -> IF(x < y, 1, IF(x = y, 0, -1))); -- ['dc', 'bc', 'ab']
SELECT array_sort(ARRAY [3, 2, null, 5, null, 1, 2], -- sort null first with descending order
                  (x, y) -> CASE WHEN x IS NULL THEN -1
                                 WHEN y IS NULL THEN 1
                                 WHEN x < y THEN 1
                                 WHEN x = y THEN 0
                                 ELSE -1 END); -- [null, null, 5, 3, 2, 2, 1]
SELECT array_sort(ARRAY [3, 2, null, 5, null, 1, 2], -- sort null last with descending order
                  (x, y) -> CASE WHEN x IS NULL THEN 1
                                 WHEN y IS NULL THEN -1
                                 WHEN x < y THEN 1
                                 WHEN x = y THEN 0
                                 ELSE -1 END); -- [5, 3, 2, 2, 1, null, null]
SELECT array_sort(ARRAY ['a', 'abcd', 'abc'], -- sort by string length
                  (x, y) -> IF(length(x) < length(y),
                               -1,
                               IF(length(x) = length(y), 0, 1))); -- ['a', 'abc', 'abcd']
SELECT array_sort(ARRAY [ARRAY[2, 3, 1], ARRAY[4, 2, 1, 4], ARRAY[1, 2]], -- sort by array length
                  (x, y) -> IF(cardinality(x) < cardinality(y),
                               -1,
                               IF(cardinality(x) = cardinality(y), 0, 1))); -- [[1, 2], [2, 3, 1], [4, 2, 1, 4]]

array_sort_desc(x) -> array()¶

arrayを降順にソートして返します。arrayの要素はソート可能である必要があります。NULL要素は、返される配列の最後に配置されます。

SELECT array_sort_desc(ARRAY [100, 1, 10, 50]); -- [100, 50, 10, 1]
SELECT array_sort_desc(ARRAY [null, 100, null, 1, 10, 50]); -- [100, 50, 10, 1, null, null]
SELECT array_sort_desc(ARRAY [ARRAY ["a", null], null, ARRAY ["a"]); -- [["a", null], ["a"], null]

array_split_into_chunks(array(T), int) -> array(array(T))¶

入力arrayを指定された長さのチャンクに分割した配列のarrayを返します。配列の長さがチャンク長の整数倍でない場合、最後のチャンクはチャンク長よりも短くなります。NULL入力は無視されますが、要素は無視されません。

SELECT array_split_into_chunks(ARRAY [1, 2, 3, 4], 3); – [[1, 2, 3], [4]] SELECT array_split_into_chunks(null, null); – null SELECT array_split_into_chunks(array[1, 2, 3, cast(null as int)], 2]); – [[1, 2], [3, null]]

array_sum(array(T)) -> bigint/double()¶

arrayのすべての非NULL要素の合計を返します。非NULL要素がない場合は0を返します。動作は集約関数sum()と同様です。

Tはdoubleに変換可能である必要があります。Tがbigintに変換可能な場合、bigintを返します。それ以外の場合はdoubleを返します。

array_top_n(array(T), int) -> array(T)¶

自然な降順に従って、指定されたarrayから上位n個の要素の配列を返します。nが指定されたarrayのサイズより小さい場合、返されるリストはnではなく、入力と同じサイズになります。

SELECT array_top_n(ARRAY [1, 100, 2, 5, 3], 3); -- [100, 5, 3]
SELECT array_top_n(ARRAY [1, 100], 5); -- [100, 1]
SELECT array_top_n(ARRAY ['a', 'zzz', 'zz', 'b', 'g', 'f'], 3); -- ['zzz', 'zz', 'g']

arrays_overlap(x, y) -> boolean()¶

配列xとyに共通の非NULL要素があるかどうかをテストします。共通の非NULL要素がないが、いずれかの配列にNULLが含まれる場合はNULLを返します。NULL値を含むROWまたはARRAY型の要素に対してはNOT_SUPPORTED例外をスローします。

SELECT arrays_overlap(ARRAY [1, 2, null], ARRAY [2, 3, null]) -- true
SELECT arrays_overlap(ARRAY [1, 2], ARRAY [3, 4]) -- false
SELECT arrays_overlap(ARRAY [1, null], ARRAY[2]) -- null
SELECT arrays_overlap(ARRAY[ROW(1, null)], ARRAY[1, 2]) -- "ROW comparison not supported for fields with null elements"

array_union(x, y) -> array()¶

xとyの和集合の要素の配列を、重複なしで返します。この関数はIS NOT DISTINCT FROMを使用して、どの要素が同じであるかを判断します。

SELECT array_union(ARRAY[1, 2, 3, 2, null], ARRAY[1,2, 2, 4, null]) -- ARRAY[1, 2, 3, 4 null]

cardinality(x) -> bigint()¶

配列xのカーディナリティ（サイズ）を返します。

concat(array1, array2, ..., arrayN) -> array()

配列array1、array2、…、arrayNを連結します。この関数は、SQL標準の連結演算子（||）と同じ機能を提供します。

combinations(array(T), n) -> array(array(T))¶

入力配列のn要素の組み合わせを返します。入力配列に重複がない場合、combinationsはn要素の部分集合を返します。サブグループの順序は決定論的ですが、指定されていません。サブグループ内の要素の順序は決定論的ですが、指定されていません。nは5を超えてはならず、生成されるサブグループの総サイズは100000より小さくする必要があります。

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]]
SELECT combinations(ARRAY[1,2,2],2); --[[1,2],[1,2],[2,2]]

contains(x, element) -> boolean()¶

配列xにelementが含まれている場合、trueを返します。

element_at(array(E), index) -> E()¶

指定されたindexにあるarrayの要素を返します。index > 0の場合、この関数はSQL標準の添字演算子（[]）と同じ機能を提供します。index < 0の場合、element_atは最後から最初の要素にアクセスします。

filter(array(T), function(T, boolean)) -> array(T)¶

functionがtrueを返すarrayの要素から配列を構築します。

SELECT filter(ARRAY [], x -> true); -- []
SELECT filter(ARRAY [5, -6, NULL, 7], x -> x > 0); -- [5, 7]
SELECT filter(ARRAY [5, NULL, 7, NULL], x -> x IS NOT NULL); -- [5, 7]

flatten(x) -> array()¶

array(array(T))を、含まれる配列を連結することでarray(T)にフラット化します。

find_first(array(E), function(T,boolean)) -> E()¶

function(T,boolean)に対してtrueを返すarrayの最初の要素を返します。返された要素がNULLの場合、例外をスローします。そのような要素が存在しない場合はNULLを返します。

find_first(array(E), index, function(T,boolean)) -> E()¶

function(T,boolean)に対してtrueを返すarrayの最初の要素を返します。返された要素がNULLの場合、例外をスローします。そのような要素が存在しない場合はNULLを返します。index > 0の場合、要素の検索はindexの位置から配列の最後まで開始されます。index < 0の場合、要素の検索は最後から数えてabs(index)の位置から配列の先頭まで開始されます。

SELECT find_first(ARRAY[3, 4, 5, 6], 2, x -> x > 0); -- 4
SELECT find_first(ARRAY[3, 4, 5, 6], -2, x -> x > 0); -- 5
SELECT find_first(ARRAY[3, 4, 5, 6], 2, x -> x < 4); -- NULL
SELECT find_first(ARRAY[3, 4, 5, 6], -2, x -> x > 5); -- NULL

find_first_index(array(E), function(T,boolean)) -> BIGINT()¶

function(T,boolean)に対してtrueを返すarrayの最初の要素のインデックスを返します。そのような要素が存在しない場合はNULLを返します。

find_first_index(array(E), index, function(T,boolean)) -> BIGINT()¶

arrayの最初の要素で、function(T,boolean)がtrueを返すもののインデックスを返します。そのような要素が存在しない場合はNULLを返します。index > 0の場合、要素の検索はindexの位置から配列の最後まで行われます。index < 0の場合、要素の検索はabs(index)の位置から最後尾に向かって配列の先頭まで行われます。

SELECT find_first(ARRAY[3, 4, 5, 6], 2, x -> x > 0); -- 2
SELECT find_first(ARRAY[3, 4, 5, 6], -2, x -> x > 0); -- 3
SELECT find_first(ARRAY[3, 4, 5, 6], 2, x -> x < 4); -- NULL
SELECT find_first(ARRAY[3, 4, 5, 6], -2, x -> x > 5); -- NULL

ngrams(array(T), n) -> array(array(T))¶

arrayのn-gramを返します。

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]]

none_match(array(T), function(T,boolean)) -> boolean()¶

配列の要素が与えられた述語に一致しないかどうかを返します。いずれの要素も述語に一致しない場合（配列が空の場合も含まれます）、trueを返します。1つ以上の要素が一致する場合はfalseを返します。述語関数が1つ以上の要素に対してNULLを返し、他のすべての要素に対してfalseを返す場合はNULLを返します。

reduce(array(T), initialState S, inputFunction(S,T,S), outputFunction(S,R)) -> R()¶

arrayから削減された単一の値を返します。inputFunctionは、array内の各要素に対して順に呼び出されます。inputFunctionは、要素を受け取ることに加えて、現在の状態（最初はinitialState）を受け取り、新しい状態を返します。outputFunctionは、最終状態を結果値に変換するために呼び出されます。これは恒等関数（i -> i）の場合があります。

SELECT reduce(ARRAY [], 0, (s, x) -> s + x, s -> s); -- 0
SELECT reduce(ARRAY [5, 20, 50], 0, (s, x) -> s + x, s -> s); -- 75
SELECT reduce(ARRAY [5, 20, NULL, 50], 0, (s, x) -> s + x, s -> s); -- NULL
SELECT reduce(ARRAY [5, 20, NULL, 50], 0, (s, x) -> s + COALESCE(x, 0), s -> s); -- 75
SELECT reduce(ARRAY [5, 20, NULL, 50], 0, (s, x) -> IF(x IS NULL, s, s + x), s -> s); -- 75
SELECT reduce(ARRAY [2147483647, 1], CAST (0 AS BIGINT), (s, x) -> s + x, s -> s); -- 2147483648
SELECT reduce(ARRAY [5, 6, 10, 20], -- calculates arithmetic average: 10.25
              CAST(ROW(0.0, 0) AS ROW(sum DOUBLE, count INTEGER)),
              (s, x) -> CAST(ROW(x + s.sum, s.count + 1) AS ROW(sum DOUBLE, count INTEGER)),
              s -> IF(s.count = 0, NULL, s.sum / s.count));

remove_nulls(array(T)) -> array()¶

配列内のすべてのNULL要素を削除します。

repeat(element, count) -> array()¶

elementをcount回繰り返します。

reverse(x) -> array()

配列xの順序を反転させた配列を返します。

sequence(start, stop) -> array(bigint)¶

startからstopまでの整数のシーケンスを生成します。startがstop以下であれば1ずつ増加し、そうでなければ-1ずつ減少します。

sequence(start, stop, step) -> array(bigint)¶

startからstopまで、stepずつ増加する整数のシーケンスを生成します。

sequence(start, stop) -> array(date)¶

start日付からstop日付までの日付のシーケンスを生成します。start日付がstop日付以下であれば1日ずつ増加し、そうでなければ-1日ずつ減少します。

sequence(start, stop, step) -> array(date)¶

startからstopまで、stepずつ増加する日付のシーケンスを生成します。stepの型はINTERVAL DAY TO SECONDまたはINTERVAL YEAR TO MONTHのいずれかです。

sequence(start, stop, step) -> array(timestamp)¶

startからstopまで、stepずつ増加するタイムスタンプのシーケンスを生成します。stepの型はINTERVAL DAY TO SECONDまたはINTERVAL YEAR TO MONTHのいずれかです。

shuffle(x) -> array()¶

与えられた配列xのランダムな順列を生成します。

slice(x, start, length) -> array()¶

インデックスstartから始まる（startが負の場合は最後尾から始まる）長さlengthの配列xの部分配列を返します。

trim_array(x, n) -> array()¶

配列の末尾からn個の要素を削除します。

SELECT trim_array(ARRAY[1, 2, 3, 4], 1);
-- [1, 2, 3]

SELECT trim_array(ARRAY[1, 2, 3, 4], 2);
-- [1, 2]

transform(array(T), function(T, U)) -> array(U)¶

functionをarrayの各要素に適用した結果の配列を返します。

SELECT transform(ARRAY [], x -> x + 1); -- []
SELECT transform(ARRAY [5, 6], x -> x + 1); -- [6, 7]
SELECT transform(ARRAY [5, NULL, 6], x -> COALESCE(x, 0) + 1); -- [6, 1, 7]
SELECT transform(ARRAY ['x', 'abc', 'z'], x -> x || '0'); -- ['x0', 'abc0', 'z0']
SELECT transform(ARRAY [ARRAY [1, NULL, 2], ARRAY[3, NULL]], a -> filter(a, x -> x IS NOT NULL)); -- [[1, 2], [3]]

zip(array1, array2[, ...]) -> array(row)¶

与えられた配列を、要素ごとに単一の行配列にマージします。N番目の引数のM番目の要素は、M番目の出力要素のN番目のフィールドになります。引数の長さが不揃いの場合、欠損値はNULLで埋められます。

SELECT zip(ARRAY[1, 2], ARRAY['1b', null, '3b']); -- [ROW(1, '1b'), ROW(2, null), ROW(null, '3b')]

zip_with(array(T), array(U), function(T, U, R)) -> array(R)¶

与えられた2つの配列を、要素ごとに1つの配列にマージします。function を使用します。一方の配列が短い場合、functionを適用する前に、長い配列の長さに合わせるために、末尾にNULLが追加されます。

SELECT zip_with(ARRAY[1, 3, 5], ARRAY['a', 'b', 'c'], (x, y) -> (y, x)); -- [ROW('a', 1), ROW('b', 3), ROW('c', 5)]
SELECT zip_with(ARRAY[1, 2], ARRAY[3, 4], (x, y) -> x + y); -- [4, 6]
SELECT zip_with(ARRAY['a', 'b', 'c'], ARRAY['d', 'e', 'f'], (x, y) -> concat(x, y)); -- ['ad', 'be', 'cf']
SELECT zip_with(ARRAY['a'], ARRAY['d', null, 'f'], (x, y) -> coalesce(x, y)); -- ['a', null, 'f']