Amazon Redshift は、パッチ 198 以降、新しい Python UDF の作成をサポートしなくなります。既存の Python UDF は、2026 年 6 月 30 日まで引き続き機能します。詳細については、[ブログ記事](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/)を参照してください。
# 集計関数
**Topics**
+ [ANY\$1VALUE 関数](r_ANY_VALUE.md)
+ [APPROXIMATE PERCENTILE\$1DISC 関数](r_APPROXIMATE_PERCENTILE_DISC.md)
+ [AVG 関数](r_AVG.md)
+ [COUNT 関数](r_COUNT.md)
+ [LISTAGG 関数](r_LISTAGG.md)
+ [MAX 関数](r_MAX.md)
+ [MEDIAN 関数](r_MEDIAN.md)
+ [MIN 関数](r_MIN.md)
+ [PERCENTILE\$1CONT 関数](r_PERCENTILE_CONT.md)
+ [STDDEV\$1SAMP および STDDEV\$1POP 関数](r_STDDEV_functions.md)
+ [SUM 関数](r_SUM.md)
+ [VAR\$1SAMP および VAR\$1POP 関数](r_VARIANCE_functions.md)
集計関数は入力値のセットから 1 つの結果の値を計算します。
集計関数を使用する SELECT ステートメントには、2 つのオプション句 (GROUP BY および HAVING) を含めることができます。これらの句の構文は次のとおりです (例として COUNT 関数を使用)。
```
SELECT count (*) expression FROM table_reference
WHERE condition [GROUP BY expression ] [ HAVING condition]
```
GROUP BY 句は、指定した列 (単数または複数) の一意の値によって結果を集計およびグループ化します。HAVING 句は、特定の集計条件が真の場合 (例: count (\$1) > 1) に行に返す結果を制限します。HAVING 句は行の値に基づく列を制限するために、WHERE と同様に使用されます。追加されたこれらの句の例については、[COUNT](r_COUNT.md)を参照してください。
集計関数は、入れ子にした集計関数またはウィンドウ関数を引数として使用できません。
# ANY\$1VALUE 関数
ANY\$1VALUE 関数は、入力式の値から任意の値を非決定的に返します。この関数は、入力式で行が返されない場合に `NULL` を返します。この関数は、入力式に `NULL` 値がある場合にも `NULL` を返します。入力に `NULL` 以外の `NULL` 値と混合された値が含まれている場合、`NULL` が返される可能性があります。すべての値が `NULL` の場合、`NULL` が返されます。条件に一致する行がない場合、`NULL` が返されます。
## 構文
```
ANY_VALUE( [ DISTINCT | ALL ] expression )
```
## 引数
DISTINCT \$1 ALL
DISTINCT または ALL のいずれかを指定すると、入力式の値から任意の値が返されます。DISTINCT 引数は効果がなく、無視されます。
* 式*
関数が動作するターゲット列または式。*式*は、以下に示すデータ型の 1 つを取ります。
+ SMALLINT
+ INTEGER
+ BIGINT
+ DECIMAL
+ REAL
+ DOUBLE PRECISION
+ BOOLEAN
+ CHAR
+ VARCHAR
+ DATE
+ TIMESTAMP
+ TIMESTAMPTZ
+ TIME
+ TIMETZ
+ INTERVAL YEAR TO MONTH
+ INTERVAL DAY TO SECOND
+ VARBYTE
+ SUPER
+ HLLSKETCH
+ GEOMETRY
+ GEOGRAPHY
## 戻り値
同じデータ型を *expression* として返します。
## 使用に関する注意事項
列の ANY\$1VALUE 関数を指定するステートメントに 2 番目の列参照も含まれている場合、2 番目の列は GROUP BY 句に含めるか、集計関数に含める必要があります。
## 例
この例では、*Amazon Redshift 入門ガイド*の「[ステップ 4: Amazon S3 のサンプルデータをロードする](https://docs.aws.amazon.com/redshift/latest/gsg/rs-gsg-create-sample-db.html)」で作成したイベントテーブルを使用します。次の例では、イベント名が Eagles である任意の dateid のインスタンスを返します。
```
select any_value(dateid) as dateid, eventname from event where eventname ='Eagles' group by eventname;
```
結果は、以下の通りです。
```
dateid | eventname
-------+---------------
1878 | Eagles
```
次の例では、イベント名が Eagles または Cold War Kids である任意の dateid のインスタンスを返します。
```
select any_value(dateid) as dateid, eventname from event where eventname in('Eagles', 'Cold War Kids') group by eventname;
```
結果は、以下のとおりです。
```
dateid | eventname
-------+---------------
1922 | Cold War Kids
1878 | Eagles
```
# APPROXIMATE PERCENTILE\$1DISC 関数
APPROXIMATE PERCENTILE\$1DISC は、離散型分散モデルを前提とする逆分散関数です。これは、パーセンタイル値とソート仕様を取得し、特定のセットからエレメントを返します。概算により、関数の実行がはるかに高速になり、相対誤差は約 0.5% と低くなります。
特定の *percentile* 値に対して、APPROXIMATE PERCENTILE\$1DISC は分位数要約アルゴリズムを使用して ORDER BY 句の式の離散パーセンタイルを概算します。APPROXIMATE PERCENTILE\$1DISC は、*percentile* と同じであるかそれより大きい最少累積分散値 (同じソート仕様を基準とする) を持つ値を返します。
## 構文
```
APPROXIMATE PERCENTILE_DISC ( percentile )
WITHIN GROUP (ORDER BY expr)
```
## 引数
*パーセンタイル*
0 と 1 の間の数値定数。Null は計算では無視されます。
WITHIN GROUP ( ORDER BY *expr*)
パーセンタイルをソートして計算するための数値または日付/時間値を指定する句。
## 戻り値
WITHIN GROUP 句の ORDER BY 式と同じデータ型。
## 使用に関する注意事項
APPROXIMATE PERCENTILE\$1DISC ステートメントに GROUP BY 句が含まれている場合、結果セットは制限されます。制限は、ノードタイプとノード数によって異なります。制限を超えると、関数は失敗して以下のエラーを返します。
```
GROUP BY limit for approximate percentile_disc exceeded.
```
評価するグループの数が制限の許可数を超える場合は、[PERCENTILE\$1CONT 関数](r_PERCENTILE_CONT.md)の使用を検討してください。
## 例
次の例では、上位 10 日の販売数、販売総額、50 番目のパーセンタイル値を返します。
```
select top 10 date.caldate,
count(totalprice), sum(totalprice),
approximate percentile_disc(0.5)
within group (order by totalprice)
from listing
join date on listing.dateid = date.dateid
group by date.caldate
order by 3 desc;
caldate | count | sum | percentile_disc
-----------+-------+------------+----------------
2008-01-07 | 658 | 2081400.00 | 2020.00
2008-01-02 | 614 | 2064840.00 | 2178.00
2008-07-22 | 593 | 1994256.00 | 2214.00
2008-01-26 | 595 | 1993188.00 | 2272.00
2008-02-24 | 655 | 1975345.00 | 2070.00
2008-02-04 | 616 | 1972491.00 | 1995.00
2008-02-14 | 628 | 1971759.00 | 2184.00
2008-09-01 | 600 | 1944976.00 | 2100.00
2008-07-29 | 597 | 1944488.00 | 2106.00
2008-07-23 | 592 | 1943265.00 | 1974.00
```
# AVG 関数
AVG 関数は、入力式の値の平均 (算術平均) を返します。AVG 関数は数値に対してはたらき、NULL 値は無視します。
## 構文
```
AVG ( [ DISTINCT | ALL ] expression )
```
## 引数
* 式*
関数の対象となる列または式。*式*は、以下に示すデータ型の 1 つを取ります。
+ SMALLINT
+ INTEGER
+ BIGINT
+ NUMERIC
+ DECIMAL
+ REAL
+ DOUBLE PRECISION
+ SUPER
DISTINCT \$1 ALL
引数 DISTINCT を指定すると、この関数は平均を計算する前に重複した値をすべて指定された式から削除します。引数 ALL を指定すると、この関数は平均を計算する式の重複した値をすべて保持します。ALL がデフォルトです。
## データ型
AVG 関数でサポートされる引数の型は、SMALLINT、INTEGER、BIGINT、NUMERIC、DECIMAL、REAL、DOUBLE PRECISION および SUPER です。
AVG 関数でサポートされる戻り値の型は次のとおりです。
+ 整数型の引数の場合は BIGINT
+ 浮動小数点の引数の場合は DOUBLE PRECISION
+ 他の引数型については、expression と同じデータ型を返します。
NUMERIC または DECIMAL 引数を使用した AVG 関数の結果のデフォルト精度は 38 です。結果のスケールは、引数のスケールと同じです。例えば、DEC(5,2) 列の AVG は DEC(38,2) のデータ型を返します。
## 例
SALES テーブルから取引ごとの平均販売量を検索します。
```
select avg(qtysold)from sales;
avg
-----
2
(1 row)
```
すべてのリストに一覧表示された合計額の平均を検索します。
```
select avg(numtickets*priceperticket) as avg_total_price from listing;
avg_total_price
-----------------
3034.41
(1 row)
```
支払い額の平均を月ごとに降順で検索します。
```
select avg(pricepaid) as avg_price, month
from sales, date
where sales.dateid = date.dateid
group by month
order by avg_price desc;
avg_price | month
-----------+-------
659.34 | MAR
655.06 | APR
645.82 | JAN
643.10 | MAY
642.72 | JUN
642.37 | SEP
640.72 | OCT
640.57 | DEC
635.34 | JUL
635.24 | FEB
634.24 | NOV
632.78 | AUG
(12 rows)
```
# COUNT 関数
COUNT 関数は式で定義された行をカウントします。
COUNT 関数には 3 つのバリエーションがあります。
+ COUNT(\$1) は null を含むかどうかにかかわらず、ターゲットテーブルのすべての行をカウントします。
+ COUNT ( *expression* ) は、特定の列または式にある Null 以外の値を持つ行数を計算します。
+ COUNT ( DISTINCT *expression* ) は、列または式にある Null 以外の一意な値の数を計算します。
+ APPROXIMATE COUNT DISTINCT は、列または式にある Null 以外の個別の値の数を概算します。
## 構文
```
COUNT( * | expression )
```
```
COUNT ( [ DISTINCT | ALL ] expression )
```
```
APPROXIMATE COUNT ( DISTINCT expression )
```
## 引数
* 式*
関数の対象となる列または式。COUNT 関数は引数のデータ型をすべてサポートしています。
DISTINCT \$1 ALL
引数 DISTINCT を指定すると、この関数はカウントを行う前に指定された式から重複した値をすべて削除します。引数 ALL を指定すると、この関数はカウントに使用する式から重複する値をすべて保持します。ALL がデフォルトです。
APPROXIMATE
COUNT DISTINCT 関数を APPROXIMATE とともに使用すると、HyperLogLog アルゴリズムを使用して、列または式にある Null 以外の個別の値の数を概算します。APPROXIMATE キーワードを使用するクエリは、はるかに高速に実行され、相対誤差は約 2% と低くなります。クエリあたり、または GROUP BY 句がある場合にはグループあたりで、数百万個以上の多数の個別の値を返すクエリについては、概算を使用するのが妥当です。個別の値が数千個のように比較的少ない場合は、概算は正確なカウントよりも低速になる可能性があります。APPROXIMATE は、COUNT DISTINCT でのみ使用できます。
## 戻り型
COUNT 関数は BIGINT を返します。
## 例
フロリダ州のユーザーをすべてカウントします。
```
select count(*) from users where state='FL';
count
-------
510
```
EVENT テーブルからすべてのイベント名をカウントします。
```
select count(eventname) from event;
count
-------
8798
```
EVENT テーブルからすべてのイベント名をカウントします。
```
select count(all eventname) from event;
count
-------
8798
```
EVENT テーブルから一意の会場 ID をすべてカウントします。
```
select count(distinct venueid) as venues from event;
venues
--------
204
```
4 枚より多いチケットをまとめて販売した販売者ごとの回数をカウントします。販売者 ID で結果をグループ化します。
```
select count(*), sellerid from listing
where numtickets > 4
group by sellerid
order by 1 desc, 2;
count | sellerid
------+----------
12 | 6386
11 | 17304
11 | 20123
11 | 25428
...
```
次の例では、COUNT および APPROXIMATE COUNT の戻り値と実行時間を比較します。
```
select count(distinct pricepaid) from sales;
count
-------
4528
Time: 48.048 ms
select approximate count(distinct pricepaid) from sales;
count
-------
4553
Time: 21.728 ms
```
# LISTAGG 関数
クエリの各グループについて、LISTAGG 集計関数は、ORDER BY 式に従ってそのグループの行をソートしてから、それらの値を 1 つの文字列に連結します。
## 構文
```
LISTAGG( [DISTINCT] aggregate_expression [, 'delimiter' ] )
[ WITHIN GROUP (ORDER BY order_list) ]
```
## 引数
DISTINCT
連結する前に、指定した式から重複した値を削除する句。末尾のスペースは無視されます。例えば、文字列 `'a'` および `'a '` は重複として扱われます。LISTAGG は、発生した最初の値を使用します。詳細については、「[末尾の空白の重要性](r_Character_types.md#r_Character_types-significance-of-trailing-blanks)」を参照してください。
*aggregate\$1expression*
集計する値を返す任意の有効な式 (列名など)。NULL 値および空の文字列は無視されます。
*delimiter*
連結された値を区切る文字列定数。デフォルトは NULL です。
*WITHIN GROUP (ORDER BY order\$1list)*
集計値のソート順を指定する句。
## 戻り値
VARCHAR(MAX)。結果セットが VARCHAR の最大サイズより大きい場合、LISTAGG は次のエラーを返します。
```
Invalid operation: Result size exceeds LISTAGG limit
```
## 使用に関する注意事項
+ WITHIN GROUP 句を使用する複数の LISTAGG 関数が 1 つのステートメントに含まれる場合、各 WITHIN GROUP 句で ORDER BY 値を使用する必要があります。
例えば、次のステートメントはエラーを返します。
```
SELECT LISTAGG(sellerid)
WITHIN GROUP (ORDER BY dateid) AS sellers,
LISTAGG(dateid)
WITHIN GROUP (ORDER BY sellerid) AS dates
FROM sales;
```
以下のステートメントは正常に実行されます。
```
SELECT LISTAGG(sellerid)
WITHIN GROUP (ORDER BY dateid) AS sellers,
LISTAGG(dateid)
WITHIN GROUP (ORDER BY dateid) AS dates
FROM sales;
SELECT LISTAGG(sellerid)
WITHIN GROUP (ORDER BY dateid) AS sellers,
LISTAGG(dateid) AS dates
FROM sales;
```
+ LISTAGG、PERCENTILE\$1CONT、MEDIAN 集計関数は、他の個別の集計関数で使用することはできません。
## 例
以下の例は、販売者 ID を集計し、販売者 ID 順で返します。
```
SELECT LISTAGG(sellerid, ', ')
WITHIN GROUP (ORDER BY sellerid)
FROM sales
WHERE eventid = 4337;
listagg
----------------------------------------------------------------------------------------------------------------------------------------
380, 380, 1178, 1178, 1178, 2731, 8117, 12905, 32043, 32043, 32043, 32432, 32432, 38669, 38750, 41498, 45676, 46324, 47188, 47188, 48294
```
次の例では、DISTINCT を使用して一意の販売者 ID のリストを返します。
```
SELECT LISTAGG(DISTINCT sellerid, ', ')
WITHIN GROUP (ORDER BY sellerid)
FROM sales
WHERE eventid = 4337;
listagg
-------------------------------------------------------------------------------------------
380, 1178, 2731, 8117, 12905, 32043, 32432, 38669, 38750, 41498, 45676, 46324, 47188, 48294
```
以下の例は、販売者 ID を集計し、日付順で返します。
```
SELECT LISTAGG(sellerid, ', ')
WITHIN GROUP (ORDER BY dateid)
FROM sales
WHERE eventid = 4337;
listagg
-----------------------------------------------------------------------------------------------------------------------------------------
41498, 47188, 47188, 1178, 1178, 1178, 380, 45676, 46324, 48294, 32043, 32043, 32432, 12905, 8117, 38750, 2731, 32432, 32043, 380, 38669
```
次の例は、ID が 660 の購入者についてパイプで区切った販売日のリストを返します。
```
SELECT LISTAGG(
(SELECT caldate FROM date WHERE date.dateid=sales.dateid), ' | '
)
WITHIN GROUP (ORDER BY sellerid DESC, salesid ASC)
FROM sales
WHERE buyerid = 660;
listagg
-------------------------------------------------
2008-07-16 | 2008-07-09 | 2008-01-01 | 2008-10-26
```
次の例は、ID が 660、661、662 の購入者についてカンマで区切った販売 ID のリストを返します。
```
SELECT buyerid,
LISTAGG(salesid,', ')
WITHIN GROUP (ORDER BY salesid) AS sales_id
FROM sales
WHERE buyerid BETWEEN 660 AND 662
GROUP BY buyerid
ORDER BY buyerid;
buyerid | sales_id
--------+-----------------------------------------------------
660 | 32872, 33095, 33514, 34548
661 | 19951, 20517, 21695, 21931
662 | 3318, 3823, 4215, 51980, 53202, 55908, 57832, 171603
```
# MAX 関数
MAX 関数は行のセットの最大値を返します。DISTINCT または ALL が使用される可能性がありますが、結果には影響しません。
## 構文
```
MAX ( [ DISTINCT | ALL ] expression )
```
## 引数
* 式*
関数の対象となる列または式。*式*は、以下に示すデータ型の 1 つを取ります。
+ SMALLINT
+ INTEGER
+ BIGINT
+ DECIMAL
+ REAL
+ DOUBLE PRECISION
+ CHAR
+ VARCHAR
+ DATE
+ TIMESTAMP
+ TIMESTAMPTZ
+ TIME
+ TIMETZ
+ VARBYTE
+ SUPER
DISTINCT \$1 ALL
引数 DISTINCT を指定すると、この関数は最大値を計算する前に指定された式から重複した値をすべて削除します。引数 ALL を指定すると、この関数は最大値を計算する式から重複する値をすべて保持します。ALL がデフォルトです。
## データ型
同じデータ型を *expression* として返します。MIN 関数のブールバージョンは [BOOL\$1AND 関数](r_BOOL_AND.md) であり、MAX 関数のブールバージョンは [BOOL\$1OR 関数](r_BOOL_OR.md) です。
## 例
すべての販売から最高支払価格を検索します。
```
select max(pricepaid) from sales;
max
----------
12624.00
(1 row)
```
すべての販売からチケットごとの最高支払価格を検索します。
```
select max(pricepaid/qtysold) as max_ticket_price
from sales;
max_ticket_price
-----------------
2500.00000000
(1 row)
```
# MEDIAN 関数
値の範囲の中央値を計算します。範囲内の `NULL` 値は無視されます。
MEDIAN は、連続型分散モデルを前提とする逆分散関数です。
MEDIAN は [PERCENTILE\$1CONT](r_PERCENTILE_CONT.md) の特殊なケースです。
## 構文
```
MEDIAN(median_expression)
```
## 引数
*median\$1expression*
関数の対象となる列または式。
## データ型
戻り値の型は、データ型 *median\$1expression* によって決まります。次の表は、各 *median\$1expression* 式のデータ型に対応する戻り型を示しています。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/r_MEDIAN.html)
## 使用に関する注意事項
*median\$1expression* 引数が `DECIMAL` データ型であり、その最大精度が 38 桁である場合、MEDIAN が不正確な結果またはエラーを返す可能性があります。MEDIAN 関数の戻り値が 38 桁を超える場合、結果は 38 桁までとなり、39 桁以降は切り捨てられるため、精度が失われます。補間中に中間結果が最大精度を超えた場合には、数値オーバーフローが発生し、この関数はエラーを返します。このような状態を回避するため、精度が低いデータ型を使用するか、*median\$1expression* 引数を低い精度にキャストすることをお勧めします。
ステートメントにソートベースの集計関数 (LISTAGG、PERCENTILE\$1CONT、または MEDIAN) に対する複数の呼び出しが含まれる場合、すべて同じ ORDER BY 値を使用する必要があります。MEDIAN では、式の値による暗黙的な順序が適用されることに注意してください。
例えば、次のステートメントはエラーを返します。
```
SELECT TOP 10 salesid, SUM(pricepaid),
PERCENTILE_CONT(0.6) WITHIN GROUP(ORDER BY salesid),
MEDIAN(pricepaid)
FROM sales
GROUP BY salesid, pricepaid;
An error occurred when executing the SQL command:
SELECT TOP 10 salesid, SUM(pricepaid),
PERCENTILE_CONT(0.6) WITHIN GROUP(ORDER BY salesid),
MEDIAN(pricepaid)
FROM sales
GROUP BY salesid, pricepaid;
ERROR: within group ORDER BY clauses for aggregate functions must be the same
```
次のステートメントは正常に実行されます。
```
SELECT TOP 10 salesid, SUM(pricepaid),
PERCENTILE_CONT(0.6) WITHIN GROUP(ORDER BY salesid),
MEDIAN(salesid)
FROM sales
GROUP BY salesid, pricepaid;
```
## 例
次の例では、TICKIT サンプルデータを使用します。詳細については、「[サンプルデータベース](c_sampledb.md)」を参照してください。
以下は、MEDIAN が PERCENTILE\$1CONT(0.5) と同じ結果を生成する例です。
```
SELECT TOP 10 DISTINCT sellerid, qtysold,
PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY qtysold),
MEDIAN(qtysold)
FROM sales
GROUP BY sellerid, qtysold;
+----------+---------+-----------------+--------+
| sellerid | qtysold | percentile_cont | median |
+----------+---------+-----------------+--------+
| 2 | 2 | 2 | 2 |
| 26 | 1 | 1 | 1 |
| 33 | 1 | 1 | 1 |
| 38 | 1 | 1 | 1 |
| 43 | 1 | 1 | 1 |
| 48 | 2 | 2 | 2 |
| 48 | 3 | 3 | 3 |
| 77 | 4 | 4 | 4 |
| 85 | 4 | 4 | 4 |
| 95 | 2 | 2 | 2 |
+----------+---------+-----------------+--------+
```
次の例では、各 sellerid の平均販売数量を求めます。
```
SELECT sellerid,
MEDIAN(qtysold)
FROM sales
GROUP BY sellerid
ORDER BY sellerid
LIMIT 10;
+----------+--------+
| sellerid | median |
+----------+--------+
| 1 | 1.5 |
| 2 | 2 |
| 3 | 2 |
| 4 | 2 |
| 5 | 1 |
| 6 | 1 |
| 7 | 1.5 |
| 8 | 1 |
| 9 | 4 |
| 12 | 2 |
+----------+--------+
```
最初の sellerid に対する前回のクエリの結果を検証するには、次の例を使用します。
```
SELECT qtysold
FROM sales
WHERE sellerid=1;
+---------+
| qtysold |
+---------+
| 2 |
| 1 |
+---------+
```
# MIN 関数
MIN 関数は行のセットの最小値を返します。DISTINCT または ALL が使用される可能性がありますが、結果には影響しません。
## 構文
```
MIN ( [ DISTINCT | ALL ] expression )
```
## 引数
* 式*
関数の対象となる列または式。*式*は、以下に示すデータ型の 1 つを取ります。
+ SMALLINT
+ INTEGER
+ BIGINT
+ DECIMAL
+ REAL
+ DOUBLE PRECISION
+ CHAR
+ VARCHAR
+ DATE
+ TIMESTAMP
+ TIMESTAMPTZ
+ TIME
+ TIMETZ
+ VARBYTE
+ SUPER
DISTINCT \$1 ALL
引数 DISTINCT を指定すると、この関数は最小値を計算する前に指定された式から重複した値をすべて削除します。引数 ALL を指定すると、この関数は最小値を計算する式から重複する値をすべて保持します。ALL がデフォルトです。
## データ型
同じデータ型を *expression* として返します。MIN 関数のブールバージョンは [BOOL\$1AND 関数](r_BOOL_AND.md) であり、MAX 関数のブールバージョンは [BOOL\$1OR 関数](r_BOOL_OR.md) です。
## 例
すべての販売から最低支払価格を検索します。
```
select min(pricepaid) from sales;
min
-------
20.00
(1 row)
```
すべての販売からチケットごとの最低支払価格を検索します。
```
select min(pricepaid/qtysold)as min_ticket_price
from sales;
min_ticket_price
------------------
20.00000000
(1 row)
```
# PERCENTILE\$1CONT 関数
PERCENTILE\$1CONT は、連続型分散モデルを前提とする逆分散関数です。これは、パーセンタイル値とソート仕様を取得し、ソート仕様を基準として、そのパーセンタイル値に該当する補間値を返します。
PERCENTILE\$1CONT は、値の順序付けを行った後に値の間の線形補間を計算します。この関数は、パーセンタイル値 `(P)` と集計グループの Null ではない行の数 `(N)` を使用して、ソート使用に従って行の順序付けを行った後に行番号を計算します。この行番号 `(RN)` は、計算式 `RN = (1+ (P*(N-1))` に従って計算されます。集計関数の最終結果は、行番号 `CRN = CEILING(RN)` および `FRN = FLOOR(RN)` にある行の値の間の線形補間に基づいて計算されます。
最終結果は次のとおりです。
`(CRN = FRN = RN)` である場合、結果は `(value of expression from row at RN)`
そうでない場合、結果は
`(CRN - RN) * (value of expression for row at FRN) + (RN - FRN) * (value of expression for row at CRN)`.
## 構文
```
PERCENTILE_CONT(percentile)
WITHIN GROUP(ORDER BY expr)
```
## 引数
*パーセンタイル*
0 と 1 の間の数値定数。`NULL` 値は計算で無視されます。
*\$1 expr*
パーセンタイルをソートして計算するための数値または日付/時間値を指定します。
## 戻り値
戻り型は、WITHIN GROUP 句の ORDER BY 式のデータ型に基づいて決定されます。次の表は、各 ORDER BY 式のデータ型に対応する戻り型を示しています。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/redshift/latest/dg/r_PERCENTILE_CONT.html)
## 使用に関する注意事項
ORDER BY 式が DECIMAL データ型であり、その最大精度が 38 桁である場合、PERCENTILE\$1CONT が不正確な結果またはエラーを返す可能性があります。PERCENTILE\$1CONT 関数の戻り値が 38 桁を超える場合、結果は 38 桁までとなり、39 桁以降は切り捨てられるため、精度が失われます。補間中に中間結果が最大精度を超えた場合には、数値オーバーフローが発生し、この関数はエラーを返します。このような状態を回避するため、精度が低いデータ型を使用するか、ORDER BY 式を低い精度にキャストすることをお勧めします。
ステートメントにソートベースの集計関数 (LISTAGG、PERCENTILE\$1CONT、または MEDIAN) に対する複数の呼び出しが含まれる場合、すべて同じ ORDER BY 値を使用する必要があります。MEDIAN では、式の値による暗黙的な順序が適用されることに注意してください。
例えば、次のステートメントはエラーを返します。
```
SELECT TOP 10 salesid, SUM(pricepaid),
PERCENTILE_CONT(0.6) WITHIN GROUP(ORDER BY salesid),
MEDIAN(pricepaid)
FROM sales
GROUP BY salesid, pricepaid;
An error occurred when executing the SQL command:
SELECT TOP 10 salesid, SUM(pricepaid),
PERCENTILE_CONT(0.6) WITHIN GROUP(ORDER BY salesid),
MEDIAN(pricepaid)
FROM sales
GROUP BY salesid, pricepaid;
ERROR: within group ORDER BY clauses for aggregate functions must be the same
```
次のステートメントは正常に実行されます。
```
SELECT TOP 10 salesid, SUM(pricepaid),
PERCENTILE_CONT(0.6) WITHIN GROUP(ORDER BY salesid),
MEDIAN(salesid)
FROM sales
GROUP BY salesid, pricepaid;
```
## 例
次の例では、TICKIT サンプルデータを使用します。詳細については、「[サンプルデータベース](c_sampledb.md)」を参照してください。
以下は、PERCENTILE\$1CONT(0.5) が MEDIAN と同じ結果を生成する例です。
```
SELECT TOP 10 DISTINCT sellerid, qtysold,
PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY qtysold),
MEDIAN(qtysold)
FROM sales
GROUP BY sellerid, qtysold;
+----------+---------+-----------------+--------+
| sellerid | qtysold | percentile_cont | median |
+----------+---------+-----------------+--------+
| 2 | 2 | 2 | 2 |
| 26 | 1 | 1 | 1 |
| 33 | 1 | 1 | 1 |
| 38 | 1 | 1 | 1 |
| 43 | 1 | 1 | 1 |
| 48 | 2 | 2 | 2 |
| 48 | 3 | 3 | 3 |
| 77 | 4 | 4 | 4 |
| 85 | 4 | 4 | 4 |
| 95 | 2 | 2 | 2 |
+----------+---------+-----------------+--------+
```
次の例では、SALES テーブルの各 selleridD の販売数量の PERCENTILE\$1CONT(0.5) と PERCENTILE\$1CONT(0.75) を求めます。
```
SELECT sellerid,
PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY qtysold) as pct_50,
PERCENTILE_CONT(0.75) WITHIN GROUP(ORDER BY qtysold) as pct_75
FROM sales
GROUP BY sellerid
ORDER BY sellerid
LIMIT 10;
+----------+--------+---------+
| sellerid | pct_50 | pct_75 |
+----------+--------+---------+
| 1 | 1.5 | 1.75 |
| 2 | 2 | 2.25 |
| 3 | 2 | 3 |
| 4 | 2 | 2 |
| 5 | 1 | 1.5 |
| 6 | 1 | 1 |
| 7 | 1.5 | 1.75 |
| 8 | 1 | 1 |
| 9 | 4 | 4 |
| 12 | 2 | 3.25 |
+----------+--------+---------+
```
最初の sellerid に対する前回のクエリの結果を検証するには、次の例を使用します。
```
SELECT qtysold
FROM sales
WHERE sellerid=1;
+---------+
| qtysold |
+---------+
| 2 |
| 1 |
+---------+
```
# STDDEV\$1SAMP および STDDEV\$1POP 関数
STDDEV\$1SAMP および STDDEV\$1POP 関数は、数値のセットの標本標準偏差と母集団標準偏差 (整数、10 進数、または浮動小数点) を返します。STDDEV\$1SAMP 関数の結果は、値の同じセットの標本分散の平方根に相当します。
STDDEV\$1SAMP および STDDEV は、同じ関数のシノニムです。
## 構文
```
STDDEV_SAMP | STDDEV ( [ DISTINCT | ALL ] expression)
STDDEV_POP ( [ DISTINCT | ALL ] expression)
```
この式は整数、10 進数、または浮動小数点数データ型である必要があります。式のデータ型にかかわらず、この関数の戻り値の型は倍精度の数値です。
**注記**
標準偏差は浮動小数点演算を使用して計算されます。これはわずかに不正確である可能性があります。
## 使用に関する注意事項
標本標準偏差 (STDDEV または STDDEV\$1SAMP) が 1 つの値で構成される式に対して計算される場合、関数の結果は 0 ではなく、NULL になります。
## 例
次のクエリは VENUE テーブルの VENUESEATS 列の値の平均、続いて値の同じセットの標本標準偏差と母集団標準偏差を返します。VENUESEATS は INTEGER 列です。結果のスケールは 2 桁に減らされます。
```
select avg(venueseats),
cast(stddev_samp(venueseats) as dec(14,2)) stddevsamp,
cast(stddev_pop(venueseats) as dec(14,2)) stddevpop
from venue;
avg | stddevsamp | stddevpop
-------+------------+-----------
17503 | 27847.76 | 27773.20
(1 row)
```
次のクエリは SALES テーブルの COMMISSION 列に標本標準偏差を返します。COMMISSION は DECIMAL 列です。結果のスケールは 10 桁に減らされます。
```
select cast(stddev(commission) as dec(18,10))
from sales;
stddev
----------------
130.3912659086
(1 row)
```
次のクエリは整数として COMMISSION 列の標本標準偏差をキャストします。
```
select cast(stddev(commission) as integer)
from sales;
stddev
--------
130
(1 row)
```
次のクエリは COMMISSION 列に標本標準偏差と標本分散の平方根の両方を返します。これらの計算の結果は同じです。
```
select
cast(stddev_samp(commission) as dec(18,10)) stddevsamp,
cast(sqrt(var_samp(commission)) as dec(18,10)) sqrtvarsamp
from sales;
stddevsamp | sqrtvarsamp
----------------+----------------
130.3912659086 | 130.3912659086
(1 row)
```
# SUM 関数
SUM 関数は入力列または式の値の合計を返します。SUM 関数は数値に対してはたらき、NULL 値を無視します。
## 構文
```
SUM ( [ DISTINCT | ALL ] expression )
```
## 引数
* 式*
関数の対象となる列または式。*式*は、以下に示すデータ型の 1 つを取ります。
+ SMALLINT
+ INTEGER
+ BIGINT
+ NUMERIC
+ DECIMAL
+ REAL
+ DOUBLE PRECISION
+ SUPER
DISTINCT \$1 ALL
引数 DISTINCT を指定すると、この関数は合計を計算する前に指定された式から重複した値をすべて削除します。引数 ALL を指定すると、この関数は合計を計算する式から重複する値をすべて保持します。ALL がデフォルトです。
## データ型
SUM 関数でサポートされる引数の型は、SMALLINT、INTEGER、BIGINT、NUMERIC、DECIMAL、REAL、DOUBLE PRECISION および SUPER です。
SUM 関数でサポートされる戻り値の型は次のとおりです。
+ BIGINT、SMALLINT、および INTEGER 引数の場合は BIGINT
+ NUMERIC 引数の場合は NUMERIC
+ 浮動小数点の引数の場合は DOUBLE PRECISION
+ 他の引数型については、expression と同じデータ型を返します。
NUMERIC または DECIMAL 引数を持つ SUM 関数結果のデフォルト精度は 38 です。結果のスケールは、引数のスケールと同じです。例えば、DEC(5,2) 列の SUM は DEC(38,2) のデータ型を返します。
## 例
SALES テーブルから支払われたすべての手数料の合計を検索します。
```
select sum(commission) from sales;
sum
-------------
16614814.65
(1 row)
```
フロリダ州の全会場の座席数を検索します。
```
select sum(venueseats) from venue
where venuestate = 'FL';
sum
--------
250411
(1 row)
```
5 月に販売された座席数を検索します。
```
select sum(qtysold) from sales, date
where sales.dateid = date.dateid and date.month = 'MAY';
sum
-------
32291
(1 row)
```
# VAR\$1SAMP および VAR\$1POP 関数
VAR\$1SAMP および VAR\$1POP 関数は、数値のセットの標本分散と母集団分散 (整数、10 進数、または浮動小数点) を返します。VAR\$1SAMP 関数の結果は、値の同じセットの 2 乗の標本標準偏差に相当します。
VAR\$1SAMP および VARIANCE は同じ関数のシノニムです。
## 構文
```
VAR_SAMP | VARIANCE ( [ DISTINCT | ALL ] expression)
VAR_POP ( [ DISTINCT | ALL ] expression)
```
この式は整数、10 進数、または浮動小数点数データ型である必要があります。式のデータ型にかかわらず、この関数の戻り値の型は倍精度の数値です。
**注記**
これらの関数の結果は、それぞれのクラスターの設定に応じて、データウェアハウスクラスターによって変わる場合があります。
## 使用に関する注意事項
標本分散 (VARIANCE または VAR\$1SAMP) が 1 つの値で構成される式に対して計算される場合、関数の結果は 0 ではなく、NULL になります。
## 例
次のクエリは LISTING テーブルの NUMTICKETS 列の四捨五入した標本分散と母集団分散を返します。
```
select avg(numtickets),
round(var_samp(numtickets)) varsamp,
round(var_pop(numtickets)) varpop
from listing;
avg | varsamp | varpop
-----+---------+--------
10 | 54 | 54
(1 row)
```
次のクエリは同じ計算を実行しますが、10 進値の結果をキャストします。
```
select avg(numtickets),
cast(var_samp(numtickets) as dec(10,4)) varsamp,
cast(var_pop(numtickets) as dec(10,4)) varpop
from listing;
avg | varsamp | varpop
-----+---------+---------
10 | 53.6291 | 53.6288
(1 row)
```