配列演算関数は、入力された配列データに対して要素の追加、削除、検索などの基本的な操作を行い、操作後の配列データを返します。OceanBaseデータベースが現在サポートしている配列演算関数には、array_append()、array_distinct()、array_remove()、cardinality()、element_at()、string_to_array()、array_agg()、unnest()、split()、および contains() が含まれます。
array_append
array_append()関数は、ターゲット配列に指定された要素を追加するために使用されます。構文は次のとおりです：
array_append(arr1, element)
入力パラメータの説明は以下のとおりです：
arr1がベース配列の場合、elementは配列がサポートする基本型である必要があり、Tinyint、Smallint、Int、Bigint、Float、Double、VarChar型がサポートされています。arr1がネスト配列の場合、elementは配列であり、そのネストレベルはarr1のサブ配列のネストレベルと等しくなければなりません。
戻り値は配列型です。
例：
SELECT array_append([1,2,3], 2);
+--------------------------+
| array_append([1,2,3], 2) |
+--------------------------+
| [1,2,3,2] |
+--------------------------+
1 row in set
SELECT array_append([1,2,3], -1);
+---------------------------+
| array_append([1,2,3], -1) |
+---------------------------+
| [1,2,3,-1] |
+---------------------------+
1 row in set
SELECT array_append(["1", "2", "a"], "OceanBase");
+--------------------------------------------+
| array_append(["1", "2", "a"], "OceanBase") |
+--------------------------------------------+
| ["1","2","a","OceanBase"] |
+--------------------------------------------+
1 row in set
SELECT array_append([[1,2],[3,4]], [5]);
+----------------------------------+
| array_append([[1,2],[3,4]], [5]) |
+----------------------------------+
| [[1,2],[3,4],[5]] |
+----------------------------------+
1 row in set
array_distinct
array_distinct()関数は、ターゲット配列に対して重複を削除する操作を行います。構文は以下のとおりです：
array_distinct(arr1)
入力パラメータの説明は以下のとおりです：
arr1渡される型は配列型でなければなりません。
戻り値は配列型です。
配列の要素型が一致しない場合（例えば、文字列型配列と数値型配列など）、エラーが報告されます。
例：
SELECT array_distinct([1,2,3,2,3]);
+-----------------------------+
| array_distinct([1,2,3,2,3]) |
+-----------------------------+
| [1,2,3] |
+-----------------------------+
1 row in set
SELECT array_distinct([null,2,3,null]);
+-----------------------------+
| array_distinct([null,2,3,null]) |
+---------------------------------+
| [NULL,2,3] |
+---------------------------------+
1 row in set
SELECT array_distinct([1,2,3,2.0]);
+-----------------------------+
| array_distinct([1,2,3,2.0]) |
+-----------------------------+
| [1,2,3] |
+-----------------------------+
1 row in set
SELECT array_distinct([1.1,2.2,3.3,2.2]);
+-------------------------------+
| array_distinct([1.1,2.2,3.3,2.2]) |
+-----------------------------------+
| [1.1,2.2,3.3] |
+-----------------------------------+
1 row in set
SELECT array_distinct(["hello", "hi", "hi"]);
+---------------------------------------+
| array_distinct(["hello", "hi", "hi"]) |
+---------------------------------------+
| ["hello","hi"] |
+---------------------------------------+
1 row in set
SELECT array_distinct([[1,2],[3,4], [3,4]]);
+--------------------------------------+
| array_distinct([[1,2],[3,4], [3,4]]) |
+--------------------------------------+
| [[1,2],[3,4]] |
+--------------------------------------+
1 row in set
SELECT array_distinct([["hello", "world"], ["hi", "what"], ["are you?"], ["are you?"]]);
+----------------------------------------------------------------------------------+
| array_distinct([["hello", "world"], ["hi", "what"], ["are you?"], ["are you?"]]) |
+----------------------------------------------------------------------------------+
| [["hello","world"],["hi","what"],["are you?"]] |
+----------------------------------------------------------------------------------+
1 row in set
array_remove
array_remove()関数は、指定された要素を対象配列から削除するために使用されます。構文は次のとおりです：
array_remove(arr1, element)
入力パラメータの説明は以下のとおりです：
arr1が基本配列の場合、elementは配列でサポートされる基本型である必要があり、Tinyint、Smallint、Int、Bigint、Float、Double、VarChar型がサポートされています。arr1がネスト配列の場合、elementは配列であり、そのネストレベルはarr1のサブ配列のネストレベルと等しくなければなりません。
戻り値は配列型です。
例：
SELECT array_remove([1,2,3], 2);
+--------------------------+
| array_remove([1,2,3], 2) |
+--------------------------+
| [1,3] |
+--------------------------+
1 row in set
SELECT array_remove([1,2,3], 2.0);
+----------------------------+
| array_remove([1,2,3], 2.0) |
+----------------------------+
| [1,3] |
+----------------------------+
1 row in set
SELECT array_remove([1.1,2.2,3.3], 2.2);
+----------------------------------+
| array_remove([1.1,2.2,3.3], 2.2) |
+----------------------------------+
| [1.1,3.3] |
+----------------------------------+
1 row in set
SELECT array_remove(["hello", "hi"], "hi");
+-------------------------------------+
| array_remove(["hello", "hi"], "hi") |
+-------------------------------------+
| ["hello"] |
+-------------------------------------+
1 row in set
SELECT array_remove([[1,2],[3,4]], [3,4]);
+------------------------------------+
| array_remove([[1,2],[3,4]], [3,4]) |
+------------------------------------+
| [[1,2]] |
+------------------------------------+
1 row in set
SELECT array_remove([[1,2],[3,4]], [3.0,4.0]);
+----------------------------------------+
| array_remove([[1,2],[3,4]], [3.0,4.0]) |
+----------------------------------------+
| [[1,2]] |
+----------------------------------------+
1 row in set
SELECT array_remove([["hello", "world"], ["hi", "what"], ["are you?"]], ["are you?"]);
+--------------------------------------------------------------------------------+
| array_remove([["hello", "world"], ["hi", "what"], ["are you?"]], ["are you?"]) |
+--------------------------------------------------------------------------------+
| [["hello","world"],["hi","what"]] |
+--------------------------------------------------------------------------------+
1 row in set
カルデナリティ
cardinality()関数は、ターゲット配列の基本要素数を返すために使用されます。ターゲット配列がネスト配列の場合、すべての非空のサブ配列の基本要素数の合計を返します。構文は次のとおりです：
cardinality(arr1)
入力パラメータの説明は以下のとおりです：
arr1渡される型は配列型でなければなりません。
戻り値は整数型です。
例：
SELECT cardinality([1,2,3]);
+----------------------+
| cardinality([1,2,3]) |
+----------------------+
| 3 |
+----------------------+
1 row in set
SELECT cardinality([1,2,3,NULL]);
+----------------------------+
| cardinality([1,2,3,NULL]) |
+----------------------------+
| 4 |
+----------------------------+
1 row in set
SELECT cardinality(['a','b','c','d']);
+----------------------------+
| cardinality(['a','b','c','d']) |
+----------------------------+
| 4 |
+----------------------------+
1 row in set
SELECT cardinality([[1,2,3],[4]]);
+----------------------------+
| cardinality([[1,2,3],[4]]) |
+----------------------------+
| 4 |
+----------------------------+
1 row in set
SELECT cardinality([['a','b',NULL,'c'],[NULL,'d']]);
+----------------------------------------------+
| cardinality([['a','b',NULL,'c'],[NULL,'d']]) |
+----------------------------------------------+
| 6 |
+----------------------------------------------+
1 row in set
SELECT cardinality([[1,2,3],NULL]);
+-----------------------------+
| cardinality([[1,2,3],NULL]) |
+-----------------------------+
| 3 |
+-----------------------------+
1 row in set
element_at
element_at()関数は、インデックスに基づいて、ターゲット配列の指定された位置の要素を返します。構文は以下のとおりです：
element_at(arr1, index)
入力パラメータの説明は以下のとおりです：
arr1渡される型は配列型でなければなりません。index取得するサブ要素の位置で、整数型をサポートします。
戻り値の説明は以下のとおりです：
arr1ネストされた配列の場合、戻り値の型は配列です。arr1基本型の場合、戻り値の型は対応する基本型です。
例：
SELECT element_at([1,2,3], 2);
+------------------------+
| element_at([1,2,3], 2) |
+------------------------+
| 2 |
+------------------------+
1 row in set
SELECT element_at([1,2,3], 4);
+------------------------+
| element_at([1,2,3], 4) |
+------------------------+
| NULL |
+------------------------+
1 row in set
SELECT element_at(['a',NULL,'bb','ccc'], 4);
+--------------------------------------+
| element_at(['a',NULL,'bb','ccc'], 4) |
+--------------------------------------+
| ccc |
+--------------------------------------+
1 row in set
SELECT element_at([[1,2],[3,4]], 1);
+------------------------------+
| element_at([[1,2],[3,4]], 1) |
+------------------------------+
| [1,2] |
+------------------------------+
1 row in set
SELECT element_at([["hello", "world"], ["hi", "what"], ["are you?"]], 3);
+-------------------------------------------------------------------+
| element_at([["hello", "world"], ["hi", "what"], ["are you?"]], 3) |
+-------------------------------------------------------------------+
| ["are you?"] |
+-------------------------------------------------------------------+
1 row in set
string_to_array
string_to_array()関数は、文字を配列に変換するために使用されます。具体的には、指定された区切り文字と空要素文字に基づいて入力された文字を複数の要素に分割し、その後、要素を順番に配列に配置します。区切り文字と空要素文字は大文字と小文字が区別されます。構文は以下のとおりです：
string_to_array(arr_str, delimiter[, null_str])
入力パラメータの説明は以下のとおりです：
arr_str渡されるタイプは文字列タイプでなければならず、Char、Varcharタイプが含まれます。delimiter区切り文字であり、Char、Varcharタイプを含む文字列タイプをサポートします。null_str（オプション）空要素文字であり、Char、Varcharタイプを含む文字列タイプをサポートします。
戻り値は、要素が文字である配列タイプです。
例：
SELECT string_to_array('1and2and3and', 'and');
+----------------------------------------+
| string_to_array('1and2and3and', 'and') |
+----------------------------------------+
| ["1","2","3",""] |
+----------------------------------------+
1 row in set
SELECT string_to_array('1,2,3', '');
+------------------------------+
| string_to_array('1,2,3', '') |
+------------------------------+
| ["1,2,3"] |
+------------------------------+
1 row in set
SELECT string_to_array('1andNULLand3andNULL', 'and', 'NULL');
+-------------------------------------------------------+
| string_to_array('1andNULLand3andNULL', 'and', 'NULL') |
+-------------------------------------------------------+
| ["1",NULL,"3",NULL] |
+-------------------------------------------------------+
1 row in set
split
split()関数は、文字列stringを区切り文字delimiterで分割し、配列を返すために使用されます。構文は以下のとおりです：
split(string, delimiter)
パラメータの説明は以下のとおりです：
stringとdelimiterはどちらもVARCHARタイプです。戻り値のタイプは
ARRAY<varchar>です。
例：
SELECT split('1#2#3', '#'), split('#1#2#3#', '#'), split('123', '#');
+---------------------+-----------------------+-------------------+
| split('1#2#3', '#') | split('#1#2#3#', '#') | split('123', '#') |
+---------------------+-----------------------+-------------------+
| ["1","2","3"] | ["","1","2","3",""] | ["123"] |
+---------------------+-----------------------+-------------------+
contains
contains()関数は、指定されたコンテナまたは文字列に特定の要素が存在するかどうかをチェックし、ブール値を返します。構文は次のとおりです：
CONTAINS(array_expr, value)
例：
SELECT CONTAINS([1, 2, 3, 4, 5], 3), CONTAINS([1, 2, 3, 4, 5], 6), CONTAINS(['a', 'b', 'c'], 'b'), CONTAINS(['a', 'b', 'c'], 'd');
+------------------------------+------------------------------+--------------------------------+--------------------------------+
| CONTAINS([1, 2, 3, 4, 5], 3) | CONTAINS([1, 2, 3, 4, 5], 6) | CONTAINS(['a', 'b', 'c'], 'b') | CONTAINS(['a', 'b', 'c'], 'd') |
+------------------------------+------------------------------+--------------------------------+--------------------------------+
| 1 | 0 | 1 | 0 |
+------------------------------+------------------------------+--------------------------------+--------------------------------+
array_agg
array_agg()関数は、指定された列の複数行のデータを1つの配列値に集約して結果を返すために使用されます。構文は以下のとおりです：
array_agg([DISTINCT] col [ORDER BY col0 [DESC | ASC] [NULLS FIRST | NULLS LAST] ...])
入力パラメータの説明は以下のとおりです：
col集約データの対象列。DISTINCT（オプション）col列に対する重複排除操作を実行するかどうかを指定します。ORDER BY（オプション）col列に対するソート操作を実行するかどうかを指定します。DESC（オプション） ソート方向を降順に指定します。ASC（オプション） ソート方向を昇順に指定します。NULLS FIRST（オプション） ソート時にNULL値を先頭に配置するように指定します。NULLS LAST（オプション） ソート時にNULL値を末尾に配置するように指定します。
戻り値は配列型です。
制約事項は以下のとおりです：
ORDER BYで指定されたcol0は配列型をサポートしません。ORDER BYは1, 2, ...などの数字でソート列を指定することをサポートしていません。数字を使用した場合、ORDER BYは無視されます。
例：
SELECT * FROM ss;
+------+------+-----------+-------+--------+
| id | name | subject | score | arr |
+------+------+-----------+-------+--------+
| 1 | Tom | English | 90.5 | [1,2] |
| 1 | Tom | Math | 80.8 | [1,2] |
| 2 | Tom | English | NULL | [1] |
| 2 | Tom | NULL | NULL | NULL |
| 3 | May | NULL | NULL | [2] |
| 3 | Ti | English | 98.3 | [NULL] |
| 4 | NULL | NULL | NULL | NULL |
| NULL | NULL | NULL | NULL | NULL |
| NULL | Ti | 物理Phy | 99 | [3,4] |
+------+------+-----------+-------+--------+
9 rows in set
SELECT array_agg(DISTINCT name ORDER BY name ASC), array_agg(name ORDER BY name DESC) FROM ss ORDER BY id;
+--------------------------------------------+-----------------------------------------------------+
| array_agg(distinct name order by name asc) | array_agg(name order by name desc) |
+--------------------------------------------+-----------------------------------------------------+
| [NULL,"May","Ti","Tom"] | ["Tom","Tom","Tom","Tom","Ti","Ti","May",NULL,NULL] |
+--------------------------------------------+-----------------------------------------------------+
1 row in set
SELECT array_agg(score ORDER BY score DESC NULLS FIRST), array_agg(score ORDER BY score DESC NULLS LAST) FROM ss ORDER BY id;
+--------------------------------------------------+-------------------------------------------------+
| array_agg(score order by score desc nulls first) | array_agg(score order by score desc nulls last) |
+--------------------------------------------------+-------------------------------------------------+
| [NULL,NULL,NULL,NULL,NULL,99,98.3,90.5,80.8] | [99,98.3,90.5,80.8,NULL,NULL,NULL,NULL,NULL] |
+--------------------------------------------------+-------------------------------------------------+
1 row in set
SELECT array_agg(arr ORDER BY id), array_agg(DISTINCT arr) FROM ss;
+---------------------------------------------------+-----------------------------------+
| array_agg(arr order by id) | array_agg(distinct arr) |
+---------------------------------------------------+-----------------------------------+
| [NULL,[3,4],[1,2],[1,2],[1],NULL,[2],[NULL],NULL] | [[1,2],[1],NULL,[2],[NULL],[3,4]] |
+---------------------------------------------------+-----------------------------------+
1 row in set
unnest
unnest()関数は、配列内の要素を複数行に展開し、これらの要素を含むリレーショナルテーブルを返します。構文は以下のとおりです：
unnest(arr_list) [AS] [table_name[(col_name_list)]]
入力パラメータの説明は以下のとおりです：
arr_list1つまたは複数の配列値をカンマで区切って渡します。table_name(オプション) 返されるテーブル名を指定するために使用されます。デフォルト値はunnestです。ASキーワードは省略可能であり、機能に変更はありません。col_name_list(オプション) 返される各列の列名を個別に指定するために使用されます。デフォルト値はunnestで、カンマで区切られています。入力される列名の数は、配列値の数と一致していなければなりません。
戻り値の説明は以下のとおりです：
- 入力された配列の最大要素数と入力された配列の数に等しい行数を持つテーブルを返します。配列要素が少ない列は、
NULLで補完された空の行になります。 - n層ネストされた配列に対して、
unnestは最初の層（つまり最も外側の層）の配列のみを解きほぐし、出力結果はn-1層ネストされた配列になります。 - n行目の内容は、各配列のn番目のサブ要素です。
arr_listの要素が基本データ型の場合、出力タイプは該当する要素のタイプになります。要素が配列型の場合、出力タイプは配列型になります。
制約は以下のとおりです：
unnest()関数はFROM句の後にのみ配置できます。
例：
SELECT * FROM unnest([1,2,3]);
+--------+
| unnest |
+--------+
| 1 |
| 2 |
| 3 |
+--------+
3 rows in set
SELECT * FROM unnest([1,2,NULL,3], ['11',NULL,'22']);
+--------+--------+
| unnest | unnest |
+--------+--------+
| 1 | 11 |
| 2 | NULL |
| NULL | 22 |
| 3 | NULL |
+--------+--------+
4 rows in set
SELECT t.* FROM unnest([[1,2],[3],NULL,[4,5,6]]) AS t;
+---------+
| unnest |
+---------+
| [1,2] |
| [3] |
| NULL |
| [4,5,6] |
+---------+
4 rows in set
SELECT t.* FROM unnest([[1,2],[3],NULL,[4,5,6]], ['hi','hello']) AS t(c1,c2);
+---------+-------+
| c1 | c2 |
+---------+-------+
| [1,2] | hi |
| [3] | hello |
| NULL | NULL |
| [4,5,6] | NULL |
+---------+-------+
4 rows in set
SELECT * FROM unnest([1,2,3]) t1(c1), unnest(['11','22']) AS t2(c2);
+------+------+
| c1 | c2 |
+------+------+
| 1 | 11 |
| 1 | 22 |
| 2 | 11 |
| 2 | 22 |
| 3 | 11 |
| 3 | 22 |
+------+------+
6 rows in set
array_prepend
array_prepend()関数は、配列の先頭に要素を追加し、新しい配列を返します。構文は以下のとおりです：
array_prepend(array, element)
入力パラメータの説明は以下のとおりです：
array配列値を渡します。element追加する対象の要素を渡します。この要素は、arrayパラメータの配列要素の型と一致している必要があります。
戻り値は配列型です。
例：
SELECT array_prepend([1,2,3], 2);
+--------------------------------+
| array_prepend([1,2,3], 2) |
+--------------------------------+
| [2,1,2,3] |
+--------------------------------+
1 row in set
SELECT array_prepend([1,2,3], NULL);
+------------------------------+
| array_prepend([1,2,3], NULL) |
+------------------------------+
| [NULL,1,2,3] |
+------------------------------+
1 row in set
SELECT array_prepend(["1", "2", "a"], "OceanBase");
+---------------------------------------------+
| array_prepend(["1", "2", "a"], "OceanBase") |
+---------------------------------------------+
| ["OceanBase","1","2","a"] |
+---------------------------------------------+
1 row in set
array_concat
array_concat()関数は、複数の配列を結合し、新しい配列を返します。構文は以下のとおりです：
array_concat(array_list)
入力パラメータの説明は以下のとおりです：
array_list1つまたは複数の配列値を渡します。
戻り値は配列型です。
制約は以下のとおりです：
- ネストされた配列の結合はサポートされていますが、各配列のネストレベルが同じである必要があり、結果は最初のレベル（つまり最も外側のレベル）の要素の結合結果となります。
例：
SELECT array_concat([1,2,3], [4,5,6]);
+--------------------------------+
| array_concat([1,2,3], [4,5,6]) |
+--------------------------------+
| [1,2,3,4,5,6] |
+--------------------------------+
1 row in set
SELECT array_concat([1,2,3], [-4], [5.5,6]);
+--------------------------------------+
| array_concat([1,2,3], [-4], [5.5,6]) |
+--------------------------------------+
| [1,2,3,-4,5.5,6] |
+--------------------------------------+
1 row in set
SELECT array_concat([[1,2,3]],[[11],[22,44]]);
+----------------------------------------+
| array_concat([[1,2,3]],[[11],[22,44]]) |
+----------------------------------------+
| [[1,2,3],[11],[22,44]] |
+----------------------------------------+
1 row in set
array_compact
array_compact()関数は、配列内の連続する重複要素を削除し、新しい配列を返します。構文は次のとおりです：
array_compact(array)
入力パラメータの説明は以下のとおりです：
array配列値を渡します。
戻り値は配列型です。
例：
SELECT array_compact([1,2,2,3,3,2]);
+------------------------------+
| array_compact([1,2,2,3,3,2]) |
+------------------------------+
| [1,2,3,2] |
+------------------------------+
1 row in set
SELECT array_compact(["hello","hello",NULL,NULL,"OceanBase"]);
+--------------------------------------------------------+
| array_compact(["hello","hello",NULL,NULL,"OceanBase"]) |
+--------------------------------------------------------+
| ["hello",NULL,"OceanBase"] |
+--------------------------------------------------------+
1 row in set
SELECT array_compact([[1,2,3,NULL],[4,NULL],[4,NULL]]);
+-------------------------------------------------+
| array_compact([[1,2,3,NULL],[4,NULL],[4,NULL]]) |
+-------------------------------------------------+
| [[1,2,3,NULL],[4,NULL]] |
+-------------------------------------------------+
1 row in set
array_sort
array_sort()関数は、配列を昇順にソートし、ソート時にNULL値を配列の末尾に配置します。構文は以下のとおりです：
array_sort(arr)
入力パラメータの説明は以下のとおりです：
arr配列値を渡します。
戻り値は配列型です。
例：
SELECT array_sort([2,1,3]);
+---------------------+
| array_sort([2,1,3]) |
+---------------------+
| [1,2,3] |
+---------------------+
1 row in set
SELECT array_sort([NULL,1,2,NULL,2,NULL,NULL]);
+-----------------------------------------+
| array_sort([NULL,1,2,NULL,2,NULL,NULL]) |
+-----------------------------------------+
| [1,2,2,NULL,NULL,NULL,NULL] |
+-----------------------------------------+
1 row in set
SELECT array_sort(["hello","hello",NULL,NULL,"OceanBase"]);
+-----------------------------------------------------+
| array_sort(["hello","hello",NULL,NULL,"OceanBase"]) |
+-----------------------------------------------------+
| ["OceanBase","hello","hello",NULL,NULL] |
+-----------------------------------------------------+
1 row in set
array_length
array_length()関数は、配列の長さを返すために使用されます。ネストされた配列の場合、返されるのは最初のレベル（つまり最も外側の）配列の長さです。構文は以下のとおりです：
array_length(arr)
入力パラメータの説明は以下のとおりです：
arr配列値を渡します。ネストされた配列をサポートしています。
戻り値はunit32符号なし整数型です。
例：
SELECT array_length([1,2,3]);
+-----------------------+
| array_length([1,2,3]) |
+-----------------------+
| 3 |
+-----------------------+
1 row in set
SELECT array_length([[1],[2,3]]);
+---------------------------+
| array_length([[1],[2,3]]) |
+---------------------------+
| 2 |
+---------------------------+
1 row in set
array_range
array_range()関数は、等差数列の配列を生成するために使用されます。構文は次のとおりです：
array_range(end)
array_range(start, end)
array_range(start, end, step)
入力パラメータの説明は以下のとおりです：
start開始値で、デフォルト値は0です。end終了値で、整数タイプのみサポートします。stepステップで、整数タイプのみサポートし、デフォルト値は1です。
BIGINT要素の配列タイプを返します。出力結果には入力したstart値が含まれ、end値は含まれません。(end - start) / step <= 0の場合、空の配列を返します。
具体的な説明は以下のとおりです：
- 生成される配列：
array_rangeは、連続する整数を含む配列を生成します。この配列にはstart要素が含まれますが、end要素は含まれません。つまり、生成される配列の開始値はstartで、終了値はendですが、end自体は結果に含まれません。 - ステップ：ステップパラメータ（step）が指定されている場合、生成される配列の各要素は前の要素よりも
step大きくなります。例えば、startが1、endが10、stepが2の場合、生成される配列は[1, 3, 5, 7, 9]となります。 - 空の配列を返す条件：
(end - start)/step <= 0の場合、関数は空の配列を返します。これは、endがstart以下またはstartと等しい場合、またはステップstepがゼロまたは負の数の場合、生成される配列に有効な要素がないため、空の配列が返されることを意味します。
例：
SELECT array_range(5);
+----------------+
| array_range(5) |
+----------------+
| [0,1,2,3,4] |
+----------------+
1 row in set
SELECT array_range(-1,4);
+-------------------+
| array_range(-1,4) |
+-------------------+
| [-1,0,1,2,3] |
+-------------------+
1 row in set
SELECT array_range(-1,4,2);
+---------------------+
| array_range(-1,4,2) |
+---------------------+
| [-1,1,3] |
+---------------------+
1 row in set
array_sum
array_sum()関数は、配列内のすべての要素の合計を計算するために使用されます。構文は次のとおりです：
array_sum(arr)
入力パラメータの説明は以下のとおりです：
arr数値要素タイプの配列値を渡します。NULL値の処理：- 配列要素がすべて
NULLの場合、NULL返します。 - 配列要素がすべて
NULLではない場合、NULL値を0として計算に含めます。
- 配列要素がすべて
戻り値の説明は以下のとおりです：
- 整数型（INT）要素の配列タイプを返します。
- または浮動小数点数（DOUBLE）要素の配列タイプを返します。
機能制約は以下のとおりです：
- 配列要素は、整数型（INT、BIGINTなど）と浮動小数点数（FLOAT、DOUBLEなど）の数値型のみサポートします。
- ネスト配列はサポートされていません。
例：
SELECT array_sum([1,2,3]);
+--------------------+
| array_sum([1,2,3]) |
+--------------------+
| 6 |
+--------------------+
1 row in set
SELECT array_sum([1,2.2,3]);
+----------------------+
| array_sum([1,2.2,3]) |
+----------------------+
| 6.2 |
+----------------------+
1 row in set
array_difference
array_difference()関数は、配列内の2つの隣接する要素の差を計算し、結果を新しい配列に格納して返すために使用されます。構文は以下のとおりです：
array_difference(arr)
入力パラメータの説明は以下のとおりです：
arr渡される型は配列型でなければなりません。
戻り値は配列型です。
機能制約は以下のとおりです：
- 配列要素は整数型（INT、BIGINTなど）と浮動小数点型（FLOAT、DOUBLEなど）の数値型のみサポートします。
- ネスト配列はサポートされていません。
具体的な説明は以下のとおりです：
- 計算方法：
- 返される配列の最初の要素は常に
0となります。 - 返される配列のn番目の要素の値は
array[n] - array[n-1]、つまり現在の要素から前の要素を引いたものになります。
- 返される配列の最初の要素は常に
- 戻り値：
- 最初の要素が
0で、その後の要素が隣接する要素の差となる新しい配列を返します。
- 最初の要素が
例：
SELECT array_difference([1,5,3]);
+---------------------------+
| array_difference([1,5,3]) |
+---------------------------+
| [0,4,-2] |
+---------------------------+
1 row in set
SELECT array_difference([1.1,2.2,4.4]);
+---------------------------------+
| array_difference([1.1,2.2,4.4]) |
+---------------------------------+
| [0,1.1,2.2] |
+---------------------------------+
1 row in set
array_min
array_min()関数は、配列内の最小値を返すために使用されます。構文は以下のとおりです：
array_min(arr)
入力パラメータの説明は以下のとおりです：
arr渡される型は配列型でなければなりません。NULL値の処理：- 配列要素がすべて
NULL場合、NULL返します。 - 配列要素がすべて
NULLではない場合、NULL要素をスキップします。
- 配列要素がすべて
戻り値は入力された配列要素の型です。
機能制約は以下のとおりです：
- ネスト配列はサポートされていません。
例：
SELECT array_min([1,2,4]);
+--------------------+
| array_min([1,2,4]) |
+--------------------+
| 1 |
+--------------------+
1 row in set
SELECT array_min([1.1,2.2,4.4]);
+--------------------------+
| array_min([1.1,2.2,4.4]) |
+--------------------------+
| 1.1 |
+--------------------------+
1 row in set
SELECT array_min([1,2,NULL,3]);
+-------------------------+
| array_min([1,2,NULL,3]) |
+-------------------------+
| 1 |
+-------------------------+
1 row in set
array_max
array_max()関数は、配列内の最大値を返すために使用されます。構文は次のとおりです：
array_max(arr)
入力パラメータの説明は以下のとおりです：
arr渡されるタイプは配列タイプでなければなりません。NULL値の処理：- 配列要素がすべて
NULL場合、NULL返します。 - 配列要素がすべて
NULLではない場合、NULL要素をスキップします。
- 配列要素がすべて
戻り値は、入力された配列要素のタイプです。
機能制約は以下のとおりです：
- ネスト配列はサポートされていません。
例：
SELECT array_max([1,2,4]);
+--------------------+
| array_max([1,2,4]) |
+--------------------+
| 4 |
+--------------------+
1 row in set
SELECT array_max([1.1,2.2,4.4]);
+--------------------------+
| array_max([1.1,2.2,4.4]) |
+--------------------------+
| 4.4 |
+--------------------------+
1 row in set
SELECT array_max([1,2,NULL,3]);
+-------------------------+
| array_max([1,2,NULL,3]) |
+-------------------------+
| 3 |
+-------------------------+
1 row in set
array_avg
array_avg()関数は、配列内のすべての要素の平均値を返すために使用されます。構文は次のとおりです：
array_avg(arr)
入力パラメータの説明は以下のとおりです：
arr渡されるタイプは配列タイプでなければなりません。NULL値の処理：- 配列要素がすべて
NULL場合、NULL返します。 - 配列要素がすべて
NULLではない場合、NULL値を0として計算に含めます。
- 配列要素がすべて
戻り値は、浮動小数点数（DOUBLE）要素の配列タイプです。
機能制約は以下のとおりです：
- 配列要素は、整数型（INT、BIGINTなど）と浮動小数点数（FLOAT、DOUBLEなど）の数値型のみをサポートします。
- ネスト配列はサポートされていません。
例：
SELECT array_avg([1,2,-4]);
+---------------------+
| array_avg([1,2,-4]) |
+---------------------+
| -0.3333333333333333 |
+---------------------+
1 row in set
SELECT array_avg([1,2,NULL,3]);
+-------------------------+
| array_avg([1,2,NULL,3]) |
+-------------------------+
| 1.5 |
+-------------------------+
1 row in set
array_position
array_position()関数は、配列内の指定された要素の位置を見つけるために使用されます。構文は次のとおりです：
array_position(arr, element)
入力パラメータの説明は以下のとおりです：
arr渡される型は配列型でなければなりません。element検索する要素。配列がサポートする基本型と配列型をサポートします。
戻り値は整数（INT）であり、要素の配列型です。その要素が存在しない場合は、0返します。
例：
SELECT array_position([1,2,3], 2);
+--------------------------------+
| array_position([1,2,3], 2) |
+--------------------------------+
| 2 |
+--------------------------------+
1 row in set
SELECT array_position(["hello", "hi"], "hi");
+---------------------------------------+
| array_position(["hello", "hi"], "hi") |
+---------------------------------------+
| 2 |
+---------------------------------------+
1 row in set
SELECT array_position(["hello", "hi"], "hel");
+----------------------------------------+
| array_position(["hello", "hi"], "hel") |
+----------------------------------------+
| 0 |
+----------------------------------------+
1 row in set
array_slice
array_slice()関数は、配列の指定された位置から一部の要素を抽出し、抽出した要素を新しい配列として返すために使用されます。構文は以下のとおりです：
array_slice(arr, offset, length)
入力パラメータの説明は以下のとおりです：
arr渡される型は配列タイプでなければなりません。offset抽出を開始する要素の位置を表します：- 正の数を入力すると、左から数えて
offset番目の要素から抽出を開始します。 - 負の数を入力すると、右から数えて
-offset番目の要素から抽出を開始します。
- 正の数を入力すると、左から数えて
length長さの制限を表します(オプション)：- 正の数を入力すると、抽出できる最大の要素数を表します。
- 負の数を入力すると、抽出の右端、つまり右から数えて
-length番目の値を表します。 - 指定しない場合は、
offsetから始まるすべての要素を表します。
戻り値の説明は以下のとおりです：
- 戻り値は配列タイプです。
offset>配列の長さまたはoffset=0の場合、空の配列が返されます。
例：
-- offsetが正の数の場合、左から数えて2番目の要素、つまり2から抽出を開始します
SELECT array_slice([1,2,3,4,5,6,7,8,9],2);
+------------------------------------+
| array_slice([1,2,3,4,5,6,7,8,9],2) |
+------------------------------------+
| [2,3,4,5,6,7,8,9] |
+------------------------------------+
1 row in set
-- offsetが正の数の場合、左から数えて10番目の要素、このときoffsetは配列の長さを超えているため、空の配列が返されます
SELECT array_slice([1,2,3,4,5,6,7,8,9],10);
+-------------------------------------+
| array_slice([1,2,3,4,5,6,7,8,9],10) |
+-------------------------------------+
| [] |
+-------------------------------------+
1 row in set
-- offsetが0の場合、空の配列が返されます
SELECT array_slice([1,2,3,4,5,6,7,8,9],0);
+------------------------------------+
| array_slice([1,2,3,4,5,6,7,8,9],0) |
+------------------------------------+
| [] |
+------------------------------------+
1 row in set
-- offsetが負の数の場合、右から数えて2番目の要素、つまり8から抽出を開始します
SELECT array_slice([1,2,3,4,5,6,7,8,9],-2);
+-------------------------------------+
| array_slice([1,2,3,4,5,6,7,8,9],-2) |
+-------------------------------------+
| [8,9] |
+-------------------------------------+
1 row in set
-- lengthが正の数の場合、2つの要素を抽出します
SELECT array_slice([1,2,3,4,5,6,7,8,9],2,2);
+--------------------------------------+
| array_slice([1,2,3,4,5,6,7,8,9],2,2) |
+--------------------------------------+
| [2,3] |
+--------------------------------------+
1 row in set
-- lengthが正の数の場合、10個の要素を取得しますが、右端を超えています
SELECT array_slice([1,2,3,4,5,6,7,8,9],2,10);
+---------------------------------------+
| array_slice([1,2,3,4,5,6,7,8,9],2,10) |
+---------------------------------------+
| [2,3,4,5,6,7,8,9] |
+---------------------------------------+
1 row in set
-- lengthが-2の場合、右から数えて2つの要素、つまり8と9を取得しません
SELECT array_slice([1,2,3,4,5,6,7,8,9],2,-2);
+---------------------------------------+
| array_slice([1,2,3,4,5,6,7,8,9],2,-2) |
+---------------------------------------+
| [2,3,4,5,6,7] |
+---------------------------------------+
1 row in set
-- lengthが-10の場合、右から数えて10個の要素、このとき左端を超えているため、空の配列が返されます
SELECT array_slice([1,2,3,4,5,6,7,8,9],2,-10);
+----------------------------------------+
| array_slice([1,2,3,4,5,6,7,8,9],2,-10) |
+----------------------------------------+
| [] |
+----------------------------------------+
1 row in set
-- offsetが-10の場合、右から数えて10番目の位置から抽出を開始します。このとき左端を1つ超えているため、その位置からlength(4)個の要素を取得します
SELECT array_slice([1,2,3,4,5,6,7,8,9],-10,4);
+----------------------------------------+
| array_slice([1,2,3,4,5,6,7,8,9],-10,4) |
+----------------------------------------+
| [1,2,3] |
+----------------------------------------+
1 row in set
-- offsetが-6の場合、右から数えて6番目の位置から抽出を開始します。つまり4; lengthが-4の場合、右から数えて4つの要素、つまり6、7、8、9を取得しません
SELECT array_slice([1,2,3,4,5,6,7,8,9],-6,-4);
+-----------------------------------------+
| array_slice([1,2,3,4,5,6,7,8,9],-6,-4) |
+-----------------------------------------+
| [4,5] |
+-----------------------------------------+
1 row in set
reverse
reverse()関数は、配列内の要素を逆順に並べ替えるために使用されます。ネストされた配列の場合、最も内部の要素が逆順に並べ替えられます。構文は以下のとおりです：
reverse(arr)
入力パラメータの説明は以下のとおりです：
arr渡される型は配列型でなければなりません。ネストされた配列をサポートしています。
戻り値は配列型です。
例：
SELECT reverse([1,2,3]);
+----------------+
| reverse([1,2,3]) |
+----------------+
| [3,2,1] |
+----------------+
1 row in set
SELECT reverse([['a'], ['b'], ['c']]) ;
+--------------------------------+
| reverse([['a'], ['b'], ['c']]) |
+--------------------------------+
| [["c"],["b"],["a"]] |
+--------------------------------+
1 row in set
array_map
array_map()関数は、入力された各配列の要素をLambda関数に従って変換し、各変換後に得られるすべての新しい要素を1つの新しい配列として出力結果として合成するために使用されます。構文は以下のとおりです：
arrayMap((x1,...,xn) -> (expression), arr1,...,arrn)
入力パラメータの説明は以下のとおりです：
(x1,...,xn) -> (expression)Lambda関数。Lambda関数は匿名関数であり、定義時に通常のdefステートメントを使用する必要はなく、lambdaキーワードを使用して作成します。Lambda関数は任意の数の引数を受け取ることができますが、式は1つだけです。arr1,...,arrn入力される配列。渡される型は配列型でなければならず、配列の要素数はすべて同じでなければなりません。また、nはLambda関数の引数数と一致していなければなりません。- 各入力配列のi番目の要素を順番に取り出してLambda関数の入力引数とし、戻り値を新しい配列のi番目の要素として返します。
戻り値は配列型であり、要素の型はLambda値の戻り値の型であり、配列の長さは渡された配列の要素数です。
機能制約は以下のとおりです：
- Lambda関数の
expressionはサブクエリステートメントをサポートしていません。 - Lambda関数の
expressionは集計関数をサポートしていません。 - Lambda関数の
expressionは生成列の式として使用することはできません。
例：
SELECT array_map((x,y,z) -> (x is null and y is not null or z is not null), [[1]], [1],['abc']);
+------------------------------------------------------------------------------------------+
| array_map((x,y,z) -> (x is null and y is not null or z is not null), [[1]], [1],['abc']) |
+------------------------------------------------------------------------------------------+
| [1] |
+------------------------------------------------------------------------------------------+
1 row in set
SELECT array_map((x,y) -> (x + y),[1], [2]);
+--------------------------------------+
| array_map((x,y) -> (x + y),[1], [2]) |
+--------------------------------------+
| [3] |
+--------------------------------------+
1 row in set
SELECT array_map((x,y)->((x is null) and (y is null)), [1232], [[['abc']]]);
+----------------------------------------------------------------------+
| array_map((x,y)->((x is null) and (y is null)), [1232], [[['abc']]]) |
+----------------------------------------------------------------------+
| [0] |
+----------------------------------------------------------------------+
1 row in set
SELECT array_map((x,y)->(x+y), array_map(x2->(x2+1),[1,2,3]),array_map(x1->(x1+2),[1,2,3]));
+--------------------------------------------------------------------------------------+
| array_map((x,y)->(x+y), array_map(x2->(x2+1),[1,2,3]),array_map(x1->(x1+2),[1,2,3])) |
+--------------------------------------------------------------------------------------+
| [5,7,9] |
+--------------------------------------------------------------------------------------+
1 row in set
SELECT array_map(x ->(length(x)), ['abc', 'efgaa']);
+----------------------------------------------+
| array_map(x ->(length(x)), ['abc', 'efgaa']) |
+----------------------------------------------+
| [3,5] |
+----------------------------------------------+
1 row in set
SELECT array_map((x, y)->(floor((y - x) / x)), [4, 5, 6], [3,8,5]);
+-------------------------------------------------------------+
| array_map((x, y)->(floor((y - x) / x)), [4, 5, 6], [3,8,5]) |
+-------------------------------------------------------------+
| [-1,0,-1] |
+-------------------------------------------------------------+
1 row in set
array_filter
array_filter()は、Lambda関数の戻り値に基づいてarr1配列の要素をフィルタリングします。Lambda関数が0またはNULLを返す場合、対応するarr1要素がフィルタリングされ、新しい配列が返されます。構文は以下のとおりです：
array_filter((x1,...,xn) -> (expression), arr1,...,arrn)
入力パラメータの説明は以下のとおりです：
(x1,...,xn) -> (expression)Lambda関数。Lambda関数は匿名関数であり、定義時に通常のdefステートメントを使用する必要はなく、lambdaキーワードを使用して作成します。Lambda関数は任意の数の引数を受け取ることができますが、式は1つだけです。arr1,...,arrn入力される配列。渡される型は配列型でなければならず、配列の要素数はすべて同じでなければなりません。nはLambda関数の引数数と一致していなければなりません。ネスト配列もサポートされています。
戻り値は配列型であり、フィルタリング後のarr1配列です。
機能制約は以下のとおりです：
- Lambda関数の戻り値は整数型または
NULLのみサポートされています。
例：
SELECT array_filter(x ->(x + 1 > 2),[1,2,3,4]);
+-----------------------------------------+
| array_filter(x ->(x + 1 > 2),[1,2,3,4]) |
+-----------------------------------------+
| [2,3,4] |
+-----------------------------------------+
1 row in set
SELECT array_filter((x, y) ->(y), [1,2,3,4,5], [NULL,1,-1,0,2]);
+----------------------------------------------------------+
| array_filter((x, y) ->(y), [1,2,3,4,5], [NULL,1,-1,0,2]) |
+----------------------------------------------------------+
| [2,3,5] |
+----------------------------------------------------------+
1 row in set
SELECT array_filter((x, y) ->(y), [['a'],['b','c'],['d']], [1,0,1]);
+--------------------------------------------------------------+
| array_filter((x, y) ->(y), [['a'],['b','c'],['d']], [1,0,1]) |
+--------------------------------------------------------------+
| [["a"],["d"]] |
+--------------------------------------------------------------+
1 row in set
array_sortby
array_sortby()関数は、指定されたLambda関数に基づいて配列をソートします。構文は次のとおりです：
array_sortby((x1,...,xn) -> (expression), arr1,...,arrn)
入力パラメータの説明は以下のとおりです：
(x1,...,xn) -> (expression)Lambda関数。Lambda関数は匿名関数であり、定義時に通常のdefステートメントを使用する必要はなく、lambdaキーワードを使用して作成します。Lambda関数は任意の数の引数を受け取ることができますが、式は1つだけです。arr1,...,arrn入力される配列。渡される型は配列型でなければならず、配列要素の数はすべて同じでなければなりません。nはLambda関数の引数の数と一致していなければなりません。ネスト配列もサポートされています。
戻り値は配列型です。
機能制約は以下のとおりです：
- Lambda関数の戻り値は、配列をサポートする基本要素型に限られ、配列型はサポートされていません。
具体的な処理フローは以下のとおりです：
- ソート基準の生成：最初に、
array_sortbyは提供されたLambda関数に基づいて入力配列の各要素を計算し、新しい配列を生成します。この配列には、各要素がLambda関数によって処理された結果が含まれます。 - 昇順ソートと
NULL値の処理：次に、この新しく生成された配列を昇順ソートし、同時にNULL値を最後に配置します。これは、ソート時にNULL以外のすべての値が優先され、NULL値がソート結果の末尾に配置されることを意味します。 - ソート順序に従って元の配列を再ソート：最後に、
array_sortbyは新しく生成された配列のソート順序に基づいて元の配列をソートします。これは、元の配列の要素がLambda関数の計算結果のソート順序に従って並べ替えられることを意味します。 - ソート後の配列を返す：最終的に、関数はソートされた元の配列を返します。
例：
SELECT array_sortby(x ->(x), [4,2,1,3]);
+----------------------------------+
| array_sortby(x ->(x), [4,2,1,3]) |
+----------------------------------+
| [1,2,3,4] |
+----------------------------------+
1 row in set
SELECT array_sortby(x ->(x), ['c',NULL,'a',NULL]);
+--------------------------------------------+
| array_sortby(x ->(x), ['c',NULL,'a',NULL]) |
+--------------------------------------------+
| ["a","c",NULL,NULL] |
+--------------------------------------------+
1 row in set
SELECT array_sortby((x,y) ->(y),['a','b','c'], [2,1,3]);
+--------------------------------------------------+
| array_sortby((x,y) ->(y),['a','b','c'], [2,1,3]) |
+--------------------------------------------------+
| ["b","a","c"] |
+--------------------------------------------------+
1 row in set
SELECT array_sortby((x,y) ->(y),[['a'],['b'],['c']], [2,1,3]);
+--------------------------------------------------------+
| array_sortby((x,y) ->(y),[['a'],['b'],['c']], [2,1,3]) |
+--------------------------------------------------------+
| [["b"],["a"],["c"]] |
+--------------------------------------------------------+
1 row in set
array_first
array_first()関数は、与えられたLambda関数の戻り値が0以外になる最初の要素を返すために使用されます。構文は次のとおりです：
array_first(（x1,...,xn) -> (expression), array1,...,arrayn)
入力パラメータの説明は以下のとおりです：
(x1,...,xn) -> (expression)Lambda関数を提供します。arr1,...,arrn入力される配列。渡される型は配列でなければならず、配列の要素数は同じでなければなりません。また、nはLambda関数の引数の数と一致していなければなりません。ネスト配列をサポートしています。
戻り値は任意のデータ型です。
具体的な説明は以下のとおりです：
- Lambda関数：配列内の各要素を評価するLambda関数を提供する必要があります。Lambda関数の戻り値は整数型でなければなりません。
- 配列はネストをサポートします：
array_first関数はネスト配列をサポートしており、他の配列を含む配列を渡すことができます。 - 戻り値：関数は
arr1内の要素をイテレーションし、Lambda関数の戻り値が0以外になる最初の要素を見つけて結果として返します。Lambda関数によって非ゼロ値が返される要素がない場合、NULL返される可能性があります。
例：
SELECT array_first(x ->(x + 1 > 2),[1,2,3,4]);
+----------------------------------------+
| array_first(x ->(x + 1 > 2),[1,2,3,4]) |
+----------------------------------------+
| 2 |
+----------------------------------------+
1 row in set
SELECT array_first((x,y) ->(y),[[1],[2],[3]], [0,1,3]);
+-------------------------------------------------+
| array_first((x,y) ->(y),[[1],[2],[3]], [0,1,3]) |
+-------------------------------------------------+
| [2] |
+-------------------------------------------------+
1 row in set
例の説明は以下のとおりです：
- Lambda関数：
(x,y) -> (y)は、2つの引数xとyを受け取り、yの値を返すLambda関数です。この特定の呼び出しでは、xは実際には使用されません。 - 入力配列：
[[1],[2],[3]]は、3つのサブ配列を含むネスト配列です。[0,1,3]は、3つの整数を含む1次元配列です。
- 戻り値の計算：
array_first関数は、入力された配列[[1],[2],[3]]内の各要素をイテレーションし、各要素に対してLambda関数を呼び出して、対応するy値（[0,1,3]から）を評価します。- この例では、Lambda関数の戻り値は
0、1、3であり、それぞれ[1]に対して0、[2]に対して1、[3]に対して3に対応します。 - したがって、
array_firstは[[1],[2],[3]]内でLambda関数の戻り値が0以外になる最初の要素を見つけます。ここでは、[2]に対応するy値は1であり、これが最初の非ゼロ値です。最終的な戻り値は[2]です。
array_except
array_except()関数は、arr1に属しているがarr2には属していない要素からなる配列を返すために使用されます。構文は以下のとおりです：
array_except(arr1, arr2)
入力パラメータの説明は以下のとおりです：
arr1：計算対象の左側の配列。arr2：計算対象の右側の配列。
戻り値は配列型です。
具体的な説明は以下のとおりです：
- 配列はネスト可能です：入力される配列はネスト配列であっても構いませんが、すべての配列のネストレベルが一致している必要があります。配列がネスト配列の場合、演算に参加するのは最初のレベルの配列であり、2つの配列の要素が同じでも順序が異なれば、それぞれ異なる配列と見なされます。
NULL値の処理：配列要素のうち1つがNULLの場合、結果はNULL返します。
例：
SELECT array_except([1,2,3], [1,2]);
+------------------------------+
| array_except([1,2,3], [1,2]) |
+------------------------------+
| [3] |
+------------------------------+
1 row in set
SELECT array_except(["test", "array"], ["test"]);
+-------------------------------------------+
| array_except(["test", "array"], ["test"]) |
+-------------------------------------------+
| ["array"] |
+-------------------------------------------+
1 row in set
SELECT array_except([[1,2,3],[1,2]], [[1,2],[3,4]]);
+----------------------------------------------+
| array_except([[1,2,3],[1,2]], [[1,2],[3,4]]) |
+----------------------------------------------+
| [[1,2,3]] |
+----------------------------------------------+
1 row in set
SELECT array_except([1,2,3,NULL], [1]);
+---------------------------------+
| array_except([1,2,3,NULL], [1]) |
+---------------------------------+
| [2,3,NULL] |
+---------------------------------+
1 row in set
array_intersect
array_intersect()関数は、すべての入力配列の1次元要素の共通部分を計算します。構文は以下のとおりです：
array_intersect(arr_list)
入力パラメータの説明は以下のとおりです：
arr_list: 交差演算を実行する配列リスト。
戻り値は配列型です。
具体的な説明は以下のとおりです：
- 配列のネストがサポートされています：入力配列はネストされた配列であっても構いませんが、すべての配列のネストレベルが一致している必要があります。配列がネストされた配列の場合、演算に参加する要素は1次元配列です。たとえ2つの配列の要素が同じでも順序が異なる場合、それらは異なる配列と見なされます。
NULL値の処理：特別な処理はありません。
例：
SELECT array_intersect([1,2,3], [1,2]);
+---------------------------------+
| array_intersect([1,2,3], [1,2]) |
+---------------------------------+
| [1,2] |
+---------------------------------+
1 row in set
-- 結果は自動的に重複を削除します
SELECT array_intersect([1,1,2,2,3], [1,1,2]);
+---------------------------------------+
| array_intersect([1,1,2,2,3], [1,1,2]) |
+---------------------------------------+
| [1,2] |
+---------------------------------------+
1 row in set
SELECT array_intersect([1,2,4,NULL], [4,5,NULL]);
+-------------------------------------------+
| array_intersect([1,2,4,NULL], [4,5,NULL]) |
+-------------------------------------------+
| [4,NULL] |
+-------------------------------------------+
1 row in set
SELECT array_intersect([[1,2,3], [1,2]], [[1,2],[2,3,4]]);
+----------------------------------------------------+
| array_intersect([[1,2,3], [1,2]], [[1,2],[2,3,4]]) |
+----------------------------------------------------+
| [[1,2]] |
+----------------------------------------------------+
1 row in set
array_union
array_union()関数は、すべての入力配列の和集合を計算するために使用されます。構文は次のとおりです：
array_union(arr_list)
入力パラメータの説明は以下のとおりです：
arr_list：和集合演算を実行する配列リスト。
戻り値は配列型です。
具体的な説明は以下のとおりです：
- 配列のネストはサポートされています：入力される配列はネストされた配列であっても構いませんが、すべての配列のネストレベルが一致している必要があります。配列がネストされた配列の場合、演算に参加する要素は最初のレベルの配列です。たとえ2つの配列の要素が同じでも順序が異なる場合、それらは異なる配列と見なされます。
NULL値の処理：特別な処理はありません。
例：
SELECT array_union([1,2,3], [1,2], [2,3,4]);
+--------------------------------------+
| array_union([1,2,3], [1,2], [2,3,4]) |
+--------------------------------------+
| [1,2,3,4] |
+--------------------------------------+
1 row in set
SELECT array_union([1,2,3], [4,5,NULL]);
+----------------------------------+
| array_union([1,2,3], [4,5,NULL]) |
+----------------------------------+
| [1,2,3,4,5,NULL] |
+----------------------------------+
1 row in set
SELECT array_union([[1,2,3], [1,2]], [[1,2],[2,3,4]]);
+------------------------------------------------+
| array_union([[1,2,3], [1,2]], [[1,2],[2,3,4]]) |
+------------------------------------------------+
| [[1,2,3],[1,2],[2,3,4]] |
+------------------------------------------------+
1 row in set