複雜類型函數 - MaxCompute

您可以在MaxCompute SQL中使用複雜類型函數處理複雜資料類型，例如ARRAY、MAP、STRUCT、JSON。本文為您提供MaxCompute SQL支援的複雜類型函數的命令格式、參數說明及樣本，指導您使用複雜類型函數完成開發。

MaxCompute SQL支援的複雜類型函數如下。其中JSON函數的使用限制請參見使用限制。

函數類別	函數	功能
ARRAY函數	ALL_MATCH	判斷ARRAY數組中是否所有元素都滿足指定條件。
	ANY_MATCH	判斷ARRAY數組中是否存在滿足指定條件的元素。
	ARRAY	使用給定的值構造ARRAY。
	ARRAY_CONTAINS	檢測指定的ARRAY中是否包含指定的值。
	ARRAY_DISTINCT	去除ARRAY數組中的重複元素。
	ARRAY_EXCEPT	找出在ARRAY A中，但不在ARRAY B中的元素，並去掉重複的元素後，以ARRAY形式返回結果。
	ARRAY_INTERSECT	計算兩個ARRAY數組的交集。
	ARRAY_JOIN	將ARRAY數組中的元素按照指定字串進行拼接。
	ARRAY_MAX	計算ARRAY數組中的最大值。
	ARRAY_MIN	計算ARRAY數組中的最小值。
	ARRAY_NORMALIZE	返回根據指定p範數（p Norm）對數組元素正常化後的數組。
	ARRAY_POSITION	計算指定元素在ARRAY數組中第一次出現的位置。
	ARRAY_REDUCE	將ARRAY數組的元素進行彙總。
	ARRAY_REMOVE	在ARRAY數組中刪除指定元素。
	ARRAY_REPEAT	返回將指定元素重複指定次數後的ARRAY數組。
	ARRAY_SORT	將ARRAY數組的元素進行排序。
	ARRAY_UNION	計算兩個ARRAY數組的並集並去掉重複元素。
	ARRAYS_OVERLAP	判斷兩個ARRAY數組中是否包含相同元素。
	ARRAYS_ZIP	合并多個ARRAY數組。
	COMBINATIONS	返回輸入數組元素的N元組合組成的數組。
	CONCAT	將ARRAY數組或字串串連在一起。
	EXPLODE	將一行資料轉為多行的UDTF。
	FILTER	將ARRAY數組中的元素進行過濾。
	FLATTEN	將數群組類型的數群組轉換為單個數組。
	INDEX	返回ARRAY數組指定位置的元素值。
	NGRAMS	返回指定數組元素的N元文法（n-gram）數組。
	POSEXPLODE	將指定的ARRAY展開，每個Value一行，每行兩列分別對應數組從0開始的下標和數組元素。
	REVERSE	返回指定數組的元素倒序數組。
	SEQUENCE	根據運算式產生包含指定元素的數組。
	SHUFFLE	返回指定數組的元素隨機排列數組。
	SIZE	返回指定ARRAY中的元素數目。
	SLICE	對ARRAY資料切片，返回從指定位置開始、指定長度的數組。
	SORT_ARRAY	為指定的數組中的元素排序。
	SPLIT	將字串按照指定的分隔字元分割後返回數組。
	TRANSFORM	將ARRAY數組中的元素進行轉換。
	ZIP_WITH	將2個ARRAY數組按照位置進行元素層級的合并。
MAP函數	EXPLODE	將一行資料轉為多行的UDTF。
	INDEX	返回MAP型別參數中滿足指定條件的Value。
	MAP	使用指定的Key-Value對建立MAP。
	MAP_CONCAT	返回多個MAP的並集。
	MAP_ENTRIES	將MAP中的Key、Value索引值映射轉換為STRUCT結構數組。
	MAP_FILTER	將MAP中的元素進行過濾。
	MAP_FROM_ARRAYS	通過給定的ARRAY數組構造MAP。
	MAP_FROM_ENTRIES	通過給定的結構體數組構造MAP。
	MAP_KEYS	將參數MAP中的所有Key作為數組返回。
	MAP_VALUES	將參數MAP中的所有Value作為數組返回。
	MAP_ZIP_WITH	對輸入的兩個MAP進行合并得到一個新MAP。
	MULTIMAP_FROM_ENTRIES	結構體數組中返回一個MAP。
	SIZE	返回指定MAP中的K/V對數。
	TRANSFORM_KEYS	對MAP進行變換，保持Value不變，根據指定Function Compute新的Key。
	TRANSFORM_VALUES	對MAP進行變換，保持Key不變，根據指定Function Compute新的Value。
STRUCT函數	FIELD	擷取STRUCT中的成員變數的取值。
	INLINE	將指定的STRUCT數組展開。每個數組元素對應一行，每行每個STRUCT元素對應一列。
	NAMED_STRUCT	使用給定的Name、Value列表建立STRUCT。
	STRUCT	使用給定Value列表建立STRUCT。
JSON函數	FROM_JSON	根據給定的JSON字串和輸出格式資訊，返回ARRAY、MAP或STRUCT類型。
	GET_JSON_OBJECT	在一個標準JSON字串中，按照指定方式抽取指定的字串。
	JSON_TUPLE	在一個標準的JSON字串中，按照輸入的一組鍵抽取各個鍵指定的字串。
	TO_JSON	將指定的複雜類型輸出為JSON字串。
	JSON_OBJECT	產生JSON OBJECT，要求key和value成對出現。
	JSON_ARRAY	產生JSON ARRAY。將一個可能為空白的JSON類型對象，轉換為包含這些類型的數組。
	JSON_EXPLODE	支援將JSON數組或JSON對象中的每個元素拆解（展開）成多行記錄輸出。
	JSON_EXTRACT	解析JSON運算式中對應json_path的資料，注意json_path非法時會報錯。
	JSON_EXISTS	查看json_path對應的JSON值是否存在。
	JSON_PRETTY	美化JSON，增加換行及空格。
	JSON_TYPE	返回JSON資料所屬的資料類型名稱。
	JSON_FORMAT	將JSON資料轉換成STRING類型，預設不自動進行美化。
	JSON_PARSE	將STRING類型轉成JSON類型，非JSON格式轉換為字串會報錯。
	JSON_VALID	檢查字串是否為合法的JSON格式。
	CAST	支援基本類型與JSON類型的轉換。

說明

以下函數樣本中涉及->的使用，關於Lambda函數->的介紹，詳情請參見Lambda函數。

ALL_MATCH

命令格式

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

命令說明
判斷ARRAY數組a中是否所有元素都滿足predicate條件。
參數說明
- a：必填。ARRAY數組。array<T>中的T指代ARRAY數組元素的資料類型，數組中的元素可以為任意類型。
- predicate：必填。用於對ARRAY數組a中的元素進行判斷的函數（內建函數或自訂函數）或運算式。輸入參數的資料類型必須與ARRAY數組a中元素的資料類型一致。
傳回值說明
返回BOOLEAN類型。返回規則如下：
- 如果ARRAY數組a中所有的元素滿足predicate條件或ARRAY數組為空白，返回結果為True。
- 如果ARRAY數組a中存在元素不滿足predicate條件，返回結果為False。
- 如果ARRAY數組a中存在元素為NULL，且其他元素都滿足predicate條件，返回結果為NULL。
樣本
- 樣本1：判斷ARRAY數組array(4, 5, 6)的所有元素是否滿足x x > 3條件（所有元素大於3）。命令樣本如下。
```
--返回true。
select all_match(array(4, 5, 6), x -> x>3);
```
- 樣本2：ARRAY數組為空白。命令樣本如下。
```
--返回true。
select all_match(array(), x -> x>3);
```
- 樣本3：判斷ARRAY數組array(1, 2, -10, 100, -30)的所有元素是否滿足x-> x > 3條件。命令樣本如下。
```
--返回false。
select all_match(array(1, 2, -10, 100, -30), x -> x>3);
```
- 樣本4：判斷存在NULL元素的ARRAY數組array(10, 100, 30, null)的所有元素是否滿足x-> x > 3條件。命令樣本如下。
```
--返回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中是否存在元素滿足predicate條件。
參數說明
- a：必填。ARRAY數組。array<T>中的T指代ARRAY數組元素的資料類型，數組中的元素可以為任意類型。
- predicate：必填。用於對ARRAY數組a中的元素進行判斷的函數（內建函數或自訂函數）或運算式。輸入參數的資料類型必須與ARRAY數組a中元素的資料類型一致。
傳回值說明
返回BOOLEAN類型。返回規則如下：
- 如果ARRAY數組a中存在一個或多個元素滿足predicate條件，返回結果為True。
- 如果ARRAY數組a中沒有元素滿足predicate條件或ARRAY數組為空白，返回結果為False。
- 如果ARRAY數組a中存在元素為NULL，且其他元素都不滿足predicate條件，返回結果為NULL。
樣本
- 樣本1：判斷ARRAY數組array(1, 2, -10, 100, -30)中是否有元素滿足x-> x > 3條件。命令樣本如下。
```
--返回true。
select any_match(array(1, 2, -10, 100, -30), x-> x > 3);
```
- 樣本2：ARRAY數組為空白。命令樣本如下。
```
--返回false。
select any_match(array(), x-> x > 3);
```
- 樣本3：判斷ARRAY數組array(1, 2, -10, -20, -30)中是否有元素滿足x-> x > 3條件。命令樣本如下。
```
--返回false。
select any_match(array(1, 2, -10, -20, -30), x-> x > 3);
```
- 樣本4：判斷存在NULL元素的ARRAY數組array(1, 2, null, -10)中是否有元素滿足x-> x > 3條件。命令樣本如下。
```
--返回NULL。
select any_match(array(1, 2, null, -10), x-> x > 3);
```

ARRAY

命令格式
```
array array(<value>,<value>[, ...])
```
命令說明
使用指定的值構造ARRAY數組。
參數說明
value：必填。可以為任意類型。所有value的資料類型必須一致。
傳回值說明
返回ARRAY類型。

樣本

例如表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          |
+------------+----+----+------------+------------+

命令樣本如下。

--根據c2、c4、c3、c5列的資料構造ARRAY數組。
select array(c2,c4,c3,c5) from t_table;

--返回結果如下。
+------+
| _c0  |
+------+
| [k11, 86, k21, 15] |
| [k12, 97, k22, 2] |
| [k13, 99, k23, 1] |
+------+

ARRAY_CONTAINS

命令格式

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

命令說明
判斷ARRAY數組a中是否存在元素v。
參數說明
- a：必填。ARRAY數組。array<T>中的T指代ARRAY數組元素的資料類型，數組中的元素可以為任意類型。
- v：必填。待判斷的元素。必須與ARRAY數組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] |
+------------+---------+

命令樣本如下。

--檢測t_array列是否包含1。
select c1, array_contains(t_array,'1') from t_table_array;
--返回結果如下。
+------------+------+
| c1         | _c1  |
+------------+------+
| 1000       | false |
| 1001       | false |
| 1002       | true |
+------------+------+

ARRAY_DISTINCT

命令格式
```
array<T> array_distinct(array<T> <a>)
```
命令說明
去除ARRAY數組a中的重複元素。
參數說明
a：必填。ARRAY數組。array<T>中的T指代ARRAY數組元素的資料類型，數組中的元素可以為任意類型。
傳回值說明
返回ARRAY類型。返回規則如下：
- 新ARRAY數組無重複元素且元素順序與a中的元素順序保持一致。
- ARRAY數組a中存在元素為NULL時，NULL值會參與運算。
- 輸入數組為空白時，返回空數組。
樣本
- 樣本1：去除ARRAY數組array(10, 20, 30, 30, 20, 10)中的重複元素。命令樣本如下。
```
--返回[10,20,30]。
select array_distinct(array(10, 20, 30, 30, 20, 10));
```
- 樣本2：去除ARRAY數組array(10, 20, 20, null, null, 30, 20, null)中的重複元素。命令樣本如下。
```
--返回[10,20,null,30]。
select array_distinct(array(10, 20, 20, null, null, 30, 20, null)); 
```
- 樣本3：ARRAY數組為空白。命令樣本如下。
```
--返回[]。
select array_distinct(array());
```

ARRAY_EXCEPT

命令格式

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

命令說明
找出在ARRAY數組a中，但不在ARRAY數組b中的元素，並去掉重複的元素後，返回新的ARRAY數組。
參數說明
a、b：必填。ARRAY數組。array<T>中的T指代ARRAY數組元素的資料類型，數組中的元素可以為任意類型。a和b的資料類型必須保持一致。
傳回值說明
返回ARRAY類型。返回規則如下：
- 新ARRAY數組無重複元素且元素順序與a中的元素順序保持一致。
- ARRAY數組中存在元素為NULL時，NULL值會參與運算。
- 任一輸入數組為空白時，返回對非空數組去重後的新ARRAY數組。
- 輸入數組全部為空白時，返回空數組。
樣本
- 樣本1：找出在ARRAY數組array(1, 1, 3, 3, 5, 5)中，不在ARRAY數組array(1, 1, 2, 2, 3, 3)中的元素並去重。命令樣本如下。
```
--返回[5]。
select array_except(array(1, 1, 3, 3, 5, 5), array(1, 1, 2, 2, 3, 3));
```
- 樣本2：找出在ARRAY數組array(1, 1, 3, 3, 5, 5, null, null)中，不在ARRAY數組array(1, 1, 2, 2, 3, 3)中的元素並去重。命令樣本如下。
```
--返回[5,null]。
select array_except(array(1, 1, 3, 3, 5, 5, null, null), array(1, 1, 2, 2, 3, 3));
```
- 樣本3：任一輸入ARRAY數組為空白。命令樣本如下。
```
--返回[2,1]。
select array_except(array(2, 1, 1, 2), cast(array() as array<int>)); 
```
- 樣本4：輸入ARRAY數組全部為空白。命令樣本如下。
```
--返回[]。
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>)

命令說明
計算ARRAY數組a和b的交集，並去掉重複元素。
參數說明
a、b：必填。ARRAY數組。array<T>中的T指代ARRAY數組元素的資料類型，數組中的元素可以為任意類型。a和b的資料類型必須保持一致。
傳回值說明
返回ARRAY類型。返回規則如下：
- ARRAY數組中存在元素為NULL時，NULL值會參與運算。
- 新ARRAY數組無重複元素且元素順序與a中的元素順序保持一致。
- 如果ARRAY數組a或b為NULL，返回NULL。
樣本
- 樣本1：計算ARRAY數組array(1, 2, 3)和array(1, 3, 5)的交集，並去掉重複元素。命令樣本如下。
```
--返回[1,3]。
select array_intersect(array(1, 2, 3), array(1, 3, 5));
```
- 樣本2：計算ARRAY數組array(10, 20, 20, 30, 30, null, null)和array(30, 30, 20, 20, 40, null, null)的交集，並去掉重複元素。命令樣本如下。
```
--返回[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>])

命令說明
將ARRAY數組a中的元素使用delimiter拼接為字串。當數組中元素為NULL時，用nullreplacement替代，沒有設定nullreplacement時，會忽略NULL元素。
參數說明
- a：必填。ARRAY數組。array<T>中的T指代ARRAY數組元素的資料類型。
  說明
  當ARRAY數組中的元素非STRING類型時，MaxCompute會將非STRING類型元素轉換為STRING類型。
- delimiter：必填。STRING類型。串連ARRAY數組a中元素的字串。
- nullreplacement：可選。替代NULL元素的字串。
傳回值說明
返回STRING類型。

樣本

--返回10,20,20,30。
select array_join(array(10, 20, 20, null, null, 30), ",");
--返回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>) 
```
命令說明
計算ARRAY數組a中的最大元素。
參數說明
a：必填。ARRAY數組。array<T>中的T指代ARRAY數組元素的資料類型。
數組中的元素可以為如下類型：
- TINYINT、SMALLINT、INT、BIGINT
- FLOAT、DOUBLE
- BOOLEAN
- DECIMAL、DECIMALVAL
- DATE、DATETIME、TIMESTAMP、IntervalDayTime、IntervalYearMonth
- STRING、BINARY、VARCHAR、CHAR
- ARRAY、STRUCT、MAP
傳回值說明
返回ARRAY數組a中的最大元素。返回規則如下：
- 如果ARRAY數組a為NULL，返回NULL。
- 如果ARRAY數組a中存在元素為NULL，NULL值不參與運算。

樣本

--返回20。
select array_max(array(1, 20, null, 3));

ARRAY_MIN

命令格式
```
T array_min(array<T> <a>) 
```
命令說明
計算ARRAY數組a中的最小元素。
參數說明
a：必填。ARRAY數組。array<T>中的T指代ARRAY數組元素的資料類型。
數組中的元素可以為如下類型：
- TINYINT、SMALLINT、INT、BIGINT
- FLOAT、DOUBLE
- BOOLEAN
- DECIMAL、DECIMALVAL
- DATE、DATETIME、TIMESTAMP、IntervalDayTime、IntervalYearMonth
- STRING、BINARY、VARCHAR、CHAR
- ARRAY、STRUCT、MAP
傳回值說明
返回ARRAY數組a中的最小元素。返回規則如下：
- 如果ARRAY數組a為NULL，返回NULL。
- 如果ARRAY數組a中存在元素為NULL時，NULL值不參與運算。

樣本

--返回1。
select array_min(array(1, 20, null, 3));

ARRAY_NORMALIZE

命令格式
```
array_normalize(array, p)
```
命令說明
返回根據指定p範數（p Norm）對數組元素正常化後的數組。
此函數等價於TRANSFORM(array, v -> v / REDUCE(array, 0, (a, v) -> a + POW(ABS(v), p), a -> POW(a, 1 / p))，但是REDUCE部分只執行一次。
參數說明
array：輸入數組，數組元素只支援Float和Double類型。
p: 數組的p Norm。
傳回值說明
返回正常化之後的數組。
- 如果數組為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>)

命令說明
計算元素element在ARRAY數組a中第一次出現的位置。ARRAY數組元素位置編號自左往右，從1開始計數。
參數說明
- a：必填。ARRAY數組。array<T>中的T指代ARRAY數組元素的資料類型。支援的資料類型如下：
  - TINYINT、SMALLINT、INT、BIGINT
  - FLOAT、DOUBLE
  - BOOLEAN
  - DECIMAL、DECIMALVAL
  - DATE、DATETIME、TIMESTAMP、IntervalDayTime、IntervalYearMonth
  - STRING、BINARY、VARCHAR、CHAR
  - ARRAY、STRUCT、MAP
- element：必填。待查詢的元素，資料類型必須與a中元素的資料類型相同。
傳回值說明
返回BIGINT類型。返回規則如下：
- 如果ARRAY數組a或element為NULL，返回NULL。
- 未找到元素時返回0。
樣本
- 樣本1：計算元素1第一次出現在ARRAY數組array(3, 2, 1)中的位置。命令樣本如下。
```
--返回3。
select array_position(array(3, 2, 1), 1);
```
- 樣本2：element為NULL。命令樣本如下。
```
--返回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>)

命令說明
對ARRAY數組a中的元素進行彙總。
參數說明
- a：必填。ARRAY數組。array<T>中的T指代ARRAY數組元素的資料類型，數組中的元素可以為任意類型。
- init：必填。用於彙總的中間結果的初始值。
- merge：必填。將ARRAY數組a中的每一個元素與中間結果進行運算的函數（內建函數或自訂函數）或運算式。它的兩個輸入參數為ARRAY數組a的元素和init。
- final：必填。將中間結果轉換為最終結果的函數（內建函數或自訂函數）或運算式。它的輸入參數為merge運行結果，R指代輸出結果的資料類型。
傳回值說明
返回結果類型與final函數定義的輸出結果類型一致。

樣本

--返回6。
select array_reduce(array(1, 2, 3), 0, (buf, e)->buf + e, buf->buf);
--返回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>)

命令說明
在ARRAY數組a中刪除與element相等的元素。
參數說明
- a：必填。ARRAY數組。array<T>中的T指代ARRAY數組元素的資料類型。支援的資料類型如下：
  - TINYINT、SMALLINT、INT、BIGINT
  - FLOAT、DOUBLE
  - BOOLEAN
  - DECIMAL、DECIMALVAL
  - DATE、DATETIME、TIMESTAMP、IntervalDayTime、IntervalYearMonth
  - STRING、BINARY、VARCHAR、CHAR
  - ARRAY、STRUCT、MAP
- element：必填。待刪除的元素，資料類型必須與a中元素的資料類型相同。
傳回值說明
返回ARRAY類型。返回規則如下：
- 如果ARRAY數組a中存在元素為NULL時，NULL值不參與運算。
- 如果ARRAY數組a或element為NULL，返回NULL。
- ARRAY數組a中不存在element時返回原ARRAY數組a。
樣本
- 樣本1：刪除ARRAY數組array(3, 2, 1)中等於1的元素。命令樣本如下。
```
--返回[3,2]。
select array_remove(array(3, 2, 1), 1);
```
- 樣本2：element為NULL。命令樣本如下。
```
--返回NULL。
select array_remove(array(3, 1, null), null);
```
- 樣本3：刪除ARRAY數組array(3, 1, null)中等於2的元素。命令樣本如下。
```
--返回[3,1,null]。
select array_remove(array(3, 1, null), 2);
```

ARRAY_REPEAT

命令格式

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

命令說明
返回將元素t重複count次後新產生的ARRAY數組。
參數說明
- t：必填。待重複的元素。支援的類型如下：
  - TINYINT、SMALLINT、INT、BIGINT
  - FLOAT、DOUBLE
  - BOOLEAN
  - DECIMAL、DECIMALVAL
  - DATE、DATETIME、TIMESTAMP、IntervalDayTime、IntervalYearMonth
  - STRING、BINARY、VARCHAR、CHAR
  - ARRAY、STRUCT、MAP
- count：必填。重複的次數，INT類型。必須大於等於0。
傳回值說明
返回ARRAY類型。返回規則如下：
- 如果count為NULL，返回NULL。
- 如果count小於0，返回空數組。
樣本
- 樣本1：將123重複2次，產生新的ARRAY數組。命令樣本如下。
```
--返回[123, 123]。
select array_repeat('123', 2);
```
- 樣本2：count為NULL。命令樣本如下。
```
--返回NULL。
select array_repeat('123', null);
```
- 樣本3：count小於0。命令樣本如下。
```
--返回[]。
select array_repeat('123', -1);
```

ARRAY_SORT

命令格式

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

命令說明
將ARRAY數組a中的元素根據comparator進行排序。
參數說明
- a：必填。ARRAY數組。array<T>中的T指代ARRAY數組元素的資料類型，數組中的元素可以為任意類型。
- comparator：必填。用於比較ARRAY數組中2個元素大小的函數（內建函數或自訂函數）或運算式。
  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 。
  不自洽函數樣本如下：
  (left, right) -> CASE WHEN left <= right THEN -1L ELSE 0L END ：
  假如設定a = 1, b = 1，則compare(a, b) = -1，compare(b, a) = -1，兩個比較結果相互矛盾即函數不自洽。
  (left, right) -> CASE WHEN left < right THEN -1L WHEN left = right THEN 0L ELSE 1L END：
  假如設定a = NULL，b = 1，則compare(a, b) = 1，compare(b, a) = 1，兩個比較結果相互矛盾即函數不自洽。
傳回值說明
返回ARRAY類型。

樣本

樣本1：對數組array(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);

--返回結果
+------------+
| _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);
  
 -- 返回結果
+------+
| _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>)

命令說明
計算ARRAY數組a和b的並集，並去掉重複元素。
參數說明
a、b：必填。ARRAY數組。array<T>中的T指代ARRAY數組元素的資料類型，數組中的元素可以為任意類型。a和b中元素的資料類型必須一致。
數組中的元素可以為如下類型：
- TINYINT、SMALLINT、INT、BIGINT
- FLOAT、DOUBLE
- BOOLEAN
- DECIMAL、DECIMALVAL
- DATE、DATETIME、TIMESTAMP、IntervalDayTime、IntervalYearMonth
- STRING、BINARY、VARCHAR、CHAR
- ARRAY、STRUCT、MAP
傳回值說明
返回ARRAY類型。如果a或b為NULL，返回NULL。
樣本
- 樣本1：計算ARRAY數組array(1, 2, 3)和array(1, 3, 5)的並集，並去掉重複元素。命令樣本如下。
```
--返回[1,2,3,5]。
select array_union(array(1, 2, 3), array(1, 3, 5));
```
- 樣本2：任一ARRAY數組為NULL。命令樣本如下。
```
--返回NULL。
select array_union(array(1, 2, 3), null);
```

ARRAYS_OVERLAP

命令格式

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

命令說明
判斷ARRAY數組a和b是否存在相同元素。
參數說明
a、b：必填。ARRAY數組。array<T>中的T指代ARRAY數組元素的資料類型，數組中的元素可以為任意類型。a和b中元素的資料類型必須一致。
數組中的元素可以為如下類型：
- TINYINT、SMALLINT、INT、BIGINT
- FLOAT、DOUBLE
- BOOLEAN
- DECIMAL、DECIMALVAL
- DATE、DATETIME、TIMESTAMP、IntervalDayTime、IntervalYearMonth
- STRING、BINARY、VARCHAR、CHAR
- ARRAY、STRUCT、MAP
傳回值說明
返回BOOLEAN類型。返回規則如下：
- 如果ARRAY數組a中至少包含ARRAY數組b中的一個非NULL元素，返回結果為True。
- 如果ARRAY數組a和b中沒有公用元素、都非空，且其中任意一個數組中包含NULL元素，返回結果為NULL。
- 如果ARRAY數組a和b中沒有公用元素、都非空，且其中任意一個數組中都不包含NULL元素，返回結果為False。
樣本
- 樣本1：判斷ARRAY數組array(1, 2, 3)和array(3, 4, 5)中是否存在相同元素。命令樣本如下。
```
--返回true。
select arrays_overlap(array(1, 2, 3), array(3, 4, 5));
```
- 樣本2：判斷ARRAY數組array(1, 2, 3)和array(6, 4, 5)中是否存在相同元素。命令樣本如下。
```
--返回false。
select arrays_overlap(array(1, 2, 3), array(6, 4, 5));
```
- 樣本3：任一ARRAY數組中存在NULL元素。命令樣本如下。
```
--返回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>[, ...])

命令說明
合并多個給定數組並返回一個結構數組，其中第N個結構包含輸入數組的所有第N個值。
參數說明
a、b：必填。ARRAY數組。array<T>及array<U>中的T和U指代ARRAY數組元素的資料類型，數組中的元素可以為任意類型。
數組中的元素可以為如下類型：
- TINYINT、SMALLINT、INT、BIGINT
- FLOAT、DOUBLE
- BOOLEAN
- DECIMAL、DECIMALVAL
- DATE、DATETIME、TIMESTAMP、IntervalDayTime、IntervalYearMonth
- STRING、BINARY、VARCHAR、CHAR
- ARRAY、STRUCT、MAP
傳回值說明
返回ARRAY類型。返回規則如下：
- 產生的結構數組中第N個結構包含輸入數組的所有第N個值，不足N的元素以NULL填充。
- 如果輸入ARRAY數組中任意一個為NULL，返回結果為NULL。
樣本
- 樣本1：通過ARRAY數組array(1, 2, 3)和array(2, 3, 4)構造結構數組。命令樣本如下。
```
--返回[{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數組array(1, 2, 3)和array(4, 5)構造結構數組。命令樣本如下。
```
--返回[{0:1, 1:4}, {0:2, 1:5}, {0:3, 1:NULL}]。
select arrays_zip(array(1, 2, 3), array(4, 5));
```

COMBINATIONS

命令格式
```
combinations(array(T), n)
```
命令說明
返回輸入數組元素的N元組合組成的數組。
參數說明
array：為輸入數組。
n：元數。
傳回值說明
返回輸入數組元素的N元組合組成的數組。
- 如果輸入數組沒有重複項，則返回N元子集數組。子集是確定的但順序不保證，子集中元素是確定的但順序不保證。
- 目前n的值預設不能大於5（可通過設定odps.sql.max.combination.length值進行調整），產生總子集數量預設不能大於100000（可通過設定odps.sql.max.combinations值進行調整）。
- 如果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>[,...])

命令說明
- 輸入為ARRAY數組：將多個ARRAY數組中的所有元素串連在一起，產生一個新的ARRAY數組。
- 輸入為字串：將多個字串串連在一起，產生一個新的字串。
參數說明
- a、b：必填。ARRAY數組。array<T>中的T指代ARRAY數組元素的資料類型，數組中的元素可以為任意類型。a和b中元素的資料類型必須一致。數組中的元素為NULL值時會參與運算。
- str1、str2：必填。STRING類型。如果輸入參數為BIGINT、DOUBLE、DECIMAL或DATETIME類型，則會隱式轉換為STRING類型後參與運算，其他類型會返回報錯。
傳回值說明
- 返回ARRAY類型。如果任一輸入ARRAY數組為NULL，返回結果為NULL。
- 返回STRING類型。如果沒有參數或任一參數為NULL，返回結果為NULL。
樣本
- 樣本1：串連ARRAY數組array(10, 20)和array(20, -20)。命令樣本如下。
```
--返回[10, 20, 20, -20]。
select concat(array(10, 20), array(20, -20));
```
- 樣本2：ARRAY數組元素包含NULL。命令樣本如下。
```
--返回[10, NULL, 20, -20]。
select concat(array(10, null), array(20, -20));
```
- 樣本3：任一ARRAY數組為NULL。命令樣本如下。
```
--返回NULL。
select concat(array(10, 20), null);
```
- 樣本4：連接字串aabc和abcde。命令樣本如下。
```
--返回aabcabcde。
select concat('aabc','abcde');
```
- 樣本5：輸入為空白。命令樣本如下。
```
--返回NULL。
select concat();
```
- 樣本6：任一字串輸入為NULL。命令樣本如下。
```
--返回NULL。
select concat('aabc', 'abcde', null);
```

EXPLODE

使用限制
- 在一個select中只能出現一個explode函數，不可以出現表的其他列。
- 不可以與group by、cluster by、distribute by、sort by一起使用。
命令格式
```
explode (<var>)
```
命令說明
將一行資料轉為多行的UDTF。
- 如果參數是array<T>類型，則將列中儲存的ARRAY轉為多行。
- 如果參數是map<K, V>類型，則將列中儲存的MAP的每個Key-Value對轉換為包含兩列的行，其中一列儲存Key，另一列儲存Value。
參數說明
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;
--返回結果如下。
+-----+------------+
| key | value      |
+-----+------------+
| k11 | 86         |
| k21 | 15         |
| k12 | 97         |
| k22 | 2          |
| k13 | 99         |
| k23 | 1          |
+-----+------------+

FIELD

命令格式
```
T field(struct <s>, string <fieldName>)
```
命令說明
擷取STRUCT對象中成員變數的取值。
參數說明
- s：必填。STRUCT類型對象。STRUCT的結構為{f1:T1, f2:T2[, ...]}，f1、f2代表成員變數，T1、T2分別代表成員變數f1、f2的取值。
- fieldName：必填。STRING類型。STRUCT類型對象的成員變數。
傳回值說明
返回STRUCT類型對象的成員變數的取值。

樣本

--返回hello。
select field(named_struct('f1', 'hello', 'f2', 3), 'f1');

FILTER

命令格式

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

命令說明
將ARRAY數組a中的元素利用func進行過濾，返回一個新的ARRAY數組。
參數說明
- a：必填。ARRAY數組。array<T>中的T指代ARRAY數組元素的資料類型，數組中的元素可以為任意類型。
- func：必填。用於對a中元素進行過濾的函數（內建函數或自訂函數）或運算式，其輸入參數類型必須與a中元素的資料類型一致，其輸出結果資料類型為BOOLEAN。
傳回值說明
返回ARRAY類型。

樣本

--返回[2, 3]。
select filter(array(1, 2, 3), x -> x > 1);

FLATTEN

命令格式
```
flatten(arrayOfArray)
```
命令說明
將數群組類型的數群組轉換為單個數組。
參數說明
arrayOfArray：為數群組類型的數組。
傳回值說明
將數群組類型的數組按元素順序展開為單個數組。
- 如果輸入值為null，則返回NULL。
- 如果輸入參數不是數群組類型的數組，則拋出異常。

樣本

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

返回結果如下：

[1,2,3,4]

FROM_JSON

命令格式
```
from_json(<jsonStr>, <schema>)
```
命令說明
根據JSON字串jsonStr和schema資訊，返回ARRAY、MAP或STRUCT類型。

參數說明

jsonStr：必填。輸入的JSON字串。

schema：必填。寫法與建表語句的類型一致。例如array<bigint>、map<string, array<string>>或struct<a:int, b:double, `C`:map<string,string>>。

說明

STRUCT的Key區分大小寫。此外，STRUCT類型還有一種寫法a bigint, b double，等同於struct<a:bigint, b:double>。

JSON資料類型與MaxCompute資料類型的對應關係如下。

JSON資料類型	MaxCompute資料類型
OBJECT	STRUCT、MAP、STRING
ARRAY	ARRAY、STRING
NUMBER	TINYINT、SMALLINT、INT、BIGINT、FLOAT、DOUBLE、DECIMAL、STRING
BOOLEAN	BOOLEAN、STRING
STRING	STRING、CHAR、VARCHAR、BINARY、DATE、DATETIME
NULL	所有類型

說明

對於OBJECT和ARRAY類型，會採用儘可能解析的方式，不匹配的類型會忽略。為了便於使用，所有的JSON類型都可以轉換為MaxCompute的STRING類型。同時您需要注意，對應FLOAT、DOUBLE、DECIMAL三種資料類型無法保證小數的精度，如果需要確保精度可以先用STRING類型取出資料，再轉換為對應數實值型別。

傳回值說明
返回ARRAY、MAP或STRUCT類型。

樣本

樣本1：將指定JSON字串以指定格式輸出。命令樣本如下。

--返回{"a":1,"b":0.8}。
select from_json('{"a":1, "b":0.8}', 'a int, b double');
--返回{"time":"26/08/2015"}。
select from_json('{"time":"26/08/2015"}', 'time string');
--返回{"a":1,"b":0.8}。
select from_json('{"a":1, "b":0.8}', 'a int, b double, c string');
--返回[1,2,3]。
select from_json('[1, 2, 3, "a"]', 'array<bigint>');
--返回{"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_KEYS的作用，擷取JSON字串中所有key的集合。命令樣本如下。
```
--返回["a","b"]。
select map_keys(from_json('{"a":1,"b":2}','map<string,string>'));
```

GET_JSON_OBJECT

使用說明

GET_JSON_OBJECT函數的作用是在一個標準JSON字串中，按照JSON PATH抽取指定的字串。當前函數的入參支援兩種類型：

入參為JSON類型：基於最新支援的JSON資料類型，採用更為規範的JSON PATH。
入參為STRING類型：原有的JSON PATH解析方式。

入參類型不同時函數的使用方式和注意事項不同，本文為您展示入參分別為JSON和STRING類型時，GET_JSON_OBJECT函數的使用方法。

說明

新JSON類型所使用的JSON PATH與原有的JSON PATH規範不同，可能存在相容性問題。
GET_JSON_OBJECT不支援JSON PATH的正則文法。

入參為JSON類型

命令格式

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

命令說明
在一個標準JSON字串中，按照JSON PATH抽取指定的字串。
參數說明
- json：必填，待處理的JSON資料。
- json_path：必填，需要返回的值的JSON路徑。
傳回值說明
返回STRING類型。

樣本

樣本1：從JSON中擷取key為a的value值。

select get_json_object(json '{"a":1, "b":2}', '$.a');

返回結果：

+-----+
| _c0 |
+-----+
| 1   |
+-----+

樣本2：從JSON中擷取key為c的value值。

select get_json_object(json '{"a":1, "b":2}', '$.c');

返回結果：

+-----+
| _c0 |
+-----+
| NULL |
+-----+

樣本3：JSON Path非法時，返回NULL。

select get_json_object(json '{"a":1, "b":2}', '$invalid_json_path');

返回結果：

+-----+
| _c0 |
+-----+
| NULL |
+-----+

入參為STRING類型

命令格式

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

命令說明
在一個標準JSON字串中，按照path抽取指定的字串。每次調用該函數時，都會讀一次未經處理資料，因此反覆調用可能影響效能和產生費用。您可以通過get_json_object，結合UDTF，輕鬆轉換JSON格式日誌資料，避免多次調用函數，詳情請參見利用MaxCompute內建函數及UDTF轉換JSON格式日誌資料。
參數說明
- json：必填。STRING類型。標準的JSON格式對象，格式為{Key:Value, Key:Value,...}。如果遇到英文雙引號（"），需要用兩個反斜線（\\）進行轉義。如果遇到英文單引號（'），需要用一個反斜線（\）進行轉義。
- path：必填。STRING類型。表示在json中的path，以$開頭。更多path資訊，請參見LanguageManual UDF。相關最佳實務案例，請參見JSON資料從OSS遷移至MaxCompute。不同字元的含義如下：
  - $：表示根節點。
  - .或['']：表示子節點。MaxCompute支援用這兩種字元解析JSON對象，當JSON的Key本身包含.時，可以用['']來替代。
  - []：[number]表示數組下標，從0開始。
  - *：Wildcard for []，返回整個數組。*不支援轉義。
限制條件
用['']取數只在新版本支援，您需要添加設定Flag的語句set odps.sql.udf.getjsonobj.new=true;。
傳回值說明
- 如果json為空白或非法的json格式，返回NULL。
- 如果json合法，path也存在，則返回對應字串。
- 您可以通過在Session層級設定odps.sql.udf.getjsonobj.new屬性來控制函數的返回方式：
  - 當設定set odps.sql.udf.getjsonobj.new=true;時，函數返回行為採用了保留原始字串的方式進行輸出。
    推薦您使用此配置，函數返回行為更標準，處理資料更方便，效能更好。如果MaxCompute專案有使用JSON保留字元轉義行為的存量作業，建議保留原有行為方式，避免因未驗證而直接使用該行為產生錯誤或正確性問題。函數返回行為規則如下：
    - 傳回值仍是一個JSON字串，可以繼續當做JSON來解析，而不再需要額外使用replace或regexp_replace等函數替換反斜線。
    - 一個JSON對象中可以出現相同的Key，可以成功解析。
      --返回1。 select get_json_object('{"a":"1","a":"2"}', '$.a');
    - 支援EmojiEmoji對應的編碼字串。但DataWorks暫不支援輸入EmojiEmoji，僅支援通過Data Integration等工具直接將EmojiEmoji對應的編碼字串寫入MaxCompute，再用get_json_object函數處理。
      --返回Emoji符號。 select get_json_object('{"a":"<Emoji符號>"}', '$.a');
    - 輸出結果按照JSON字串的原始排序方式輸出。
      --返回{"b":"1","a":"2"}。 select get_json_object('{"b":"1","a":"2"}', '$');
  - 當設定set odps.sql.udf.getjsonobj.new=false;時，函數返回行為採用了JSON保留字元轉義的方式進行輸出。函數返回行為規則如下：
    - 分行符號（\n）、引號（"）等JSON保留字元使用字串'\n'、'\"'顯示。
    - 一個JSON對象中不可以出現相同的Key，可能導致無法解析。
```
--返回NULL。
select get_json_object('{"a":"1","a":"2"}', '$.a');
```
    - 不支援解析EmojiEmoji編碼的字串。
```
--返回NULL。
select get_json_object('{"a":"<Emoji符號>"}', '$.a');
```
    - 輸出結果按照字典排序方式輸出。
```
--返回{"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保留字元轉義。您可以通過以下樣本判斷MaxCompute專案中get_json_object函數採用了哪種行為，執行命令如下：
```
select get_json_object('{"a":"[\\"1\\"]"}', '$.a');
--JSON保留字元轉義的行為返回：
[\"1\"]

--保留原始字串的行為返回：
["1"]
```
  您可以通過申請連結或搜尋（DingTalk群號：11782920）加入MaxCompute開發人員社區釘群聯絡MaxCompute支援人員團隊，將您的專案中的get_json_object函數返回行為切換為保留原始字串的行為，避免在Session層級頻繁設定屬性。

樣本

樣本1：提取JSON對象src_json.json中的資訊。命令樣本如下。

--JSON對象src_json.json的內容。
+----+
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"
}
--提取owner欄位資訊，返回amy。
select get_json_object(src_json.json, '$.owner') from src_json;
--提取store.fruit欄位第一個數組資訊，返回{"weight":8,"type":"apple"}。
select get_json_object(src_json.json, '$.store.fruit[0]') from src_json;
--提取不存在的欄位資訊，返回NULL。
select get_json_object(src_json.json, '$.non_exist_key') from src_json;

樣本2：提取數組型JSON對象的資訊。命令樣本如下。

--返回2222。
select get_json_object('{"array":[["aaaa",1111],["bbbb",2222],["cccc",3333]]}','$.array[1][1]');
--返回["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[*]');
--返回["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');
--返回h1。
select get_json_object('{"aaa":"bbb","ccc":{"ddd":"eee","fff":"ggg","hhh":["h0","h1","h2"]},"iii":"jjj"}','$.ccc.hhh[1]');

樣本3：提取帶有.的JSON對象中的資訊。命令樣本如下。

--建立一張表。
create table mf_json (id string, json string);
--向表中插入資料，Key帶.。
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}]}}}");
--向表中插入資料，Key不帶.。
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}]}}}");
--取id的值，查詢key為China.beijing，返回0。由於包含.，只能用['']來解析。
select get_json_object(json, "$['China.beijing'].school['id']") from mf_json where id =1;
--取id的值，查詢key為China_beijing，返回0。查詢方法有如下兩種。
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輸入為空白或非法格式。命令樣本如下。

--返回NULL。
select get_json_object('','$.array[1][1]');
--返回NULL。
select get_json_object('"array":["aaaa",1111],"bbbb":["cccc",3333]','$.array[1][1]');

樣本5：JSON字串涉及轉義。命令樣本如下。

set odps.sql.udf.getjsonobj.new=true;
--返回"1"。
select get_json_object('{"a":"\\"1\\"","b":"2"}', '$.a'); 
--返回'1'。
select get_json_object('{"a":"\'1\'","b":"2"}', '$.a');

INDEX

命令格式
```
index(<var1>[<var2>])
```
命令說明
- 如果var1是array<T>類型，擷取var1的第var2個元素。ARRAY數組元素編號自左往右，從0開始計數。
- 如果var1是map<K, V>類型，擷取var1中Key為var2的Value。
說明
使用該函數時需要去掉index，請直接執行<var1>[<var2>]，否則會返回報錯。
參數說明
- var1：必填。array<T>類型或map<K, V>類型。array<T>中的T指代ARRAY數組元素的資料類型，數組中的元素可以為任意類型。map<K, V>中的K、V指代MAP對象的Key、Value。
- var2：必填。
  - 如果var1是array<T>類型，則var2為BIGINT類型且大於等於0。
  - 如果var1是map<K, V>類型，則var2與K的類型保持一致。
傳回值說明
- 如果var1是array<T>類型，函數返回T類型。返回規則如下：
  - 如果var2超出var1的元素數目範圍，返回結果為NULL。
  - 如果var1為NULL，返回結果為NULL。
- 如果var1是map<K, V>類型，函數返回V類型。返回規則如下：
  - 如果map<K, V>中不存在Key為var2的情況，返回結果為NULL。
  - 如果var1為NULL，返回結果為NULL。
樣本
- 樣本1：var1為array<T>類型。命令樣本如下。
```
--返回c。
select array('a','b','c')[2];
```
- 樣本2：var1為map<K, V>類型，命令樣本如下。
```
--返回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、T2分別代表成員變數f1、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} |
+----------+

命令樣本如下。

--將t_struct列展開。
select inline(array(t_struct)) from t_table;
--返回結果如下。
+------------+-----------+---------+------------+
| 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>,...)

命令說明
用於一個標準的JSON字串中，按照輸入的一組鍵(key1,key2,...)抽取各個鍵指定的字串。
參數說明
- json：必填。STRING類型，標準的JSON格式字串。
- key：必填。STRING類型，用於描述在JSON中的path，一次可輸入多個，不能以貨幣符號（$）開頭。MaxCompute支援用.或['']這兩種字元解析JSON，當JSON的Key本身包含.時，可以用['']來替代。
傳回值
返回STRING類型。
說明
- 如果JSON為空白或者為非法的JSON格式，返回NULL。
- 如果鍵Key為空白或者不合法（JSON中不存在）返回NULL。
- 如果JSON合法，鍵Key也存在，則返回對應字串。
- 支援包含中文的JSON資料解析。
- 支援多層嵌套的JSON資料解析。
- 支援包含多重嵌套的數組的JSON資料解析。
- 解析行為和設定了set odps.sql.udf.getjsonobj.new=true;後的GET_JSON_OBJECT的行為保持一致。在需要對同一個JSON字串多次解析的情況下，相比於多次調用GET_JSON_OBJECT，JSON_TUPLE可以一次輸入多個Key，且JSON字串只被解析一次，效率更高。
- JSON_TUPLE是UDTF，在需要選取其他列時應配合Lateral View使用。

JSON_OBJECT

命令格式

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

命令說明
產生JSON OBJECT，要求key和value成對出現。
參數說明
- key：最少需要存在1個key，也可以存在多個，支援的類型為STRING。
- value：最少需要存在1個value，也可以存在多個，支援的類型包括STRING、BIGINT、INT和BOOLEAN。
傳回值說明
返回JSON類型。

樣本

樣本1：只包含一對key和value。

--產生json對象
select json_object('a', 123);

返回結果：

+-----+
| _c0 |
+-----+
| {"a":123} |
+-----+

樣本2：包含多對key和value。

--產生json對象
select json_object('a', 123,'b','hello');

返回結果：

+-----+
| _c0 |
+-----+
| {"a":123,"b":"hello"} |
+-----+

JSON_ARRAY

命令格式
```
json json_array(<element>)
```
命令說明
產生JSON ARRAY。
參數說明
element：必填。該參數支援的類型包括STRING、BIGINT、BOOLEAN和JSON。
傳回值說明
返回JSON類型。

樣本

--產生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 |
|-------+-------|
```
- 當var是JSON ARRAY類型時，將最外層JSON ARRAY展開為多行JSON資料，其中KEY為NULL，VALUE為JSON ARRAY的元素。
- 當var是JSON OBJECT類型時，將最外層JSON OBJECT的每個KEY和VALUE展開為包含兩列的行，其中KEY列（STRING類型）儲存JSON OBJECT的KEY，VALUE列（JSON類型）儲存JSON OBJECT的VALUE。

樣本

建立表table_json並寫入資料，其中第一行為JSON OBJECT類型，第二行為JSON ARRAY類型。

-- 建立表
CREATE TABLE table_json(c1 json);
-- 插入資料
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}');
-- 查看錶資料
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運算式中對應json_path的資料，注意json_path非法時會報錯。
參數說明
- json：必填，待處理的JSON。
- json_path：必填，需要返回的值的JSON路徑。
傳回值說明
返回JSON類型。

樣本

樣本1：從JSON中擷取key為a的value值。

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 Path格式非法時，返回報錯資訊Invalid argument - Param json path $invalid_json_path is invalid。
```
select json_extract(json '{"a":1, "b":2}', '$a');
```
返回結果：
```
--返回報錯資訊
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路徑。
傳回值說明
返回BOOLEAN類型的true或者false。

樣本

樣本1：從JSON中查詢key為a的value值是否存在。

select json_exists(json '{"a":1, "b":2}', '$.a');

返回結果：

+------+
| _c0  |
+------+
| true |
+------+

樣本2：從JSON中查詢key為c的value值是否存在。

select json_exists(json '[1,2, {"a":34}]', '$[2].a');

返回結果：

+------+
| _c0  |
+------+
| true |
+------+

樣本3：根據下標位置取回對應的values是否存在。

select json_exists(json '{"a":1, "b":2}', 'strict $.c');

返回結果：

+------+
| _c0  |
+------+
| false |
+------+

JSON_PRETTY

命令格式
```
string json_pretty(<json>)
```
命令說明
美化JSON，增加換行及空格。
參數說明
json：必填，待處理的JSON。
傳回值說明
返回STRING類型。

樣本

--美化json
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內的資料類型（number類型）。
```
select json_type(json '123');
```
  返回結果：
```
+-----+
| _c0 |
+-----+
| number |
+-----+
```
- 樣本3：返回JSON內的資料類型（string類型）。
```
select json_type(json '"123"');
```
  返回結果：
```
+-----+
| _c0 |
+-----+
| string |
+-----+
```

JSON_FORMAT

命令格式
```
string json_format(<json>)
```
命令說明
將JSON資料轉換成STRING類型，預設不自動進行美化。
參數說明
json：必填，待處理的JSON。
傳回值說明
返回STRING類型。
樣本
- 樣本1：將NUMBER類型的JSON資料轉換為字串。
```
select json_format(json '123');
```
  返回結果：
```
+-----+
| _c0 |
+-----+
| 123 |
+-----+
```
- 樣本2：將STRING類型的JSON資料轉換為字串。
```
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字串。
傳回值說明
返回BOOLEAN類型的true或者false。
樣本
- 樣本1：檢查"abc"是否為合法的JSON格式字串。
```
select json_valid('"abc"');
```
  返回結果：
```
+------+
| _c0  |
+------+
| true |
+------+
```
- 樣本2：檢查abc是否為合法的JSON格式字串。
```
select json_valid('abc');
```
  返回結果：
```
+------+
| _c0  |
+------+
| false |
+------+
```

CAST

命令格式

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資料在JSON文法中為STRING類型。注意其與JSON_PARSE和JSON_FORMAT的區別：
  - JSON_PARSE只支援合法的JSON STRING轉換為JSON，而且可以轉換成JSON OBJECT。
  - 而CAST函數可以將任意STRING轉換為JSON STRING，轉換後的JSON資料為STRING類型。
- json 'null'和null會轉換成sql null。
傳回值說明
返回對應的JSON類型和基礎資料類型。

樣本

樣本1：STRING和JSON類型相互轉換。

--json轉成string
select cast(json '123' as string);
--返回：
+-----+
| _c0 |
+-----+
| 123 |
+-----+

--json轉成string
select cast(json '"abc"' as string);
--返回：
+-----+
| _c0 |
+-----+
| abc |
+-----+

--json轉成string
select cast(json 'true' as string); 
--返回：
+-----+
| _c0 |
+-----+
| TRUE |
+-----+

--json轉成string
select cast(json 'null' as string);
--返回：
+-----+
| _c0 |
+-----+
| NULL |
+-----+

--string轉成json
select cast('{"a":2}' as json); 
--返回：
+-----+
| _c0 |
+-----+
| "{\"a\":2}" |
+-----+


--json轉成string的錯誤樣本，不支援array/object類型的JSON運算式轉換為string。
select cast(json '{"a":2}' as string);
--返回報錯：
FAILED: ODPS-0123091:Illegal type cast - Unsupported cast from json array/object to string

樣本2：NUMBER和JSON類型相互轉換。

--json轉成bigint
select cast(json '123' as bigint);
--返回：
+------------+
| _c0        |
+------------+
| 123        |
+------------+

--json轉成float
select cast(json '"1.23"' as float);
--返回：
+------+
| _c0  |
+------+
| 1.23 |
+------+

--json轉成double
select cast(json '1.23' as double);
--返回：
+------------+
| _c0        |
+------------+
| 1.23       |
+------------+

--int轉成json
select cast(123 as json);
--返回：
+-----+
| _c0 |
+-----+
| 123 |
+-----+

--float轉成json
select cast(1.23 as json);
--返回：
+-----+
| _c0 |
+-----+
| 1.23 |
+-----+

樣本3：BOOLEAN和JSON類型的相互轉換。

--boolean轉成bigint
select cast(true as json);
--返回：
+-----+
| _c0 |
+-----+
| true |
+-----+

--json轉成boolean
select cast(json 'false' as boolean);
--返回：
+------+
| _c0  |
+------+
| false |
+------+

--json轉成boolean
select cast(json '"abc"' as boolean);
--返回：
+------+
| _c0  |
+------+
| true |
+------+

--array/object不能轉成boolean
select cast(json '[1,2]' as boolean);
--返回報錯：
Unsupported cast from json array/object to boolean

樣本4：NULL和JSON類型的相互轉換。

--null轉成string
select json_type(cast(null as json));
--返回：
+-----+
| _c0 |
+-----+
| NULL |
+-----+

MAP

命令格式

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

命令說明
使用給定的Key-Value對產生MAP。
參數說明
- key：必填。所有key類型一致（包括隱式轉換後類型一致），必須是基本類型。
- value：必填。所有value類型一致（包括隱式轉換後類型一致），支援除Decimal之外的其它資料類型。
傳回值說明
返回MAP類型。
說明
您可以在Session層級通過odps.sql.map.key.dedup.policy參數設定出現重複Key時的處理方式。取值範圍如下：
- exception：如果出現重複的Key，返回報錯。
- last_win：如果出現重複的Key，後邊的值將覆蓋前邊的值。
不設定時，該參數預設值為last_win。

樣本

樣本1：無重複Key。例如表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          |
+------------+----+----+------------+------------+

命令樣本如下。

--將c2、c4，c3、c5組成MAP。
select map(c2,c4,c3,c5) from t_table;
--返回結果如下。
+------+
| _c0  |
+------+
| {k11:86, k21:15} |
| {k12:97, k22:2} |
| {k13:99, k23:1} |
+------+

樣本2。有重複Key。例如表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

命令樣本如下。

--將c2、c4，c3、c5組成MAP。
select map(c2,c4,c3,c5) from t_table;
--返回結果如下。
+------+
| _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>[,...])

命令說明
計算多個MAP對象的並集。
參數說明
- mapDupKeyPolicy：可選。STRING類型。指定出現重複Key時的處理方式。取值範圍如下：
  - exception：如果出現重複的Key，返回報錯。
  - last_win：如果出現重複的Key，後邊的值將覆蓋前邊的值。
  該參數也可以在Session層級通過odps.sql.map.key.dedup.policy參數進行設定，例如set odps.sql.map.key.dedup.policy=exception;，不設定時該參數預設值為last_win。
  說明
  MaxCompute的行為實現優先以函數中mapDupKeyPolicy的取值為準，當函數未配置mapDupKeyPolicy時，以odps.sql.map.key.dedup.policy參數的取值為準。
- a、b：必填。MAP對象。多個MAP對象的參數資料類型必須一致。map<K, V>中的K、V指代MAP對象的Key、Value。
傳回值說明
返回MAP類型。返回規則如下：
- 某個MAP對象為NULL或某個MAP對象的Key為NULL時，返回報錯。
- 多個MAP對象的資料類型不一致時，返回報錯。

樣本

--返回{1:a, 2:b, 3:c}。
select map_concat(map(1, 'a', 2, 'b'), map(3, 'c'));
--返回{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的K、Value映射轉換為STRUCT結構數組。
參數說明
a：必填。MAP對象。map<K, V>中的K、V指代MAP對象的Key、Value。
傳回值說明
返回STRUCT結構數組。如果輸入為NULL，返回結果為NULL。

樣本

--返回[{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的元素進行過濾，只保留滿足predicate條件的元素。
參數說明
- input：必填。MAP類型。map<K, V>中的K、V指代MAP對象的Key、Value。
- predicate：必填。用於對輸入MAP對象中的元素進行過濾的函數（內建函數或自訂函數）或運算式。它的兩個輸入參數，分別對應input中的Key和Value，輸出結果為BOOLEAN類型。
傳回值說明
返回MAP類型。

樣本

--返回{-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>))

命令說明
將ARRAY數組a和b組合成一個MAP對象。
參數說明
- mapDupKeyPolicy：可選。STRING類型。指定出現重複Key時的處理方式。取值範圍如下：
  - exception：如果出現重複的Key，返回報錯。
  - last_win：如果出現重複的Key，後邊的值將覆蓋前邊的值。
  該參數也可以在Session層級通過odps.sql.map.key.dedup.policy參數進行設定，例如set odps.sql.map.key.dedup.policy=exception;，不設定時該參數預設值為last_win。
  說明
  MaxCompute的行為實現優先以函數中mapDupKeyPolicy的取值為準，當函數未配置mapDupKeyPolicy時，以odps.sql.map.key.dedup.policy參數的取值為準。
- a：必填。ARRAY數組。對應產生MAP的Key值。array<K>中的K指代ARRAY數組元素的資料類型，數組中的元素可以為任意類型。
- b：必填。ARRAY數組。對應產生MAP的Value值。array<V>中的V指代ARRAY數組元素的資料類型，數組中的元素可以為任意類型。
傳回值說明
返回MAP類型。返回規則如下：
- 如果a或b為NULL，返回結果為NULL。
- 如果a中元素包含NULL值或兩個數組長度不相等，會返回報錯。

樣本

--返回{1:2, 3:4}。
select map_from_arrays(array(1.0, 3.0), array('2', '4'));
--返回{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>[,...]>)

命令說明
將多個結構數組組合成一個MAP對象。
參數說明
- mapDupKeyPolicy：可選。STRING類型。指定出現重複Key時的處理方式。取值範圍如下：
  - exception：如果出現重複的Key，返回報錯。
  - last_win：如果出現重複的Key，後邊的值將覆蓋前邊的值。
  該參數也可以在Session層級通過odps.sql.map.key.dedup.policy參數進行設定，例如set odps.sql.map.key.dedup.policy=exception;，不設定時該參數預設值為last_win。
  說明
  MaxCompute的行為實現優先以函數中mapDupKeyPolicy的取值為準，當函數未配置mapDupKeyPolicy時，以odps.sql.map.key.dedup.policy參數的取值為準。
- 輸入為STRUCT類型的資料。其中：K對應產生MAP的Key值，V對應產生MAP的Value值。struct<K, V>中的K、V指代STRUCT的Key、Value。
傳回值說明
返回MAP類型。返回規則如下：
- 如果結構體數組為NULL，返回結果為NULL。
- 如果結構體的Field數量不是2或K包含NULL值，會返回報錯。

樣本

--返回{1:a, 2:b}。
select map_from_entries(array(struct(1, 'a'), struct(2, 'b')));
--返回{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中的所有Key產生ARRAY數組。
參數說明
a：必填。MAP對象。map<K, V>中的K、V指代MAP對象的Key、Value。
傳回值說明
返回ARRAY類型。輸入MAP對象為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} |
+------------+-------+

命令樣本如下。

--將t_map中的Key作為數組返回。
select c1, map_keys(t_map) from t_table_map;
--返回結果如下。
+------------+------+
| c1         | _c1  |
+------------+------+
| 1000       | [k11, k21] |
| 1001       | [k12, k22] |
| 1002       | [k13, k23] |
+------------+------+

MAP_VALUES

命令格式
```
array<V> map_values(map<K, V> <a>)
```
命令說明
將MAP對象a中的所有Value產生ARRAY數組。
參數說明
a：必填。MAP對象。map<K, V>中的K、V指代MAP對象的Key、Value。
傳回值說明
返回ARRAY類型。輸入MAP對象為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} |
+------------+-------+

命令樣本如下。

--將t_map中的Key作為數組返回。
select c1,map_values(t_map) from t_table_map;
--返回結果如下。
+------------+------+
| 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和input2進行合并得到一個新MAP對象。新MAP的Key是兩個MAP的Key的並集。針對新MAP的每一個Key，通過func來計算它的Value。
參數說明
- input1、input2：必填。MAP對象。map<K, V>中的K、V指代MAP對象的Key、Value。
- func：必填。func有三個輸入參數，分別對應MAP的Key、Key相對應的input1以及input2的Value。如果Key在input1或者input2中不存在，func對應參數補充為NULL。
傳回值說明
返回func定義的類型。

樣本

--返回{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>>)

命令說明
返回由結構體數組中的Key和包含所有Value的數組所組成的Map。
參數說明
array<struct<K, V>>：為Key/Value組成的結構體數組。
傳回值說明
返回由結構體數組中的Key和包含所有Value的數組所組成的Map，Map格式為map<K, array<V>>。
- 在返回的Map中每個Key可以與多個值相關聯，這些相關聯的值存放在一個數組裡。
- 如果數組為Null，返回Null值。
- 如果結構體中的欄位（StructFiled）數量不是2或Key包含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>[, ...])

命令說明
使用指定的name、value列表建立STRUCT。
參數說明
- value：必填。可以為任意類型。
- name：必填。指定STRING類型的Field名稱。此參數為常量。
傳回值說明
返回STRUCT類型。Field的名稱依次為name1，name2，…。

樣本

--返回{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元文法（n-gram）數組。
參數說明
- array：為輸入數組。
- n：元數。
傳回值說明
返回指定數組元素的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>)
```
命令說明
將ARRAY數組a展開，每個Value一行，每行兩列分別對應數組從0開始的下標和數組元素。
參數說明
a：必填。ARRAY數組。array<T>中的T指代ARRAY數組元素的資料類型，數組中的元素可以為任意類型。
傳回值說明
返回表。

樣本

select posexplode(array('a','c','f','b'));
--返回結果如下。
+------------+------------+
| pos        | val        |
+------------+------------+
| 0          | a          |
| 1          | c          |
| 2          | f          |
| 3          | b          |
+------------+------------+

REVERSE

命令格式
```
array reverse(array <value>)
```
命令說明
根據輸入數組產生一個元素倒序的數組。
參數說明
value：輸入數組。
傳回值說明
返回輸入數組元素倒序的數組。如果輸入值為null，則返回NULL。

樣本

--返回[3, 4, 1, 2]
SELECT reverse(array(2, 1, 4, 3));

SEQUENCE

命令格式
```
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，否則為-1。
  如果元素序列為時間類型時，預設分別為1天或-1天；如果提供step值，當start大於stop時，step必須為負數，反之必須為正數，否則拋出異常。
傳回值說明
返回由指定運算式產生元素組成的數組。
- 如果start大於stop而step為正數時拋出異常，反之亦然。
- sequence函數預設產生的元素數量上限為10000，可以通過設定odps.sql.max.sequence.lengthFlag值改變元素數量上限。

樣本

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

命令格式
```
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> )

命令說明
- 輸入為ARRAY數組：計算ARRAY數組a中的元素數目。
- 輸入為MAP對象：計算MAP對象b中的Key-Value對數。
參數說明
- a：必填。ARRAY數組。array<T>中的T指代ARRAY數組元素的資料類型，數組中的元素可以為任意類型。
- b：必填。MAP對象。map<K, V>中的K、V指代MAP對象的Key 和 Value。
傳回值說明
返回INT類型。
樣本
- 樣本1：計算ARRAY數組array('a','b')中的元素數目。命令樣本如下。
```
--返回2。
select size(array('a','b'));
```
- 樣本2：計算MAP對象map('a',123,'b',456)中的Key-Value對數。
```
--返回2。
select size(map('a',123,'b',456)); 
```

SLICE

命令格式

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

命令說明
對ARRAY數組切片，截取從start位置開始長度為length的元素組成新的ARRAY數組。
參數說明
- a：必填。ARRAY數組。array<T>中的T指代ARRAY數組元素的資料類型，數組中的元素可以為任意類型。
- start：必填。切片起點，從1開始，表示從數組的首個元素開始向右切片。start可以為負數，表示從數組的末尾元素開始向右切片。
- length：必填。切片長度，必須大於或等於0。切片長度如果大於ARRAY數組長度時，會返回從start位置開始到末尾元素組成的ARRAY數組。
傳回值說明
返回ARRAY類型。
樣本
- 樣本1：截取ARRAY數組array(10, 20, 20, null, null, 30)從第1個位置開始，切片長度為3的元素。命令樣本如下。
```
--返回[10, 20, 20]。
select slice(array(10, 20, 20, null, null, 30), 1, 3);
```
- 樣本2：截取ARRAY數組array(10, 20, 20, null, null, 30)從第-2個位置開始，切片長度為2的元素。命令樣本如下。
```
--返回[NULL, 30]。
select slice(array(10, 20, 20, null, null, 30), -2, 2);  
```
- 樣本3：截取ARRAY數組array(10, 20, 20, null, null, 30)從第3個位置開始，切片長度為10的元素。命令樣本如下。
```
--返回[20, NULL, NULL, 30]。
select slice(array(10, 20, 20, null, null, 30), 3, 10); 
```
- 樣本4：截取ARRAY數組array(10, 20, 20, null, null, 30)從第3個位置開始，切片長度為0的元素。命令樣本如下。
```
--返回[]。
select slice(array(10, 20, 20, null, null, 30), 3, 0);
```

SORT_ARRAY

命令格式

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

命令說明
對ARRAY數組中的元素進行排序。
參數說明
- a：必填。ARRAY數組。array<T>中的T指代ARRAY數組元素的資料類型，數組中的元素可以為任意類型。
- isasc：可選。用於設定定序。取值為True（升序）或False（降序）。預設為升序。
傳回值說明
返回ARRAY類型。NULL值為最小值。

樣本

樣本1：例如表t_array的欄位為c1 array<string>,c2 array<int> ,c3 array<string>，包含資料如下：

+------------+---------+--------------+
| c1         | c2      | c3           |
+------------+---------+--------------+
| [a, c, f, b]  | [4, 5, 7, 2, 5, 8]  |  [你, 我, 他] |
+------------+---------+--------------+

對錶的每列資料進行排序。命令樣本如下。

--返回[a, b, c, f] [2, 4, 5, 5, 7, 8] [他, 你, 我]。
select sort_array(c1),sort_array(c2),sort_array(c3) from t_array;

樣本2：對ARRAY數組array(10, 20, 40, 30, 30, null, 50)進行降序排序。命令樣本如下。

--返回[50, 40, 30, 30, 20, 10, NULL]。
select sort_array(array(10, 20, 40, 30, 30, null, 50), false);

SPLIT

命令格式
```
split(<str>, <pat>)
```
命令說明
通過pat將str分割後返回數組。
參數說明
- str：必填。STRING類型。指被分割的字串。
- pat：必填。STRING類型的分隔字元。支援Regex。更多Regex資訊，請參見RLIKE字元匹配。
傳回值說明
返回ARRAY數組。數組中的元素為STRING類型。

樣本

--返回[a,  b,  c]。
select split("a, b, c", ",");

STRUCT

命令格式
```
struct struct(<value1>,<value2>[, ...])
```
命令說明
使用指定value列表建立STRUCT。
參數說明
value：必填。可以為任意類型。
傳回值說明
返回STRUCT類型。Field的名稱依次為col1，col2，…。

樣本

--返回{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字串時，Key會全部轉為小寫。
- value如果為NULL，則不輸出value本組的資料。例如value2為NULL，則key2:value2不會輸出到JSON字串。
傳回值說明
返回JSON格式的字串。

樣本

樣本1：將指定複雜類型以指定格式輸出。命令樣本如下。

--返回{"a":1,"b":2}。
select to_json(named_struct('a', 1, 'b', 2));
--返回{"time":"26/08/2015"}。
select to_json(named_struct('time', "26/08/2015"));
--返回[{"a":1,"b":2}]。
select to_json(array(named_struct('a', 1, 'b', 2)));
--返回{"a":{"b":1}}。
select to_json(map('a', named_struct('b', 1)));
--返回{"a":1}。
select to_json(map('a', 1));
--返回[{"a":1}]。
select to_json(array((map('a', 1))));

樣本2：輸入為STRUCT類型的特殊情況。命令樣本如下。

--返回{"a":"B"}。STRUCT類型轉換為JSON字串時，key會全部轉為小寫。
select to_json(named_struct("A", "B"));
--返回{"k2":"v2"}。NULL值所在組的資料，不會輸出到JSON字串。
select to_json(named_struct("k1", cast(null as string), "k2", "v2"));

TRANSFORM

命令格式

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

命令說明
將ARRAY數組a的元素利用func進行轉換，返回一個新的ARRAY數組。
參數說明
- a：必填。ARRAY數組。array<T>中的T指代ARRAY數組元素的資料類型，數組中的元素可以為任意類型。
- func：必填。用於對a中元素進行轉換的函數（內建函數或自訂函數）或運算式，其輸入類型應與a中的元素類型一致。R指代輸出結果的資料類型。
傳回值說明
返回ARRAY類型。

樣本

--返回[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>)

命令說明
對MAP對象input進行變換，保持Value不變，通過func計算新的Key值。
參數說明
- mapDupKeyPolicy：可選。STRING類型。指定出現重複Key時的處理方式。取值範圍如下：
  - exception：如果出現重複的Key，返回報錯。
  - last_win：如果出現重複的Key，後邊的值將覆蓋前邊的值。
  該參數也可以在Session層級通過odps.sql.map.key.dedup.policy參數進行設定，例如set odps.sql.map.key.dedup.policy=exception;，不設定時該參數預設值為last_win。
  說明
  MaxCompute的行為實現優先以函數中mapDupKeyPolicy的取值為準，當函數未配置mapDupKeyPolicy時，以odps.sql.map.key.dedup.policy參數的取值為準。
- input：必填。MAP對象。map<K1, V>中的K1、V指代MAP對象的Key、Value。
- func：必填。變換的函數（內建函數或自訂函數）或運算式。它的兩個輸入參數分別對應input的Key和Value，K2指代新MAP的Key類型。
傳回值說明
返回MAP類型。如果計算的新Key為NULL，會返回報錯。

樣本

--返回{-10:-20, 70:50, 71:101}。
select transform_keys(map(10, -20, 20, 50, -30, 101), (k, v) -> k + v);
--不報錯，返回的結果依賴於輸入map中元素的順序。
select transform_keys("last_win", map(10, -20, 20, 50, -30, 100), (k, v) -> k + v);
--因出現重複Key，返回報錯。
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>)

命令說明
對輸入MAP對象input進行變換，保持Key不變，通過func計算新的Value值。
參數說明
- input：必填。MAP對象。map<K, V1>中的K、V1指代MAP對象的Key、Value。
- func：必填。變換的函數（內建函數或自訂函數）或運算式。它的兩個輸入參數分別對應input的Key和Value，V2指代新MAP的Value類型。
傳回值說明
返回MAP類型。

樣本

--返回{-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>)

命令說明
將ARRAY數組a和b的元素按照位置，使用combiner進行元素層級的合并，返回一個新的ARRAY數組。
參數說明
- a、b：必填。ARRAY數組。array<T>、array<S>中的T、S指代ARRAY數組元素的資料類型，數組中的元素可以為任意類型。
- combiner：必填。用於合并ARRAY數組a、b中元素的函數（內建函數或自訂函數）或運算式。它的兩個輸入參數類型分別與ARRAY數組a、b中元素的資料類型一致。
傳回值說明
返回ARRAY類型。返回規則如下：
- 新產生的ARRAY數組中元素位置與a、b中相應元素的位置相同。
- 如果ARRAY數組a和b的長度不一致，會將長度較短的ARRAY數組使用NULL值進行填充，然後進行合并。

樣本

--返回[2, 4, 6, NULL]。
select zip_with(array(1,2,3), array(1,2,3,4), (x,y) -> x + y);