SQL 集計関数の使用方法とリファレンス - MaxCompute

集計関数は、複数の入力レコードを単一の出力値に結合します。MaxCompute SQL では、group by 句と集計関数を併用できます。このトピックでは、MaxCompute SQL がサポートする集計関数の構文、パラメーター、および使用例について説明し、これらの関数を使用したデータ開発をガイドします。

次の表に、MaxCompute SQL でサポートされている集計関数を示します。

関数	機能
ANY	入力値の少なくとも 1 つが True であるかどうかをチェックします。
ANY_VALUE	指定された範囲から値を返します。
APPROX_DISTINCT	指定された列内の個別入力値の概数を返します。
ARG_MAX	指定された列の最大値に対応する行の列値を返します。
ARG_MIN	特定の列の最小値に対応する行の列値を返します。
AVG	平均値を計算します。
BITWISE_AND_AGG	ビット単位の AND 演算に基づいて入力値を集計します。
BITWISE_OR_AGG	ビット単位の OR 演算に基づいて入力値を集計します。
BITWISE_XOR_AGG	ビット単位の XOR 演算に基づいて入力値を集計します。
BOOL_AND	ブール値のセットに対して論理 AND 演算を実行します。
BOOL_OR	ブール値のセットに対して論理 OR 演算を実行します。
COLLECT_LIST	指定された列を配列に集計します。
COLLECT_SET	指定された列から重複しない値を配列に集計します。
CORR	2 つの列のピアソンの相関係数を計算します。
COUNT	レコードをカウントします。
COUNT_IF	expr の値が True であるレコードの数を返します。
COVAR_POP	指定された 2 つの数値列の母共分散を計算します。
COVAR_SAMP	指定された 2 つの数値列の標本共分散を計算します。
HISTOGRAM	各入力値が出現する回数を含むマップを返します。
MAP_AGG	2 つの入力フィールドのマップを構築します。
MAP_UNION	すべての入力マップの和集合である新しいマップを返します。
MAP_UNION_SUM	すべての入力マップの和集合である新しいマップを返します。出力マップは、すべての入力マップで一致するキーの値を合計します。
MAX	最大値を計算します。
MAX_BY	指定された列の最大値に対応する行の列値を返します。
MEDIAN	中央値を計算します。
MIN	最小値を計算します。
MIN_BY	特定の列の最小値に対応する行の列値を返します。
MULTIMAP_AGG	a と b を使用して作成されたマップを返します。a はマップのキーです。b は配列の作成に使用され、その配列がマップのキーの値として使用されます。
NUMERIC_HISTOGRAM	指定された列に基づいて近似ヒストグラムを返します。
PERCENTILE	正確なパーセンタイルを計算します。この関数は、少量のデータを計算するシナリオに適しています。
PERCENTILE_APPROX	近似パーセンタイルを返します。この関数は、大量のデータが計算されるシナリオに適用されます。
PERCENTILE_CONT	正確なパーセンタイルを計算します。
PERCENTILE_DISC	指定されたパーセンタイル値を計算します。
STDDEV	すべての入力値の母集団標準偏差を返します。
STDDEV_SAMP	すべての入力値の標本標準偏差を返します。
SUM	列の合計を返します。
VAR_SAMP	指定された数値列の標本分散を計算します。
VARIANCE/VAR_POP	指定された数値列の分散を計算します。
WM_CONCAT	指定されたデリミタで文字列を連結します。

注意事項

MaxCompute V2.0 は追加の関数を提供します。使用する関数に MaxCompute V2.0 データ型エディションでサポートされている新しいデータ型が含まれる場合は、`SET` 文を実行して MaxCompute V2.0 データ型エディションを有効にする必要があります。新しいデータ型には、`TINYINT`、`SMALLINT`、`INT`、`FLOAT`、`VARCHAR`、`TIMESTAMP`、`BINARY` が含まれます。

セッションレベル：新しいデータ型を使用するには、SQL 文の前に set odps.sql.type.system.odps2=true; 文を追加し、両方を一緒に実行のために送信します。
プロジェクトオーナーは、必要に応じてプロジェクトレベルで設定を構成できます。変更は 10〜15 分以内に有効になります。コマンドは次のとおりです。
```
setproject odps.sql.type.system.odps2=true;
```
setproject の詳細については、「プロジェクト操作」をご参照ください。プロジェクトレベルのデータ型を有効にする際の注意事項の詳細については、「データ型バージョン」をご参照ください。
ワーカーには最大 200 万の要素を含めることができます。

複数の集計関数を含む SQL 文を使用し、プロジェクトのリソースが不足している場合、メモリオーバーフローが発生する可能性があります。必要に応じて SQL 文を最適化するか、コンピューティングリソースを購入することを推奨します。

集計関数の構文

集計関数の構文：

<aggregate_name>(<expression>[,...]) [WITHIN GROUP (ORDER BY <col1>[,<col2>…])] [FILTER (WHERE <where_condition>)]

<aggregate_name>(<expression>[,...])：組み込みの集計関数またはユーザー定義集計関数 (UDAF)。特定のフォーマットは、集計関数の構文に依存します。

WITHIN GROUP (ORDER BY <col1>[,<col2>…])：集計関数にこの式が含まれている場合、<col1>[,<col2>…] の入力データはデフォルトで昇順にソートされます。データを降順にソートするには、WITHIN GROUP (ORDER BY <col1>[,<col2>…] DESC) 式を使用します。

この式を使用する際は、次の点に注意してください：

この式は、WM_CONCAT、COLLECT_LIST、COLLECT_SET、および UDAF でのみ使用できます。
SELECT 文内の複数の集計関数に WITHIN GROUP (ORDER BY <col1>[,<col2>…]) 式が含まれている場合、ORDER BY <col1>[,<col2>…] 句はすべてのそのような関数で同一でなければなりません。
集計関数のパラメーターに DISTINCT キーワードが含まれている場合、ORDER BY <col1>[,<col2>…] 句では DISTINCT 列のみを使用できます。ORDER BY 句の列のセットは、DISTINCT 列のサブセットでなければなりません。さらに、<col1>[,<col2>…] のフィールドのデータ型は、集計関数の入力パラメーターのデータ型と一致する必要があります。
説明
WITHIN GROUP (ORDER BY <col1>[,<col2>…]) 式をサポートする集計関数は、1 つの入力パラメーターしか受け付けません。したがって、集計関数が DISTINCT キーワードを使用する場合、ORDER BY 句には 1 つの列しか含めることができず、そのデータ型は集計関数の入力パラメーターのデータ型と一致する必要があります。
たとえば、WM_CONCAT 関数の入力パラメーターは STRING 型でなければならないため、ORDER BY 句に続くフィールドも STRING 型でなければなりません。詳細については、以下の例 4 をご参照ください。例で使用されている emp テーブルの作成方法の詳細については、「サンプルデータ」をご参照ください。

例：

-- 例 1：入力データを昇順にソートしてから出力を返します。
SELECT x, wm_concat(',', y) WITHIN GROUP (ORDER BY y) FROM 
  VALUES('k', 1),('k', 3),('k', 2) AS t(x, y) GROUP BY x;
-- 次の結果が返されます。
+------------+------------+
| x          | _c1        |
+------------+------------+
| k          | 1,2,3      |
+------------+------------+

-- 例 2：入力データを降順にソートしてから出力を返します。
SELECT x, wm_concat(',', y) WITHIN GROUP (ORDER BY y DESC) FROM
  VALUES('k', 1),('k', 3),('k', 2) AS t(x, y) GROUP BY x;
-- 次の結果が返されます。
+------------+------------+
| x          | _c1        |
+------------+------------+
| k          | 3,2,1      |
+------------+------------+

-- 例 3
SELECT id, wm_concat(DISTINCT ',', name) WITHIN GROUP (ORDER BY name DESC) FROM 
  VALUES('k', '1'),('k', '3'),('k', '2') AS t(id, name) GROUP BY id;

-- 次の結果が返されます。
+------------+------------+
| id         | _c1        |
+------------+------------+
| k          | 3,2,1      |
+------------+------------+

-- 例 4
-- 集計関数のパラメーターに DISTINCT キーワードが含まれているため、wm_concat 関数の BIGINT 型の sal 入力パラメーターは暗黙的に STRING 型に変換されます。
-- wm_concat 関数の入力パラメーター型と一致させるために、`order by sal` で cast を使用して sal を STRING 型に変換する必要があります。そうしないと、エラーが報告されます。
SELECT deptno, wm_concat(DISTINCT ',', sal) 
  WITHIN GROUP (ORDER BY cast(sal AS STRING ) DESC) 
  FROM emp GROUP BY deptno ORDER BY deptno;

-- 次の結果が返されます。
+------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | 5000,2450,1300 |
| 20         | 800,3000,2975,1100 |
| 30         | 950,2850,1600,1500,1250 |
+------------+------------+

[FILTER (WHERE <where_condition>)]：集計関数にこの式が含まれている場合、<where_condition> を満たすデータのみを処理します。<where_condition> の詳細については、「WHERE 句 (where_condition)」をご参照ください。

この式を使用する際は、次の点に注意してください：

組み込みの集計関数のみがこの式をサポートします。UDAF はこの式をサポートしません。
count(*) は [FILTER (WHERE <where_condition>)] 式をサポートします。
COUNT_IF は [FILTER (WHERE <where_condition>)] 式をサポートしません。

例：

-- 例 1：データをフィルターして集計します。
select
  sum(x),
  sum(x) filter (where y > 1),
  sum(x) filter (where y > 2)
  from values(null, 1),(1, 2),(2, 3),(3, null) as t(x, y);
-- 次の結果が返されます。
+------------+------------+------------+
| _c0        | _c1        | _c2        |
+------------+------------+------------+
| 6          | 3          | 2          |
+------------+------------+------------+

-- 例 2：複数の集計関数を使用してデータをフィルターし、集計します。
select
  count_if(x > 2),
  sum(x) filter (where y > 1),
  sum(x) filter (where y > 2)
  from values(null, 1),(1, 2),(2, 3),(3, null) as t(x, y);
-- 次の結果が返されます。
+------------+------------+------------+
| _c0        | _c1        | _c2        |
+------------+------------+------------+
| 1          | 3          | 2          |
+------------+------------+------------+

サンプルデータ

各関数の使用方法を理解しやすくするために、このトピックではソースデータと、そのデータに基づいた関数の例を示します。次のコマンド例では、emp という名前のテーブルを作成し、データを追加します：

create table if not exists emp
   (empno bigint,
    ename string,
    job string,
    mgr bigint,
    hiredate datetime,
    sal bigint,
    comm bigint,
    deptno bigint);
tunnel upload emp.txt emp;

emp.txt ファイルには次のデータが含まれています：

7369,SMITH,CLERK,7902,1980-12-17 00:00:00,800,,20
7499,ALLEN,SALESMAN,7698,1981-02-20 00:00:00,1600,300,30
7521,WARD,SALESMAN,7698,1981-02-22 00:00:00,1250,500,30
7566,JONES,MANAGER,7839,1981-04-02 00:00:00,2975,,20
7654,MARTIN,SALESMAN,7698,1981-09-28 00:00:00,1250,1400,30
7698,BLAKE,MANAGER,7839,1981-05-01 00:00:00,2850,,30
7782,CLARK,MANAGER,7839,1981-06-09 00:00:00,2450,,10
7788,SCOTT,ANALYST,7566,1987-04-19 00:00:00,3000,,20
7839,KING,PRESIDENT,,1981-11-17 00:00:00,5000,,10
7844,TURNER,SALESMAN,7698,1981-09-08 00:00:00,1500,0,30
7876,ADAMS,CLERK,7788,1987-05-23 00:00:00,1100,,20
7900,JAMES,CLERK,7698,1981-12-03 00:00:00,950,,30
7902,FORD,ANALYST,7566,1981-12-03 00:00:00,3000,,20
7934,MILLER,CLERK,7782,1982-01-23 00:00:00,1300,,10
7948,JACCKA,CLERK,7782,1981-04-12 00:00:00,5000,,10
7956,WELAN,CLERK,7649,1982-07-20 00:00:00,2450,,10
7956,TEBAGE,CLERK,7748,1982-12-30 00:00:00,1300,,10

フィルター式

制限事項
- MaxCompute の組み込み集計関数のみがフィルター式をサポートします。UDAF はフィルター式をサポートしません。
- count(*) はフィルター式と一緒には使用できません。代わりに COUNT_IF 関数を使用してください。

構文

<aggregate_name>(<expression>[,...]) [filter (where <where_condition>)]

説明
すべての集計関数はフィルター式をサポートします。フィルター条件を指定すると、フィルター条件を満たす行データのみが関連する集計関数に渡されてデータ処理が行われます。
説明
- aggregate_name：必須。集計関数の名前。このトピックで説明されている集計関数から必要に応じて選択します。
- expression：必須。選択した集計関数のパラメーター。選択した集計関数の説明に基づいてこのパラメーターを指定します。
- where_condition：任意。フィルター条件。where_condition の詳細については、「WHERE 句 (where_condition)」をご参照ください。
戻り値の説明
詳細については、各集計関数の戻り値の説明をご参照ください。

使用例

select sum(sal) filter (where deptno=10), sum(sal) filter (where deptno=20), sum(sal) filter (where deptno=30) from emp;

次の結果が返されます：

+------------+------------+------------+
| _c0        | _c1        | _c2        |
+------------+------------+------------+
| 17500      | 10875      | 9400       |
+------------+------------+------------+

ANY

構文
```
BOOLEAN ANY(BOOLEAN <colname>)
```
説明
colname で指定された列の値を配列に集計し、少なくとも 1 つの要素が TRUE であるかどうかをチェックします。少なくとも 1 つの値が TRUE の場合、関数は TRUE を返します。
説明
colname：必須。列は BOOLEAN 型でなければなりません。
戻り値
BOOLEAN 型の値を返します。colname の値が NULL の場合、その行は計算から除外されます。

例

-- true を返します。
SELECT ANY(colname) FROM VALUES (true), (false), (false) AS tab(colname);
-- true を返します。
SELECT ANY(colname) FROM VALUES (NULL), (true), (false) AS tab(colname);
-- false を返します。
SELECT ANY(colname) FROM VALUES (false), (false), (NULL) AS tab(colname);
-- true を返します。
SELECT ANY(colname1) FILTER(WHERE colname2 = 2) FROM VALUES (true, 1), (false, 1), (true, 2) AS tab(colname1, colname2);

ANY_VALUE

構文
```
any_value(<colname>)
```
説明
この MaxCompute V2.0 拡張関数は、指定された範囲から任意の値を返します。
パラメーター
colname：必須。列は任意のデータ型にすることができます。
戻り値
戻り値のデータ型は、colname パラメーターのデータ型と同じです。colname パラメーターの値が null の場合、この値を含む行は計算に使用されません。

例

例 1：従業員の 1 人を選択します。サンプル文：

select any_value(ename) from emp;

次の結果が返されます：

+------------+
| _c0        |
+------------+
| SMITH      |
+------------+

例 2：この関数を group by と共に使用して、すべての従業員を部署 (deptno) ごとにグループ化し、各グループからランダムな従業員を選択します。サンプルコマンド：

select deptno, any_value(ename) from emp group by deptno;

次の結果が返されます：

+------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | CLARK      |
| 20         | SMITH      |
| 30         | ALLEN      |
+------------+------------+

APPROX_DISTINCT

構文
```
approx_distinct(<colname>)
```
コマンドの説明
指定された列内の個別入力値の概数を返します。この関数は MaxCompute V2.0 の追加機能です。
説明
colname：必須。重複を削除する必要がある列の名前。
戻り値
BIGINT 型の値が返されます。この関数は 5% の標準誤差を生じます。colname パラメーターで指定された列の値が null の場合、この値を含む行は計算に使用されません。

例

例 1：sal 列の個別値の概数を計算します。サンプル文：

select approx_distinct(sal) from emp;

次の結果が返されます：

+-------------------+
| numdistinctvalues |
+-------------------+
| 12                |
+-------------------+

例 2：この関数を group by と共に使用して、すべての従業員を部署 (deptno) ごとにグループ化し、各グループの給与 (sal) の個別値の概数を計算します。サンプルコマンド：

select deptno, approx_distinct(sal) from emp group by deptno;

次の結果が返されます：

+------------+-------------------+
| deptno     | numdistinctvalues |
+------------+-------------------+
| 10         | 3                 |
| 20         | 4                 |
| 30         | 5                 |
+------------+-------------------+

ARG_MAX

構文

arg_max(<valueToMaximize>, <valueToReturn>)

コマンドの説明
valueToMaximize の値が含まれる行を見つけ、その行の valueToReturn の値を返します。この関数は MaxCompute V2.0 の追加機能です。
説明
- valueToMaximize：必須。このパラメーターは任意のデータ型を受け入れます。
- valueToReturn：必須。このパラメーターは任意のデータ型の値を受け入れます。
戻り値
戻り値のデータ型は valueToReturn パラメーターのデータ型と同じです。複数の行が valueToMaximize の最大値を含む場合、それらの行のいずれかの valueToReturn の値がランダムに返されます。valueToMaximize の値が null の場合、この値を含む行は計算に使用されません。
例
- 例 1：最高給与の従業員の名前を返します。サンプル文：
```
select arg_max(sal, ename) from emp;
```
  次の結果が返されます：
```
+------------+
| _c0        |
+------------+
| KING       |
+------------+
```
- 例 2：この関数を group by と共に使用して、すべての従業員を部署 (deptno) ごとにグループ化し、各グループで最高給与の従業員の名前を返します。サンプルコマンド：
```
select deptno, arg_max(sal, ename) from emp group by deptno;
```
  次の結果が返されます：
```
+------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | KING       |
| 20         | SCOTT      |
| 30         | BLAKE      |
+------------+------------+
```

ARG_MIN

構文

arg_min(<valueToMinimize>, <valueToReturn>)

説明
valueToMinimize の最小値が含まれる行を見つけ、その行の valueToReturn の値を返します。この関数は MaxCompute V2.0 の追加機能です。
説明
- valueToMinimize：必須。任意のデータ型の値。
- valueToReturn：必須。任意のデータ型の値。
戻り値は以下で説明します。
戻り値のデータ型は valueToReturn パラメーターのデータ型と同じです。複数の行が valueToMinimize の最小値を含む場合、それらの行のいずれかの valueToReturn の値がランダムに返されます。valueToMinimize の値が null の場合、この値を含む行は計算に使用されません。
例
- 例 1：最低給与の従業員の名前を返します。サンプル文：
```
select arg_min(sal, ename) from emp;
```
  次の結果が返されます：
```
+------------+
| _c0        |
+------------+
| SMITH      |
+------------+
```
- 例 2：この関数を group by と共に使用して、すべての従業員を部署 (deptno) ごとにグループ化し、各グループで最低給与の従業員の名前を返します。サンプルコマンド：
```
select deptno, arg_min(sal, ename) from emp group by deptno;
```
  次の結果が返されます：
```
+------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | MILLER     |
| 20         | SMITH      |
| 30         | JAMES      |
+------------+------------+
```

AVG

構文
```
DECIMAL｜DOUBLE  avg(<colname>)
```
説明
平均値を計算します。
説明
colname：必須。列の値はすべてのデータ型をサポートし、計算前に DOUBLE 型に変換できます。
戻り値
colname の値が null の場合、この値を含む行は計算に使用されません。次の表は、入力データと戻り値のデータ型のマッピングを示しています。
入力型
戻り値の型
TINYINT
DOUBLE
SMALLINT
DOUBLE
INT
DOUBLE
BIGINT
DOUBLE
FLOAT
DOUBLE
DOUBLE
DOUBLE
DECIMAL
DECIMAL

例

例 1：すべての従業員の平均給与 (sal) を計算します。サンプル文：
```
select avg(sal) from emp;
```
次の結果が返されます：
```
+------------+
| _c0        |
+------------+
| 2222.0588235294117 |
+------------+
```

例 2：この関数を group by と共に使用して、すべての従業員を部署 (deptno) ごとにグループ化し、各部署の平均給与 (sal) を計算します。サンプルコマンド：

select deptno, avg(sal) from emp group by deptno;

次の結果が返されます：

+------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | 2916.6666666666665 |
| 20         | 2175.0     |
| 30         | 1566.6666666666667 |
+------------+------------+

BITWISE_AND_AGG

構文
```
BIGINT bitwise_and_agg(BIGINT value)
```
説明
ビット単位の AND 演算に基づいて入力値を集計します。
説明
value：必須。BIGINT 型の値。NULL 値は計算から除外されます。
このセクションでは戻り値について説明します。
BIGINT 型の値が返されます。

例

SELECT id, bitwise_and_agg(v) FROM
    VALUES (1L, 2L), (1L, 1L), (2L, null), (1L, null) t(id, v) GROUP BY id;

次の結果が返されます：

+------------+------------+
| id         | _c1        |
+------------+------------+
| 1          | 0          |
| 2          | NULL       |
+------------+------------+

BITWISE_OR_AGG

これは関数の宣言です。
```
bigint bitwise_or_agg(bigint value)
```
説明
ビット単位の OR 演算に基づいて入力値を集計します。
メトリックの説明
value：必須。BIGINT 型の値。null 値は計算に使用されません。
戻り値の説明
BIGINT 型の値が返されます。

例

select id, bitwise_or_agg(v) from
    values (1L, 2L), (1L, 1L), (2L, null), (1L, null) t(id, v) group by id;

次の結果が返されます：

+------------+------------+
| id         | _c1        |
+------------+------------+
| 1          | 3          |
| 2          | NULL       |
+------------+------------+

BITWISE_XOR_AGG

関数の宣言

BIGINT BITWISE_XOR_AGG(BIGINT|INT|SMALLINT|TINYINT value)

説明
ビット単位の XOR 演算を使用して入力値を集計します。
メトリックの説明
value：必須。BIGINT、INT、SMALLINT、または TINYINT 型の値。NULL 値は計算から除外されます。
戻り値
BIGINT 型の値を返します。次のルールが適用されます：
- value が BIGINT、INT、SMALLINT、または TINYINT 型でない場合、エラーが返されます。
- value が NULL の場合、NULL を返します。

例

SELECT id, bitwise_xor_agg(v) FROM 
  VALUES (1L, 2L), (1L, 1L), (2L, NULL), (1L, NULL) t(id, v) GROUP BY id;

次の結果が返されます。

+------------+------------+
| id         | _c1        | 
+------------+------------+
| 1          | 3          | 
| 2          | NULL       | 
+------------+------------+

BOOL_AND

構文
```
BOOLEAN BOOL_AND(<colname>)
```
コマンドの説明
colname で指定された列の値を配列に集計し、ブール値に対して論理 AND 演算を実行します。
パラメーター
colname：必須。テーブル列の名前。列は BOOLEAN 型でなければなりません。
戻り値
BOOLEAN 型の値を返します。次のルールが適用されます：
- すべての入力値が true の場合、関数は true を返します。それ以外の場合は false を返します。
- BOOL_AND() 関数はグループ内の NULL 値を無視します。

例

-- 例 1：単純な論理 AND 演算を実行します。
SELECT bool_and(colname) FROM VALUES (true), (false), (true) AS tab(colname);
-- 次の結果が返されます。
+------+
| _c0  | 
+------+
| false | 
+------+

-- 例 2：BOOL_AND() 関数はグループ内の NULL 値を無視します。
SELECT bool_and(colname) FROM VALUES (NULL), (true), (true) AS tab(colname);
-- 次の結果が返されます。
+------+
| _c0  | 
+------+
| true | 
+------+

-- 例 3：特定の列のみを集計します。
SELECT bool_and(colname1) FROM VALUES (true, 1), (false, 2), (true, 1) AS tab(colname1, colname2);
-- 次の結果が返されます。
+------+
| _c0  | 
+------+
| false | 
+------+

-- 例 4：フィルタリング後に論理 AND 演算を実行します。
SELECT bool_and(colname1) FILTER(WHERE colname2 = 1) FROM VALUES (true, 1), (false, 2), (true, 1) AS tab(colname1, colname2);
-- 次の結果が返されます。
+------+
| _c0  | 
+------+
| true | 
+------+

BOOL_OR

構文
```
BOOLEAN BOOL_OR(BOOLEAN <colname>)
```
このトピックでは、コマンドについて説明します。
colname で指定された列の値を配列に集計し、ブール値に対して論理 OR 演算を実行します。
メトリックの詳細
colname：必須。テーブル列の名前。列は BOOLEAN 型でなければなりません。
戻り値
BOOLEAN 型の値を返します。次のルールが適用されます：
- グループ内の少なくとも 1 つの入力値が true の場合、関数は true を返します。すべての値が false の場合、関数は false を返します。
- BOOL_OR() 関数はグループ内の NULL 値を無視します。

例

-- 例 1：単純な論理 OR 演算を実行します。
SELECT bool_or(colname) FROM VALUES (true), (false), (false) AS tab(colname);
-- 次の結果が返されます。
+------+
| _c0  | 
+------+
| true | 
+------+

-- 例 2：BOOL_OR() 関数はグループ内の NULL 値を無視します。
SELECT bool_or(colname) FROM VALUES (NULL), (true), (false) AS tab(colname);
-- 次の結果が返されます。
+------+
| _c0  | 
+------+
| true | 
+------+

-- 例 3
SELECT bool_or(colname1) FROM VALUES (false), (false), (NULL) AS tab(colname1);
-- 次の結果が返されます。
+------+
| _c0  | 
+------+
| false | 
+------+

-- 例 4：フィルタリング後に論理 OR 演算を実行します。
SELECT bool_or(colname1) FILTER(WHERE colname2 = 1) FROM VALUES (true, 1), (false, 1), (true, 2) AS tab(colname1, colname2);
-- 次の結果が返されます。
+------+
| _c0  | 
+------+
| true | 
+------+

COLLECT_LIST

構文
```
array collect_list(<colname>)
```
説明
colname で指定された列の値を配列に集計します。この関数は MaxCompute V2.0 によって提供される拡張機能です。
パラメーター
colname：必須。テーブル列の名前。列は任意のデータ型にすることができます。
戻り値
ARRAY 型の値が返されます。colname で指定された列の値が null の場合、この値を含む行は計算に使用されません。

例

例 1：すべての従業員の給与 (sal) を配列に集計します。サンプル文：

select collect_list(sal) from emp;

次の結果が返されます：

+------------+
| _c0        |
+------------+
| [800,1600,1250,2975,1250,2850,2450,3000,5000,1500,1100,950,3000,1300,5000,2450,1300] |
+------------+

例 2：この関数を group by と共に使用して、すべての従業員を部署 (deptno) ごとにグループ化し、同じグループの従業員の給与 (sal) を配列に集計します。サンプルコマンド：

select deptno, collect_list(sal) from emp group by deptno;

次の結果が返されます：

+------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | [2450,5000,1300,5000,2450,1300] |
| 20         | [800,2975,3000,1100,3000] |
| 30         | [1600,1250,1250,2850,1500,950] |
+------------+------------+

例 3：この関数を group by と共に使用して、すべての従業員を部署 (deptno) ごとにグループ化し、同じグループの従業員の個別給与 (sal) を配列に集計します。サンプルコマンド：

select deptno, collect_list(distinct sal) from emp group by deptno;

次の結果が返されます：

+------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | [1300,2450,5000] |
| 20         | [800,1100,2975,3000] |
| 30         | [950,1250,1500,1600,2850] |
+------------+------------+

COLLECT_SET

構文
```
array collect_set(<colname>)
```
説明
colname で指定された値を、重複しない値のみを含む配列に集計します。この関数は MaxCompute V2.0 の追加機能です。
説明
colname：必須。任意のデータ型の列の名前。
戻り値
ARRAY 型の値が返されます。colname で指定された列の値が null の場合、この値を含む行は計算に使用されません。
例
- 例 1：すべての従業員の給与 (sal) を、重複しない値のみを含む配列に集計します。サンプル文：
```
select collect_set(sal) from emp;
```
  次の結果が返されます：
```
+------------+
| _c0        |
+------------+
| [800,950,1100,1250,1300,1500,1600,2450,2850,2975,3000,5000] |
+------------+
```
- 例 2：この関数を group by と共に使用して、すべての従業員を部署 (deptno) ごとにグループ化し、同じグループの従業員の給与 (sal) を重複しない値の配列に集計します。サンプルコマンド：
```
select deptno, collect_set(sal) from emp group by deptno;
```
  次の結果が返されます：
```
+------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | [1300,2450,5000] |
| 20         | [800,1100,2975,3000] |
| 30         | [950,1250,1500,1600,2850] |
+------------+------------+
```

CORR

構文
```
double corr(<col1>, <col2>)
```
説明
2 つのデータ列のピアソンの相関係数を計算します。これは MaxCompute V2.0 の拡張関数です。
パラメーター
col1 と col2：必須。ピアソンの相関係数を計算したいテーブル内の 2 つの列の名前。列は DOUBLE、BIGINT、INT、SMALLINT、TINYINT、FLOAT、または DECIMAL 型でなければなりません。col1 と col2 のデータ型は異なっていてもかまいません。
戻り値
DOUBLE 型の値が返されます。入力列のいずれかの行に NULL 値が含まれている場合、その行は計算に使用されません。
例
サンプルデータに基づいて、次のコマンドは double_data 列と float_data 列のピアソンの相関係数を計算します。
```
select corr(double_data,float_data) from mf_math_fun_t;
```
戻り値は 1.0 です。

COUNT

構文

-- レコード数を計算します。
BIGINT COUNT([DISTINCT|ALL] <colname>)

-- ウィンドウ内のレコード数を計算します。
BIGINT COUNT(*) OVER ([partition_clause] [orderby_clause] [frame_clause])
BIGINT COUNT([DISTINCT] <expr>[,...]) OVER ([partition_clause] [orderby_clause] [frame_clause])

パラメーター

DISTINCT|ALL：任意。カウントする前に重複レコードを削除するかどうかを指定します。デフォルト値は ALL で、すべてのレコードをカウントします。DISTINCT を指定すると、関数は一意のレコードのみをカウントします。
colname：必須。値をカウントしたい列。このパラメーターは任意のデータ型にすることができます。COUNT(*) のように、colname に * を指定できます。この場合、関数は総行数を返します。colname の値が NULL の行は計算に含まれません。
expr：必須。式。このパラメーターは任意のデータ型にすることができます。式が NULL と評価される行は計算に含まれません。DISTINCT キーワードを指定すると、関数は一意の値のカウントを返します。
COUNT([DISTINCT] <expr>[,...])：指定されたウィンドウ内で、指定されたすべての式の値が NULL でない行の数をカウントします。DISTINCT キーワードを指定すると、関数は重複行を削除した後の行をカウントします。
partition_clause、orderby_clause、および frame_clause：詳細については、「windowing_definition」をご参照ください。

戻り値

この関数は BIGINT 値を返します。colname が NULL の行は計算に含まれません。

例

テストデータの準備

すでにデータがある場合は、このステップをスキップできます。

テストデータ test_data.txt をダウンロードします。

テストテーブルを作成します。

CREATE TABLE IF NOT EXISTS emp(
  empno BIGINT,
  ename STRING,
  job STRING,
  mgr BIGINT,
  hiredate DATETIME,
  sal BIGINT,
  comm BIGINT,
  deptno BIGINT
);

データをロードします。
FILE_PATH をデータファイルの実際のパスと名前に置き換えます。
```
TUNNEL UPLOAD FILE_PATH emp;   
```

例 1：ウィンドウの列を指定し、ソートせずに累積カウントを返す

この例では、ウィンドウを給与 (sal) 列でパーティション分割します。データはソートされません。関数は現在のウィンドウ内のすべての行の累積カウントを返します。ウィンドウには、同じ sal 値を持つすべての行が含まれます。

サンプルコマンド

SELECT sal, COUNT(sal) OVER (PARTITION BY sal) AS count FROM emp;

結果

+------------+------------+
| sal        | count      | 
+------------+------------+
| 800        | 1          | 
| 950        | 1          | 
| 1100       | 1          | 
| 1250       | 2          |  -- パーティションには sal が 1250 の行が 2 つ含まれています。関数は両方の行に対して 2 を返します。
| 1250       | 2          |  -- パーティション内の 2 番目の行のカウントも 2 です。
| 1300       | 2          | 
| 1300       | 2          | 
| 1500       | 1          | 
| 1600       | 1          | 
| 2450       | 2          | 
| 2450       | 2          | 
| 2850       | 1          | 
| 2975       | 1          | 
| 3000       | 2          | 
| 3000       | 2          | 
| 5000       | 2          | 
| 5000       | 2          | 
+------------+------------+

例 2：Hive 互換モード以外の場合、ウィンドウの列を指定し、ソート後に累積カウントを返す

Hive 互換モード以外の場合、この例ではウィンドウを給与 (sal) 列でパーティション分割し、データをソートします。関数は現在のウィンドウの最初の行から現在の行までの累積カウントを返します。ウィンドウには、同じ sal 値を持つすべての行が含まれます。

サンプルコマンド

-- Hive 互換モードを無効にします。
SET odps.sql.hive.compatible=false;

SELECT sal, COUNT(sal) OVER (PARTITION BY sal ORDER BY sal) AS count FROM emp;

戻り値

+------------+------------+
| sal        | count      |
+------------+------------+
| 800        | 1          |
| 950        | 1          |
| 1100       | 1          |
| 1250       | 1          |   -- ウィンドウパーティションが開始します。最初の行の実行カウントは 1 です。
| 1250       | 2          |   -- 2 番目の行の実行カウントは 2 です。
| 1300       | 1          |
| 1300       | 2          |
| 1500       | 1          |
| 1600       | 1          |
| 2450       | 1          |
| 2450       | 2          |
| 2850       | 1          |
| 2975       | 1          |
| 3000       | 1          |
| 3000       | 2          |
| 5000       | 1          |
| 5000       | 2          |
+------------+------------+

例 3：Hive 互換モードの場合、ウィンドウの列を指定し、ソート後に累積カウントを返す

Hive 互換モードの場合、この例ではウィンドウを給与 (sal) 列でパーティション分割し、データをソートします。関数は現在のウィンドウの最初の行から最後の行までの累積カウントを返します。ウィンドウには、同じ sal 値を持つすべての行が含まれます。

サンプルコマンド

-- Hive 互換モードを有効にします。
SET odps.sql.hive.compatible=true;

SELECT sal, COUNT(sal) OVER (PARTITION BY sal ORDER BY sal) AS count FROM emp;

結果

+------------+------------+
| sal        | count      |
+------------+------------+
| 800        | 1          |
| 950        | 1          |
| 1100       | 1          |
| 1250       | 2          |   -- パーティションには sal が 1250 の行が 2 つ含まれています。関数は両方の行に対して 2 を返します。
| 1250       | 2          |   -- パーティション内の 2 番目の行のカウントも 2 です。
| 1300       | 2          |
| 1300       | 2          |
| 1500       | 1          |
| 1600       | 1          |
| 2450       | 2          |
| 2450       | 2          |
| 2850       | 1          |
| 2975       | 1          |
| 3000       | 2          |
| 3000       | 2          |
| 5000       | 2          |
| 5000       | 2          |
+------------+------------+

例 4：総行数を返す

すべての部署の総従業員数を計算します。

サンプルコマンド
```
SELECT COUNT(*) FROM emp;
```

結果

+------------+
| _c0        |
+------------+
| 17         |
+------------+

例 5：データをグループ化し、各グループの合計を計算する

この例では、COUNT 関数と GROUP BY を使用して、すべての従業員を部署 (deptno) ごとにグループ化し、各部署の従業員数を計算します。

サンプルコマンド

SELECT deptno, COUNT(*) FROM emp GROUP BY deptno;

結果

+------------+------------+
| deptno     | _c1        | 
+------------+------------+
| 20         | 5          | 
| 30         | 6          | 
| 10         | 6          | 
+------------+------------+

例 6：一意の値をカウントする

この例では、DISTINCT を使用して重複値を削除し、部署の数をカウントします。

サンプルコマンド
```
SELECT COUNT(DISTINCT deptno) FROM emp;
```

戻り値

+------------+
| _c0        |
+------------+
| 3          |
+------------+

COUNT_IF

構文
```
bigint count_if(boolean <expr>)
```
説明
expr の値が True であるレコードの数を返します。
パラメーター
expr：必須。BOOLEAN 式。
戻り値
BIGINT 型の値が返されます。expr パラメーターの値が False または expr 内の特定の列の値が null の場合、この値を含む行は計算に使用されません。

例

select count_if(sal > 1000), count_if(sal <=1000) from emp;

次の結果が返されます：

+------------+------------+
| _c0        | _c1        |
+------------+------------+
| 15         | 2          |
+------------+------------+

COVAR_POP

構文

double covar_pop(<colname1>, <colname2>)

説明
指定された 2 つの数値列の母共分散を計算します。この関数は MaxCompute V2.0 の追加機能です。
パラメーターの説明
colname1 と colname2：必須。数値データ型の列。指定された列が数値列でない場合、null 値が返されます。

例

次のコマンドを実行して、emp テーブルにデータを追加します：

-- sal_new は新しい給与列です。
alter table emp add columns (sal_new bigint);
insert overwrite table emp select empno, ename, job, mgr, hiredate, sal, comm, deptno, sal+1000 from emp;

例 1：sal 列と sal_new 列の母共分散を計算します。サンプル文：

select covar_pop(sal, sal_new) from emp;

次の結果が返されます：

+------------+
| _c0        |
+------------+
| 1594550.1730103805 |
+------------+

例 2：この関数を group by と共に使用して、すべての従業員を部署 (deptno) ごとにグループ化し、各グループの sal 列と sal_new 列の母共分散を計算します。サンプルコマンド：

select deptno, covar_pop(sal, sal_new) from emp group by deptno;

次の結果が返されます：

+------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | 2390555.5555555555 |
| 20         | 1009500.0  |
| 30         | 372222.2222222222 |
+------------+------------+

COVAR_SAMP

構文

double covar_samp(<colname1>, <colname2>)

説明
指定された 2 つの数値列の標本共分散を計算します。この関数は MaxCompute V2.0 の追加機能です。
説明
colname1 と colname2：必須。数値データ型の列。指定された列が数値列でない場合、null 値が返されます。

例

次のコマンドを実行して、emp テーブルにデータを追加します：

-- sal_new は新しい給与列です。
alter table emp add columns (sal_new bigint);
insert overwrite table emp select empno, ename, job, mgr, hiredate, sal, comm, deptno, sal+1000 from emp;

例 1：sal 列と sal_new 列の標本共分散を計算します。サンプル文：

select covar_samp(sal, sal_new) from emp;

次の結果が返されます：

+------------+
| _c0        |
+------------+
| 1694209.5588235292 |
+------------+

例 2：この関数を group by と共に使用して、すべての従業員を部署 (deptno) ごとにグループ化し、各グループの sal 列と sal_new 列の標本共分散を計算します。サンプルコマンド：

select deptno, covar_samp(sal, sal_new) from emp group by deptno;

次の結果が返されます：

+------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | 2868666.6666666665 |
| 20         | 1261875.0  |
| 30         | 446666.6666666666 |
+------------+------------+

HISTOGRAM

関数の宣言
```
map<K, bigint> histogram(K input);
```
コマンドの説明
各入力値が出現する回数を含むマップを返します。マップのキーは入力値です。マップの各値は、入力値が出現する回数です。null 値は無視されます。
説明
input：入力値。マップのキーとして使用されます。
戻り値
各入力値が出現する回数を含むマップが返されます。

例

select histogram(a) from values
    ('hi'), (null), ('apple'), ('pie'), ('apple') t(a);

次の結果が返されます：

+----------------------------+
| _c0                        |
+----------------------------+
| {"pie":1,"hi":1,"apple":2} |
+----------------------------+

MAP_AGG

関数の宣言
```
map<K, V> map_agg(K a, V b);
```
このトピックでは、コマンドについて説明します。
a と b を使用して作成されたマップを返します。a はマップのキーです。b はマップのキーの値です。マップのキーが null の場合、キーは無視されます。キーフィールドに重複する値がある場合、値の 1 つがランダムに保持されます。
説明
- a：マップのキーとして使用される入力フィールド。
- b：マップの値として使用される入力フィールド。
戻り値の説明
新しいマップが返されます。

例

select map_agg(a, b) from
        values (1L, 'apple'), (2L, 'hi'), (null, 'good'), (1L, 'pie') t(a, b);

次の結果が返されます：

+------------------------+
| _c0                    |
+------------------------+
| {"2":"hi","1":"apple"} |
+------------------------+

MAP_UNION

関数の宣言
```
map<K, V> map_union(map<K, V> input);
```
このセクションでは、コマンドについて説明します。
すべての入力マップの和集合である新しいマップを返します。キーが複数の入力マップに存在する場合、キーに対応する値の 1 つがランダムに保持されます。
パラメーター
input：入力マップ。
戻り値の説明
新しいマップが返されます。

例

select map_union(a) from values
    (map(1L, 'hi', 2L, 'apple', 3L, 'pie')), (map(1L, 'good', 4L, 'this')), (null) t(a);

次の結果が返されます：

+-----------------------------------------------+
| _c0                                           |
+-----------------------------------------------+
| {"4":"this","1":"good","2":"apple","3":"pie"} |
+-----------------------------------------------+

MAP_UNION_SUM

関数の宣言

map<K, V> map_union_sum(map<K, V> input);

説明
すべての入力マップの和集合である新しいマップを返します。出力マップは、すべての入力マップで一致するキーの値を合計します。キーに対応する値が NULL の場合、値は 0 に変換されます。
説明
入力マップの値は、BIGINT、INT、SMALLINT、TINYINT、FLOAT、DOUBLE、または DECIMAL データ型でなければなりません。
パラメーターの説明
input：入力マップ。
戻り値の説明
新しいマップが返されます。
説明
新しいマップの値は、BIGINT、DOUBLE、または DECIMAL 型です。

例

select map_union_sum(a) from values
    (map('hi', 2L, 'apple', 3L, 'pie', 1L)), (map('apple', null, 'hi', 4L)), (null) t(a);

次の結果が返されます：

+----------------------------+
| _c0                        |
+----------------------------+
| {"apple":3,"hi":6,"pie":1} |
+----------------------------+

MAX

構文
```
max(<colname>)
```
説明
列の最大値を返します。
パラメーターの説明
colname：必須。BOOLEAN 以外の任意のデータ型の列の名前。
戻り値
戻り値の型は colname パラメーターの型と同じです。戻り値は次のルールに基づいて異なります：
- colname の値が null の場合、この値を含む行は計算に使用されません。
- colname の値が BOOLEAN 型の場合、その値は計算に使用されません。
例
- 例 1：すべての従業員の最高給与 (sal) を計算します。サンプル文：
```
select max(sal) from emp;
```
  次の結果が返されます：
```
+------------+
| _c0        |
+------------+
| 5000       |
+------------+
```
- 例 2：この関数を group by と共に使用して、すべての従業員を部署 (deptno) ごとにグループ化し、各部署の最高給与 (sal) を計算します。サンプルコマンド：
```
select deptno, max(sal) from emp group by deptno;
```
  次の結果が返されます：
```
+------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | 5000       |
| 20         | 3000       |
| 30         | 2850       |
+------------+------------+
```

MAX_BY

構文

max_by(<valueToReturn>,<valueToMaximize>)

説明
説明
MAX_BY 関数は ARG_MAX 関数と同じ機能を提供します。違いはパラメーターの順序にあります。MAX_BY 関数は、オープンソースの構文との互換性を維持するために MaxCompute に導入されました。
valueToMaximize の値が含まれる行を見つけ、その行の valueToReturn の値を返します。この関数は MaxCompute V2.0 の追加機能です。
パラメーターの説明
- valueToMaximize：必須。任意のデータ型の値。
- valueToReturn：必須。任意のデータ型の値。
戻り値
戻り値のデータ型は valueToReturn パラメーターのデータ型と同じです。複数の行が valueToMaximize の最大値を持つ場合、それらの行のいずれかの valueToReturn の値がランダムに返されます。valueToMaximize の値が null の場合、この値を含む行は計算に使用されません。
例
- 例 1：最高給与の従業員の名前を返します。サンプル文：
```
select max_by(ename,sal) from emp;
```
  次の結果が返されます：
```
+------------+
| _c0        |
+------------+
| KING       |
+------------+
```
- 例 2：この関数を group by と共に使用して、すべての従業員を部署 (deptno) ごとにグループ化し、各グループで最高給与の従業員の名前を返します。サンプルコマンド：
```
select deptno, max_by(ename,sal) from emp group by deptno;
```
  次の結果が返されます：
```
+------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | KING       |
| 20         | SCOTT      |
| 30         | BLAKE      |
+------------+------------+
```

MEDIAN

構文

double median(double <colname>)
decimal median(decimal <colname>)

説明
列の中央値を返します。
説明
colname：必須。DOUBLE または DECIMAL 型の列の名前。入力値が STRING または BIGINT 型の場合、計算前に暗黙的に DOUBLE 型に変換されます。
戻り値
colname の値が null の場合、この値を含む行は計算に使用されません。次の表は、入力データと戻り値のデータ型のマッピングを示しています。
入力型
戻り値の型
TINYINT
DOUBLE
SMALLINT
DOUBLE
INT
DOUBLE
BIGINT
DOUBLE
FLOAT
DOUBLE
DOUBLE
DOUBLE
DECIMAL
DECIMAL
例
- 例 1：すべての従業員の給与 (sal) の中央値を計算します。サンプル文：
```
select median(sal) from emp;
```
  次の結果が返されます：
```
+------------+
| _c0        |
+------------+
| 1600.0     |
+------------+
```
- 例 2：この関数を group by と共に使用して、すべての従業員を部署 (deptno) ごとにグループ化し、各部署の給与 (sal) の中央値を計算します。サンプルコマンド：
```
select deptno, median(sal) from emp group by deptno;
```
  次の結果が返されます：
```
+------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | 2450.0     |
| 20         | 2975.0     |
| 30         | 1375.0     |
+------------+------------+
```

MIN

構文
```
min(<colname>)
```
コマンドの説明
最小値を計算します。
パラメーター
colname：必須。BOOLEAN 以外の任意のデータ型の列の名前。
戻り値
戻り値の型は colname パラメーターの型と同じです。戻り値は次のルールに基づいて異なります：
- colname の値が null の場合、この値を含む行は計算に使用されません。
- colname の値が BOOLEAN 型の場合、その値は計算に使用されません。
例
- 例 1：すべての従業員の最低給与 (sal) を計算します。サンプル文：
```
select min(sal) from emp;
```
  次の結果が返されます：
```
+------------+
| _c0        |
+------------+
| 800        |
+------------+
```
- 例 2：この関数を group by と共に使用して、すべての従業員を部署 (deptno) ごとにグループ化し、各部署の最低給与 (sal) を計算します。サンプルコマンド：
```
select deptno, min(sal) from emp group by deptno;
```
  次の結果が返されます：
```
+------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | 1300       |
| 20         | 800        |
| 30         | 950        |
+------------+------------+
```

MIN_BY

構文

min_by(<valueToReturn>,<valueToMinimize>)

説明
説明
MIN_BY 関数は ARG_MIN 関数と同じ機能を提供します。ただし、関数のパラメーターの順序が異なります。MIN_BY 関数は、オープンソースの構文との互換性を維持するために MaxCompute に導入されました。
valueToMinimize の最小値が含まれる行を見つけ、その行の valueToReturn の値を返します。この関数は MaxCompute V2.0 の追加機能です。
パラメーターの説明
- valueToMinimize：必須。任意のデータ型の値。
- valueToReturn：必須。任意のデータ型の値。
戻り値の説明
戻り値のデータ型は valueToReturn パラメーターのデータ型と同じです。複数の行が valueToMinimize の最小値を含む場合、それらの行のいずれかの valueToReturn の値がランダムに返されます。valueToMinimize の値が null の場合、この値を含む行は計算に使用されません。
例
- 例 1：最低給与の従業員の名前を返します。サンプル文：
```
 select min_by(ename,sal) from emp;
```
  次の結果が返されます：
```
+------------+
| _c0        |
+------------+
| SMITH      |
+------------+
```
- 例 2：この関数を group by と共に使用して、すべての従業員を部署 (deptno) ごとにグループ化し、各グループで最低給与の従業員の名前を返します。サンプルコマンド：
```
select deptno, min_by(ename,sal) from emp group by deptno;
```
  次の結果が返されます：
```
+------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | MILLER     |
| 20         | SMITH      |
| 30         | JAMES      |
+------------+------------+
```

MULTIMAP_AGG

関数の宣言

map<K, array<V>> multimap_agg(K a, V b);

説明
a と b を使用して作成されたマップを返します。a はマップのキーです。b は配列の作成に使用され、その配列がマップのキーの値として使用されます。マップのキーが null の場合、キーは無視されます。
パラメーター
- a：マップのキーとして使用される入力フィールド。
- b：マップの値として使用される入力フィールド。同じキーに対応するフィールドは同じ配列に配置され、マップの値として使用されます。
戻り値の説明
新しいマップが返されます。

例

select multimap_agg(a, b) from
        values (1L, 'apple'), (2L, 'hi'), (null, 'good'), (1L, 'pie') t(a, b);

次の結果が返されます：

+----------------------------------+
| _c0                              |
+----------------------------------+
| {"2":["hi"],"1":["apple","pie"]} |
+----------------------------------+

NUMERIC_HISTOGRAM

構文

map<double key, double value> numeric_histogram(bigint <buckets>,
                                                double <colname>
                                                [, double <weight>])

説明
指定された列に基づいて近似ヒストグラムを返します。この関数は MaxCompute V2.0 の追加機能です。
パラメーターの説明
- buckets：必須。BIGINT 型の値。このパラメーターは、近似ヒストグラムが返される列のバケットの最大数を指定します。
- colname：必須。DOUBLE 型の値。このパラメーターは、近似ヒストグラムを計算する必要がある列を指定します。
- weight：任意。各行のデータの重み値。値は DOUBLE 型です。
戻り値の説明
map<double key, double value> 型の値を返します。戻り値では、キーは近似ヒストグラムの x 軸座標を表し、値は y 軸上の近似高さを表します。次のルールが適用されます：
- buckets の値が null の場合、null が返されます。
- colname の値が null の場合、この値を含む行は計算に使用されません。

例

sal 列の近似ヒストグラムを返します。サンプル文：

select numeric_histogram(5, sal) from emp;

次の結果が返されます：

+------------+
| _c0        |
+------------+
| {"1328.5714285714287":7.0,"2450.0":2.0,"5000.0":2.0,"875.0":2.0,"2956.25":4.0} |
+------------+

給与 (sal) 列の近似ヒストグラムを計算します。ここで、各行の deptno は部署の重みを表します。サンプルコマンド：

select numeric_histogram(5, sal, deptno) from emp;

次の結果が返されます：

+------------+
| _c0        |
+------------+
| {"2944.4444444444443":90.0,"2450.0":20.0,"5000.0":20.0,"890.0":50.0,"1350.0":160.0} |
+------------+

PERCENTILE

構文

double percentile(bigint <colname>, <p>)
-- 複数の正確なパーセンタイルを配列として返します。
array percentile(bigint <colname>, array(<p1> [, <p2>...]))

説明
正確なパーセンタイルを計算します。この関数は、少量のデータに適しています。まず指定された列を昇順にソートし、次に正確な p 番目のパーセンタイルを取得します。p は 0 から 1 の間でなければなりません。percentile の計算はインデックス 0 から始まります。たとえば、列に 100、200、300 の値が含まれている場合、それらのインデックスは 0、1、2 です。0.3 パーセンタイルを計算する場合、percentile の結果は 2 × 0.3 = 0.6 となります。これは、値がインデックス 0 と 1 の間にあることを意味します。結果は 100 + (200 - 100) × 0.6 = 160 です。この関数は MaxCompute V2.0 の拡張関数です。
説明
- colname：必須。BIGINT 型の列。
- p：必須。正確なパーセンタイル。範囲 [0.0, 1.0] 内でなければなりません。
戻り値の説明
DOUBLE または ARRAY 型の値が返されます。

例

例 1：次のコマンドは、給与 (sal) の 0.3 パーセンタイルを計算します：
```
select percentile(sal, 0.3) from emp;
```
次の結果が返されます：
```
+------------+
| _c0        |
+------------+
| 1290.0     |
+------------+
```
例 2：この関数を group by と共に使用して、すべての従業員を部署 (deptno) ごとにグループ化し、各グループの給与 (sal) の 0.3 パーセンタイルを計算します。サンプルコマンド：
```
select deptno, percentile(sal, 0.3) from emp group by deptno;
```
次の結果が返されます：
```
+------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | 1875.0     |
| 20         | 1475.0     |
| 30         | 1250.0     |
+------------+------------+
```

例 3：この関数を group by と共に使用して、すべての従業員を部署 (deptno) ごとにグループ化し、各グループの給与 (sal) の 0.3、0.5、0.8 パーセンタイルを計算します。サンプルコマンド：

set odps.sql.type.system.odps2=true;
select deptno, percentile(sal, array(0.3, 0.5, 0.8)) from emp group by deptno;

次の結果が返されます：

+------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | [1875.0,2450.0,5000.0] |
| 20         | [1475.0,2975.0,3000.0] |
| 30         | [1250.0,1375.0,1600.0] |
+------------+------------+

PERCENTILE_APPROX

構文

double percentile_approx (double <colname>[, double <weight>], <p> [, <B>]))
-- 複数の近似パーセンタイルを配列として返します。
array<double> percentile_approx (double <colname>
                                 [, double <weight>],
                                 array(<p1> [, <p2>...])
                                 [, <B>])

説明
これは MaxCompute V2.0 の拡張関数です。percentile_approx の計算は 1 から始まります。n 個のデータエントリを持つ列の p 番目のパーセンタイルを計算するために、percentile_approx 関数はまず列を昇順にソートします。ソートされた列データは arr という名前の配列として扱われ、percentile_approx の結果は res です。パーセンタイルのインデックスは index = n * p として計算されます。
- index <= 1 の場合、res = arr[0] です。
- index >= n - 1 の場合、res = arr[n-1] です。
- 1 < index < n - 1 の場合、diff = index + 0.5 - ceil(index) を計算します：
  abs(diff) < 0.5 条件が満たされる場合、res は次の数式に基づいて計算されます：res = arr[ceil(index) - 1]。
  abs(diff) = 0.5 条件が満たされる場合、res は次の数式に基づいて計算されます：res = arr[index - 1] + (arr[index] - arr[index - 1]) × 0.5。
  abs(diff) の値は 0.5 を超えることはできません。
たとえば、col 列に 100、200、300、400 の値が含まれている場合、それらのインデックスは 1、2、3、4 です。すると：
- percentile_approx(col, 0.25) = 100 (インデックス = 1)。
- percentile_approx(col, 0.5) = 200 + (300 - 200) * 0.5 = 250 (インデックス = 2)。
- percentile_approx(col, 0.75) = 400 (インデックス = 3)。
説明
percentile_approx と percentile の違いは次のとおりです：
- percentile_approx は近似パーセンタイルを計算しますが、percentile は正確なパーセンタイルを計算します。大量のデータの場合、percentile はメモリ制限により失敗する可能性がありますが、percentile_approx にはこの問題はありません。
- percentile_approx の実装は、Hive の percentile_approx 関数と一致しています。ただし、その計算アルゴリズムは percentile のものとは異なります。したがって、非常に少量のデータのシナリオでは、percentile_approx の結果は percentile の結果と異なる場合があります。
説明
- colname：必須。DOUBLE 型の列の名前。
- weight：任意。各行のデータの重み値。値は DOUBLE 型です。
- p：必須。近似パーセンタイル。範囲 [0.0, 1.0] 内でなければなりません。
- B：戻り値の精度。精度が高いほど、値はより正確になります。このパラメーターを指定しない場合、10000 が使用されます。
戻り値の説明
DOUBLE または ARRAY 型の値が返されます。戻り値は次のルールに基づいて異なります：
- colname の値が null の場合、この値を含む行は計算に使用されません。
- p または B の値が null の場合、エラーが返されます。

例

例 1：次のコマンドは、給与 (sal) の 0.3 パーセンタイルを計算します：
```
select percentile_approx(sal, 0.3) from emp;
```
次の結果が返されます：
```
+------------+
| _c0        |
+------------+
| 1252.5     |
+------------+
```
例 2：この関数を group by と共に使用して、すべての従業員を部署 (deptno) ごとにグループ化し、各グループの給与 (sal) の 0.3 パーセンタイルを計算します。サンプルコマンド：
```
select deptno, percentile_approx(sal, 0.3) from emp group by deptno;
```
次の結果が返されます：
```
+------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | 1300.0     |
| 20         | 950.0      |
| 30         | 1070.0     |
+------------+------------+
```

set odps.sql.type.system.odps2=true;
select deptno, percentile_approx(sal, array(0.3, 0.5, 0.8), 1000) from emp group by deptno;

次の結果が返されます：

+------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | [1300.0,1875.0,3470.000000000001] |
| 20         | [950.0,2037.5,2987.5] |
| 30         | [1070.0,1250.0,1580.0] |
+------------+------------+

例 4 (重み付き)：この関数を group by と共に使用して、すべての従業員を部署 (deptno) ごとにグループ化し、各グループの給与 (sal) の 0.3、0.5、0.8 パーセンタイルを計算します。emp テーブルの cnt 列は、その給与を持つ人数を表します。サンプルコマンド：
```
select deptno, percentile_approx(sal, deptno, array(0.3, 0.5, 0.8), 1000)
  from emp group by deptno;
```
次の結果が返されます：
```
+------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | [1300.0,1875.0,3470.0] |
| 20         | [950.0,2037.5,2987.5] |
| 30         | [1070.0,1250.0,1580.0] |
+------------+------------+
```

PERCENTILE_CONT

構文

-- 正確なパーセンタイルを計算します
PERCENTILE_CONT(<col_name>, DOUBLE <percentile>[, BOOLEAN <isIgnoreNull>])

-- ウィンドウ内で正確なパーセンタイルを計算します
PERCENTILE_CONT(<col_name>, DOUBLE <percentile>[, BOOLEAN <isIgnoreNull>]) OVER ([partition_clause] [orderby_clause])

説明
正確なパーセンタイルを計算します。線形補間アルゴリズムを使用し、指定された列を昇順にソートし、指定された percentile での正確な値を返します。
パラメーター
- col_name：必須。DOUBLE または DECIMAL 型の列。
- percentile：必須。計算するパーセンタイル。[0, 1] の範囲の DOUBLE 定数。
- isIgnoreNull：任意。NULL 値を無視するかどうかを指定します。BOOLEAN 定数。デフォルト値は TRUE です。FALSE に設定すると、NULL 値はソート中に最小値として扱われます。
- partition_clause と orderby_clause：詳細については、「ウィンドウ関数」をご参照ください。
戻り値
計算されたパーセンタイル値を DOUBLE として返します。

例

例 1：NULL 値を無視し、ウィンドウ内で正確なパーセンタイルを計算します。

SELECT
  PERCENTILE_CONT(x, 0) OVER() AS min,
  PERCENTILE_CONT(x, 0.01) OVER() AS percentile1,
  PERCENTILE_CONT(x, 0.5) OVER() AS median,
  PERCENTILE_CONT(x, 0.9) OVER() AS percentile90,
  PERCENTILE_CONT(x, 1) OVER() AS max
FROM VALUES(0D),(3D),(NULL),(1D),(2D) AS tbl(x) LIMIT 1;

-- 戻り結果
+------------+-------------+------------+--------------+------------+
| min        | percentile1 | median     | percentile90 | max        | 
+------------+-------------+------------+--------------+------------+
| 0.0        | 0.03        | 1.5        | 2.7          | 3.0        | 
+------------+-------------+------------+--------------+------------+

例 2：NULL 値を無視しません。NULL 値はソート中に最小値として扱われます。ウィンドウ内で正確なパーセンタイルを計算します。

SELECT
  PERCENTILE_CONT(x, 0, false) OVER() AS min,
  PERCENTILE_CONT(x, 0.01, false) OVER() AS percentile1,
  PERCENTILE_CONT(x, 0.5, false) OVER() AS median,
  PERCENTILE_CONT(x, 0.9, false) OVER() AS percentile90,
  PERCENTILE_CONT(x, 1, false) OVER() AS max
FROM VALUES(0D),(3D),(NULL),(1D),(2D) AS tbl(x) LIMIT 1;

-- 戻り結果
+------------+-------------+------------+--------------+------------+
| min        | percentile1 | median     | percentile90 | max        | 
+------------+-------------+------------+--------------+------------+
| NULL       | 0.0         | 1.0        | 2.6          | 3.0        | 
+------------+-------------+------------+--------------+------------+

PERCENTILE_DISC

構文

-- 指定されたパーセンタイル値を計算します
PERCENTILE_DISC(<col_name>, DOUBLE <percentile>[, BOOLEAN <isIgnoreNull>])

-- ウィンドウ内でパーセンタイル値を計算します
PERCENTILE_DISC(<col_name>, DOUBLE <percentile>[, BOOLEAN <isIgnoreNull>]) OVER ([partition_clause] [orderby_clause])

説明
指定されたパーセンタイル値を計算します。まず指定された列を昇順にソートし、次に累積分布が指定されたパーセンタイル以上である最初の値を返します。
パラメーター
- col_name：必須。ソート可能な任意のデータ型の列。
- percentile：必須。計算するパーセンタイル。[0, 1] の範囲の DOUBLE 定数。
- isIgnoreNull：任意。NULL 値を無視するかどうかを指定します。BOOLEAN 定数。デフォルト値は TRUE です。FALSE に設定すると、NULL 値はソート中に最小値として扱われます。
- partition_clause と orderby_clause：詳細については、「ウィンドウ関数」をご参照ください。
戻り値
計算されたパーセンタイル値を返します。データ型は入力の col_name 列と同じです。

例

例 1：NULL 値を無視し、ウィンドウ内でパーセンタイル値を計算します。

SELECT
  x,
  PERCENTILE_DISC(x, 0) OVER() AS min,
  PERCENTILE_DISC(x, 0.5) OVER() AS median,
  PERCENTILE_DISC(x, 1) OVER() AS max
FROM VALUES('c'),(NULL),('b'),('a') AS tbl(x);

-- 戻り結果
+------------+------------+------------+------------+
| x          | min        | median     | max        | 
+------------+------------+------------+------------+
| c          | a          | b          | c          | 
| NULL       | a          | b          | c          | 
| b          | a          | b          | c          | 
| a          | a          | b          | c          | 
+------------+------------+------------+------------+

例 2：NULL 値を無視しません。NULL 値はソート中に最小値として扱われます。ウィンドウ内でパーセンタイル値を計算します。

SELECT
  x,
  PERCENTILE_DISC(x, 0, false) OVER() AS min,
  PERCENTILE_DISC(x, 0.5, false) OVER() AS median,
  PERCENTILE_DISC(x, 1, false) OVER() AS max
FROM VALUES('c'),(NULL),('b'),('a') AS tbl(x);

-- 戻り結果
+------------+------------+------------+------------+
| x          | min        | median     | max        | 
+------------+------------+------------+------------+
| c          | NULL       | a          | c          | 
| NULL       | NULL       | a          | c          | 
| b          | NULL       | a          | c          | 
| a          | NULL       | a          | c          | 
+------------+------------+------------+------------+

STDDEV

構文

double stddev(double <colname>)
decimal stddev(decimal <colname>)

説明
すべての入力値の母集団標準偏差を返します。
パラメーター
colname：必須。DOUBLE または DECIMAL 型の列の名前。入力値が STRING または BIGINT 型の場合、計算前に暗黙的に DOUBLE 型に変換されます。
戻り値
colname の値が null の場合、この値を含む行は計算に使用されません。次の表は、入力データと戻り値のデータ型のマッピングを示しています。
入力型
戻り値の型
TINYINT
DOUBLE
SMALLINT
DOUBLE
INT
DOUBLE
BIGINT
DOUBLE
FLOAT
DOUBLE
DOUBLE
DOUBLE
DECIMAL
DECIMAL
例
- 例 1：すべての従業員の給与 (sal) の母集団標準偏差を計算します。サンプル文：
```
select stddev(sal) from emp;
```
  次の結果が返されます：
```
+------------+
| _c0        |
+------------+
| 1262.7549932628976 |
+------------+
```
- 例 2：この関数を group by と共に使用して、すべての従業員を部署 (deptno) ごとにグループ化し、各部署の給与 (sal) の母集団標準偏差を計算します。サンプルコマンド：
```
select deptno, stddev(sal) from emp group by deptno;
```
  次の結果が返されます：
```
+------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | 1546.1421524412158 |
| 20         | 1004.7387720198718 |
| 30         | 610.1001739241043 |
+------------+------------+
```

STDDEV_SAMP

構文

double stddev_samp(double <colname>)
decimal stddev_samp(decimal <colname>)

説明
すべての入力値の標本標準偏差を返します。
パラメーター
colname：必須。DOUBLE または DECIMAL 型の列の名前。入力値が STRING または BIGINT 型の場合、計算前に暗黙的に DOUBLE 型に変換されます。
戻り値
colname の値が null の場合、この値を含む行は計算に使用されません。次の表は、入力データと戻り値のデータ型のマッピングを示しています。
入力型
戻り値の型
TINYINT
DOUBLE
SMALLINT
DOUBLE
INT
DOUBLE
BIGINT
DOUBLE
FLOAT
DOUBLE
DOUBLE
DOUBLE
DECIMAL
DECIMAL
例
- 例 1：すべての従業員の給与 (sal) の標本標準偏差を計算します。サンプル文：
```
select stddev_samp(sal) from emp;
```
  次の結果が返されます：
```
+------------+
| _c0        |
+------------+
| 1301.6180541247609 |
+------------+
```
- 例 2：この関数を group by と共に使用して、すべての従業員を部署 (deptno) ごとにグループ化し、各部署の給与 (sal) の標本標準偏差を計算します。サンプルコマンド：
```
select deptno, stddev_samp(sal) from emp group by deptno;
```
  次の結果が返されます：
```
+------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | 1693.7138680032901 |
| 20         | 1123.3320969330487 |
| 30         | 668.3312551921141 |
+------------+------------+
```

SUM

構文

DECIMAL｜DOUBLE｜BIGINT  sum(<colname>)

説明
合計を計算します。
パラメーター
colname：必須。列の値はすべてのデータ型をサポートし、計算前に DOUBLE 型に変換できます。DOUBLE、DECIMAL、または BIGINT 型の列の名前。入力値が STRING 型の場合、計算前に暗黙的に DOUBLE 型に変換されます。
このセクションでは戻り値について説明します。
colname の値が null の場合、この値を含む行は計算に使用されません。次の表は、入力データと戻り値のデータ型のマッピングを示しています。
入力型
戻り値の型
TINYINT
BIGINT
SMALLINT
BIGINT
INT
BIGINT
BIGINT
BIGINT
FLOAT
DOUBLE
DOUBLE
DOUBLE
DECIMAL
DECIMAL
例
- 例 1：すべての従業員の給与 (sal) の合計を計算します。サンプル文：
```
select sum(sal) from emp;
```
  次の結果が返されます：
```
+------------+
| _c0        |
+------------+
| 37775      |
+------------+
```
- 例 2：この関数を group by と共に使用して、すべての従業員を部署 (deptno) ごとにグループ化し、各部署の給与 (sal) の合計を計算します。サンプルコマンド：
```
select deptno, sum(sal) from emp group by deptno;
```
  次の結果が返されます：
```
+------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | 17500      |
| 20         | 10875      |
| 30         | 9400       |
+------------+------------+
```

VAR_SAMP

構文
```
double var_samp(<colname>)
```
説明
指定された数値列の標本分散を計算します。この関数は MaxCompute V2.0 の追加機能です。
パラメーター
colname：必須。数値データ型の列。指定された列が数値列でない場合、null 値が返されます。
戻り値
DOUBLE 型の値が返されます。
例
- 例 1：すべての従業員の給与 (sal) の標本分散を計算します。サンプル文：
```
select var_samp(sal) from emp;
```
  次の結果が返されます：
```
+------------+
| _c0        |
+------------+
| 1694209.5588235292 |
+------------+
```
- 例 2：この関数を group by と共に使用して、すべての従業員を部署 (deptno) ごとにグループ化し、各グループの給与 (sal) の標本分散を計算します。サンプルコマンド：
```
select deptno, var_samp(sal) from emp group by deptno;
```
  次の結果が返されます：
```
+------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | 2868666.666666667 |
| 20         | 1261875.0  |
| 30         | 446666.6666666667 |
+------------+------------+
```

VARIANCE/VAR_POP

構文

double variance(<colname>)
double var_pop(<colname>)

このトピックでは、コマンドについて説明します。
指定された数値列の分散を計算します。
メトリックの説明
colname：必須。数値データ型の列。指定された列が数値列でない場合、null 値が返されます。この関数は MaxCompute V2.0 の追加機能です。
戻り値
DOUBLE 型の値が返されます。

例

例 1：すべての従業員の給与 (sal) の分散を計算します。サンプル文：

select variance(sal) from emp;
-- これは次の文と同等です。
select var_pop(sal) from emp;

次の結果が返されます：

+------------+
| _c0        |
+------------+
| 1594550.1730103805 |
+------------+

例 2：この関数を group by と共に使用して、すべての従業員を部署 (deptno) ごとにグループ化し、各グループの給与 (sal) の分散を計算します。サンプルコマンド：

select deptno, variance(sal) from emp group by deptno;
-- これは次の文と同等です。
select deptno, var_pop(sal) from emp group by deptno;

次の結果が返されます：

+------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | 2390555.5555555555 |
| 20         | 1009500.0  |
| 30         | 372222.22222222225 |
+------------+------------+

WM_CONCAT

構文

string wm_concat(string <separator>, string <colname>)

コマンドの説明
separator で指定されたデリミタを使用して、colname の値を連結します。
説明
- separator：必須。デリミタ。STRING 型の定数です。
- colname：必須。STRING 型の値。入力値が BIGINT、DOUBLE、または DATETIME 型の場合、計算前に暗黙的に STRING 型に変換されます。
戻り値 (group by を使用してグループ化する場合、グループ内の戻り値はソートされません)
STRING 型の値が返されます。戻り値は次のルールに基づいて異なります：
- separator の値が STRING 型の定数でない場合、エラーが返されます。
- colname の値が STRING、BIGINT、DOUBLE、または DATETIME 型でない場合、エラーが返されます。
- colname の値が null の場合、この値を含む行は計算に使用されません。
説明
select wm_concat(',', name) from table_name; 文で、table_name が空のセットの場合、文は NULL を返します。

例

例 1：すべての従業員の名前 (ename) を連結します。サンプル文：

select wm_concat(',', ename) from emp;

次の結果が返されます：

+------------+
| _c0        |
+------------+
| SMITH,ALLEN,WARD,JONES,MARTIN,BLAKE,CLARK,SCOTT,KING,TURNER,ADAMS,JAMES,FORD,MILLER,JACCKA,WELAN,TEBAGE |
+------------+

例 2：この関数を group by と共に使用して、すべての従業員を部署 (deptno) ごとにグループ化し、同じグループの従業員の名前 (ename) を連結します。サンプルコマンド：

select deptno, wm_concat(',', ename) from emp group by deptno order by deptno;

次の結果が返されます：

+------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | CLARK,KING,MILLER,JACCKA,WELAN,TEBAGE |
| 20         | SMITH,JONES,SCOTT,ADAMS,FORD |
| 30         | ALLEN,WARD,MARTIN,BLAKE,TURNER,JAMES |
+------------+------------+

例 3：この関数を group by と共に使用して、すべての従業員を部署 (deptno) ごとにグループ化し、同じグループの従業員の個別給与 (sal) を連結します。サンプルコマンド：

select deptno, wm_concat(distinct ',', sal) from emp group by deptno order by deptno;

次の結果が返されます：

+------------+------------+
| deptno     | _c1        |
+------------+------------+
| 10         | 1300,2450,5000 |
| 20         | 1100,2975,3000,800 |
| 30         | 1250,1500,1600,2850,950 |
+------------+------------+

例 4：この関数を group by と order by と共に使用して、すべての従業員を部署 (deptno) ごとにグループ化し、給与 (sal) をソートして連結します。サンプルコマンド：

select deptno, wm_concat(',',sal) within group(order by sal) from emp group by deptno order by deptno;

次の結果が返されます：

+------------+------------+
|deptno|_c1|
+------------+------------+
|10|1300,1300,2450,2450,5000,5000|
|20|800,1100,2975,3000,3000|
|30|950,1250,1250,1500,1600,2850|
+------------+------------+

入力型	戻り値の型
TINYINT	DOUBLE
SMALLINT	DOUBLE
INT	DOUBLE
BIGINT	DOUBLE
FLOAT	DOUBLE
DOUBLE	DOUBLE
DECIMAL	DECIMAL