配列演算子は、入力された配列データに対して要素の追加、削除、検索などの基本的な操作を行い、操作後の配列データを返します。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() 関数は、対象配列の要素数を返します。対象配列がネストされた配列の場合は、すべての非空のサブ配列の要素数の合計を返します。構文は以下のとおりです：
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() 関数は、文字を配列に変換するために使用されます。具体的には、指定された区切り文字とNULL文字を用いて入力された文字を複数の要素に分割し、それらの要素を順次配列に格納します。区切り文字とNULL文字は大文字小文字を区別します。構文は以下のとおりです：
string_to_array(arr_str, delimiter[, null_str])
入力パラメータの説明は以下のとおりです：
arr_str引数の型は文字型でなければなりません。Char型およびVarchar型が含まれます。delimiter区切り文字。文字型をサポートします。Char型およびVarchar型が含まれます。null_str（オプション） NULL文字。文字型をサポートします。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以下、またはステップ幅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() 関数は、arr1 配列のうち、指定された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：共通部分を計算する配列のリスト。
戻り値は配列型です。
詳細な説明は以下のとおりです：
- ネスト配列のサポート：入力配列はネスト配列であってもかまいませんが、すべての配列のネストレベルが同じである必要があります。配列がネスト配列の場合、演算に参加するのは最外層の配列であり、たとえ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