複合型関数 - MaxCompute - Alibaba Cloud ドキュメントセンター

MaxCompute SQLの複合型関数を使用して、ARRAY、MAP、STRUCT、JSONなどの複合データ型のデータを処理できます。このトピックでは、MaxCompute SQLでサポートされている複合型関数の構文とパラメーターについて説明し、複合型関数の使用方法の例を示します。このトピックでは、複合型関数を使用したデータ開発について説明します。

次の表に、MaxCompute SQLでサポートされている複合型関数を示します。 JSON関数の制限の詳細については、「制限」をご参照ください。

関数タイプ	関数	説明
ARRAY関数	ALL_MATCH	配列内のすべての要素が特定の条件を満たすかどうかをチェックします。
	ANY_MATCH	配列内の要素が特定の条件を満たしているかどうかをチェックします。
	ARRAY	指定された値に基づいて配列を作成します。
	ARRAY_CONTAINS	配列に指定された値が含まれているかどうかをチェックします。
	ARRAY_DISTINCT	配列から重複要素を削除します。
	ARRAY_EXCEPT	配列Aに存在するが配列Bには存在しない要素を検索し、要素を重複なしで新しい配列として返します。
	ARRAY_INTERSECT	2つの配列の交差を計算します。
	ARRAY_JOIN	デリミタを使用して、配列内の要素を連結します。
	ARRAY_MAX	配列内の最大の要素を返します。
	ARRAY_MIN	配列内の最小の要素を返します。
	ARRAY_NORMALIZE	指定されたpノルムに基づいて要素が正規化されている配列を返します。
	ARRAY_POSITION	配列内の指定された要素の最初の出現位置を返します。
	ARRAY_REDUCE	配列内の要素を集計します。
	ARRAY_REMOVE	配列から特定の要素を削除します。
	ARRAY_REPEAT	指定された要素が複数回繰り返される新しい配列を返します。
	ARRAY_SORT	配列内の要素をコンパレータに基づいてソートします。
	ARRAY_UNION	2つの配列の和集合を計算し、重複のない新しい配列として和集合を返します。
	ARRAYS_OVERLAP	2つの配列に同じ要素が含まれているかどうかを確認します。
	ARRAYS_ZIP	複数の配列をマージします。
	組み合わせ	入力配列の要素に基づいてn要素のサブセットの配列を返します。
	CONCAT	複数の配列または文字列を連結します。
	EXPLODE	1行のデータを複数の行に変換します。この関数は、ユーザー定義のテーブル値関数 (UDTF) です。
	フィルター	配列内の要素をフィルターします。
	フラットテン	ARRAYデータ型の複数の配列を1つの配列に変換します。
	INDEX	配列内の特定の位置にある要素を返します。
	NGRAMS	指定した配列の要素のn-gram配列を返します。
	POSEXPLODE	配列を2つの列を持つテーブルに変換します。最初の列には、配列内の各要素の位置が0から始まります。 2番目の列は要素をリストします。
	逆	特定の配列の要素の逆順で配列を返します。
	シーケンス	式に基づいて指定された要素を含む配列を返します。
	シャッフル	配列の要素をランダムな順序で返します。
	SIZE	配列内の要素の数を返します。
	スライス	特定の長さに基づいて特定の位置から配列内の要素をコピーし、新しい配列として返します。
	SORT_ARRAY	配列内の要素を並べ替えます。
	SPLIT	指定された区切り文字で文字列を分割し、配列を返します。
	変身	配列内の要素を変換します。
	ZIP_WITH	要素位置に基づいて要素レベルで2つの配列をマージし、新しい配列を返します。
MAP関数	EXPLODE	1行のデータを複数の行に変換します。この関数はUDTFです。
	INDEX	マップ内の特定の条件を満たす値を返します。
	MAP	指定されたキーと値のペアに基づいてマップを作成します。
	MAP_CONCAT	複数のマップの和集合を返します。
	MAP_ENTRIES	マップ内のキーと値のペアを構造体配列に変換します。
	MAP_FILTER	マップ内の要素をフィルターします。
	MAP_FROM_ARRAYS	指定された配列に基づいてマップを作成します。
	MAP_FROM_ENTRIES	指定されたstruct配列に基づいてマップを作成します。
	MAP_KEYS	マップ内のすべてのキーを配列として返します。
	MAP_VALUES	マップ内のすべての値を配列として返します。
	MAP_ZIP_WITH	与えられた2つのマップを単一のマップにマージします。
	MULTIMAP_FROM_ENTRIES	構造体配列のキーとすべての値を含む配列で構成されるマップを返します。
	SIZE	マップ内のキーと値のペアの数を返します。
	TRANSFORM_KEYS	指定された関数を使用して、マップ内のキーを変換します。マップの値は変更されません。
	TRANSFORM_VALUES	指定された関数を使用して、マップ内の値を変換します。マップ内のキーは変更されません。
STRUCT関数	フィールド	構造体のメンバー変数の値を取得します。
	INLINE	特定のstruct配列を展開します。各配列要素は行に対応し、各struct要素は各行の列に対応する。
	NAMED_STRUCT	指定された名前と値のペアに基づいて構造体を作成します。
	STRUCT	指定された値リストに基づいて構造体を作成します。
JSON 関数	FROM_JSON	指定されたJSON文字列と指定された出力形式に基づいて、ARRAY、MAP、またはSTRUCT型のデータを返します。
	GET_JSON_OBJECT	特定のメソッドを使用して、標準のJSON文字列から単一の文字列を抽出します。
	JSON_TUPLE	一連の入力キーに基づいて、標準のJSON文字列から文字列を抽出します。
	TO_JSON	複雑なデータ型のデータをJSON文字列に変換します。
	JSON_オブジェクト	キーと値のペアを含むJSONオブジェクトを返します。
	JSON_ARRAY	空の可能性のある値のリストを評価し、これらの値を含むJSON配列を返します。空の可能性のある値のリストを評価し、これらの値を含むJSON配列を返します。
	JSON_EXPLODE	JSON配列またはJSONオブジェクトの各要素を複数の出力行に展開します。
	JSON_EXTRACT	json_pathの値をJSON式で解析します。 json_pathの値が無効な場合はエラーが返されます。
	JSON_EXISTS	json_pathのJSON値が存在するかどうかを判断します。
	JSON_PRETTY	改行とスペースを追加することで読みやすい形式のJSON値を返します。
	JSON_TYPE	JSON値のデータ型を返します。
	JSON_フォーマット	JSONデータ型の値をSTRINGデータ型の値に変換します。デフォルトでは、JSONデータは自動的にプリティファイされません。
	JSON_PARSE	STRINGデータ型の値をJSONデータ型の値に変換します。非JSON形式の値がSTRINGデータ型の値に変換された場合、エラーが返されます。
	JSON_VALID	文字列が有効なJSON形式であるかどうかを決定します。
	キャスト	基本データ型とJSONデータ型間の変換をサポートします。

説明

以下の例では、ハイフンとクロージングアングルブラケット (->) の組み合わせが使用されます。 Lambda関数でハイフンとクロージングアングルブラケット (->) の組み合わせを使用する方法の詳細については、「Lambda関数」をご参照ください。

ALL_MATCH

構文

boolean all_match(array<T> <a>, function<T, boolean> <predicate>)

説明
Array aのすべての要素が述語条件を満たすかどうかを確認します。
パラメーター
- a: 必須です。このパラメーターは、配列を指定します。 array<T> のTは、配列内の要素のデータ型を指定します。要素は任意のデータ型にすることができます。
- 述語: 必須です。このパラメーターには、Array aのすべての要素が要件を満たしているかどうかを判断するために使用される組み込み関数、ユーザー定義関数、または式を指定します。入力パラメーターのデータ型は、配列aの要素のデータ型と同じである必要があります。
戻り値
BOOLEAN型の値が返されます。戻り値は、次のルールによって異なります。
- Array aのすべての要素が述語条件を満たすか、または配列が空の場合、Trueが返されます。
- Array aの1つ以上の要素が述語条件を満たさない場合、falseが返されます。
- Array aの要素がnullで、他の要素が述語条件を満たす場合、nullが返されます。
例
- 例1: array(4、5、6) のすべての要素がx x > 3の条件を満たすかどうかを確認します。この条件は、すべての要素が3より大きいことを指定します。例：
```
-- The return value is true. 
select all_match(array(4, 5, 6), x -> x>3);
```
- 例2: 配列が空です。例：
```
-- The return value is true. 
select all_match(array(), x -> x>3);
```
- 例3: array(1、2、-10、100、-30) のすべての要素がx-> x > 3の条件を満たすかどうかを確認します。例：
```
-- The return value is false. 
select all_match(array(1, 2, -10, 100, -30), x -> x>3);
```
- 例4: array(10、100、30、null) のすべての要素がx-> x > 3の条件を満たすかどうかを確認します。例：
```
-- The return value is null. 
select all_match(array(10, 100, 30, null), x -> x>3);
```

ANY_MATCH

構文

boolean any_match(array<T> <a>, function<T, boolean> <predicate>)

説明
Array aの要素が述語条件を満たしているかどうかを確認します。
パラメーター
- a: 必須です。このパラメーターは、配列を指定します。 array<T> のTは、配列内の要素のデータ型を指定します。要素は任意のデータ型にすることができます。
- 述語: 必須です。このパラメーターには、Array aのすべての要素が要件を満たしているかどうかを判断するために使用される組み込み関数、ユーザー定義関数、または式を指定します。入力パラメーターのデータ型は、配列aの要素のデータ型と同じである必要があります。
戻り値
BOOLEAN型の値が返されます。戻り値は、次のルールによって異なります。
- Array aの1つ以上の要素が述語条件を満たす場合、trueが返されます。
- Array aの要素が述語条件を満たしていないか、または配列が空の場合、falseが返されます。
- Array aの要素がnullで、他の要素が述語条件を満たさない場合、nullが返されます。
例
- 例1: array(1、2、-10、100、-30) の要素がx-> x > 3の条件を満たすかどうかを確認します。例：
```
-- The return value is true. 
select any_match(array(1, 2, -10, 100, -30), x-> x > 3);
```
- 例2: 配列が空です。例：
```
-- The return value is false. 
select any_match(array(), x-> x > 3);
```
- 例3: array(1、2、-10、-20、-30) の要素がx-> x > 3の条件を満たすかどうかを確認します。例：
```
-- The return value is false. 
select any_match(array(1, 2, -10, -20, -30), x-> x > 3);
```
- 例4: array(1, 2, null, -10) の要素がx-> x > 3の条件を満たすかどうかを確認します。例：
```
-- The return value is null. 
select any_match(array(1, 2, null, -10), x-> x > 3);
```

ARRAY

構文
```
array array(<value>,<value>[, ...])
```
説明
指定された値に基づいて配列を作成します。
パラメーター
value: 必須です。任意のデータ型の値。すべての値は同じデータ型である必要があります。
戻り値
ARRAY型の値が返されます。

例

c1 (BIGINT) 、c2 (STRING) 、c3 (STRING) 、c4 (BIGINT) 、およびc5 (BIGINT) 列を含むt_tableテーブルのデータに基づいて配列を作成します。テーブル内のデータ:

+------------+----+----+------------+------------+
| c1         | c2 | c3 | c4         | c5         |
+------------+----+----+------------+------------+
| 1000       | k11 | k21 | 86         | 15         |
| 1001       | k12 | k22 | 97         | 2          |
| 1002       | k13 | k23 | 99         | 1          |
+------------+----+----+------------+------------+

例：

-- Create an array based on the data in the c2, c4, c3, and c5 columns. 
select array(c2,c4,c3,c5) from t_table;

-- The following result is returned: 
+------+
| _c0  |
+------+
| [k11, 86, k21, 15] |
| [k12, 97, k22, 2] |
| [k13, 99, k23, 1] |
+------+

ARRAY_CONTAINS

構文

boolean array_contains(array<T> <a>, value <v>)

説明
配列aに要素vが含まれているかどうかをチェックします。
パラメーター
- a: 必須です。このパラメーターは、配列を指定します。 array<T> のTは、配列内の要素のデータ型を指定します。要素は任意のデータ型にすることができます。
- v: 必須です。このパラメータは、チェックする要素を指定します。 vの値は、配列aの要素と同じデータ型である必要があります。
戻り値
BOOLEAN型の値が返されます。

例

t_table_arrayテーブルには、c1 (BIGINT) およびt_array (array <STRING>) 列が含まれます。テーブル内のデータ:

+------------+---------+
| c1         | t_array |
+------------+---------+
| 1000       | [k11, 86, k21, 15] |
| 1001       | [k12, 97, k22, 2] |
| 1002       | [k13, 99, k23, 1] |
+------------+---------+

例：

-- Check whether the t_array column contains the value 1. 
select c1, array_contains(t_array,'1') from t_table_array;
-- The following result is returned: 
+------------+------+
| c1         | _c1  |
+------------+------+
| 1000       | false |
| 1001       | false |
| 1002       | true |
+------------+------+

ARRAY_DISTINCT

構文
```
array<T> array_distinct(array<T> <a>)
```
説明
配列aから重複要素を削除します。
パラメーター
a: 必須です。このパラメーターは、配列を指定します。 array<T> のTは、配列内の要素のデータ型を指定します。要素は任意のデータ型にすることができます。
戻り値
ARRAY型の値が返されます。戻り値は、次のルールによって異なります。
- 返された配列には重複する要素はなく、要素は配列aと同じ順序でソートされます。
- 配列aの要素がnullの場合、null要素は操作に含まれます。
- 入力配列が空の場合、空の配列が返されます。
例
- 実施例1: アレイ (10、20、30、30、20、10) から重複要素を除去する。例：
```
-- The return value is [10,20,30]. 
select array_distinct(array(10, 20, 30, 30, 20, 10));
```
- 実施例2: 配列 (10、20、20、ヌル、ヌル、30、20、ヌル) から重複要素を除去する。例：
```
-- The return value is [10,20,null,30]. 
select array_distinct(array(10, 20, 20, null, null, 30, 20, null)); 
```
- 例3: 空の配列から重複する要素を削除します。例：
```
-- The return value is []. 
select array_distinct(array());
```

ARRAY_EXCEPT

構文

array<T> array_except(array<T> <a>, array<T> <b>)

説明
配列aに存在するが配列bには存在しない要素を検索し、要素を重複なしで新しい配列として返します。
パラメーター
aおよびb: 必須。これらのパラメータは配列を指定します。 array<T> のTは、配列内の要素のデータ型を指定します。要素は任意のデータ型にすることができます。配列aの要素と配列bの要素は同じデータ型である必要があります。
戻り値
ARRAY型の値が返されます。戻り値は、次のルールによって異なります。
- 返された配列には重複する要素はなく、要素は配列aと同じ順序でソートされます。
- 配列内の要素がnullの場合、null要素は操作に含まれます。
- 入力配列の1つが空の場合、重複なしに空でない配列に基づいて新しい配列が返されます。
- 2つの入力配列が空の場合、空の配列が返されます。
例
- 例1: array(1、1、3、3、5、5) に存在するが、array(1、1、2、2、3、3) には存在しない要素を見つけ、要素を重複なしで新しい配列として返します。例：
```
-- The return value is [5]. 
select array_except(array(1, 1, 3, 3, 5, 5), array(1, 1, 2, 2, 3, 3));
```
- 例2: array(1、1、3、3、5、5、null、null) に存在するが、array(1、1、2、2、3、3) には存在しない要素を見つけ、要素を重複なしで新しい配列として返します。例：
```
-- The return value is [5,null]. 
select array_except(array(1, 1, 3, 3, 5, 5, null, null), array(1, 1, 2, 2, 3, 3));
```
- 例3: 配列に存在するが別の配列には存在しない要素を見つけ、重複なしで新しい配列として要素を返します。入力配列の1つは空です。例：
```
-- The return value is [2,1]. 
select array_except(array(2, 1, 1, 2), cast(array() as array<int>)); 
```
- 例4: 配列に存在するが別の配列には存在しない要素を見つけ、重複なしで新しい配列として要素を返します。 2つの入力アレイは空である。例：
```
-- The return value is []. 
select array_except(cast(array() as array<int>), cast(array() as array<int>));
```

ARRAY_INTERSECT

構文

array<T> array_intersect(array<T> <a>, array<T> <b>)

説明
配列aと配列bの交差を計算し、重複する要素を削除します。
パラメーター
aおよびb: 必須。これらのパラメータは配列を指定します。 array<T> のTは、配列内の要素のデータ型を指定します。要素は任意のデータ型にすることができます。配列aの要素と配列bの要素は同じデータ型である必要があります。
戻り値
ARRAY型の値が返されます。戻り値は、次のルールによって異なります。
- 配列内の要素がnullの場合、null要素は操作に含まれます。
- 返された配列には重複する要素はなく、要素は配列aと同じ順序でソートされます。
- 配列aまたは配列bがnullの場合、nullが返されます。
例
- 例1: array(1、2、3) とarray(1、3、5) の交差を計算し、重複する要素を削除します。例：
```
-- The return value is [1,3]. 
select array_intersect(array(1, 2, 3), array(1, 3, 5));
```
- 例2: 配列 (10、20、20、30、null、null) と配列 (30、30、20、20、40、null、null) の共通部分を計算し、重複要素を削除します。例：
```
-- The return value is [20,30,null]. 
select array_intersect(array(10, 20, 20, 30, 30, null, null), array(30, 30, 20, 20, 40, null, null)); 
```

ARRAY_JOIN

構文

array_join(array<T> <a>, <delimiter>[, <nullreplacement>])

説明
区切り文字を使用して、配列aの要素を連結します。配列にnull要素が含まれている場合は、nullreplacementを使用して、結果のnull要素を置き換えるために使用する文字列を指定します。 nullreplacementを設定しない場合、null要素は無視されます。
パラメーター
- a: 必須です。このパラメーターは、配列を指定します。 array<T> のTは、配列内の要素のデータ型を指定します。
  説明
  配列内の要素がSTRING型でない場合、MaxComputeは要素のデータ型をSTRINGに変換します。
- delimiter: 必須です。 STRING型の値。このパラメーターは、配列aの連結要素を区切るために使用される文字列を指定します。
- nullreplacement: オプション。このパラメーターは、null要素を置き換えるために使用される文字列を指定します。
戻り値
STRING型の値が返されます。

例

-- The return value is 10,20,20,30. 
select array_join(array(10, 20, 20, null, null, 30), ",");
-- The return value is 10##20##20##null##null##30. 
select array_join(array(10, 20, 20, null, null, 30), "##", "null");

ARRAY_MAX

構文
```
T array_max(array<T> <a>) 
```
説明
配列aの最大の要素を返します。
パラメーター
a: 必須です。このパラメーターは、配列を指定します。 array<T> のTは、配列内の要素のデータ型を指定します。
次のデータ型がサポートされています。
- TINYINT、SMALLINT、INT、およびBIGINT
- フロートとダブル
- BOOLEAN
- デシマルとデシマル
- DATE、DATETIME、TIMESTAMP、IntervalDayTime、およびIntervalYearMonth
- STRING、BINARY、VARCHAR、CHAR
- アレイ、STRUCT、マップ
戻り値
配列aの最大の要素が返されます。戻り値は、次のルールによって異なります。
- 配列aがnullの場合、nullが返されます。
- 配列aの要素がnullの場合、null要素は操作に含まれません。

例

-- The return value is 20. 
select array_max(array(1, 20, null, 3));

ARRAY_MIN

構文
```
T array_min(array<T> <a>) 
```
説明
配列aの最小の要素を返します。
パラメーター
a: 必須です。このパラメーターは、配列を指定します。 array<T> のTは、配列内の要素のデータ型を指定します。
次のデータ型がサポートされています。
- TINYINT、SMALLINT、INT、およびBIGINT
- フロートとダブル
- BOOLEAN
- デシマルとデシマル
- DATE、DATETIME、TIMESTAMP、IntervalDayTime、およびIntervalYearMonth
- STRING、BINARY、VARCHAR、CHAR
- アレイ、STRUCT、マップ
戻り値
配列aの最小の要素が返されます。戻り値は、次のルールによって異なります。
- 配列aがnullの場合、nullが返されます。
- 配列aの要素がnullの場合、null要素は操作に含まれません。

例

-- The return value is 1. 
select array_min(array(1, 20, null, 3));

ARRAY_NORMALIZE

構文
```
array_normalize(array, p)
```
説明
指定されたpノルムに基づいて要素が正規化されている配列を返します。
この関数は、TRANSFORM(array, v -> v / REDUCE(array, 0, (a, v) -> a + POW(ABS(v), p), a -> POW(a, 1 / p)) と等価である。ただし、REDUCE関数は1回だけ呼び出されます。
パラメーター
array: 入力配列。配列内の要素は、FLOATおよびDOUBLEデータ型のみにすることができます。
p: 配列のpノルム。
戻り値
指定されたpノルムに基づいて要素が正規化された配列が返されます。
- 配列がnullまたはnull要素を含む場合、nullが返されます。
- p=0の条件が満たされると、元の配列が返されます。 p<0の条件が満たされると、エラーが返されます。

例

SELECT  array_normalize(array(10.0, 20.0, 50.0), 1.0);

次の応答が返されます。

[0.125, 0.25, 0.625]

ARRAY_POSITION

構文

bigint array_position(array<T> <a>, T <element>)

説明
配列a内の指定された要素の最初の出現位置を返します。要素の位置番号は左から右に数え、1から始まります。
パラメーター
- a: 必須です。このパラメーターは、配列を指定します。 array<T> のTは、配列内の要素のデータ型を指定します。次のデータ型がサポートされています。
  - TINYINT、SMALLINT、INT、およびBIGINT
  - フロートとダブル
  - BOOLEAN
  - デシマルとデシマル
  - DATE、DATETIME、TIMESTAMP、IntervalDayTime、およびIntervalYearMonth
  - STRING、BINARY、VARCHAR、CHAR
  - アレイ、STRUCT、マップ
- element: 必須です。位置を照会する要素です。このパラメーターのデータ型は、配列aの要素のデータ型と同じである必要があります。
戻り値
BIGINT型の値が返されます。戻り値は、次のルールによって異なります。
- Array aまたはelementがnullの場合、nullが返されます。
- 特定の要素が見つからない場合、0が返されます。

例

例1: 配列 (3、2、1) の最初の1の位置を返します。例：
```
-- The return value is 3. 
select array_position(array(3, 2, 1), 1);
```

例2: 指定された要素はnullです。例：

-- The return value is null. 
select array_position(array(3, 1, null), null);

ARRAY_REDUCE

構文

R array_reduce(array<T> <a>, buf <init>, function<buf, T, buf> <merge>, function<buf, R> <final>)

説明
配列aの要素を集計します。
パラメーター
- a: 必須です。このパラメーターは、配列を指定します。 array<T> のTは、配列内の要素のデータ型を指定します。要素は任意のデータ型にすることができます。
- init: 必須です。要素の集計に使用される中間結果の初期値。
- merge: 必須です。 Array Aの各要素と中間結果に対して操作を実行するために使用される組み込み関数、ユーザー定義関数、または式を指定します。この関数または式は、Array aの要素とinitパラメーターを入力パラメーターとして使用します。
- final: 必須です。中間結果を最終結果に変換するために使用される組み込み関数、ユーザー定義関数、または式。この関数または式は、mergeの結果を入力パラメーターとして使用します。 Rは、出力のデータ型を指定します。
戻り値
戻り値のデータ型は, finalに指定したデータ型と同じです。

例

-- The return value is 6. 
select array_reduce(array(1, 2, 3), 0, (buf, e)->buf + e, buf->buf);
-- The return value is 2.5. 
select array_reduce(array(1, 2, 3, 4), named_struct('sum', 0, 'count', 0), (buf, e)->named_struct('sum', buf.sum + e, 'count', buf.count + 1), buf -> buf.sum / buf.count);

ARRAY_REMOVE

構文

array<T> array_remove(array<T> <a>, T <element>)

説明
配列aから特定の要素を削除します。
パラメーター
- a: 必須です。このパラメーターは、配列を指定します。 array<T> のTは、配列内の要素のデータ型を指定します。次のデータ型がサポートされています。
  - TINYINT、SMALLINT、INT、およびBIGINT
  - フロートとダブル
  - BOOLEAN
  - デシマルとデシマル
  - DATE、DATETIME、TIMESTAMP、IntervalDayTime、およびIntervalYearMonth
  - STRING、BINARY、VARCHAR、CHAR
  - アレイ、STRUCT、マップ
- element: 必須です。削除する要素。The element that you want to remove. このパラメーターのデータ型は、配列aの要素のデータ型と同じである必要があります。
戻り値
ARRAY型の値が返されます。戻り値は、次のルールによって異なります。
- 配列aの要素がnullの場合、null要素は操作に含まれません。
- Array aまたはelementがnullの場合、nullが返されます。
- Array aに特定の要素が含まれていない場合、Array aが返されます。

例

実施例1: アレイ (3、2、1) から1を除去する。例：

-- The return value is [3,2]. 
select array_remove(array(3, 2, 1), 1);

例2: 指定された要素はnullです。例：

-- The return value is null. 
select array_remove(array(3, 1, null), null);

例3: アレイ (3、1、ヌル) から2を除去する。例：

-- The return value is [3,1,null]. 
select array_remove(array(3, 1, null), 2);

ARRAY_REPEAT

構文

array<T> array_repeat(T <element>, int <count>)

説明
要素tがcount回繰り返される新しい配列を返します。
パラメーター
- t: 必須です。このパラメータは、繰り返す要素を指定します。次のデータ型がサポートされています。
  - TINYINT、SMALLINT、INT、およびBIGINT
  - フロートとダブル
  - BOOLEAN
  - デシマルとデシマル
  - DATE、DATETIME、TIMESTAMP、IntervalDayTime、およびIntervalYearMonth
  - STRING、BINARY、VARCHAR、CHAR
  - アレイ、STRUCT、マップ
- count: 必須です。このパラメータは、繰り返し回数を指定します。 INT型の値が必要です。値は0以上である必要があります。
戻り値
ARRAY型の値が返されます。戻り値は、次のルールによって異なります。
- countの値がnullの場合、nullが返されます。
- countの値が0未満の場合、空の配列が返されます。

例

例1: 123を2回繰り返し、新しい配列を返します。例：
```
-- The return value is [123, 123]. 
select array_repeat('123', 2);
```

例2: countの値がnullです。例：

-- The return value is null. 
select array_repeat('123', null);

例3: countの値が0未満です。例：

-- The return value is []. 
select array_repeat('123', -1);

ARRAY_SORT

構文

array<T> array_sort(array<T> <a>, function<T, T, bigint> <comparator>)

説明
コンパレータに基づいて配列aの要素を並べ替えます。
パラメーター
- a: 必須です。このパラメーターは、配列を指定します。 array<T> のTは、配列内の要素のデータ型を指定します。要素は任意のデータ型にすることができます。
- comparator: 必須。配列内の2つの要素を比較するために使用される組み込み関数、ユーザー定義関数 (UDF) 、または式。
  comparator(a, b) の処理ロジック: aがbに等しい場合、0が返されます。 aがbより小さい場合、負の整数が返されます。 aがbより大きい場合、正の整数が返されます。 comparator(a, b) がnullを返すと、エラーが返されます。
  重要
  ARRAY_SORTの比較関数は自己整合的でなければなりません。例：
  compare(a, b) > 0が満たされる場合、compare(b, a) < 0が満たされなければならない。
  compare(a, b) = 0が満たされる場合、compare(b, a) = 0が満たされなければならない。
  compare(a, b) < 0が満たされる場合、compare(b, a) > 0が満たされなければならない。
  自己整合性ではない関数の例:
  (左、右) -> ケース左 <=右THEN -1L ELSE 0L END:
  a = 1とb = 1を設定した場合、compare(a, b) 関数は-1を返し、compare(b, a) 関数も-1を返します。比較結果は互いに矛盾し、関数は自己矛盾していません。
  (左、右) -> ケース左 <右THEN - 1L左=右THEN 0L ELSE 1L END:
  a = NULLおよびb = 1を設定した場合、compare(a, b) 関数は1を返し、compare(b, a) 関数も1を返します。比較結果は互いに矛盾し、関数は自己矛盾していません。
戻り値
ARRAY型の値が返されます。

例

例1: 配列 (5,6,1) の要素をソートします。

SELECT array_sort(array(5,6,1), (left,right) -> CASE WHEN left < right THEN -1L WHEN left > right THEN 1L ELSE 0L END);

-- The following result is returned:
+------------+
| _c0        |
+------------+
| [1,5,6]    |
+------------+

例 2：

SELECT array_sort(a, (a,b)-> CASE WHEN a.a>b.a THEN 1L WHEN a.a<b.a THEN -1L ELSE 0L END) 
FROM VALUES ( 
  array(named_struct('a', 1, 'b', 10),
        named_struct('a', 3, 'b', 11),
        named_struct('a', 2, 'b', 12)))
  AS t(a);
  
-- The following result is returned:
+------+
| _c0 |
+------+
| [{a:1, b:10}, {a:2, b:12}, {a:3, b:11}] |
+------+

ARRAY_UNION

構文

array<T> array_union(array<T> <a>,  array<T> <b>)

説明
配列aと配列bの和集合を計算し、重複する要素を削除します。
パラメーター
aおよびb: 必須。これらのパラメータは配列を指定します。 array<T> のTは、配列内の要素のデータ型を指定します。要素は任意のデータ型にすることができます。配列aの要素と配列bの要素は同じデータ型である必要があります。
次のデータ型がサポートされています。
- TINYINT、SMALLINT、INT、およびBIGINT
- フロートとダブル
- BOOLEAN
- デシマルとデシマル
- DATE、DATETIME、TIMESTAMP、IntervalDayTime、およびIntervalYearMonth
- STRING、BINARY、VARCHAR、CHAR
- アレイ、STRUCT、マップ
戻り値
ARRAY型の値が返されます。配列aまたは配列bがnullの場合、nullが返されます。
例
- 例1: array(1、2、3) とarray(1、3、5) の和集合を計算し、重複する要素を削除します。例：
```
-- The return value is [1,2,3,5]. 
select array_union(array(1, 2, 3), array(1, 3, 5));
```
- 例2: 2つの配列の和集合を計算し、重複する要素を削除します。配列の1つはnullです。例：
```
-- The return value is null. 
select array_union(array(1, 2, 3), null);
```

ARRAYS_OVERLAP

構文

boolean arrays_overlap(array<T> <a>,  array<T> <b>)

説明
配列aと配列bに同じ要素が含まれているかどうかを確認します。
パラメーター
aおよびb: 必須。これらのパラメータは配列を指定します。 array<T> のTは、配列内の要素のデータ型を指定します。要素は任意のデータ型にすることができます。配列aの要素と配列bの要素は同じデータ型である必要があります。
次のデータ型がサポートされています。
- TINYINT、SMALLINT、INT、およびBIGINT
- フロートとダブル
- BOOLEAN
- デシマルとデシマル
- DATE、DATETIME、TIMESTAMP、IntervalDayTime、およびIntervalYearMonth
- STRING、BINARY、VARCHAR、CHAR
- アレイ、STRUCT、マップ
戻り値
BOOLEAN型の値が返されます。戻り値は、次のルールによって異なります。
- 配列bにある要素が少なくとも1つ含まれており、nullではない場合、trueが返されます。
- 配列aと配列bに同じ要素が含まれていない場合、両方の配列が空ではなく、一方または両方の配列にnull要素が含まれている場合、nullが返されます。
- 配列aと配列bが同じ要素を含まず、両方の配列が空ではなく、null要素を含まない場合、falseが返されます。
例
- 例1: array(1, 2, 3) とarray(3, 4, 5) に同じ要素が含まれているかどうかを確認します。例：
```
-- The return value is true. 
select arrays_overlap(array(1, 2, 3), array(3, 4, 5));
```
- 例2: array(1、2、3) とarray(6、4、5) に同じ要素が含まれているかどうかを確認します。例：
```
-- The return value is false. 
select arrays_overlap(array(1, 2, 3), array(6, 4, 5));
```
- 例3: 2つの配列に同じ要素が含まれているかどうかを確認します。配列の1つにnull要素が含まれます。例：
```
-- The return value is null. 
select arrays_overlap(array(1, 2, 3), array(5, 4, null));
```

ARRAYS_ZIP

構文

array<struct<T, U, ...>> arrays_zip(array<T> <a>, array<U> <b>[, ...])

説明
複数の指定された配列をマージし、struct配列を返します。この配列では、N番目の構造体に入力配列のN番目の要素がすべて含まれます。
パラメーター
aおよびb: 必須。これらのパラメータは配列を指定します。 array<T> のTとarray<U> のUは、配列内の要素のデータ型を指定します。要素は任意のデータ型にすることができます。
次のデータ型がサポートされています。
- TINYINT、SMALLINT、INT、およびBIGINT
- フロートとダブル
- BOOLEAN
- デシマルとデシマル
- DATE、DATETIME、TIMESTAMP、IntervalDayTime、およびIntervalYearMonth
- STRING、BINARY、VARCHAR、CHAR
- アレイ、STRUCT、マップ
戻り値
ARRAY型の値が返されます。戻り値は、次のルールによって異なります。
- 生成されたstruct配列のN番目のstructには、入力配列のN番目の要素がすべて含まれます。配列に含まれる要素がN個未満の場合、配列のN番目の要素としてnullが使用されます。
- 1つ以上の入力配列がnullの場合、nullが返されます。

例

例1: array(1, 2, 3) とarray(2, 3, 4) をstruct配列にマージします。例：

-- The return value is [{0:1, 1:2}, {0:2, 1:3}, {0:3, 1:4}]. 
select arrays_zip(array(1, 2, 3), array(2, 3, 4));

例2: array(1、2、3) とarray(4、5) をstruct配列にマージします。例：

-- The return value is [{0:1, 1:4}, {0:2, 1:5}, {0:3, 1:null}]. 
select arrays_zip(array(1, 2, 3), array(4, 5));

組み合わせ

構文
```
combinations(array(T), n)
```
説明
入力配列の要素に基づいてn要素のサブセットの配列を返します。
パラメーター
array: 入力配列。
n: 各サブセット内の要素の数。
戻り値
入力配列の要素に基づいてn要素のサブセットの配列を返します。
- 入力配列に重複する要素がない場合、n要素のサブセットの配列が返されます。サブセットは決定論的であり、ランダムな順序でリストされます。サブセット内の要素は決定論的であり、ランダムな順序でリストされます。
- デフォルトでは、nの最大値は5です。 odps.sql.max.com bination.lengthパラメーターを指定して、最大値を変更できます。デフォルトでは、生成されるサブセットの総数は100,000を超えることはできません。 odps.sql.max.comパラメーターを指定して、総数を変更できます。
- nの値が入力配列の要素数より大きい場合、空の配列が返されます。

例

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], [1, 2, 5], [1, 3, 5], [2, 3, 5], [1, 4, 5], [2, 4, 5], [3, 4, 5]]

SELECT combinations(array(1,2,2),2);

次の応答が返されます。

[[1,2], [1,2], [2,2]]

CONCAT

構文

array<T> concat(array<T> <a>, array<T> <b>[,...])
string concat(string <str1>, string <str2>[,...])

説明
- 入力としての配列: 複数の配列のすべての要素を連結し、新しい配列を返します。
- 入力としての文字列: 複数の文字列を連結し、新しい文字列を返します。
パラメーター
- aおよびb: 必須。これらのパラメータは配列を指定します。 array<T> のTは、配列内の要素のデータ型を指定します。要素は任意のデータ型にすることができます。配列aの要素と配列bの要素は同じデータ型である必要があります。 null要素も操作に含まれます。
- str1およびstr2: 必須です。 STRING型の値。入力値がBIGINT、DOUBLE、DECIMAL、またはDATETIME型の場合、計算前に暗黙的にSTRING型の値に変換されます。入力値が他のデータ型の場合、エラーが返されます。
戻り値
- ARRAY型の値が返されます。入力配列の1つがnullの場合、nullが返されます。
- STRING型の値が返されます。入力パラメーターが設定されていない場合、または入力パラメーターがnullに設定されている場合は、nullが返されます。

例

例1: 配列 (10、20) と配列 (20、-20) のすべての要素を連結します。例：
```
-- The return value is [10, 20, 20, -20]. 
select concat(array(10, 20), array(20, -20));
```

例2: 入力配列の1つにnull要素が含まれています。例：

-- The return value is [10, null, 20, -20]. 
select concat(array(10, null), array(20, -20));

例3: 入力配列の1つがnullです。例：

-- The return value is null. 
select concat(array(10, 20), null);

例4: 文字列aabcとabcdeを連結します。例：

-- The return value is aabcabcde. 
select concat('aabc','abcde');

例5: 入力が空です。例：

-- The return value is null. 
select concat();

例6: 入力文字列の1つがnullです。例：

-- The return value is null. 
select concat('aabc', 'abcde', null);

EXPLODE

制限事項
- SELECTステートメントには、EXPLODE関数を1つだけ含めることができます。 EXPLODE関数を使用して、列のデータのみを計算できます。
- この関数は、GROUP BY、CLUSTER BY、DISTRIBUTE BY、またはSORT BY句では使用できません。
構文
```
explode (<var>)
```
説明
1行のデータを複数の行に変換します。この関数はUDTFです。
- パラメーター値がarray<T> 型の場合、列に格納されている配列は複数の行に転置されます。
- パラメーター値がmap<K, V> 型の場合、列に格納されているマップの各キーと値のペアは、2つの列を持つ1つの行に置き換えられます。一方の列はキーの格納に使用され、もう一方の列は値の格納に使用されます。
パラメーター
var: 必須です。値は、array<T> 型またはmap<K, V> 型である必要があります。
戻り値
転置後の行が返されます。

例

t_table_mapテーブルは、c1 (BIGINT) およびt_map (map <STRING,BIGINT>) 列を含む。テーブル内のデータ:

  +------------+-------+
| c1         | t_map |
+------------+-------+
| 1000       | {k11:86, k21:15} |
| 1001       | {k12:97, k22:2} |
| 1002       | {k13:99, k23:1} |
+------------+-------+

例：

select explode(t_map) from t_table_map;
-- The following result is returned: 
+-----+------------+
| key | value      |
+-----+------------+
| k11 | 86         |
| k21 | 15         |
| k12 | 97         |
| k22 | 2          |
| k13 | 99         |
| k23 | 1          |
+-----+------------+

フィールド

構文
```
T field(struct <s>, string <fieldName>)
```
説明
構造体のメンバー変数の値を取得します。
パラメーター
- s: 必須です。このパラメータは、構造体を指定します。 structは、{f1:T1, f2:T2[, ...]} の形式である。 f1およびf2はメンバ変数を指定し、T1はf1の値を指定し、T2はf2の値を指定する。
- fieldName: 必須です。 STRING型の値。このパラメーターは、構造体のメンバー変数を指定します。
戻り値
構造体の特定のメンバー変数の値が返されます。

例

-- The return value is hello. 
select field(named_struct('f1', 'hello', 'f2', 3), 'f1');

フィルター

構文

array<T> filter(array<T> <a>, function<T,boolean> <func>)

説明
funcを使用してArray aの要素をフィルターし、新しい配列を返します。
パラメーター
- a: 必須です。このパラメーターは、配列を指定します。 array<T> のTは、配列内の要素のデータ型を指定します。要素は任意のデータ型にすることができます。
- func: 必須です。このパラメーターには、Array aの要素をフィルター処理するために使用される組み込み関数、ユーザー定義関数、または式を指定します。値は、配列aの要素と同じデータ型である必要があります。関数または式の出力結果はBOOLEAN型です。
戻り値
ARRAY型の値が返されます。

例

-- The return value is [2, 3]. 
select filter(array(1, 2, 3), x -> x > 1);

フラットテン

構文
```
flatten(arrayOfArray)
```
説明
ARRAYデータ型の複数の配列を1つの配列に変換します。
パラメーター
arrayOfArray: ARRAYデータ型の配列。
戻り値
ARRAYデータ型の複数の配列は、要素の順序で1つの配列に変換されます。
- 入力値がnullの場合、nullが返されます。
- 入力パラメーターがARRAYデータ型の配列でない場合、エラーが返されます。

例

SELECT flatten(array(array(1, 2), array(3, 4)));

次の応答が返されます。

[1,2,3,4]

FROM_JSON

構文
```
from_json(<jsonStr>, <schema>)
```
説明
JSON文字列jsonStrと出力形式スキーマに基づいて、ARRAY、MAP、またはSTRUCT型のデータを返します。

パラメーター

jsonStr: 必須です。入力したJSON文字列。

schema: 必須です。 JSON文字列のスキーマ。このパラメーターの値は、array<bigint> 、map<string, array<string>> 、struct<a:int, b:double, 'C':map<string,string>> など、テーブルを作成するステートメントと同じ形式である必要があります。

説明

構造体のキーは大文字と小文字を区別します。 struct <a:BIGINT, b:DOUBLE> に相当するa BIGINT, b DOUBLEの形式で構造体を指定することもできます。

次の表に、JSONデータ型とMaxComputeデータ型の間のマッピングを示します。

JSONデータ型	MaxComputeデータ型
OBJECT	STRUCT、マップ、およびストリング
ARRAY	アレイとストリング
NUMBER	TINYINT、SMALLINT、INT、BIGINT、FLOAT、DOUBLE、DECIMAL、およびSTRING
BOOLEAN	ブーリアンとストリング
STRING	STRING、CHAR、VARCHAR、BINARY、DATE、およびDATETIME
NULL	すべてのタイプ

説明

OBJECT型とARRAY型のJSON文字列は、可能な限り解析されます。 JSON文字列のデータ型がMaxComputeデータ型にマッピングされていない場合、JSON文字列は省略されます。使いやすいように、すべてのJSONデータ型をMaxComputeでサポートされているSTRINGデータ型に変換できます。 NUMBER型のJSON文字列をFLOAT型、DOUBLE型、またはDECIMAL型の値に変換すると、値の精度が保証されません。 JSON文字列をstring型の値に変換してから、取得した値をFLOAT、DOUBLE、またはDECIMAL型の値に変換することをお勧めします。

戻り値
ARRAY、MAP、またはSTRUCTタイプの値が返されます。

例

例1: 特定のJSON文字列を特定のデータ型の値に変換します。例：

-- The return value is {"a":1,"b":0.8}. 
select from_json('{"a":1, "b":0.8}', 'a int, b double');
-- The return value is {"time":"26/08/2015"}. 
select from_json('{"time":"26/08/2015"}', 'time string');
-- The return value is {"a":1,"b":0.8}. 
select from_json('{"a":1, "b":0.8}', 'a int, b double, c string');
-- The return value is [1,2,3]. 
select from_json('[1, 2, 3, "a"]', 'array<bigint>');
-- The return value is {"d":"v","a":"1","b":"[1,2,3]","c":"{}"}. 
select from_json('{"a":1,"b":[1,2,3],"c":{},"d":"v"}', 'map<string, string>');

例2: map_keysおよびfrom_json関数を使用して、JSON文字列のすべてのキーを取得します。同じ目的でJSON_KEYSを使用することもできます。例：
```
-- The return value is ["a","b"]. 
select map_keys(from_json('{"a":1,"b":2}','map<string,string>'));
```

GET_JSON_OBJECT

使用上の注意

この関数は、JSONPathを使用して標準のJSON文字列から単一の文字列を抽出するために使用されます。この関数は、次のデータ型の入力パラメーターをサポートします。

JSON型: 入力パラメータがJSON型の場合、標準のJSONPath式が使用されます。
STRING型: 入力パラメーターがSTRING型の場合、元のJSONPath式が使用されます。

この関数を使用する方法と使用法の注意点は、入力パラメーターのデータ型によって異なります。このトピックでは、入力パラメーターがJSON型とSTRING型の場合にGET_JSON_OBJECT関数を使用する方法について説明します。

説明

入力パラメータがJSON型である場合に使用されるJSONPath式と、入力パラメータがSTRING型である場合に使用されるJSONPath式は、異なる規則に準拠しています。これは、非互換性の問題を引き起こし得る。
GET_JSON_OBJECT関数は、JSONPath式の構文をサポートしていません。

JSONデータ型の入力パラメーター

構文

string get_json_object(json <json>, string <json_path>)

説明
JSON PATHに基づいて、標準のJSON文字列から単一の文字列を抽出します。
パラメーター
- json: 必須です。単一の文字列を抽出するJSON文字列。
- json_path: 必須です。単一の文字列を抽出するJSONPath式。
戻り値
STRING型の値が返されます。
例
- 例1: JSON文字列からキーaに対応する値を抽出します。
```
select get_json_object(json '{"a":1, "b":2}', '$.a');
```
  次の応答が返されます。
```
+-----+
| _c0 |
+-----+
| 1   |
+-----+
```
- 例2: JSON文字列からキーcに対応する値を抽出します。
```
select get_json_object(json '{"a":1, "b":2}', '$.c');
```
  次の応答が返されます。
```
+-----+
| _c0 |
+-----+
| NULL |
+-----+
```
- 例3: 無効なJSONパスが指定されている場合、戻り値はNULLです。
```
select get_json_object(json '{"a":1, "b":2}', '$invalid_json_path');
```
  次の応答が返されます。
```
+-----+
| _c0 |
+-----+
| NULL |
+-----+
```

STRINGデータ型の入力パラメーター

構文

string get_json_object(string <json>, string <path>)

説明
pathに基づいて、標準のJSON文字列から単一の文字列を抽出します。この関数が呼び出されるたびに、元のデータが読み取られます。したがって、繰り返される呼び出しはシステムパフォーマンスに影響を与え、コストを増加させます。繰り返し呼び出しを防ぐために、UDTFでGET_JSON_OBJECT関数を使用できます。詳細については、「MaxCompute組み込み関数とUDTFを使用したJSONログデータの変換」をご参照ください。
パラメーター
- json: 必須です。 STRING型の値。このパラメーターは、標準のJSONオブジェクトを {Key:Value, Key:Value,...} の形式で指定します。文字列に二重引用符 (") が含まれている場合は、2つのバックスラッシュ (\\) を使用して、抽出前に二重引用符 (") をエスケープします。文字列に単一引用符 (') が含まれている場合は、単一のバックスラッシュ (\) を使用して、抽出前に単一引用符 (') をエスケープします。
- path: 必須です。 STRING型の値。このパラメーターは、jsonパラメーターの値にpathを指定し、$で始まります。 pathパラメーターの詳細については、「LanguageManual UDF」をご参照ください。ベストプラクティスの詳細については、「OSSからMaxComputeへのJSON形式のデータの移行」をご参照ください。異なる文字の意味:
  - $: ルートノードを示します。
  - . または ['']: 子ノードを示します。 MaxComputeは、を使用してJSONオブジェクトを解析します。 または [''] JSONオブジェクトのキーにピリオド (.) が含まれている場合は、[''] を使用できます。
  - [] ([number] ): 0から始まる配列の下付き文字を示します。
  - *: [] のワイルドカードを示します。この文字をpathパラメーターで使用すると、配列全体が返されます。アスタリスク (*) はエスケープできません。
制限事項
MaxCompute V2.0のみが、pathパラメーターで [''] を使用してデータを抽出できます。 [''] を使用するには、実行するステートメントの前にset odps.sql.udf.getjsonobj.new=true; ステートメントを追加する必要があります。
戻り値
- jsonパラメーターが空または無効の場合、nullが返されます。
- jsonの形式が有効で、pathが存在する場合、関連する文字列が返されます。
- セッションにflagodps.sql.udf.getjsonobj.newパラメーターを指定して、この関数が値を返す方法を決定できます。
  - set odps.sql.udf.getjsonobj.new=true; ステートメントを実行すると、この関数は値を返すときに元の文字列を保持します。
    より標準的な関数の戻り動作になるため、この設定を使用することをお勧めします。これにより、データ処理が容易になり、データ処理パフォーマンスが向上します。この関数がJSON予約文字をエスケープするジョブがMaxComputeプロジェクトに存在する場合は、元のエスケープ操作を保持して、検証不足によるエラーを防ぐことを推奨します。この関数は、値を返すときに次のルールに従います。
    - この設定では、戻り値はJSON文字列のままで、JSONデータとして解析できます。REPLACEまたはREGEXP_REPLACE関数を使用してバックスラッシュ (\) を置き換える必要はありません。
    - JSONオブジェクトでは、重複キーが許可されます。重複キーが存在する場合、データを解析することができる。
      -- The return value is 1. select get_json_object('{"a":"1","a":"2"}', '$.a');
    - 絵文字に対応するエンコードされた文字列がサポートされます。ただし、DataWorksでは絵文字を入力できません。 DataWorksでは、Data Integrationなどのツールを使用して、絵文字に対応するエンコードされた文字列のみをMaxComputeに入力できます。 DataWorksはGET_JSON_OBJECT関数を使用してデータを処理します。
      -- The return value is an emoji. select get_json_object('{"a":"<Emoji>"}', '$.a');
    - 出力結果はアルファベット順に表示されます。
      -- The return value is {"b":"1","a":"2"}. select get_json_object('{"b":"1","a":"2"}', '$');
  - set odps.sql.udf.getjsonobj.new=false; 文を実行すると、この関数は値を返すときにJSON予約文字をエスケープします。この関数は、値を返すときに次のルールに従います。
    - 改行 (\n) や引用符 (") などのJSON予約文字は、'\n' および '\" 'として表示されます。
    - JSONオブジェクトの各キーは一意である必要があります。重複するキーが存在する場合、データの解析に失敗する可能性があります。例：
```
-- The return value is null. 
select get_json_object('{"a":"1","a":"2"}', '$.a');
```
    - 絵文字に対応するエンコードされた文字列は解析できません。例：
```
-- The return value is null. 
select get_json_object('{"a":"<Emoji>"}', '$.a');
```
    - 出力結果はアルファベット順に表示されます。例：
```
-- The return value is {"a":"2","b":"1"}. 
select get_json_object('{"b":"1","a":"2"}', '$');
```
  説明
  2021年1月21日以降に作成されたMaxComputeプロジェクトの場合、GET_JSON_OBJECT関数は値を返すときに元の文字列を保持します。 2021年1月21日より前に作成されたMaxComputeプロジェクトの場合、GET_JSON_OBJECT関数は値を返すときにJSON予約文字をエスケープします。次の例は、GET_JSON_OBJECT関数がMaxComputeプロジェクトで値を返す方法を決定するのに役立ちます。
```
select get_json_object('{"a":"[\\"1\\"]"}', '$.a');
-- Return JSON reserved characters by using escape characters.
[\"1\"]

-- Return the original strings.
["1"]
```
  アプリケーションを送信するか、DingTalkグループID 11782920を検索してMaxCompute開発者コミュニティDingTalkグループに参加し、MaxComputeテクニカルサポートエンジニアにGET_JSON_OBJECT関数を設定して元の文字列を保持するように依頼できます。このように、セッションに対してset odps.sql.udf.getjsonobj.new=false; を頻繁に指定する必要はありません。

例

例1: JSONオブジェクトsrc_json.jsonから情報を抽出します。例：

-- The JSON string src_json.json contains the following content: 
+----+
json
+----+
{"store":
{"fruit":[{"weight":8,"type":"apple"},{"weight":9,"type":"pear"}],
"bicycle":{"price":19.95,"color":"red"}
},
"email":"amy@only_for_json_udf_test.net",
"owner":"amy"
}
-- Extract the information of the owner field and return amy. 
select get_json_object(src_json.json, '$.owner') from src_json;
-- Extract the information of the first array in the store.fruit field and return {"weight":8,"type":"apple"}. 
select get_json_object(src_json.json, '$.store.fruit[0]') from src_json;
-- Extract the information of the non-existent field and return null. 
select get_json_object(src_json.json, '$.non_exist_key') from src_json;

例2: ARRAY型のJSONオブジェクトから情報を抽出します。例：

-- The return value is 2222. 
select get_json_object('{"array":[["aaaa",1111],["bbbb",2222],["cccc",3333]]}','$.array[1][1]');
-- The return value is ["h0","h1","h2"]. 
set odps.sql.udf.getjsonobj.new=true;
select get_json_object('{"aaa":"bbb","ccc":{"ddd":"eee","fff":"ggg","hhh":["h0","h1","h2"]},"iii":"jjj"}','$.ccc.hhh[*]');
-- The return value is ["h0","h1","h2"]. 
set odps.sql.udf.getjsonobj.new=false;
select get_json_object('{"aaa":"bbb","ccc":{"ddd":"eee","fff":"ggg","hhh":["h0","h1","h2"]},"iii":"jjj"}','$.ccc.hhh');
-- The return value is h1. 
select get_json_object('{"aaa":"bbb","ccc":{"ddd":"eee","fff":"ggg","hhh":["h0","h1","h2"]},"iii":"jjj"}','$.ccc.hhh[1]');

例3: ピリオド (.) を含むJSONオブジェクトから情報を抽出します。例：

-- Create a table. 
create table mf_json (id string, json string);
-- Insert data into the table. The key in the data contains a period (.). 
insert into table mf_json (id, json) values ("1", "{
\"China.beijing\":{\"school\":{\"id\":0,\"book\":[{\"title\": \"A\",
\"price\": 8.95},{\"title\": \"B\",\"price\": 10.2}]}}}");
-- Insert data into the table. The key in the data does not contain a period (.). 
insert into table mf_json (id, json) values ("2", "{
\"China_beijing\":{\"school\":{\"id\":0,\"book\":[{\"title\": \"A\",
\"price\": 8.95},{\"title\": \"B\",\"price\": 10.2}]}}}");
-- Query the value of id in the JSON object whose key is China.beijing. 0 is returned. Only [''] can be used to specify the key because the key contains a period (.). This way, MaxCompute can parse the key. 
select get_json_object(json, "$['China.beijing'].school['id']") from mf_json where id =1;
-- Query the value of id in the JSON object whose key is China_beijing. 0 is returned. You can use one of the following statements: 
select get_json_object(json, "$['China_beijing'].school['id']") from mf_json where id =2;
select get_json_object(json, "$.China_beijing.school['id']") from mf_json where id =2;

例4: jsonパラメーターが空または無効です。例：

-- The return value is null. 
select get_json_object('','$.array[1][1]');
-- The return value is null. 
select get_json_object('"array":["aaaa",1111],"bbbb":["cccc",3333]','$.array[1][1]');

例5: JSON文字列のエスケープ例：

set odps.sql.udf.getjsonobj.new=true;
-- The return value is "1". 
select get_json_object('{"a":"\\"1\\"","b":"2"}', '$.a'); 
-- The return value is '1'. 
select get_json_object('{"a":"\'1\'","b":"2"}', '$.a');

INDEX

構文
```
index(<var1>[<var2>])
```
説明
- var1がmap<K, V> 型の場合、この関数はvar1のvar2の位置にある要素を取得します。要素の位置番号は左から右に数え、0から始まります。
- var1がmap<K, V> 型の場合、この関数はキーがvar1のvar2である値を取得します。
説明
この関数を使用する場合は、indexを削除し、<var1>[<var2>] を直接実行する必要があります。それ以外の場合は、エラーが返されます。
パラメーター
- var1: 必須です。値は、array<T> 型またはmap<K, V> 型である必要があります。 array<T> のTは、配列内の要素のデータ型を指定します。要素は任意のデータ型にすることができます。 map<K, V> のKとVは、マップのキーと値を指定します。
- var2: 必須です。
  - var1がarray<T> 型の場合、var2はBIGINT型で、0以上でなければなりません。
  - var1がmap<K, V> 型の場合、var2はKと同じデータ型である必要があります。
戻り値
- var1がarray<T> 型の場合、Tで指定されたデータ型の値が返されます。戻り値は、次のルールによって異なります。
  - var1の要素数がvar2未満の場合、nullが返されます。
  - var1がnullの場合、nullが返されます。
- var1がmap<K, V> 型の場合、Vで指定されたデータ型の値が返されます。戻り値は、次のルールによって異なります。
  - map<K, V> に値がvar2のキーが含まれていない場合、nullが返されます。
  - var1がnullの場合、nullが返されます。

例

例1: var1はarray<T> タイプです。例：

-- The return value is c. 
select array('a','b','c')[2];

例2: var1はmap<K, V> タイプです。例：

-- The return value is 1. 
select str_to_map("test1=1,test2=2")["test1"];

INLINE

構文

inline(array<struct<f1:T1, f2:T2[, ...]>>)

説明
特定のstruct配列を展開します。各配列要素は行に対応し、各struct要素は各行の列に対応する。
パラメーター
f1:T1およびf2:T2: 必須。任意のデータ型の値。 f1およびf2はメンバ変数を指定し、T1はf1の値を指定し、T2はf2の値を指定する。
戻り値
struct配列の展開データが返されます。

例

t_tableテーブルは、t_struct (STRUCT<user_id:BIGINT,user_name:STRING,married:STRING,weight:DOUBLE>) フィールドを含む。テーブル内のデータ:

+----------+
| t_struct |
+----------+
| {user_id:10001, user_name:LiLei, married:N, weight:63.5} |
| {user_id:10002, user_name:HanMeiMei, married:Y, weight:43.5} |
+----------+

例：

-- Expand the t_struct column. 
select inline(array(t_struct)) from t_table;
-- The following result is returned: 
+------------+-----------+---------+------------+
| user_id    | user_name | married | weight     |
+------------+-----------+---------+------------+
| 10001      | LiLei     | N       | 63.5       |
| 10002      | HanMeiMei | Y       | 43.5       |
+------------+-----------+---------+------------+

JSON_TUPLE

構文

string json_tuple(string <json>, string <key1>, string <key2>,...)

説明
(key1,key2,...) などの一連の入力キーに基づいて、標準のJSON文字列から文字列を抽出します。
パラメーター
- json: 必須です。 STRING型の値。このパラメーターは、標準のJSON文字列を指定します。
- key: 必須です。 STRING型の値。このパラメーターは、JSON文字列でJSONオブジェクトのパスを記述するために使用されます。値はドル記号 ($) で始めることはできません。一度に複数のキーを入力できます。 MaxComputeは、を使用してJSONオブジェクトを解析します。 または [''] JSONオブジェクトのキーにピリオド (.) が含まれている場合、[''] を使用できます。
戻り値
STRING型の値が返されます。
説明
- jsonが空または無効の場合、nullが返されます。
- keyが空、無効、またはJSON文字列に存在しない場合、nullが返されます。
- jsonが有効でキーが存在する場合、関連する文字列が返されます。
- この関数は、漢字を含むJSONデータを解析できます。
- この関数は、ネストされたJSONデータを解析できます。
- この関数は、ネストされた配列を含むJSONデータを解析できます。
- 解析アクションは、set odps.sql.udf.getjsonobj.new=true; を伴うGET_JSON_OBJECTの実行と同等です。 JSON文字列から複数のオブジェクトを取得するには、GET_JSON_OBJECT関数を複数回呼び出す必要があります。その結果、JSON文字列は複数回解析されます。 JSON_TUPLE関数を使用すると、一度に複数のキーを入力でき、JSON文字列は1回だけ解析されます。 JSON_TUPLEはGET_JSON_OBJECTよりも効率的です。
- JSON_TUPLEは、ユーザー定義のテーブル値関数 (UDTF) です。テーブルからいくつかの列を選択する場合は、LATERAL VIEW句とともにJSON_TUPLEを使用します。

JSON_オブジェクト

構文

json json_object(<key1>,<value1>[,<keyn>,<valuen>])

説明
キーと値のペアを含むJSONオブジェクトを返します。
パラメーター
- key: 少なくとも1つのキーを指定する必要があります。キーはSTRING型でなければなりません。
- value: 少なくとも1つの値を指定する必要があります。値は、STRING、BIGINT、INT、またはBOOLEAN型である必要があります。
戻り値
戻り値はJSON型です。
例
- 例1: キーと値のペアを1つだけ含むJSONオブジェクトを生成します。
```
-- Generate a JSON object.
select json_object('a', 123);
```
  次の応答が返されます。
```
+-----+
| _c0 |
+-----+
| {"a":123} |
+-----+
```
- 例2: 複数のキーと値のペアを含むJSONオブジェクトを生成します。
```
-- Generate a JSON object.
select json_object('a', 123,'b','hello');
```
  次の応答が返されます。
```
+-----+
| _c0 |
+-----+
| {"a":123,"b":"hello"} |
+-----+
```

JSON_ARRAY

構文
```
json json_array(<element>)
```
説明
空の可能性のある値のリストを評価し、これらの値を含むJSON配列を返します。
パラメーター
要素: 必須です。このパラメーターで指定するリストの値は、STRING、BIGINT、BOOLEAN、またはJSON型である必要があります。
戻り値
戻り値はJSON型です。

例

-- Generate a JSON array.
select json_array('a', 45, true, 13, json '{"a":456}');

次の応答が返されます。

+-----+
| _c0 |
+-----+
| ["a",45,true,13,{"a":456}] |
+-----+

JSON_EXPLODE

構文
```
JSON_EXPLODE(JSON <var>)
```
説明
JSON配列またはJSONオブジェクトの各要素を複数の出力行に拡張できます。
パラメーター
var: 必須です。 JSON_ARRAYまたはJSON_OBJECTタイプをサポートします。 JSON定数、JSON STRING、JSON NUMBER、JSON BOOLEAN、およびNULL型はサポートされません。
戻り値
この関数は、次の形式で変換された行を返します。
```
+-------+-------+
|  KEY  | VALUE |
|-------+-------|
```
- JSON ARRAY型varの場合、JSON ARRAYの最も外側は、KEYをNULL、VALUEを配列要素として、JSONデータの複数の行に展開されます。
- JSON OBJECT型varの場合、JSON OBJECTの最も外側の各KEY-VALUEペアは、2つの列を持つ行に拡張されます。STRING型KEY列はJSON OBJECTのKEYであり、JSON型VALUE列はJSON OBJECTのVALUEです。

例

table_jsonという名前のテーブルを作成し、そこにデータを挿入します。1行目はJSON OBJECT型、2行目はJSON ARRAY型です。

-- Create table
CREATE TABLE table_json(c1 json);
-- Insert data
INSERT INTO table_json(c1) SELECT JSON_OBJECT('a', 123,'b','hello');
INSERT INTO table_json(c1) SELECT JSON_ARRAY(1, true, 2, json'{"a":456}');
-- View table data
SELECT * FROM table_json;

クエリは次の結果を返します。

+-----------------------------+
| c1                            |
+-------------------------------+
| {"a":123,"b":"hello"}         |
| [1,true,2,{"a":456}]          |
+-------------------------------+

JSON_EXPLODE関数は、JSON配列またはJSONオブジェクトの各要素を複数の出力行に展開します。以下はサンプルコードです:

SELECT JSON_EXPLODE(table_json.c1) FROM table_json;

クエリは次の結果を返します。

+-----+------------+
| key | value      |
+-----+------------+
| \N  | 1          |
| \N  | true       |
| \N  | 2          |
| \N  | {"a":456}  |
| a   | 123        |
| b   | hello      |
+-----+------------+

説明

JSONデータを変換するとき、同じJSONデータ内の要素は元のシーケンスを維持します。ただし、複数のJSONデータエントリの順序は異なる場合があります。

JSON_EXTRACT

構文
```
json json_extract(<json>, <json_path>)
```
説明
json_pathの値をJSON式で解析します。 json_pathの値が無効な場合はエラーが返されます。
パラメーター
- json: 必須です。このパラメーターは、処理するJSON式を指定します。
- json_path: 必須です。このパラメーターは、返される値のJSONパスを指定します。
戻り値
戻り値はJSON型です。
例
- 例1: JSONオブジェクトからキーaの値を取得します。
```
select json_extract(json '{"a":1, "b":2}', '$.a');
```
  次の応答が返されます。
```
+-----+
| _c0 |
+-----+
| 1   |
+-----+
```
- 例2: 指定されたキーがJSONオブジェクトに存在しない場合はNULLが返されます。
```
select json_extract(json '{"a":1, "b":2}', 'strict $.c');
```
  次の応答が返されます。
```
+-----+
| _c0 |
+-----+
| NULL |
+-----+
```
- 例3: 指定したjsonパスが無効な場合、エラーメッセージInvalid引数-Param JSON path $invalid_json_path is invalidが返されます。
```
select json_extract(json '{"a":1, "b":2}', '$a');
```
  次の応答が返されます。
```
-- An error message is returned.
Invalid argument - Param json path $invalid_json_path is invalid
```

JSON_EXISTS

構文

boolean json_exists(<json>, <json_path>)

説明
json_pathのJSON値が存在するかどうかを判断します。
パラメーター
- json: 必須です。このパラメーターは、処理するJSON式を指定します。
- json_path: 必須です。このパラメーターは、特定のJSON値がチェックされるJSONパスを指定します。
戻り値
戻り値はtrueまたはfalseで、BOOLEAN型です。
例
- 例1: キーaの値がJSONオブジェクトに存在するかどうかを確認します。
```
select json_exists(json '{"a":1, "b":2}', '$.a');
```
  次の応答が返されます。
```
+------+
| _c0  |
+------+
| true |
+------+
```
- 例2: キーcの値がJSONオブジェクトに存在するかどうかを確認します。
```
select json_exists(json '[1,2, {"a":34}]', '$[2].a');
```
  次の応答が返されます。
```
+------+
| _c0  |
+------+
| true |
+------+
```
- 例3: 特定の下付き文字に基づいて取得された値が存在するかどうかを確認します。
```
select json_exists(json '{"a":1, "b":2}', 'strict $.c');
```
  次の応答が返されます。
```
+------+
| _c0  |
+------+
| false |
+------+
```

JSON_PRETTY

構文
```
string json_pretty(<json>)
```
説明
改行とスペースを追加することで読みやすい形式のJSON値を返します。
パラメーター
json: 必須です。このパラメーターは、処理するJSON式を指定します。
戻り値
戻り値はSTRING型です。

例

-- Beautify a JSON object.
select json_pretty(json '{"a":1, "b":2}');

次の応答が返されます。

+-----+
| _c0 |
+-----+
| {
    "a":1,
    "b":2
} |
+-----+

JSON_TYPE

構文

string|number|boolean|null|object|array json_type(<json>)

説明
JSON値のデータ型を返します。
パラメーター
json: 必須です。処理するJSON式。
戻り値
STRING型の値が返されます。
例
- 例1: JSON値のARRAY型を返します。
```
select json_type(json '[{"a":1}, 23]');
```
  次の応答が返されます。
```
+-----+
| _c0 |
+-----+
| array |
+-----+
```
- 例2: JSON値の数値データ型を返します。
```
select json_type(json '123');
```
  次の応答が返されます。
```
+-----+
| _c0 |
+-----+
| number |
+-----+
```
- 例3: JSON値のSTRING型を返します。
```
select json_type(json '"123"');
```
  次の応答が返されます。
```
+-----+
| _c0 |
+-----+
| string |
+-----+
```

JSON_フォーマット

構文
```
string json_format(<json>)
```
説明
JSONデータ型の値をSTRINGデータ型の値に変換します。デフォルトでは、JSONデータは自動的にプリティファイされません。
パラメーター
json: 必須です。このパラメーターは、変換するJSONデータを指定します。
戻り値
戻り値はSTRING型です。
例
- 例1: JSON NUMBERデータを文字列に変換します。
```
select json_format(json '123');
```
  次の応答が返されます。
```
+-----+
| _c0 |
+-----+
| 123 |
+-----+
```
- 例2: JSON STRINGデータを文字列に変換します。
```
select json_format(json '"123"');
```
  次の応答が返されます。
```
+-----+
| _c0 |
+-----+
| "123" |
+-----+
```

JSON_PARSE

構文
```
json json_parse(<string>)
```
説明
STRINGデータ型の値をJSONデータ型の値に変換します。非JSON形式の値がSTRINGデータ型の値に変換された場合、エラーが返されます。
パラメーター
string: 必須です。このパラメータは、処理する文字列を指定します。
戻り値
戻り値はJSON型です。
例
- 例1: 文字列をJSON型のデータに変換します。
```
select json_parse('{"a":1, "b":2}');
```
  次の応答が返されます。
```
+-----+
| _c0 |
+-----+
| {"a":1,"b":2} |
+-----+
```
- 例2: 文字列をJSON型のデータに変換します。
```
select json_parse('"abc"');
```
  次の応答が返されます。
```
+-----+
| _c0 |
+-----+
| "abc" |
+-----+
```
- 例3: 無効な文字列をJSON型のデータに変換します。エラーが報告されます。
```
select json_parse('abc');
```
  次の応答が返されます。
```
Invalid input syntax for type json, detail:Token "abc" is invalid.
```

JSON_VALID

構文
```
boolean json_valid(<string>)
```
説明
文字列が有効なJSON形式であるかどうかを決定します。
パラメーター
string: 必須です。このパラメーターは、処理するJSON文字列を指定します。
戻り値
戻り値はtrueまたはfalseで、BOOLEAN型です。
例
- 例1: "abc" が有効なJSON文字列であるかどうかを確認します。
```
select json_valid('"abc"');
```
  次の応答が返されます。
```
+------+
| _c0  |
+------+
| true |
+------+
```
- 例2: abcが有効なJSON文字列であるかどうかを確認します。
```
select json_valid('abc');
```
  次の応答が返されます。
```
+------+
| _c0  |
+------+
| false |
+------+
```

キャスト

構文

json/string/bigint/int/tinyint/smallint/double/float/boolean/sql-type 
cast(json as string/
     string as json/
     json as bigint/
     bigint as json/
     json as int/
     int as json/
     json as tinyint/
     tinyint as json/
     json as smallint/
     smallint as json/
     json as double/
     double as json/
     json as float/
     float as json/
     boolean as json/
     json as boolean/
     null as json/
     json 'null' as ...
     )

説明
基本データ型とJSONデータ型間の変換をサポートします。
パラメーター
- JSON、STRING、BIGINT、INT、TINYINT、SMALLINT、DOUBLE、FLOAT、BOOLEAN、およびSQL-TYPEのデータ型がサポートされています。
- JSONデータをSTRINGデータ型のデータに変換するには、JSONデータにARRAYまたはOBJECTデータ型の値が含まれていないことを確認する必要があります。
- STRINGデータ型のデータをJSONデータに変換すると、出力されたJSONデータにはSTRINGデータ型の値のみが含まれます。 CAST関数とJSON_PARSEおよびJSON_FORMAT関数の次の違いに注意してください。
  - JSON_PARSE関数を使用して、有効なJSON文字列のみをJSONデータ (JSONオブジェクト) に変換できます。
  - CAST関数を使用して、任意の文字列をstringデータ型の値を含むJSON文字列に変換できます。
- JSONの「null」値と共通のnull値は、SQLのnull値に変換されます。
戻り値
JSONデータまたは特定の基本データ型のデータが返されます。

例

例1: STRINGデータ型とJSONデータ型の間の変換を実行します。

-- Convert a JSON number into a value of the STRING type.
select cast(json '123' as string);
-- The following result is returned:
+-----+
| _c0 |
+-----+
| 123 |
+-----+

-- Convert a JSON string into a value of the STRING type.
select cast(json '"abc"' as string);
-- The following result is returned:
+-----+
| _c0 |
+-----+
| abc |
+-----+

-- Convert a JSON boolean into a value of the STRING type.
select cast(json 'true' as string); 
-- The following result is returned:
+-----+
| _c0 |
+-----+
| TRUE |
+-----+

-- Convert JSON 'null' into a null value of the STRING type.
select cast(json 'null' as string);
-- The following result is returned:
+-----+
| _c0 |
+-----+
| NULL |
+-----+

-- Convert a string into a value of a JSON type.
select cast('{"a":2}' as json); 
-- The following result is returned:
+-----+
| _c0 |
+-----+
| "{\"a\":2}" |
+-----+


-- Incorrect sample statement. Convert JSON expressions of the ARRAY or OBJECT type into values of the STRING type. 
select cast(json '{"a":2}' as string);
-- An error is returned.
FAILED: ODPS-0123091:Illegal type cast - Unsupported cast from json array/object to string

例2: NUMBERデータ型とJSONデータ型の間の変換を実行します。

-- Convert a JSON number into a value of the BIGINT type.
select cast(json '123' as bigint);
-- The following result is returned:
+------------+
| _c0        |
+------------+
| 123        |
+------------+

-- Convert a JSON number into a value of the FLOAT type.
select cast(json '"1.23"' as float);
-- The following result is returned:
+------+
| _c0  |
+------+
| 1.23 |
+------+

-- Convert a JSON number into a value of the DOUBLE type.
select cast(json '1.23' as double);
-- The following result is returned:
+------------+
| _c0        |
+------------+
| 1.23       |
+------------+

-- Convert a value of the INT type into a JSON number.
select cast(123 as json);
-- The following result is returned:
+-----+
| _c0 |
+-----+
| 123 |
+-----+

-- Convert a value of the FLOAT type into a JSON number.
select cast(1.23 as json);
-- The following result is returned:
+-----+
| _c0 |
+-----+
| 1.23 |
+-----+

例3: BOOLEANデータ型とJSONデータ型の間の変換を実行します。

-- Convert a value of the BOOLEAN type into the BIGINT type.
select cast(true as json);
-- The following result is returned:
+-----+
| _c0 |
+-----+
| true |
+-----+

-- Convert a JSON boolean into a value of the BOOLEAN type.
select cast(json 'false' as boolean);
-- The following result is returned:
+------+
| _c0  |
+------+
| false |
+------+

-- Convert a JSON string into a value of the BOOLEAN type.
select cast(json '"abc"' as boolean);
-- The following result is returned:
+------+
| _c0  |
+------+
| true |
+------+

-- Convert a JSON array or JSON object into the BOOLEAN type.
select cast(json '[1,2]' as boolean);
-- An error is returned.
Unsupported cast from json array/object to boolean

例4: null値とJSONデータ型の値の間の変換を実行します。

-- Convert a null value into a value of the STRING type.
select json_type(cast(null as json));
-- The following result is returned:
+-----+
| _c0 |
+-----+
| NULL |
+-----+

MAP

構文

map(K, V) map(K <key1>, V <value1>, K <key2>, V <value2>[, ...])

説明
指定されたキーと値のペアに基づいてマップを作成します。
パラメーター
- key: 必須です。暗黙的な変換の後、すべてのキーは同じデータ型である必要があります。基本データ型のみがサポートされています。
- value: 必須です。すべての値は同じデータ型であるか、暗黙的な変換後に同じデータ型である必要があります。 DECIMAL以外のデータ型がサポートされています。
戻り値
MAPタイプの値が返されます。
説明
セッションレベルでodps.sql.map.key.de dup.policyパラメーターを設定して、重複キーの処理に使用する方法を指定できます。有効な値：
- exception: エラーが返されます。
- last_win: 後者のキーは前者のキーを上書きします。
パラメーターを指定しない場合、デフォルト値last_winが使用されます。

例

例1: 重複するキーが存在しない。 t_tableテーブルは、c1 (BIGINT) 、c2 (STRING) 、c3 (STRING) 、c4 (BIGINT) 、およびc5 (BIGINT) 列を含む。テーブル内のデータ:

+------------+----+----+------------+------------+
| c1         | c2 | c3 | c4         | c5         |
+------------+----+----+------------+------------+
| 1000       | k11 | k21 | 86         | 15         |
| 1001       | k12 | k22 | 97         | 2          |
| 1002       | k13 | k23 | 99         | 1          |
+------------+----+----+------------+------------+

例：

-- Define a map based on the key-value pairs between the c2 and c4 columns, and between the c3 and c5 columns. 
select map(c2,c4,c3,c5) from t_table;
-- The following result is returned: 
+------+
| _c0  |
+------+
| {k11:86, k21:15} |
| {k12:97, k22:2} |
| {k13:99, k23:1} |
+------+

例2: 重複キーが存在します。 t_tableテーブルは、c1 (BIGINT) 、c2 (STRING) 、c3 (STRING) 、c4 (BIGINT) 、およびc5 (BIGINT) 列を含む。テーブル内のデータ:

1000,'k11','k11',86,15
1001,'k12','k22',97,2
1002,'k13','k23',99,1
1003,'k13','k24',100,1
1004,'k12','k25',95,1

例：

-- Define a map based on the key-value pairs between the c2 and c4 columns, and between the c3 and c5 columns. 
select map(c2,c4,c3,c5) from t_table;
-- The following result is returned: 
+------+
| _c0  |
+------+
| {'k11':15} |
| {'k12':97, 'k22':2} |
| {'k13':99, 'k23':1} |
| {'k13':100, 'k24':1} |
| {'k12':95, 'k25':1} |
+------+

MAP_CONCAT

構文

map<K, V> map_concat([string <mapDupKeyPolicy>,] map<K, V> <a>, map<K, V> <b>[,...])

説明
複数のマップの和集合を計算します。
パラメーター
- mapDupKeyPolicy: オプション。 STRING型の値。このパラメーターは、重複キーの処理に使用されるメソッドを指定します。有効な値：
  - exception: エラーが返されます。
  - last_win: 後者のキーは前者のキーを上書きします。
  セッションレベルでodps.sql.map.key.de dup.policyパラメーターを指定して、重複キーの処理に使用されるメソッドを構成することもできます。たとえば、odps.sql.map.key.de dup.policyを例外に設定できます。このパラメーターを指定しない場合、デフォルト値last_winが使用されます。
  説明
  MaxComputeの動作実装は、mapDupKeyPolicyに基づいて決定されます。 mapDupKeyPolicyを指定しない場合、odps.sql.map.key.de dup.policyの値が使用されます。
- aおよびb: 必須。これらのパラメータはマップを指定する。マップのキーは同じデータ型である必要があり、マップの値は同じデータ型である必要があります。 map<K, V> のKとVは、マップのキーと値を指定します。
戻り値
MAPタイプの値が返されます。戻り値は、次のルールによって異なります。
- マップがnullまたはマップのキーがnullです。
- 複数のマップのデータ型は異なります。

例

-- The return value is {1:a, 2:b, 3:c}. 
select map_concat(map(1, 'a', 2, 'b'), map(3, 'c'));
-- The return value is {1:a, 2:d, 3:c}. 
select map_concat('last_win', map(1, 'a', 2, 'b'), map(3, 'c'), map(2, 'd'));

MAP_ENTRIES

構文

array<struct<K, V>> map_entries(map<K, V> <a>):

説明
Map aのキーと値のペアを構造体配列に変換します。
パラメーター
a: 必須です。このパラメータは、マップを指定します。 map<K, V> のKとVは、マップのキーと値を指定します。
戻り値
構造体配列が返されます。入力がnullの場合、nullが返されます。

例

-- The return value is [{key:1, value:a}, {key:2, value:b}]. 
select map_entries(map(1,  'a',  2,  'b'));

MAP_FILTER

構文

map<K, V> map_filter(map<K, V> <input>, function <K, V, boolean> <predicate>)

説明
Map inputの要素をフィルター処理し、述語条件を満たす要素のみを保持します。
パラメーター
- input: 必須です。 MAPタイプの値。 map<K, V> のKとVは、マップのキーと値を指定します。
- 述語: 必須です。このパラメーターには、マップ内の要素をフィルター処理するために使用される組み込み関数、ユーザー定義関数、または式を指定します。述語条件は、入力中のキーおよび値に対応する2つの入力パラメータからなる。出力結果はBOOLEANタイプです。
戻り値
MAPタイプの値が返されます。

例

-- The return value is {-30:100, 20:50}. 
select map_filter(map(10, -20, 20, 50, -30, 100, 21, null), (k, v) -> (k+v) > 10);

MAP_FROM_ARRAYS

構文

map<K, V> map_from_arrays([string <mapDupKeyPolicy>,] array<K> <a>, array<V> <b>))

説明
配列aと配列bに基づいてマップを作成します。
パラメーター
- mapDupKeyPolicy: オプション。 STRING型の値。このパラメーターは、重複キーの処理に使用されるメソッドを指定します。有効な値：
  - exception: エラーが返されます。
  - last_win: 後者のキーは前者のキーを上書きします。
  セッションレベルでodps.sql.map.key.de dup.policyパラメーターを指定して、重複キーの処理に使用されるメソッドを構成することもできます。たとえば、odps.sql.map.key.de dup.policyを例外に設定できます。このパラメーターを指定しない場合、デフォルト値last_winが使用されます。
  説明
  MaxComputeの動作実装は、mapDupKeyPolicyに基づいて決定されます。 mapDupKeyPolicyを指定しない場合、odps.sql.map.key.de dup.policyの値が使用されます。
- a: 必須です。このパラメーターは、配列を指定します。このパラメーターは、生成されたマップのキーに対応します。 array<K> のKは、配列内の要素のデータ型を指定します。要素は任意のデータ型にすることができます。
- b: 必須です。このパラメーターは、配列を指定します。このパラメーターは、生成されたマップの値に対応します。 array<V> のVは、配列内の要素のデータ型を指定します。要素は任意のデータ型にすることができます。
戻り値
MAPタイプの値が返されます。戻り値は、次のルールによって異なります。
- 配列aまたは配列bがnullの場合、nullが返されます。
- Array aにnull要素が含まれている場合、または2つの配列の長さが異なる場合は、エラーが返されます。

例

-- The return value is {1:2, 3:4}. 
select map_from_arrays(array(1.0, 3.0), array('2', '4'));
-- The return value is {1:2, 3:6}. 
select map_from_arrays('last_win', array(1.0, 3.0, 3), array('2', '4', '6'));

MAP_FROM_ENTRIES

構文

map<K, V> map_from_entries([string <mapDupKeyPolicy>,] array <struct<K, V> , struct<K, V>[,...]>)

説明
指定されたstruct配列に基づいてマップを作成します。
パラメーター
- mapDupKeyPolicy: オプション。 STRING型の値。このパラメーターは、重複キーの処理に使用されるメソッドを指定します。有効な値：
  - exception: エラーが返されます。
  - last_win: 後者のキーは前者のキーを上書きします。
  セッションレベルでodps.sql.map.key.de dup.policyパラメーターを指定して、重複キーの処理に使用されるメソッドを構成することもできます。たとえば、odps.sql.map.key.de dup.policyを例外に設定できます。このパラメーターを指定しない場合、デフォルト値last_winが使用されます。
  説明
  MaxComputeの動作実装は、mapDupKeyPolicyに基づいて決定されます。 mapDupKeyPolicyを指定しない場合、odps.sql.map.key.de dup.policyの値が使用されます。
- この関数の入力パラメータは、STRUCT型である。 Kは、生成されたマップ内のキーに対応する。 Vは、生成されたマップの値に対応する。 struct<K, V> のKとVは、struct配列のキーと値を指定します。
戻り値
MAPタイプの値が返されます。戻り値は、次のルールによって異なります。
- struct配列がnullの場合、nullが返されます。
- struct配列のフィールド数が2でない場合、またはstruct配列のkeyがnullの場合、エラーが返されます。

例

-- The return value is {1:a, 2:b}. 
select map_from_entries(array(struct(1, 'a'), struct(2, 'b')));
-- The return value is {1:a, 2:c}. 
select map_from_entries(array(struct(1, 'a'), struct(2, 'b'), struct(2, 'c')));

MAP_KEYS

構文
```
array<K> map_keys(map<K, V> <a>)
```
説明
Map aのすべてのキーを配列として返します。
パラメーター
a: 必須です。このパラメータは、マップを指定します。 map<K, V> のKとVは、マップのキーと値を指定します。
戻り値
ARRAY型の値が返されます。入力マップがnullの場合、nullが返されます。

例

t_table_mapテーブルは、c1 (BIGINT) およびt_map (map <STRING,BIGINT>) 列を含む。テーブル内のデータ:

+------------+-------+
| c1         | t_map |
+------------+-------+
| 1000       | {k11:86, k21:15} |
| 1001       | {k12:97, k22:2} |
| 1002       | {k13:99, k23:1} |
+------------+-------+

例：

-- Return keys in the t_map column as an array. 
select c1, map_keys(t_map) from t_table_map;
-- The following result is returned: 
+------------+------+
| c1         | _c1  |
+------------+------+
| 1000       | [k11, k21] |
| 1001       | [k12, k22] |
| 1002       | [k13, k23] |
+------------+------+

MAP_VALUES

構文
```
array<V> map_values(map<K, V> <a>)
```
説明
Map aのすべての値を配列として返します。
パラメーター
a: 必須です。このパラメータは、マップを指定します。 map<K, V> のKとVは、マップのキーと値を指定します。
戻り値
ARRAY型の値が返されます。入力マップがnullの場合、nullが返されます。

例

t_table_mapテーブルは、c1 (BIGINT) およびt_map (map <STRING,BIGINT>) 列を含む。テーブル内のデータ:

+------------+-------+
| c1         | t_map |
+------------+-------+
| 1000       | {k11:86, k21:15} |
| 1001       | {k12:97, k22:2} |
| 1002       | {k13:99, k23:1} |
+------------+-------+

例：

-- Return keys in the t_map column as an array. 
select c1,map_values(t_map) from t_table_map;
-- The following result is returned: 
+------------+------+
| c1         | _c1  |
+------------+------+
| 1000       | [86, 15] |
| 1001       | [97, 2] |
| 1002       | [99, 1] |
+------------+------+

MAP_ZIP_WITH

構文

<K, V1, V2, V3> map<K, V3> map_zip_with(map<K, V1> <input1>, map<K, V2> <input2>, function<K, V1, V2, V3> <func>)

説明
Map input1とMap input2を新しいマップにマージします。新しいマップのキーは、2つの入力マップのキーの和集合である。新しいマップの各キーの値は、funcを使用して計算されます。
パラメーター
- input1およびinput2: 必須です。このパラメータは、マップを指定します。 map<K, V> のKとVは、マップのキーと値を指定します。
- func: 必須です。 funcは、キーに対応する3つの入力パラメータ、input1のキーに対応する値、およびinput2のキーに対応する値で構成されます。キーがinput1またはinput2に存在しない場合は、funcのキーに対応する値をnullで置き換えます。
戻り値
funcで定義されたデータ型のデータが返されます。

例

-- The return value is {1:[1, 1, 4], 2:[2, 2, 5], 3:[3, null, null], 4:[4, null, 7]}. 
select map_zip_with(map(1, 1, 2, 2, 3, null), map(1, 4, 2, 5, 4, 7), (k, v1, v2) -> array(k, v1, v2));

MULTIMAP_FROM_ENTRIES

構文

	multimap_from_entries(array<struct<K, V>>)

説明
構造体配列のキーとすべての値を含む配列で構成されるマップを返します。
パラメーター
array<struct<K, V>>: キーと値のペアで構成されるstruct配列。
戻り値
構造体配列内のキーとすべての値を含む配列で構成されるマップが返されます。マップはmap<K, array<V>> 形式です。
- 返されたマップの各キーは複数の値に関連付けることができ、関連付けられた値は同じ配列にあります。
- 配列がnullの場合、nullが返されます。
- struct配列のフィールド数が2でない場合、またはキーにnull値が含まれている場合は、エラーが返されます。

例

SELECT multimap_from_entries(array(struct(1, 'a'), 
                                     struct(2, 'b'), 
                                     struct(1, 'c')));

次の応答が返されます。

{1 : ['a', 'c'],  2: ['b']}

NAMED_STRUCT

構文

struct named_struct(string <name1>, T1 <value1>, string <name2>, T2 <value2>[, ...])

説明
指定された名前と値のペアに基づいて構造体を作成します。
パラメーター
- value: 必須です。任意のデータ型の値。
- name: 必須です。 STRING型の列名。このパラメータは定数です。
戻り値
STRUCT型の値が返されます。列は、順番にname1、name2、... と名付けられます。

例

-- The return value is {user_id:10001, user_name:LiLei, married:F, weight:63.5}. 
select named_struct('user_id',10001,'user_name','LiLei','married','F','weight',63.50);

NGRAMS

構文
```
ngrams(array(T), n)
```
説明
指定した配列の要素のn-gram配列を返します。
パラメーター
- array: 入力配列。
- n: 各サブセット内の要素の数。
戻り値
指定した配列の要素のn-gram配列を返します。
n<=0の条件が満たされると、エラーが返されます。

例

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

POSEXPLODE

構文
```
posexplode(array<T> <a>)
```
説明
配列aを2つの列を持つテーブルに変換します。最初の列には、配列内の各要素の位置が0から始まります。 2番目の列は要素をリストします。
パラメーター
a: 必須です。このパラメーターは、配列を指定します。 array<T> のTは、配列内の要素のデータ型を指定します。要素は任意のデータ型にすることができます。
戻り値
テーブルが返されます。

例

select posexplode(array('a','c','f','b'));
-- The following result is returned: 
+------------+------------+
| pos        | val        |
+------------+------------+
| 0          | a          |
| 1          | c          |
| 2          | f          |
| 3          | b          |
+------------+------------+

逆

構文
```
array reverse(array <value>)
```
説明
特定の配列の要素の逆順で配列を返します。
パラメーター
value: 入力配列。
戻り値
入力配列の要素の逆順の配列が返されます。入力値がnullの場合は、nullが返されます。

例

-- The return value is [3, 4, 1, 2].
SELECT reverse(array(2, 1, 4, 3));

シーケンス

構文
```
sequence(start, stop, [step]) -> array
```
説明
式に基づいて指定された要素を含む配列を返します。
パラメーター
- start: 要素のシーケンスの始まりを表す式。シーケンスにはstartが含まれます。
  - startとstopは、TINYINT、SMALLINT、INT、BIGINTの整数型をサポートしています。上記の整数型は、stepでサポートされている型TINYINT、SMALLINT、INT、およびBIGINTに対応しています。
  - startとstopは、date、DATETIME、TIMESTAMPの日付と時刻のタイプをサポートしています。上記の日付と時刻のタイプは、stepでサポートされているIntervalDayTimeまたはIntervalYearMonthタイプに対応しています。
- stop: 要素のシーケンスの終わりを表す式。シーケンスにはstopが含まれます。
- step: オプション。要素のシーケンスのステップサイズ。
  デフォルトでは、startの値がstopの値以下の場合、stepの値は1です。 startの値がstopの値より大きい場合、stepの値は -1です。
  要素のシーケンスが時間型の場合、stepのデフォルト値は1または日数で -1です。 stepを設定するときは、次の点に注意してください。startの値がstopの値より大きい場合は、stepを負の値に設定します。 startの値がstopの値以下の場合は、stepを正の値に設定します。要件が満たされない場合、エラーが返されます。
戻り値
式に基づいて指定された要素を含む配列が返されます。
- startの値がstopの値より大きく、stepの値が正の場合、エラーが返されます。 startの値がstopの値以下で、stepの値が負の場合、エラーが返されます。
- デフォルトでは、SEQUENCE関数は最大10,000個の要素を生成できます。 odps.sql.max.sequence.lengthパラメーターを設定して、生成できる要素の最大数を変更できます。

例

```
SELECT sequence(1, 5);
```
次の応答が返されます。
```
[1, 2, 3, 4, 5]
```
```
SELECT sequence(5, 1);
```
次の応答が返されます。
```
[5, 4, 3, 2, 1] 
```

SELECT sequence(to_date('2018-01-01'), to_date('2018-03-01'), interval 1 month);

次の応答が返されます。

[2018-01-01,  2018-02-01,  2018-03-01]

シャッフル

構文
```
shuffle(array)
```
説明
パラメーター
array: 入力配列。
戻り値
配列の要素をランダムな順序で返します。
- 入力値がnullの場合は、nullが返されます。
- この関数の返される結果は未定義です。

例

SELECT shuffle(array(1, 20, 3, 5));

次の応答が返されます。

[3,1,5,20]

SELECT shuffle(array(1, 20, null, 3));

次の応答が返されます。

[20,null,3,1]

SIZE

構文

int size(array<T> <a>)
int size(map<K, V> <b> )

説明
- 入力としての配列: 配列aの要素数を計算します。
- 入力としてのマップ: マップbのキーと値のペアの数を計算します。
パラメーター
- a: 必須です。このパラメーターは、配列を指定します。 array<T> のTは、配列内の要素のデータ型を指定します。要素は任意のデータ型にすることができます。
- b: 必須です。このパラメータは、マップを指定します。 map<K, V> のKとVは、マップのキーと値を指定します。
戻り値
INT型の値が返されます。
例
- 例1: 配列 ('a' 、'b') の要素数を計算します。例：
```
-- The return value is 2. 
select size(array('a','b'));
```
- 例2: map('a' 、'b' 、'b' 、456) 内のキーと値のペアの数を計算123。
```
-- The return value is 2. 
select size(map('a',123,'b',456)); 
```

スライス

構文

array<T> slice(array<T> <a>, <start>, <length>)

説明
指定した長さに基づいて開始位置から配列内の要素をコピーし、新しい配列として返します。
パラメーター
- a: 必須です。このパラメーターは、配列を指定します。 array<T> のTは、配列内の要素のデータ型を指定します。要素は任意のデータ型にすることができます。
- start: 必須です。このパラメーターは、関数が要素を左から右にコピーし始める位置を指定します。このパラメータの正の最小値は1です。 startパラメーターを負の値に設定することもできます。この場合、開始位置は配列の終わりからカウントされますが、要素はまだ左から右にコピーされます。
- length: 必須。返される配列内の要素の数。値は0以上である必要があります。値が入力配列の長さより大きい場合、この関数は、入力配列の開始位置から終了位置までの要素で構成される新しい配列を返します。
戻り値
ARRAY型の値が返されます。
例
- 例1: 3の長さに基づいて、位置1から配列 (10,20, 20, null, null, 30) の要素をコピーします。例：
```
-- The return value is [10, 20, 20]. 
select slice(array(10, 20, 20, null, null, 30), 1, 3);
```
- 例2: 配列 (10,20, 20, null, null, 30) の要素を、2の長さに基づいて位置 -2からコピーします。例：
```
-- The return value is [null, 30]. 
select slice(array(10, 20, 20, null, null, 30), -2, 2);  
```
- 例3: 10の長さに基づいて、位置3から配列 (10,20, 20, null, null, 30) の要素をコピーする。例：
```
-- The return value is [20, null, null, 30]. 
select slice(array(10, 20, 20, null, null, 30), 3, 10); 
```
- 例4: 0の長さに基づいて、位置3から配列 (10,20, 20, null, null, 30) の要素をコピーする。例：
```
-- The return value is []. 
select slice(array(10, 20, 20, null, null, 30), 3, 0);
```

SORT_ARRAY

構文

array<T> sort_array(array<T> <a>[, <isasc>])

説明
配列内の要素を並べ替えます。
パラメーター
- a: 必須です。このパラメーターは、配列を指定します。 array<T> のTは、配列内の要素のデータ型を指定します。要素は任意のデータ型にすることができます。
- isasc: オプション。このパラメーターは、配列内の要素をソートする順序を指定します。有効な値は、true および false です。値trueは昇順を示し、falseは降順を示します。このパラメーターを指定しない場合、要素は昇順でソートされます。
戻り値
ARRAY型の値が返されます。値nullは最小値として解釈されます。

例

例1: c1 array <STRING> 、c2 ARRAY<INT> 、およびc3 ARRAY<STRING> 列を含むt_ARRAYテーブルのデータをソートします。テーブル内のデータ:

+------------+---------+--------------+
| c1         | c2      | c3           |
+------------+---------+--------------+
| [a, c, f, b]  | [4, 5, 7, 2, 5, 8]  |  [You, Me, Him] |
+------------+---------+--------------+

テーブルの各列のデータをソートします。例：

-- The return value is [a, b, c, f] [2, 4, 5, 5, 7, 8] [Him, Me, You]. 
select sort_array(c1),sort_array(c2),sort_array(c3) from t_array;

例2: 配列 (10、20、40、30、30、null、50) の要素を降順でソートします。例：

-- The return value is [50, 40, 30, 30, 20, 10, null]. 
select sort_array(array(10, 20, 40, 30, 30, null, 50), false);

SPLIT

構文
```
split(<str>, <pat>)
```
説明
strがpatで分割された後の配列を返します。
パラメーター
- str: 必須です。 STRING型の値。このパラメータは、分割する文字列を指定します。
- pat: 必須です。 STRING型の区切り文字。正規表現に対応しています。正規表現の詳細については、「正規表現」をご参照ください。
戻り値
配列が返されます。配列内の要素はSTRING型です。

例

-- The return value is [a, b, c]. 
select split("a, b, c", ",");

STRUCT

構文
```
struct struct(<value1>,<value2>[, ...])
```
説明
指定された値リストに基づいて構造体を作成します。
パラメーター
value: 必須です。任意のデータ型の値。
戻り値
STRUCT型の値が返されます。列は、順にcol1、col2、... と名付けられる。

例

-- The return value is {col1:a, col2:123, col3:true, col4:56.9}. 
select struct('a',123,'true',56.90);

TO_JSON

構文
```
string to_json(<expr>)
```
説明
指定された複合データ型のexprで指定された式をJSON文字列に変換します。
パラメーター
expr: 必須です。 ARRAY、MAP、またはSTRUCTタイプの式。
説明
入力式がSTRUCT型 (struct<key1:value1, key2:value2>) の場合は、次の点に注意してください。
- 式をJSON文字列に変換すると、すべてのキーが小文字に変換されます。
- valueがnullの場合、valueが属するキーと値のペアは、返されるJSON文字列に含まれません。たとえば、value2がnullの場合、返されるJSON文字列にはkey2:value2は含まれません。
戻り値
JSON文字列が返されます。

例

例1: 特定の複合データ型の式をJSON文字列に変換します。例：

-- The return value is {"a":1,"b":2}. 
select to_json(named_struct('a', 1, 'b', 2));
-- The return value is {"time":"26/08/2015"}. 
select to_json(named_struct('time', "26/08/2015"));
-- The return value is [{"a":1,"b":2}]. 
select to_json(array(named_struct('a', 1, 'b', 2)));
-- The return value is {"a":{"b":1}}. 
select to_json(map('a', named_struct('b', 1)));
-- The return value is {"a":1}. 
select to_json(map('a', 1));
-- The return value is [{"a":1}]. 
select to_json(array((map('a', 1))));

例2: 入力式はSTRUCT型です。例：

-- The return value is {"a":"B"}. If the expression of the STRUCT type is converted into a JSON string, all keys are converted into lowercase letters. 
select to_json(named_struct("A", "B"));
-- The return value is {"k2":"v2"}. The key-value pair to which null belongs is not included in the JSON string that is returned. 
select to_json(named_struct("k1", cast(null as string), "k2", "v2"));

変身

構文

array<R> transform(array<T> <a>, function<T, R> <func>)

説明
funcを使用してArray aの要素を変換し、新しい配列を返します。
パラメーター
- a: 必須です。このパラメーターは、配列を指定します。 array<T> のTは、配列内の要素のデータ型を指定します。要素は任意のデータ型にすることができます。
- func: 必須です。このパラメーターには、配列aの要素を変換するために使用される組み込み関数、ユーザー定義関数、または式を指定します。値は、配列aの要素と同じデータ型である必要があります。 Rは、出力結果のデータ型を指定します。
戻り値
ARRAY型の値が返されます。

例

-- The return value is [2, 3, 4]. 
select transform(array(1, 2, 3), x -> x + 1);

TRANSFORM_KEYS

構文

map<K2, V> transform_keys([string <mapDupKeyPolicy>,] map<K1, V> <input>, function<K1, V, K2> <func>)

説明
funcを使用してMap inputのキーを変換します。マップの値は変更されません。
パラメーター
- mapDupKeyPolicy: オプション。 STRING型の値。このパラメーターは、重複キーの処理に使用されるメソッドを指定します。有効な値：
  - exception: エラーが返されます。
  - last_win: 後者のキーは前者のキーを上書きします。
  セッションレベルでodps.sql.map.key.de dup.policyパラメーターを指定して、重複キーの処理に使用されるメソッドを構成することもできます。たとえば、odps.sql.map.key.de dup.policyを例外に設定できます。このパラメーターを指定しない場合、デフォルト値last_winが使用されます。
  説明
  MaxComputeの動作実装は、mapDupKeyPolicyに基づいて決定されます。 mapDupKeyPolicyを指定しない場合、odps.sql.map.key.de dup.policyの値が使用されます。
- input: 必須です。このパラメータは、マップを指定します。 map<K1, V> のK1とVは、マップのキーと値を指定します。
- func: 必須です。このパラメーターには、キーの変換に使用する組み込み関数、ユーザー定義関数、または式を指定します。関数または式は、inputのキーと値に対応する2つの入力パラメーターで構成されます。 K2は、返されるマップのキーのデータ型を指定します。
戻り値
MAPタイプの値が返されます。新しいキーの1つがnullの場合、エラーが返されます。

例

-- The return value is {-10:-20, 70:50, 71:101}. 
select transform_keys(map(10, -20, 20, 50, -30, 101), (k, v) -> k + v);
-- No error is returned. The returned result depends on the order of the elements in the input map. 
select transform_keys("last_win", map(10, -20, 20, 50, -30, 100), (k, v) -> k + v);
-- An error is returned because duplicate keys exist. 
select transform_keys("exception", map(10, -20, 20, 50, -30, 100), (k, v) -> k + v);

TRANSFORM_VALUES

構文

map<K, V2> transform_values(map<K, V1> <input>, function<K, V1, V2> <func>)

説明
funcを使用してMap inputの値を変換します。マップ内のキーは変更されません。
パラメーター
- input: 必須です。このパラメータは、マップを指定します。 map<K, V1> のKとV1は、マップのキーと値を指定します。
- func: 必須です。このパラメーターには、キーの変換に使用する組み込み関数、ユーザー定義関数、または式を指定します。関数または式は、inputのキーと値に対応する2つの入力パラメーターで構成されます。 V2は、返されるマップの値のデータ型を指定します。
戻り値
MAPタイプの値が返されます。

例

-- The return value is {-30:71, 10:-10, 20:NULL}. 
select transform_values(map(10, -20, 20, null, -30, 101), (k, v) -> k + v);

ZIP_WITH

構文

array<R> zip_with(array<T> <a>, array<S> <b>, function<T, S, R> <combiner>)

説明
要素位置とコンバイナに基づいて要素レベルで配列aと配列bをマージし、新しい配列を返します。
パラメーター
- aおよびb: 必須。このパラメーターは、配列を指定します。 array<T> のTとarray<S> のSは、配列内の要素のデータ型を指定します。要素は任意のデータ型にすることができます。
- combiner: 必須です。このパラメーターには、要素レベルで配列aと配列bをマージするために使用される組み込み関数、ユーザー定義関数、または式を指定します。コンバイナは、2つの入力パラメータからなる。 1つの入力パラメーターは、配列aの要素と同じデータ型である必要があります。もう1つの入力パラメーターは、配列bの要素と同じデータ型である必要があります。
戻り値
ARRAY型の値が返されます。戻り値は、次のルールによって異なります。
- 返される配列の要素は、配列aおよび配列bの要素と同じ位置にあります。
- 配列aと配列bの長さが異なる場合、配列がマージされる前にnull要素が短い配列に追加されます。

例

-- The return value is [2, 4, 6, null]. 
select zip_with(array(1,2,3), array(1,2,3,4), (x,y) -> x + y);