Amazon Redshift 將不再支援從修補程式 198 開始建立新的 Python UDFs。現有 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/)。
本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。
# 範圍函數
使用範圍函數，您可以更有效地建立分析業務查詢。範圍函數對結果集的一個分割區或「視窗」執行運算，然後針對該視窗中的每一列傳回一個值。反之，非視窗函數對結果集的每一列執行計算。不同於彙總結果列的群組函數，範圍函數會保留運算式中的所有列。
傳回的值是利用該視窗中列集的值來計算。對於資料表的每一列，視窗會定義用於計算其他屬性的列集。視窗是以視窗規格 (OVER 子句) 並根據三個主要概念來定義：
+ *視窗分割*，其會形成列群組 (PARTITION 子句)
+ *視窗排序*，定義每一個分割區內列的順序或序列 (ORDER BY 子句)
+ *視窗框*，相對於每一列來定義，以進一步限制列組 (ROWS 規格)
範圍函數是查詢中最後執行的一組運算 (最後的 ORDER BY 子句除外)。所有聯結和所有 WHERE、GROUP BY 及 HAVING 子句都在範圍函數處理之前完成。因此，範圍函數只能出現在 select 清單或 ORDER BY 子句中。您可以在具有不同窗框子句的單一查詢中使用多個範圍函數。您也可以在其他純量運算式 (例如 CASE) 中使用範圍函數。
視窗函數無法是巢狀。例如，彙總函數 [SUM](r_SUM.md) 可以出現在視窗函數 [SUM](r_WF_SUM.md) 內，但視窗函數 SUM 無法出現在另一個視窗函數 SUM 內。由於視窗函數巢狀嵌套在另一個視窗函數中，因此不支援以下內容。
```
SELECT SUM(SUM(selectcol) OVER (PARTITION BY ordercol)) OVER (Partition by ordercol) FROM t;
```
## 範圍函數語法摘要
範圍函數遵循標準語法，如下所示。
```
function (expression) OVER (
[ PARTITION BY expr_list ]
[ ORDER BY order_list [ frame_clause ] ] )
```
其中，*function* 是本節所述其中一個函數。
*expr\$1list* 如下。
```
expression | column_name [, expr_list ]
```
*order\$1list* 如下。
```
expression | column_name [ ASC | DESC ]
[ NULLS FIRST | NULLS LAST ]
[, order_list ]
```
*frame\$1clause* 如下。
```
ROWS
{ UNBOUNDED PRECEDING | unsigned_value PRECEDING | CURRENT ROW } |
{ BETWEEN
{ UNBOUNDED PRECEDING | unsigned_value { PRECEDING | FOLLOWING } | CURRENT ROW}
AND
{ UNBOUNDED FOLLOWING | unsigned_value { PRECEDING | FOLLOWING } | CURRENT ROW }}
```
### 引數
*函數*
範圍函數。如需詳細資訊，請參閱個別函數描述。
OVER
此子句定義視窗規格。OVER 是範圍函數的必要子句，用於區分範圍函數和其他 SQL 函數。
PARTITION BY *expr\$1list*
(選用) PARTITION BY 子句將結果集細分為分割區，很像 GROUP BY 子句。如果有分割區子句，則會對每一個分割區的列來計算函數。如果未指定分割區子句，則單一分割區包含整個資料表，且會針對這整個資料表來計算函數。
排名函數 DENSE\$1RANK、NTILE、RANK 及 ROW\$1NUMBER 需要整體比較結果集的所有列。使用 PARTITION BY 子句時，查詢最佳化工具可以根據分割區將工作負載分散至多個配量，以平行執行每一個彙總。如果沒有 PARTITION BY 子句，則必須在單一配量上循序執行彙總步驟，這可能對效能造成嚴重的負面影響，尤其對於大型叢集。
Amazon Redshift 不支援 PARTITION BY 子句中的字串常值。
ORDER BY *order\$1list*
(選用) 範圍函數會套用至每一個分割區內根據 ORDER BY 中的順序規格所排序的列。此 ORDER BY 子句不同於且完全無關於 *frame\$1clause* 中的 ORDER BY 子句。使用 ORDER BY 子句可以不搭配 PARTITION BY 子句。
對於排名函數，ORDER BY 子句可辨識排名值的量值。對於彙總函數，在為每一個窗框計算彙總函數之前，分割的列必須排序。如需範圍函數的詳細資訊，請參閱[範圍函數](#c_Window_functions)。
順序清單中需要欄識別碼或可評估為欄識別碼的欄表達式。常數或常數表達式都不能用來替代欄名。
NULLS 值自成一組，根據 NULLS FIRST 或 NULLS LAST 選項來排序和排名。根據預設，依 ASC 順序排序時，NULL 值排在最後面，而依 DESC 順序排序時，則排在最前面。
Amazon Redshift 不支援 ORDER BY 子句中的字串常值。
如果省略 ORDER BY 子句，則列的順序不確定。
在任何平行系統中，例如 Amazon Redshift，當 ORDER BY 子句無法產生唯一且完全的資料排序時，列的順序不確定。也就是說，如果 ORDER BY 運算式產生重複值 (局部排序)，則那些列的傳回順序可能隨著每一次執行 Amazon Redshift 而有所不同。於是，範圍函數可能傳回非預期或不一致的結果。如需詳細資訊，請參閱[範圍函數的資料唯一排序](#r_Examples_order_by_WF)。
*column\$1name*
分割或排序所依據的欄名。
ASC \$1 DESC
此選項會定義表達式的排序順序，如下所示：
+ ASC：遞增 (例如，數值從低到高，字元字串 'A' 到 'Z')。若未指定選項，資料會預設為遞增排序。
+ DESC：遞減 (數值從高到低，字串 'Z' 到 'A')。
NULLS FIRST \$1 NULLS LAST
這些選項指定 NULLS 應該排序在最前 (在非 Null 值之前) 或排序在最後 (在非 Null 值之後)。根據預設，NULLS 在 ASC 排序中排序和排名最後，而在 DESC 排序中排序和排名最前。
*frame\$1clause*
對於彙總函數，使用 ORDER BY 時，窗框子句會進一步調整函數視窗中的一個列集。它可讓您在排序的結果內包含或排除資料列組。窗框子句包含 ROWS 關鍵字和相關的指定元。
窗框子句不適用於排名函數。此外，當彙總函數的 OVER 子句中未使用 ORDER BY 子句時，不需要使用窗框子句。如果彙總函數使用 ORDER BY 子句，則需要明確的窗框子句。
未指定 ORDER BY 子句時，隱含的窗框無邊界：相當於 ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING。
ROWS
此子句定義視窗框作法是指定相對於目前列的實體位移。
此子句指定目前視窗或分割區中的列，以便與目前列的值結合。此子句使用引數來指定列位置，可能在目前列之前或之後。所有視窗框都以目前列為參考點。隨著視窗框在分割區中向前滑動，每一列會輪流變成目前列。
窗框可能是一組簡單的列，最遠到達且包含目前列。
```
{UNBOUNDED PRECEDING | offset PRECEDING | CURRENT ROW}
```
也可能是兩個邊界之間的一個列集。
```
BETWEEN
{ UNBOUNDED PRECEDING | offset { PRECEDING | FOLLOWING } | CURRENT ROW }
AND
{ UNBOUNDED FOLLOWING | offset { PRECEDING | FOLLOWING } | CURRENT ROW }
```
UNBOUNDED PRECEDING 表示視窗從分割區的第一列開始；*offset* PRECEDING 表示視窗從目前列之前相當於 offset 值的列數開始。UNBOUNDED PRECEDING 是預設值。
CURRENT ROW 表示視窗在目前列開始或結束。
UNBOUNDED FOLLOWING 表示視窗在分割區的最後一列結束；*offset* FOLLOWING 表示視窗在目前列之後相當於 offset 值的列數結束。
*offset* 表示目前列之前或之後的實體列數。在此案例中，*offset* 必須是評估為正數值的常數。例如，5 FOLLOWING 會在目前列之後的 5 列結束窗框。
未指定 BETWEEN 時，窗框會隱含地以目前列為邊界。例如，`ROWS 5 PRECEDING` 等於 `ROWS BETWEEN 5 PRECEDING AND CURRENT ROW`。此外，`ROWS UNBOUNDED FOLLOWING` 等於 `ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING`。
您不能指定開始邊界大於結束邊界的窗框。例如，您不能指定下列任何窗框：
```
between 5 following and 5 preceding
between current row and 2 preceding
between 3 following and current row
```
## 範圍函數的資料唯一排序
如果範圍函數的 ORDER BY 子句無法產生唯一且完全的資料排序時，列的順序不確定。如果 ORDER BY 運算式產生重複值 (局部排序)，則這些行的傳回順序在多次執行中可能會有所不同。在這種情況下，範圍函數也可能傳回非預期或不一致的結果。
例如，以下查詢會在多次執行中傳回不同的結果。發生這些不同的結果是因為 `order by dateid` 不會為 SUM 範圍函數產生唯一的資料排序。
```
select dateid, pricepaid,
sum(pricepaid) over(order by dateid rows unbounded preceding) as sumpaid
from sales
group by dateid, pricepaid;
dateid | pricepaid | sumpaid
--------+-----------+-------------
1827 | 1730.00 | 1730.00
1827 | 708.00 | 2438.00
1827 | 234.00 | 2672.00
...
select dateid, pricepaid,
sum(pricepaid) over(order by dateid rows unbounded preceding) as sumpaid
from sales
group by dateid, pricepaid;
dateid | pricepaid | sumpaid
--------+-----------+-------------
1827 | 234.00 | 234.00
1827 | 472.00 | 706.00
1827 | 347.00 | 1053.00
...
```
在此情況下，將第二個 ORDER BY 欄新增至範圍函數可能會解決問題。
```
select dateid, pricepaid,
sum(pricepaid) over(order by dateid, pricepaid rows unbounded preceding) as sumpaid
from sales
group by dateid, pricepaid;
dateid | pricepaid | sumpaid
--------+-----------+---------
1827 | 234.00 | 234.00
1827 | 337.00 | 571.00
1827 | 347.00 | 918.00
...
```
## 支援的函數
Amazon Redshift 支援兩種範圍函數：彙總和排名。
以下是支援的彙總函數：
+ [AVG 範圍函數](r_WF_AVG.md)
+ [COUNT 範圍函數](r_WF_COUNT.md)
+ [CUME\$1DIST 範圍函數](r_WF_CUME_DIST.md)
+ [DENSE\$1RANK 範圍函數](r_WF_DENSE_RANK.md)
+ [FIRST\$1VALUE 範圍函數](r_WF_first_value.md)
+ [LAG 範圍函數](r_WF_LAG.md)
+ [LAST\$1VALUE 範圍函數](r_WF_last_value.md)
+ [LEAD 範圍函數](r_WF_LEAD.md)
+ [LISTAGG 範圍函數](r_WF_LISTAGG.md)
+ [MAX 範圍函數](r_WF_MAX.md)
+ [MEDIAN 範圍函數](r_WF_MEDIAN.md)
+ [MIN 範圍函數](r_WF_MIN.md)
+ [NTH\$1VALUE 範圍函數](r_WF_NTH.md)
+ [PERCENTILE\$1CONT 範圍函數](r_WF_PERCENTILE_CONT.md)
+ [PERCENTILE\$1DISC 範圍函數](r_WF_PERCENTILE_DISC.md)
+ [RATIO\$1TO\$1REPORT 範圍函數](r_WF_RATIO_TO_REPORT.md)
+ [STDDEV\$1SAMP 和 STDDEV\$1POP 範圍函數](r_WF_STDDEV.md) (STDDEV\$1SAMP 和 STDDEV 是同義詞)
+ [SUM 範圍函數](r_WF_SUM.md)
+ [VAR\$1SAMP 和 VAR\$1POP 範圍函數](r_WF_VARIANCE.md) (VAR\$1SAMP 和 VARIANCE 是同義詞)
以下是支援的排名函數：
+ [DENSE\$1RANK 範圍函數](r_WF_DENSE_RANK.md)
+ [NTILE 範圍函數](r_WF_NTILE.md)
+ [PERCENT\$1RANK 範圍函數](r_WF_PERCENT_RANK.md)
+ [RANK 範圍函數](r_WF_RANK.md)
+ [ROW\$1NUMBER 範圍函數](r_WF_ROW_NUMBER.md)
## 範圍函數範例的範例資料表
您可以在每個函數說明中找到特定的範圍函數範例。部分範例會使用名為 WINSALES 的資料表，其中包含 11 個資料列，如下所示。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/c_Window_functions.html)
下列指令碼建立並填入範例 WINSALES 資料表。
```
CREATE TABLE winsales(
salesid int,
dateid date,
sellerid int,
buyerid char(10),
qty int,
qty_shipped int);
INSERT INTO winsales VALUES
(30001, '8/2/2003', 3, 'b', 10, 10),
(10001, '12/24/2003', 1, 'c', 10, 10),
(10005, '12/24/2003', 1, 'a', 30, null),
(40001, '1/9/2004', 4, 'a', 40, null),
(10006, '1/18/2004', 1, 'c', 10, null),
(20001, '2/12/2004', 2, 'b', 20, 20),
(40005, '2/12/2004', 4, 'a', 10, 10),
(20002, '2/16/2004', 2, 'c', 20, 20),
(30003, '4/18/2004', 3, 'b', 15, null),
(30004, '4/18/2004', 3, 'b', 20, null),
(30007, '9/7/2004', 3, 'c', 30, null);
```
# AVG 範圍函數
AVG 範圍函數傳回輸入表達式值的平均值 (算術平均數)。AVG 函數處理數值，且忽略 NULL 值。
## 語法
```
AVG ( [ALL ] expression ) OVER
(
[ PARTITION BY expr_list ]
[ ORDER BY order_list
frame_clause ]
)
```
## 引數
*expression *
函數運算的目標欄或表達式。
ALL
如果指定引數 ALL，則函數在計數時會保留表達式中的所有重複值。ALL 為預設值。不支援 DISTINCT。
OVER
指定彙總函數的視窗子句。OVER 子句區分視窗彙總函數和正常組彙總函數。
PARTITION BY *expr\$1list*
以一或多個表達式定義 AVG 函數的視窗。
ORDER BY *order\$1list*
排序每一個分割區內的列。如果未指定 PARTITION BY，ORDER BY 會使用整個資料表。
*frame\$1clause*
如果彙總函數使用 ORDER BY 子句，則需要明確的窗框子句。窗框子句在排序的結果內包含或排除列集，以調整函數視窗中的一個列集。窗框子句包含 ROWS 關鍵字和相關的指定元。請參閱 [範圍函數語法摘要](c_Window_functions.md#r_Window_function_synopsis)。
## 資料類型
AVG 函數支援的引數類型包括 SMALLINT、INTEGER、BIGINT、NUMERIC、DECIMAL、REAL 及 DOUBLE PRECISION。
AVG 函數支援的傳回類型如下：
+ BIGINT 代表 SMALLINT 或 INTEGER 引數
+ NUMERIC 代表 BIGINT 引數
+ DOUBLE PRECISION 代表浮點數引數
## 範例
下列範例會依日期計算銷售數量的移動平均數；依日期 ID 和銷售 ID 排序結果：
```
select salesid, dateid, sellerid, qty,
avg(qty) over
(order by dateid, salesid rows unbounded preceding) as avg
from winsales
order by 2,1;
salesid | dateid | sellerid | qty | avg
---------+------------+----------+-----+-----
30001 | 2003-08-02 | 3 | 10 | 10
10001 | 2003-12-24 | 1 | 10 | 10
10005 | 2003-12-24 | 1 | 30 | 16
40001 | 2004-01-09 | 4 | 40 | 22
10006 | 2004-01-18 | 1 | 10 | 20
20001 | 2004-02-12 | 2 | 20 | 20
40005 | 2004-02-12 | 4 | 10 | 18
20002 | 2004-02-16 | 2 | 20 | 18
30003 | 2004-04-18 | 3 | 15 | 18
30004 | 2004-04-18 | 3 | 20 | 18
30007 | 2004-09-07 | 3 | 30 | 19
(11 rows)
```
如需 WINSALES 資料表的描述，請參閱[範圍函數範例的範例資料表](c_Window_functions.md#r_Window_function_example)。
# COUNT 範圍函數
COUNT 範圍函數會計算表達式所定義的列數。
COUNT 函數有兩種版本。COUNT(\$1) 計算目標資料表中的所有列數，而不論是否包含 Null。COUNT (表達式) 計算特定欄或表達式中不含 NULL 值的列數。
## 語法
```
COUNT ( * | [ ALL ] expression) OVER
(
[ PARTITION BY expr_list ]
[ ORDER BY order_list
frame_clause ]
)
```
## 引數
*expression *
函數運算的目標欄或表達式。
ALL
如果指定引數 ALL，則函數在計數時會保留表達式中的所有重複值。ALL 為預設值。不支援 DISTINCT。
OVER
指定彙總函數的視窗子句。OVER 子句區分視窗彙總函數和正常組彙總函數。
PARTITION BY *expr\$1list*
以一或多個表達式定義 COUNT 函數的視窗。
ORDER BY *order\$1list*
排序每一個分割區內的列。如果未指定 PARTITION BY，ORDER BY 會使用整個資料表。
*frame\$1clause*
如果彙總函數使用 ORDER BY 子句，則需要明確的窗框子句。窗框子句在排序的結果內包含或排除列集，以調整函數視窗中的一個列集。窗框子句包含 ROWS 關鍵字和相關的指定元。請參閱 [範圍函數語法摘要](c_Window_functions.md#r_Window_function_synopsis)。
## 資料類型
COUNT 函數支援所有引數資料類型。
COUNT 函數支援的傳回類型為 BIGINT。
## 範例
下列範例顯示從資料視窗開頭的所有列的銷售 ID、數量和計數：
```
select salesid, qty,
count(*) over (order by salesid rows unbounded preceding) as count
from winsales
order by salesid;
salesid | qty | count
---------+-----+-----
10001 | 10 | 1
10005 | 30 | 2
10006 | 10 | 3
20001 | 20 | 4
20002 | 20 | 5
30001 | 10 | 6
30003 | 15 | 7
30004 | 20 | 8
30007 | 30 | 9
40001 | 40 | 10
40005 | 10 | 11
(11 rows)
```
如需 WINSALES 資料表的描述，請參閱[範圍函數範例的範例資料表](c_Window_functions.md#r_Window_function_example)。
下列範例顯示如何從資料視窗開頭計算非 null 列的銷售 ID、數量和計數。(在 WINSALES 資料表中，QTY\$1SHIPPED 欄包含一些 NULL。)
```
select salesid, qty, qty_shipped,
count(qty_shipped)
over (order by salesid rows unbounded preceding) as count
from winsales
order by salesid;
salesid | qty | qty_shipped | count
---------+-----+-------------+-------
10001 | 10 | 10 | 1
10005 | 30 | | 1
10006 | 10 | | 1
20001 | 20 | 20 | 2
20002 | 20 | 20 | 3
30001 | 10 | 10 | 4
30003 | 15 | | 4
30004 | 20 | | 4
30007 | 30 | | 4
40001 | 40 | | 4
40005 | 10 | 10 | 5
(11 rows)
```
# CUME\$1DIST 範圍函數
計算視窗或分割區內值的累積分佈。假定為遞增排序，使用此公式來決定累積分佈：
`count of rows with values <= x / count of rows in the window or partition`
其中，*x* 等於 ORDER BY 子句所指定欄之目前列中的值。以下資料集示範此公式的使用：
```
Row# Value Calculation CUME_DIST
1 2500 (1)/(5) 0.2
2 2600 (2)/(5) 0.4
3 2800 (3)/(5) 0.6
4 2900 (4)/(5) 0.8
5 3100 (5)/(5) 1.0
```
傳回值範圍是 >0 至 1 (含)。
## 語法
```
CUME_DIST ()
OVER (
[ PARTITION BY partition_expression ]
[ ORDER BY order_list ]
)
```
## 引數
OVER
用於指定視窗分割的子句。OVER 子句不能包含視窗框規格。
PARTITION BY *partition\$1expression*
選用。此表達式針對 OVER 子句中的每一個群組，設定記錄範圍。
ORDER BY *order\$1list*
要計算累積分佈的表達式。表達式必須為數值資料類型，或可隱含地轉換為數值資料類型。如果省略 ORDER BY，所有列的傳回值為 1。
如果 ORDER BY 未產生唯一排序，則列的順序不確定。如需詳細資訊，請參閱[範圍函數的資料唯一排序](c_Window_functions.md#r_Examples_order_by_WF)。
## 傳回類型
FLOAT8
## 範例
以下範例計算每一個賣方的數量累積分佈：
```
select sellerid, qty, cume_dist()
over (partition by sellerid order by qty)
from winsales;
sellerid qty cume_dist
--------------------------------------------------
1 10.00 0.33
1 10.64 0.67
1 30.37 1
3 10.04 0.25
3 15.15 0.5
3 20.75 0.75
3 30.55 1
2 20.09 0.5
2 20.12 1
4 10.12 0.5
4 40.23 1
```
如需 WINSALES 資料表的描述，請參閱[範圍函數範例的範例資料表](c_Window_functions.md#r_Window_function_example)。
# DENSE\$1RANK 範圍函數
DENSE\$1RANK 範圍函數根據 OVER 子句中的 ORDER BY 表達式，決定一組值之中某個值的排名。如果有選用的 PARTITION BY 子句，則會重設每一組列的排名。在排名準則中有相等值的列獲得相同排名。DENSE\$1RANK 函數有一方面不同於 RANK：如果兩列以上繫結在一起，則排名值的序列中沒有間隙。例如，假設兩列都排名 `1`，則下一個排名為 `2`。
在相同查詢中，排名函數可以搭配不同的 PARTITION BY 和 ORDER BY 子句。
## 語法
```
DENSE_RANK() OVER
(
[ PARTITION BY expr_list ]
[ ORDER BY order_list ]
)
```
## 引數
( )
此函數不接受引數，但需要空括號。
OVER
DENSE\$1RANK 函數的視窗子句。
PARTITION BY *expr\$1list*
(選用) 一或多個用於定義視窗的運算式。
ORDER BY *order\$1list*
(選用) 排名值所根據的運算式。如果未指定 PARTITION BY，ORDER BY 會使用整個資料表。如果省略 ORDER BY，所有列的傳回值為 `1`。
如果 ORDER BY 未產生唯一排序，則列的順序不確定。如需詳細資訊，請參閱[範圍函數的資料唯一排序](c_Window_functions.md#r_Examples_order_by_WF)。
## 傳回類型
`BIGINT`
## 範例
下列範例使用範圍函數的範例資料表。如需詳細資訊，請參閱[範圍函數範例的範例資料表](c_Window_functions.md#r_Window_function_example)。
以下範例依銷售數量排序資料表，並將密集排名和一般排名指派給每一列。套用範圍函數結果之後排序結果。
```
SELECT salesid, qty,
DENSE_RANK() OVER(ORDER BY qty DESC) AS d_rnk,
RANK() OVER(ORDER BY qty DESC) AS rnk
FROM winsales
ORDER BY 2,1;
+---------+-----+-------+-----+
| salesid | qty | d_rnk | rnk |
+---------+-----+-------+-----+
| 10001 | 10 | 5 | 8 |
| 10006 | 10 | 5 | 8 |
| 30001 | 10 | 5 | 8 |
| 40005 | 10 | 5 | 8 |
| 30003 | 15 | 4 | 7 |
| 20001 | 20 | 3 | 4 |
| 20002 | 20 | 3 | 4 |
| 30004 | 20 | 3 | 4 |
| 10005 | 30 | 2 | 2 |
| 30007 | 30 | 2 | 2 |
| 40001 | 40 | 1 | 1 |
+---------+-----+-------+-----+
```
在相同查詢中同時使用 DENSE\$1RANK 和 RANK 函數時，請注意指派給相同列集的排名差異。
下列範例會依 sellerid 分割資料表，並依數量排序每一個分割區，然後指派密集排名給每一列。套用範圍函數結果之後排序結果。
```
SELECT salesid, sellerid, qty,
DENSE_RANK() OVER(PARTITION BY sellerid ORDER BY qty DESC) AS d_rnk
FROM winsales
ORDER BY 2,3,1;
+---------+----------+-----+-------+
| salesid | sellerid | qty | d_rnk |
+---------+----------+-----+-------+
| 10001 | 1 | 10 | 2 |
| 10006 | 1 | 10 | 2 |
| 10005 | 1 | 30 | 1 |
| 20001 | 2 | 20 | 1 |
| 20002 | 2 | 20 | 1 |
| 30001 | 3 | 10 | 4 |
| 30003 | 3 | 15 | 3 |
| 30004 | 3 | 20 | 2 |
| 30007 | 3 | 30 | 1 |
| 40005 | 4 | 10 | 2 |
| 40001 | 4 | 40 | 1 |
+---------+----------+-----+-------+
```
若要成功使用最後範例，請使用下列命令將資料列插入 WINSALES 資料表。此列與另一列具有相同的 buyid、sellerid 和 qtysold。這將導致上一個範例中的兩列並列，因此將顯示 DENSE\$1RANK 和 RANK 函數之間的差異。
```
INSERT INTO winsales VALUES(30009, '2/2/2003', 3, 'b', 20, NULL);
```
下列範例會依 buyerid 和 sellerid 分割資料表，並依數量排序每一個分割區，然後同時指派密集排名和一般排名給每一列。(選用) 套用範圍函數之後對結果進行排序。
```
SELECT salesid, sellerid, qty, buyerid,
DENSE_RANK() OVER(PARTITION BY buyerid, sellerid ORDER BY qty DESC) AS d_rnk,
RANK() OVER (PARTITION BY buyerid, sellerid ORDER BY qty DESC) AS rnk
FROM winsales
ORDER BY rnk;
+---------+----------+-----+---------+-------+-----+
| salesid | sellerid | qty | buyerid | d_rnk | rnk |
+---------+----------+-----+---------+-------+-----+
| 20001 | 2 | 20 | b | 1 | 1 |
| 30007 | 3 | 30 | c | 1 | 1 |
| 10006 | 1 | 10 | c | 1 | 1 |
| 10005 | 1 | 30 | a | 1 | 1 |
| 20002 | 2 | 20 | c | 1 | 1 |
| 30009 | 3 | 20 | b | 1 | 1 |
| 40001 | 4 | 40 | a | 1 | 1 |
| 30004 | 3 | 20 | b | 1 | 1 |
| 10001 | 1 | 10 | c | 1 | 1 |
| 40005 | 4 | 10 | a | 2 | 2 |
| 30003 | 3 | 15 | b | 2 | 3 |
| 30001 | 3 | 10 | b | 3 | 4 |
+---------+----------+-----+---------+-------+-----+
```
# FIRST\$1VALUE 範圍函數
在一組已排序的列中，FIRST\$1VALUE 會針對視窗框中的第一列，傳回指定之表達式的值。
如需有關選取視窗框中最後一列的資訊，請參閱[LAST\$1VALUE 範圍函數](r_WF_last_value.md)。
## 語法
```
FIRST_VALUE( expression )[ IGNORE NULLS | RESPECT NULLS ]
OVER (
[ PARTITION BY expr_list ]
[ ORDER BY order_list frame_clause ]
)
```
## 引數
*表達式*
函數運算的目標欄或表達式。
IGNORE NULLS
此選項與 FIRST\$1VALUE 一起使用時，函數會傳回窗框中第一個非 NULL (或如果所有值都是 NULL，則為 NULL) 的值。
RESPECT NULLS
指出 Amazon Redshift 應該包含 null 值來決定要使用的列。如果您不指定 IGNORE NULLS，則預設支援 RESPECT NULLS。
OVER
引進函數的視窗子句。
PARTITION BY *expr\$1list*
以一或多個表達式定義函數的視窗。
ORDER BY *order\$1list*
排序每一個分割區內的列。如果未指定 PARTITION BY 子句，ORDER BY 會排序整個資料表。如果您指定 ORDER BY 子句，則還必須指定 *frame\$1clause*。
FIRST\$1VALUE 函數的結果取決於資料的排序。在下列情況中，結果不確定：
+ 未指定 ORDER BY 子句，且分割區包含一個表達式的兩個不同值
+ 表達式評估為不同值，而這些值對應於 ORDER BY 清單中的相同值。
*frame\$1clause*
如果彙總函數使用 ORDER BY 子句，則需要明確的窗框子句。窗框子句在排序的結果中包含或排除資料列組，以調整函數視窗中的一個列集。窗框子句包含 ROWS 關鍵字和相關的指定元。請參閱 [範圍函數語法摘要](c_Window_functions.md#r_Window_function_synopsis)。
## 傳回類型
這些函數支援使用基本 Amazon Redshift 資料類型的運算式。傳回類型與*運算式*的資料類型相同。
## 範例
下列範例會使用範例 TICKIT 資料中的 VENUE 表格。如需詳細資訊，請參閱[範本資料庫](c_sampledb.md)。
下列範例傳回 VENUE 資料表中每個會場的座位容量，且結果依容量排序 (高到低)。會使用 FIRST\$1VALUE 函數來選取與窗框之第一列對應的會場名稱：在此案例中，即座位數最多的那一列。結果依州分割，所以當 VENUESTATE 值變更時，就會選取新的第一個值。視窗框無界限，對於每一個分割區的第一列，選取的第一個值都相同。
以加利佛尼亞來說，`Qualcomm Stadium` 的座位數最多 (`70561`)，因此，對於 `CA` 分割區中的所有列，此名稱是第一個值。
```
select venuestate, venueseats, venuename,
first_value(venuename)
over(partition by venuestate
order by venueseats desc
rows between unbounded preceding and unbounded following)
from (select * from venue where venueseats >0)
order by venuestate;
venuestate | venueseats | venuename | first_value
-----------+------------+--------------------------------+------------------------------
CA | 70561 | Qualcomm Stadium | Qualcomm Stadium
CA | 69843 | Monster Park | Qualcomm Stadium
CA | 63026 | McAfee Coliseum | Qualcomm Stadium
CA | 56000 | Dodger Stadium | Qualcomm Stadium
CA | 45050 | Angel Stadium of Anaheim | Qualcomm Stadium
CA | 42445 | PETCO Park | Qualcomm Stadium
CA | 41503 | AT&T Park | Qualcomm Stadium
CA | 22000 | Shoreline Amphitheatre | Qualcomm Stadium
CO | 76125 | INVESCO Field | INVESCO Field
CO | 50445 | Coors Field | INVESCO Field
DC | 41888 | Nationals Park | Nationals Park
FL | 74916 | Dolphin Stadium | Dolphin Stadium
FL | 73800 | Jacksonville Municipal Stadium | Dolphin Stadium
FL | 65647 | Raymond James Stadium | Dolphin Stadium
FL | 36048 | Tropicana Field | Dolphin Stadium
...
```
下列範例顯示使用 IGNORE NULLS 選項，並依賴將新的一列新增至 VENUE 資料表：
```
insert into venue values(2000,null,'Stanford','CA',90000);
```
這個新列的 VENUENAME 欄包含 NULL 值。現在，重複本節稍早所示的 FIRST\$1VALUE 查詢：
```
select venuestate, venueseats, venuename,
first_value(venuename)
over(partition by venuestate
order by venueseats desc
rows between unbounded preceding and unbounded following)
from (select * from venue where venueseats >0)
order by venuestate;
venuestate | venueseats | venuename | first_value
-----------+------------+----------------------------+-------------
CA | 90000 | NULL | NULL
CA | 70561 | Qualcomm Stadium | NULL
CA | 69843 | Monster Park | NULL
...
```
因為新列包含最高 VENUESEATS 值 (`90000`)，且其 VENUENAME 為 NULL，所以 FIRST\$1VALUE 函數對 `CA` 分割區傳回 Null。若要在函數評估中忽略像這樣的列，請將 IGNORE NULLS 選項新增至函數引數：
```
select venuestate, venueseats, venuename,
first_value(venuename) ignore nulls
over(partition by venuestate
order by venueseats desc
rows between unbounded preceding and unbounded following)
from (select * from venue where venuestate='CA')
order by venuestate;
venuestate | venueseats | venuename | first_value
------------+------------+----------------------------+------------------
CA | 90000 | NULL | Qualcomm Stadium
CA | 70561 | Qualcomm Stadium | Qualcomm Stadium
CA | 69843 | Monster Park | Qualcomm Stadium
...
```
# LAG 範圍函數
LAG 範圍函數傳回分割區中目前列上方 (之前) 給定位移那一列的值。
## 語法
```
LAG (value_expr [, offset ])
[ IGNORE NULLS | RESPECT NULLS ]
OVER ( [ PARTITION BY window_partition ] ORDER BY window_ordering )
```
## 引數
*value\$1expr*
函數運算的目標欄或表達式。
*offset*
選擇性參數，指定在目前列之前要傳回值的列數。位移可以是常數整數，或評估為整數的表達式。如果您不指定位移，Amazon Redshift 會使用 `1` 做為預設值。位移 `0` 表示目前列。
IGNORE NULLS
選擇性規格，指出 Amazon Redshift 在決定要使用的列時應該略過 Null 值。如果未列出 IGNORE NULLS，則會包含 Null 值。
您可以使用 NVL 或 COALESCE 表達式，將 Null 值換成另一個值。如需詳細資訊，請參閱[NVL 和 COALESCE 函數](r_NVL_function.md)。
RESPECT NULLS
指出 Amazon Redshift 應該包含 null 值來決定要使用的列。如果您不指定 IGNORE NULLS，則預設支援 RESPECT NULLS。
OVER
指定視窗分割和排序。OVER 子句不能包含視窗框規格。
PARTITION BY *window\$1partition*
選擇性引數，針對 OVER 子句中的每一個群組，設定記錄範圍。
ORDER BY *window\$1ordering*
排序每一個分割區內的列。
LAG 範圍函數支援有使用任何 Amazon Redshift 資料類型的運算式。傳回類型與 *value\$1expr* 的類型相同。
## 範例
下列範例顯示銷售給買方 ID 為 3 之買方的門票數量，以及買方 3 購買門票的時間。為了比較買方 3 的每次銷售與前次銷售，查詢會傳回每次銷售的前次銷售數量。因為 2008/1/16 之前沒有購買，所以第一個先前銷售數量值為 Null：
```
select buyerid, saletime, qtysold,
lag(qtysold,1) over (order by buyerid, saletime) as prev_qtysold
from sales where buyerid = 3 order by buyerid, saletime;
buyerid | saletime | qtysold | prev_qtysold
---------+---------------------+---------+--------------
3 | 2008-01-16 01:06:09 | 1 |
3 | 2008-01-28 02:10:01 | 1 | 1
3 | 2008-03-12 10:39:53 | 1 | 1
3 | 2008-03-13 02:56:07 | 1 | 1
3 | 2008-03-29 08:21:39 | 2 | 1
3 | 2008-04-27 02:39:01 | 1 | 2
3 | 2008-08-16 07:04:37 | 2 | 1
3 | 2008-08-22 11:45:26 | 2 | 2
3 | 2008-09-12 09:11:25 | 1 | 2
3 | 2008-10-01 06:22:37 | 1 | 1
3 | 2008-10-20 01:55:51 | 2 | 1
3 | 2008-10-28 01:30:40 | 1 | 2
(12 rows)
```
# LAST\$1VALUE 範圍函數
在一組已排序的列中，LAST\$1VALUE 函數針對窗框中的最後一列，傳回運算式的值。
如需有關選取框架中第一列的資訊，請參閱[FIRST\$1VALUE 範圍函數](r_WF_first_value.md)。
## 語法
```
LAST_VALUE( expression )[ IGNORE NULLS | RESPECT NULLS ]
OVER (
[ PARTITION BY expr_list ]
[ ORDER BY order_list frame_clause ]
)
```
## 引數
*表達式*
函數運算的目標欄或表達式。
IGNORE NULLS
函數會傳回窗框中非 NULL (或如果所有值都是 NULL，則為 NULL) 的最後一個值。
RESPECT NULLS
指出 Amazon Redshift 應該包含 null 值來決定要使用的列。如果您不指定 IGNORE NULLS，則預設支援 RESPECT NULLS。
OVER
引進函數的視窗子句。
PARTITION BY *expr\$1list*
以一或多個表達式定義函數的視窗。
ORDER BY *order\$1list*
排序每一個分割區內的列。如果未指定 PARTITION BY 子句，ORDER BY 會排序整個資料表。如果您指定 ORDER BY 子句，則還必須指定 *frame\$1clause*。
結果取決於資料的順序。在下列情況中，結果不確定：
+ 未指定 ORDER BY 子句，且分割區包含一個表達式的兩個不同值
+ 表達式評估為不同值，而這些值對應於 ORDER BY 清單中的相同值。
*frame\$1clause*
如果彙總函數使用 ORDER BY 子句，則需要明確的窗框子句。窗框子句在排序的結果中包含或排除資料列組，以調整函數視窗中的一個列集。窗框子句包含 ROWS 關鍵字和相關的指定元。請參閱 [範圍函數語法摘要](c_Window_functions.md#r_Window_function_synopsis)。
## 傳回類型
這些函數支援使用基本 Amazon Redshift 資料類型的運算式。傳回類型與*運算式*的資料類型相同。
## 範例
下列範例會使用範例 TICKIT 資料中的 VENUE 表格。如需詳細資訊，請參閱[範本資料庫](c_sampledb.md)。
下列範例傳回 VENUE 資料表中每個會場的座位容量，且結果依容量排序 (高到低)。LAST\$1VALUE 函數用於選取與窗框之最後一列對應的會場名稱：在此案例中，即座位數最少的那一列。結果依州分割，所以當 VENUESTATE 值變更時，就會選取新的最後一個值。視窗框無界限，對於每一個分割區的第一列，選取的最後一個值都相同。
以加利佛尼亞來說，分割區中的每一列列都傳回 `Shoreline Amphitheatre`，因為其座位數最少 (`22000`)。
```
select venuestate, venueseats, venuename,
last_value(venuename)
over(partition by venuestate
order by venueseats desc
rows between unbounded preceding and unbounded following)
from (select * from venue where venueseats >0)
order by venuestate;
venuestate | venueseats | venuename | last_value
-----------+------------+--------------------------------+------------------------------
CA | 70561 | Qualcomm Stadium | Shoreline Amphitheatre
CA | 69843 | Monster Park | Shoreline Amphitheatre
CA | 63026 | McAfee Coliseum | Shoreline Amphitheatre
CA | 56000 | Dodger Stadium | Shoreline Amphitheatre
CA | 45050 | Angel Stadium of Anaheim | Shoreline Amphitheatre
CA | 42445 | PETCO Park | Shoreline Amphitheatre
CA | 41503 | AT&T Park | Shoreline Amphitheatre
CA | 22000 | Shoreline Amphitheatre | Shoreline Amphitheatre
CO | 76125 | INVESCO Field | Coors Field
CO | 50445 | Coors Field | Coors Field
DC | 41888 | Nationals Park | Nationals Park
FL | 74916 | Dolphin Stadium | Tropicana Field
FL | 73800 | Jacksonville Municipal Stadium | Tropicana Field
FL | 65647 | Raymond James Stadium | Tropicana Field
FL | 36048 | Tropicana Field | Tropicana Field
...
```
# LEAD 範圍函數
LEAD 範圍函數傳回分割區中目前列下方 (之後) 給定位移那一列的值。
## 語法
```
LEAD (value_expr [, offset ])
[ IGNORE NULLS | RESPECT NULLS ]
OVER ( [ PARTITION BY window_partition ] ORDER BY window_ordering )
```
## 引數
*value\$1expr*
函數運算的目標欄或表達式。
*offset*
選擇性參數，指定在目前列下方要傳回值的列數。位移可以是常數整數，或評估為整數的表達式。如果您不指定位移，Amazon Redshift 會使用 `1` 做為預設值。位移 `0` 表示目前列。
IGNORE NULLS
選擇性規格，指出 Amazon Redshift 在決定要使用的列時應該略過 Null 值。如果未列出 IGNORE NULLS，則會包含 Null 值。
您可以使用 NVL 或 COALESCE 表達式，將 Null 值換成另一個值。如需詳細資訊，請參閱[NVL 和 COALESCE 函數](r_NVL_function.md)。
RESPECT NULLS
指出 Amazon Redshift 應該包含 null 值來決定要使用的列。如果您不指定 IGNORE NULLS，則預設支援 RESPECT NULLS。
OVER
指定視窗分割和排序。OVER 子句不能包含視窗框規格。
PARTITION BY *window\$1partition*
選擇性引數，針對 OVER 子句中的每一個群組，設定記錄範圍。
ORDER BY *window\$1ordering*
排序每一個分割區內的列。
LEAD 範圍函數支援有使用任何 Amazon Redshift 資料類型的運算式。傳回類型與 *value\$1expr* 的類型相同。
## 範例
下列範例提供 SALES 資料表中於 2008 年 1 月 1 日和 2008 年 1 月 2 日售出門票之活動的佣金，以及對隨後銷售之門票銷售支付的佣金。下列範例使用 TICKIT 範例資料庫。如需詳細資訊，請參閱[範本資料庫](c_sampledb.md)。
```
SELECT eventid, commission, saletime, LEAD(commission, 1) over ( ORDER BY saletime ) AS next_comm
FROM sales
WHERE saletime BETWEEN '2008-01-09 00:00:00' AND '2008-01-10 12:59:59'
LIMIT 10;
+---------+------------+---------------------+-----------+
| eventid | commission | saletime | next_comm |
+---------+------------+---------------------+-----------+
| 1664 | 13.2 | 2008-01-09 01:00:21 | 69.6 |
| 184 | 69.6 | 2008-01-09 01:00:36 | 116.1 |
| 6870 | 116.1 | 2008-01-09 01:02:37 | 11.1 |
| 3718 | 11.1 | 2008-01-09 01:05:19 | 205.5 |
| 6772 | 205.5 | 2008-01-09 01:14:04 | 38.4 |
| 3074 | 38.4 | 2008-01-09 01:26:50 | 209.4 |
| 5254 | 209.4 | 2008-01-09 01:29:16 | 26.4 |
| 3724 | 26.4 | 2008-01-09 01:40:09 | 57.6 |
| 5303 | 57.6 | 2008-01-09 01:40:21 | 51.6 |
| 3678 | 51.6 | 2008-01-09 01:42:54 | 43.8 |
+---------+------------+---------------------+-----------+
```
下列範例提供 SALES 資料表中事件的佣金上限，以及針對相同事件的後續銷售所支付之門票銷售的佣金。此範例示範如何使用 LEAD 搭配 GROUP BY 子句。由於彙總子句中不允許視窗函數，因此此範例會使用子查詢。下列範例使用 TICKIT 範例資料庫。如需詳細資訊，請參閱[範本資料庫](c_sampledb.md)。
```
SELECT eventid, eventname, max(next_comm_diff) as max_commission_difference
FROM
(
SELECT sales.eventid, eventname, commission - LEAD(commission, 1) over (ORDER BY sales.eventid, saletime) AS next_comm_diff
FROM sales JOIN event ON sales.eventid = event.eventid
)
GROUP BY eventid, eventname
ORDER BY eventid
LIMIT 10
| eventid | eventname | max_commission_difference |
+---------+-----------------------------+---------------------------+
| 1 | Gotterdammerung | 7.95 |
| 2 | Boris Godunov | 227.85 |
| 3 | Salome | 1350.9 |
| 4 | La Cenerentola (Cinderella) | 790.05 |
| 5 | Il Trovatore | 214.05 |
| 6 | L Elisir d Amore | 510.9 |
| 7 | Doctor Atomic | 180.6 |
| 9 | The Fly | 147 |
| 10 | Rigoletto | 186.6 |
+---------+-----------------------------+---------------------------+
```
# LISTAGG 範圍函數
對於查詢中的每一組，LISTAGG 範圍函數依據 ORDER BY 表達式來排序該組的列，然後將這些值串連成單一字串。
## 語法
```
LISTAGG( [DISTINCT] expression [, 'delimiter' ] )
[ WITHIN GROUP (ORDER BY order_list) ]
OVER ( [PARTITION BY partition_expression] )
```
## 引數
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*)
(選用) 此子句指定彙總值的排序順序。只有在 ORDER BY 提供唯一排序時才可確定。預設是彙總所有列並傳回單一值。
OVER
用於指定視窗分割的子句。OVER 子句不能包含視窗排序或視窗框規格。
PARTITION BY *partition\$1expression*
(選用) 針對 OVER 子句中的每一個群組，設定記錄範圍。
## 傳回值
如果結果集大於 16，000，000 個位元組，則 LISTAGG 會傳回下列錯誤：
```
Invalid operation: Result size exceeds LISTAGG limit
```
## 範例
下列範例使用 WINSALES 資料表。如需 WINSALES 資料表的描述，請參閱[範圍函數範例的範例資料表](c_Window_functions.md#r_Window_function_example)。
下列範例傳回賣方 ID 清單，依賣方 ID 排序。
```
select listagg(sellerid)
within group (order by sellerid)
over() from winsales;
listagg
------------
11122333344
...
...
11122333344
11122333344
(11 rows)
```
下列範例傳回買方 B 的賣方 ID 清單，依日期排序。
```
select listagg(sellerid)
within group (order by dateid)
over () as seller
from winsales
where buyerid = 'b' ;
seller
---------
3233
3233
3233
3233
```
下列範例以逗號分隔清單傳回買方 B 的銷售日期。
```
select listagg(dateid,',')
within group (order by sellerid desc,salesid asc)
over () as dates
from winsales
where buyerid = 'b';
dates
-------------------------------------------
2003-08-02,2004-04-18,2004-04-18,2004-02-12
2003-08-02,2004-04-18,2004-04-18,2004-02-12
2003-08-02,2004-04-18,2004-04-18,2004-02-12
2003-08-02,2004-04-18,2004-04-18,2004-02-12
```
下列範例使用 DISTINCT 傳回買方 B 的唯一銷售日期清單。
```
select listagg(distinct dateid,',')
within group (order by sellerid desc,salesid asc)
over () as dates
from winsales
where buyerid = 'b';
dates
--------------------------------
2003-08-02,2004-04-18,2004-02-12
2003-08-02,2004-04-18,2004-02-12
2003-08-02,2004-04-18,2004-02-12
2003-08-02,2004-04-18,2004-02-12
```
下列範例以逗號分隔清單傳回每個買方 ID 的銷售 ID。
```
select buyerid,
listagg(salesid,',')
within group (order by salesid)
over (partition by buyerid) as sales_id
from winsales
order by buyerid;
+---------+-------------------------+
| buyerid | sales_id |
+---------+-------------------------+
| a | 10005,40001,40005 |
| a | 10005,40001,40005 |
| a | 10005,40001,40005 |
| b | 20001,30001,30003,30004 |
| b | 20001,30001,30003,30004 |
| b | 20001,30001,30003,30004 |
| b | 20001,30001,30003,30004 |
| c | 10001,10006,20002,30007 |
| c | 10001,10006,20002,30007 |
| c | 10001,10006,20002,30007 |
| c | 10001,10006,20002,30007 |
+---------+-------------------------+
```
下列範例示範 LISTAGG 支援高達 16，000，000 位元組的串連結果：
```
CREATE TABLE large_data (
id INT,
content VARCHAR(65535)
);
INSERT INTO large_data VALUES
(1, REPEAT('A', 65535)),
(2, REPEAT('B', 65535)),
(3, REPEAT('C', 65535));
SELECT LEN(LISTAGG(content, ',') WITHIN GROUP (ORDER BY id)) AS total_length
FROM large_data;
total_length
--------------
196607
```
# MAX 範圍函數
MAX 範圍函數傳回輸入表達式值的最大值。MAX 函數處理數值，且忽略 NULL 值。
## 語法
```
MAX ( [ ALL ] expression ) OVER
(
[ PARTITION BY expr_list ]
[ ORDER BY order_list frame_clause ]
)
```
## 引數
*expression *
函數運算的目標欄或表達式。
ALL
如果指定引數 ALL，函數會保留表達式中的所有重複值。ALL 為預設值。不支援 DISTINCT。
OVER
此子句指定彙總函數的視窗子句。OVER 子句區分視窗彙總函數和正常組彙總函數。
PARTITION BY *expr\$1list*
以一或多個表達式定義 MAX 函數的視窗。
ORDER BY *order\$1list*
排序每一個分割區內的列。如果未指定 PARTITION BY，ORDER BY 會使用整個資料表。
*frame\$1clause*
如果彙總函數使用 ORDER BY 子句，則需要明確的窗框子句。窗框子句在排序的結果內包含或排除列集，以調整函數視窗中的一個列集。窗框子句包含 ROWS 關鍵字和相關的指定元。請參閱 [範圍函數語法摘要](c_Window_functions.md#r_Window_function_synopsis)。
## 資料類型
接受任何資料類型做為輸入。傳回與 *expression* 相同的資料類型。
## 範例
下列範例顯示資料視窗開頭的銷售 ID、數量和最大數量：
```
select salesid, qty,
max(qty) over (order by salesid rows unbounded preceding) as max
from winsales
order by salesid;
salesid | qty | max
---------+-----+-----
10001 | 10 | 10
10005 | 30 | 30
10006 | 10 | 30
20001 | 20 | 30
20002 | 20 | 30
30001 | 10 | 30
30003 | 15 | 30
30004 | 20 | 30
30007 | 30 | 30
40001 | 40 | 40
40005 | 10 | 40
(11 rows)
```
如需 WINSALES 資料表的描述，請參閱[範圍函數範例的範例資料表](c_Window_functions.md#r_Window_function_example)。
下列範例顯示受限窗框中的 salesid、數量和最大數量：
```
select salesid, qty,
max(qty) over (order by salesid rows between 2 preceding and 1 preceding) as max
from winsales
order by salesid;
salesid | qty | max
---------+-----+-----
10001 | 10 |
10005 | 30 | 10
10006 | 10 | 30
20001 | 20 | 30
20002 | 20 | 20
30001 | 10 | 20
30003 | 15 | 20
30004 | 20 | 15
30007 | 30 | 20
40001 | 40 | 30
40005 | 10 | 40
(11 rows)
```
# MEDIAN 範圍函數
計算視窗或分割區內值範圍的中位數。忽略範圍中的 NULL 值。
MEDIAN 是採用連續分佈模型的反向分佈函數。
## 語法
```
MEDIAN ( median_expression )
OVER ( [ PARTITION BY partition_expression ] )
```
## 引數
*median\$1expression*
此表達式 (例如欄名) 提供要決定中位數的值。表達式必須為數值或日期時間資料類型，或可隱含地轉換為這種資料類型。
OVER
用於指定視窗分割的子句。OVER 子句不能包含視窗排序或視窗框規格。
PARTITION BY *partition\$1expression*
選用。此表達式針對 OVER 子句中的每一個群組，設定記錄範圍。
## 資料類型
傳回類型取決於 *median\$1expression* 的資料類型。下表顯示每一個 *median\$1expression* 資料類型的傳回類型。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_WF_MEDIAN.html)
## 使用須知
如果 *median\$1expression* 引數是以最大精確度 38 位數定義的 DECIMAL 資料類型，MEDIAN 可能會傳回不準確的結果或錯誤。如果 MEDIAN 函數的傳回值超過 38 位數，會將結果截斷為適合長度，導致精確度降低。在插補期間，如果中間結果超過最大精確度，則會發生數值溢位，且函數會傳回錯誤。為了避免這些情況，建議使用精確度較低的資料類型，或將 *median\$1expression* 引數轉換為較低精確度。
例如，搭配 DECIMAL 引數的 SUM 函數傳回的預設精確度為 38 位數。結果的小數位數和引數的小數位數相同。因此，例如，DECIMAL(5,2) 欄的 SUM 會傳回 DECIMAL(38,2) 資料類型。
下列範例在 MEDIAN 函數的 *median\$1expression* 引數中使用 SUM 函數。PRICEPAID 欄的資料類型是 DECIMAL (8,2)，所以 SUM 函數會傳回 DECIMAL(38,2)。
```
select salesid, sum(pricepaid), median(sum(pricepaid))
over() from sales where salesid < 10 group by salesid;
```
為了避免可能降低精確度或溢位錯誤，請將結果轉換為精確度較低的 DECIMAL 資料類型，如下列範例所示。
```
select salesid, sum(pricepaid), median(sum(pricepaid)::decimal(30,2))
over() from sales where salesid < 10 group by salesid;
```
## 範例
以下範例計算每一個賣方的銷售數量中位數：
```
select sellerid, qty, median(qty)
over (partition by sellerid)
from winsales
order by sellerid;
sellerid qty median
---------------------------
1 10 10.0
1 10 10.0
1 30 10.0
2 20 20.0
2 20 20.0
3 10 17.5
3 15 17.5
3 20 17.5
3 30 17.5
4 10 25.0
4 40 25.0
```
如需 WINSALES 資料表的描述，請參閱[範圍函數範例的範例資料表](c_Window_functions.md#r_Window_function_example)。
# MIN 範圍函數
MIN 範圍函數傳回輸入表達式值的最小值。MIN 函數處理數值，且忽略 NULL 值。
## 語法
```
MIN ( [ ALL ] expression ) OVER
(
[ PARTITION BY expr_list ]
[ ORDER BY order_list frame_clause ]
)
```
## 引數
*expression *
函數運算的目標欄或表達式。
ALL
如果指定引數 ALL，函數會保留表達式中的所有重複值。ALL 為預設值。不支援 DISTINCT。
OVER
指定彙總函數的視窗子句。OVER 子句區分視窗彙總函數和正常組彙總函數。
PARTITION BY *expr\$1list*
以一或多個表達式定義 MIN 函數的視窗。
ORDER BY *order\$1list*
排序每一個分割區內的列。如果未指定 PARTITION BY，ORDER BY 會使用整個資料表。
*frame\$1clause*
如果彙總函數使用 ORDER BY 子句，則需要明確的窗框子句。窗框子句在排序的結果內包含或排除列集，以調整函數視窗中的一個列集。窗框子句包含 ROWS 關鍵字和相關的指定元。請參閱 [範圍函數語法摘要](c_Window_functions.md#r_Window_function_synopsis)。
## 資料類型
接受任何資料類型做為輸入。傳回與 *expression* 相同的資料類型。
## 範例
下列範例顯示資料視窗開頭的銷售 ID、數量和最小數量：
```
select salesid, qty,
min(qty) over
(order by salesid rows unbounded preceding)
from winsales
order by salesid;
salesid | qty | min
---------+-----+-----
10001 | 10 | 10
10005 | 30 | 10
10006 | 10 | 10
20001 | 20 | 10
20002 | 20 | 10
30001 | 10 | 10
30003 | 15 | 10
30004 | 20 | 10
30007 | 30 | 10
40001 | 40 | 10
40005 | 10 | 10
(11 rows)
```
如需 WINSALES 資料表的描述，請參閱[範圍函數範例的範例資料表](c_Window_functions.md#r_Window_function_example)。
下列範例顯示受限窗框中的銷售 ID、數量和最小數量：
```
select salesid, qty,
min(qty) over
(order by salesid rows between 2 preceding and 1 preceding) as min
from winsales
order by salesid;
salesid | qty | min
---------+-----+-----
10001 | 10 |
10005 | 30 | 10
10006 | 10 | 10
20001 | 20 | 10
20002 | 20 | 10
30001 | 10 | 20
30003 | 15 | 10
30004 | 20 | 10
30007 | 30 | 15
40001 | 40 | 20
40005 | 10 | 30
(11 rows)
```
# NTH\$1VALUE 範圍函數
NTH\$1VALUE 範圍函數會相對於視窗的第一列，傳回視窗框之指定列的表達式值。
## 語法
```
NTH_VALUE (expr, offset)
[ IGNORE NULLS | RESPECT NULLS ]
OVER
( [ PARTITION BY window_partition ]
[ ORDER BY window_ordering
frame_clause ] )
```
## 引數
*expr*
函數運算的目標欄或表達式。
*offset*
相對於視窗中的第一列，決定要傳回表達式的列號。*offset* 可以是常數或表達式，且必須為大於 0 的正整數。
IGNORE NULLS
選擇性規格，指出 Amazon Redshift 在決定要使用的列時應該略過 Null 值。如果未列出 IGNORE NULLS，則會包含 Null 值。
RESPECT NULLS
指出 Amazon Redshift 應該包含 null 值來決定要使用的列。如果您不指定 IGNORE NULLS，則預設支援 RESPECT NULLS。
OVER
指定視窗分割、排序及視窗框。
PARTITION BY *window\$1partition*
針對 OVER 子句中的每一個群組，設定記錄範圍。
ORDER BY *window\$1ordering*
排序每一個分割區內的列。如果省略 ORDER BY，則預設窗框包含分割區中的所有列。
*frame\$1clause*
如果彙總函數使用 ORDER BY 子句，則需要明確的窗框子句。窗框子句在排序的結果中包含或排除資料列組，以調整函數視窗中的一個列集。窗框子句包含 ROWS 關鍵字和相關的指定元。請參閱 [範圍函數語法摘要](c_Window_functions.md#r_Window_function_synopsis)。
NTH\$1VALUE 範圍函數支援有使用任何 Amazon Redshift 資料類型的運算式。傳回類型與 *expr* 的類型相同。
## 範例
下列範例顯示加利佛尼亞、佛羅里達及紐約的前三大會場的座位數，並對照這些州其他會場的座位數：
```
select venuestate, venuename, venueseats,
nth_value(venueseats, 3)
ignore nulls
over(partition by venuestate order by venueseats desc
rows between unbounded preceding and unbounded following)
as third_most_seats
from (select * from venue where venueseats > 0 and
venuestate in('CA', 'FL', 'NY'))
order by venuestate;
venuestate | venuename | venueseats | third_most_seats
------------+--------------------------------+------------+------------------
CA | Qualcomm Stadium | 70561 | 63026
CA | Monster Park | 69843 | 63026
CA | McAfee Coliseum | 63026 | 63026
CA | Dodger Stadium | 56000 | 63026
CA | Angel Stadium of Anaheim | 45050 | 63026
CA | PETCO Park | 42445 | 63026
CA | AT&T Park | 41503 | 63026
CA | Shoreline Amphitheatre | 22000 | 63026
FL | Dolphin Stadium | 74916 | 65647
FL | Jacksonville Municipal Stadium | 73800 | 65647
FL | Raymond James Stadium | 65647 | 65647
FL | Tropicana Field | 36048 | 65647
NY | Ralph Wilson Stadium | 73967 | 20000
NY | Yankee Stadium | 52325 | 20000
NY | Madison Square Garden | 20000 | 20000
(15 rows)
```
# NTILE 範圍函數
NTILE 範圍函數將分割區中排序的列劃分為指定數量的排名群組，且大小儘可能相等，然後傳回給定列所屬的群組。
## 語法
```
NTILE (expr)
OVER (
[ PARTITION BY expression_list ]
[ ORDER BY order_list ]
)
```
## 引數
*expr*
每一個分割區的排名群組數，且結果必須為整數值 (大於 0)。*expr* 引數必須不可為 Null。
OVER
用於指定視窗分割和排序的子句。OVER 子句不能包含視窗框規格。
PARTITION BY *window\$1partition*
選用。OVER 子句中每一個群組的記錄範圍。
ORDER BY *window\$1ordering*
選用。此表達式排序每一個分割區內的列。如果省略 ORDER BY 子句，則排名行為相同。
如果 ORDER BY 未產生唯一排序，則列的順序不確定。如需詳細資訊，請參閱[範圍函數的資料唯一排序](c_Window_functions.md#r_Examples_order_by_WF)。
## 傳回類型
BIGINT
## 範例
下列範例將 2008 年 8 月 26 日 Hamlet 門票的支付價格分成四個排名群組。結果集有 17 列，幾乎平均分散於排名 1 到 4：
```
select eventname, caldate, pricepaid, ntile(4)
over(order by pricepaid desc) from sales, event, date
where sales.eventid=event.eventid and event.dateid=date.dateid and eventname='Hamlet'
and caldate='2008-08-26'
order by 4;
eventname | caldate | pricepaid | ntile
-----------+------------+-----------+-------
Hamlet | 2008-08-26 | 1883.00 | 1
Hamlet | 2008-08-26 | 1065.00 | 1
Hamlet | 2008-08-26 | 589.00 | 1
Hamlet | 2008-08-26 | 530.00 | 1
Hamlet | 2008-08-26 | 472.00 | 1
Hamlet | 2008-08-26 | 460.00 | 2
Hamlet | 2008-08-26 | 355.00 | 2
Hamlet | 2008-08-26 | 334.00 | 2
Hamlet | 2008-08-26 | 296.00 | 2
Hamlet | 2008-08-26 | 230.00 | 3
Hamlet | 2008-08-26 | 216.00 | 3
Hamlet | 2008-08-26 | 212.00 | 3
Hamlet | 2008-08-26 | 106.00 | 3
Hamlet | 2008-08-26 | 100.00 | 4
Hamlet | 2008-08-26 | 94.00 | 4
Hamlet | 2008-08-26 | 53.00 | 4
Hamlet | 2008-08-26 | 25.00 | 4
(17 rows)
```
# PERCENT\$1RANK 範圍函數
計算給定資料列的百分比排行。使用此公式決定百分比排名：
`(x - 1) / (the number of rows in the window or partition - 1)`
其中 *x* 是目前列的排名。以下資料集示範此公式的使用：
```
Row# Value Rank Calculation PERCENT_RANK
1 15 1 (1-1)/(7-1) 0.0000
2 20 2 (2-1)/(7-1) 0.1666
3 20 2 (2-1)/(7-1) 0.1666
4 20 2 (2-1)/(7-1) 0.1666
5 30 5 (5-1)/(7-1) 0.6666
6 30 5 (5-1)/(7-1) 0.6666
7 40 7 (7-1)/(7-1) 1.0000
```
傳回值範圍是 0 至 1 (含)。任何集的第一列的 PERCENT\$1RANK 為 0。
## 語法
```
PERCENT_RANK ()
OVER (
[ PARTITION BY partition_expression ]
[ ORDER BY order_list ]
)
```
## 引數
( )
此函數不接受引數，但需要空括號。
OVER
用於指定視窗分割的子句。OVER 子句不能包含視窗框規格。
PARTITION BY *partition\$1expression*
選用。此表達式針對 OVER 子句中的每一個群組，設定記錄範圍。
ORDER BY *order\$1list*
選用。要計算百分比排名的表達式。表達式必須為數值資料類型，或可隱含地轉換為數值資料類型。如果省略 ORDER BY，所有列的傳回值為 0。
如果 ORDER BY 未產生唯一排序，則列的順序不確定。如需詳細資訊，請參閱[範圍函數的資料唯一排序](c_Window_functions.md#r_Examples_order_by_WF)。
## 傳回類型
FLOAT8
## 範例
以下範例計算每一個賣方的銷售數量百分比排名：
```
select sellerid, qty, percent_rank()
over (partition by sellerid order by qty)
from winsales;
sellerid qty percent_rank
----------------------------------------
1 10.00 0.0
1 10.64 0.5
1 30.37 1.0
3 10.04 0.0
3 15.15 0.33
3 20.75 0.67
3 30.55 1.0
2 20.09 0.0
2 20.12 1.0
4 10.12 0.0
4 40.23 1.0
```
如需 WINSALES 資料表的描述，請參閱[範圍函數範例的範例資料表](c_Window_functions.md#r_Window_function_example)。
# 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)`.
您只能在 OVER 子句中指定 PARTITION 子句。如果指定 PARTITION，則對於每一列，PERCENTILE\$1CONT 會傳回在給定分割區內的一組值之中落在指定百分位數的值。
## 語法
```
PERCENTILE_CONT ( percentile )
WITHIN GROUP (ORDER BY expr)
OVER ( [ PARTITION BY expr_list ] )
```
## 引數
*percentile*
介於 0 和 1 之間的數值常數。計算時會忽略 Null。
WITHIN GROUP ( ORDER BY *expr*)
指定要排序和計算百分位數的數值或日期/時間值。
OVER
指定視窗分割。OVER 子句不能包含視窗排序或視窗框規格。
PARTITION BY *expr*
選擇性引數，針對 OVER 子句中的每一個群組，設定記錄範圍。
## 傳回值
傳回類型取決於 WITHIN GROUP 子句中 ORDER BY 表達式的資料類型。下表顯示每一個 ORDER BY 表達式資料類型的傳回類型。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_WF_PERCENTILE_CONT.html)
## 使用須知
如果 ORDER BY 表達式是以最大精確度 38 位數定義的 DECIMAL 資料類型，PERCENTILE\$1CONT 可能會傳回不準確的結果或錯誤。如果 PERCENTILE\$1CONT 函數的傳回值超過 38 位數，結果會截斷為適合長度，導致精確度降低。在插補期間，如果中間結果超過最大精確度，則會發生數值溢位，且函數會傳回錯誤。為了避免這些情況，建議使用精確度較低的資料類型，或將 ORDER BY 表達式轉換為較低精確度。
例如，搭配 DECIMAL 引數的 SUM 函數傳回的預設精確度為 38 位數。結果的小數位數和引數的小數位數相同。因此，例如，DECIMAL(5,2) 欄的 SUM 會傳回 DECIMAL(38,2) 資料類型。
下列範例在 PERCENTILE\$1CONT 函數的 ORDER BY 子句中使用 SUM 函數。PRICEPAID 欄的資料類型是 DECIMAL (8,2)，所以 SUM 函數會傳回 DECIMAL(38,2)。
```
select salesid, sum(pricepaid), percentile_cont(0.6)
within group (order by sum(pricepaid) desc) over()
from sales where salesid < 10 group by salesid;
```
為了避免可能降低精確度或溢位錯誤，請將結果轉換為精確度較低的 DECIMAL 資料類型，如下列範例所示。
```
select salesid, sum(pricepaid), percentile_cont(0.6)
within group (order by sum(pricepaid)::decimal(30,2) desc) over()
from sales where salesid < 10 group by salesid;
```
## 範例
下列範例使用 WINSALES 資料表。如需 WINSALES 資料表的描述，請參閱[範圍函數範例的範例資料表](c_Window_functions.md#r_Window_function_example)。
```
select sellerid, qty, percentile_cont(0.5)
within group (order by qty)
over() as median from winsales;
sellerid | qty | median
----------+-----+--------
1 | 10 | 20.0
1 | 10 | 20.0
3 | 10 | 20.0
4 | 10 | 20.0
3 | 15 | 20.0
2 | 20 | 20.0
3 | 20 | 20.0
2 | 20 | 20.0
3 | 30 | 20.0
1 | 30 | 20.0
4 | 40 | 20.0
(11 rows)
```
```
select sellerid, qty, percentile_cont(0.5)
within group (order by qty)
over(partition by sellerid) as median from winsales;
sellerid | qty | median
----------+-----+--------
2 | 20 | 20.0
2 | 20 | 20.0
4 | 10 | 25.0
4 | 40 | 25.0
1 | 10 | 10.0
1 | 10 | 10.0
1 | 30 | 10.0
3 | 10 | 17.5
3 | 15 | 17.5
3 | 20 | 17.5
3 | 30 | 17.5
(11 rows)
```
以下範例計算華盛頓州之賣方門票銷售的 PERCENTILE\$1CONT 和 PERCENTILE\$1DISC。
```
SELECT sellerid, state, sum(qtysold*pricepaid) sales,
percentile_cont(0.6) within group (order by sum(qtysold*pricepaid::decimal(14,2) ) desc) over(),
percentile_disc(0.6) within group (order by sum(qtysold*pricepaid::decimal(14,2) ) desc) over()
from sales s, users u
where s.sellerid = u.userid and state = 'WA' and sellerid < 1000
group by sellerid, state;
sellerid | state | sales | percentile_cont | percentile_disc
----------+-------+---------+-----------------+-----------------
127 | WA | 6076.00 | 2044.20 | 1531.00
787 | WA | 6035.00 | 2044.20 | 1531.00
381 | WA | 5881.00 | 2044.20 | 1531.00
777 | WA | 2814.00 | 2044.20 | 1531.00
33 | WA | 1531.00 | 2044.20 | 1531.00
800 | WA | 1476.00 | 2044.20 | 1531.00
1 | WA | 1177.00 | 2044.20 | 1531.00
(7 rows)
```
# PERCENTILE\$1DISC 範圍函數
PERCENTILE\$1DISC 是採用離散分佈模型的反向分佈函數。它採用百分位數值和排序規格，且會傳回給定集裡的一個元素。
針對給定的百分位數值 P，PERCENTILE\$1DISC 排序 ORDER BY 子句中的表達式值，且傳回的值具有大於或等於 P 的最小累積分佈值 (根據相同的排序規格)。
您只能在 OVER 子句中指定 PARTITION 子句。
## 語法
```
PERCENTILE_DISC ( percentile )
WITHIN GROUP (ORDER BY expr)
OVER ( [ PARTITION BY expr_list ] )
```
## 引數
*percentile*
介於 0 和 1 之間的數值常數。計算時會忽略 Null。
WITHIN GROUP ( ORDER BY *expr*)
指定要排序和計算百分位數的數值或日期/時間值。
OVER
指定視窗分割。OVER 子句不能包含視窗排序或視窗框規格。
PARTITION BY *expr*
選擇性引數，針對 OVER 子句中的每一個群組，設定記錄範圍。
## 傳回值
資料類型與 WITHIN GROUP 子句中的 ORDER BY 表達式相同。
## 範例
下列範例使用 WINSALES 資料表。如需 WINSALES 資料表的描述，請參閱[範圍函數範例的範例資料表](c_Window_functions.md#r_Window_function_example)。
```
SELECT sellerid, qty, PERCENTILE_DISC(0.5)
WITHIN GROUP (ORDER BY qty)
OVER() AS MEDIAN FROM winsales;
+----------+-----+--------+
| sellerid | qty | median |
+----------+-----+--------+
| 3 | 10 | 20 |
| 1 | 10 | 20 |
| 1 | 10 | 20 |
| 4 | 10 | 20 |
| 3 | 15 | 20 |
| 2 | 20 | 20 |
| 2 | 20 | 20 |
| 3 | 20 | 20 |
| 1 | 30 | 20 |
| 3 | 30 | 20 |
| 4 | 40 | 20 |
+----------+-----+--------+
SELECT sellerid, qty, PERCENTILE_DISC(0.5)
WITHIN GROUP (ORDER BY qty)
OVER(PARTITION BY sellerid) AS MEDIAN FROM winsales;
+----------+-----+--------+
| sellerid | qty | median |
+----------+-----+--------+
| 4 | 10 | 10 |
| 4 | 40 | 10 |
| 3 | 10 | 15 |
| 3 | 15 | 15 |
| 3 | 20 | 15 |
| 3 | 30 | 15 |
| 2 | 20 | 20 |
| 2 | 20 | 20 |
| 1 | 10 | 10 |
| 1 | 10 | 10 |
| 1 | 30 | 10 |
+----------+-----+--------+
```
若要尋找依賣家 ID 分割時數量的 PERCENTILE\$1DISC(0.25) 和 PERCENTILE\$1DISC(0.75)，請使用下列範例。
```
SELECT sellerid, qty, PERCENTILE_DISC(0.25)
WITHIN GROUP (ORDER BY qty)
OVER(PARTITION BY sellerid) AS quartile1 FROM winsales;
+----------+-----+-----------+
| sellerid | qty | quartile1 |
+----------+-----+-----------+
| 4 | 10 | 10 |
| 4 | 40 | 10 |
| 2 | 20 | 20 |
| 2 | 20 | 20 |
| 3 | 10 | 10 |
| 3 | 15 | 10 |
| 3 | 20 | 10 |
| 3 | 30 | 10 |
| 1 | 10 | 10 |
| 1 | 10 | 10 |
| 1 | 30 | 10 |
+----------+-----+-----------+
SELECT sellerid, qty, PERCENTILE_DISC(0.75)
WITHIN GROUP (ORDER BY qty)
OVER(PARTITION BY sellerid) AS quartile3 FROM winsales;
+----------+-----+-----------+
| sellerid | qty | quartile3 |
+----------+-----+-----------+
| 3 | 10 | 20 |
| 3 | 15 | 20 |
| 3 | 20 | 20 |
| 3 | 30 | 20 |
| 4 | 10 | 40 |
| 4 | 40 | 40 |
| 2 | 20 | 20 |
| 2 | 20 | 20 |
| 1 | 10 | 30 |
| 1 | 10 | 30 |
| 1 | 30 | 30 |
+----------+-----+-----------+
```
# RANK 範圍函數
RANK 範圍函數根據 OVER 子句中的 ORDER BY 表達式，決定一組值之中某個值的排名。如果有選用的 PARTITION BY 子句，則會重設每一組列的排名。在排名準則中有相等值的列獲得相同排名。Amazon Redshift 將綁定的行數添加到綁定的排名中以計算下一個排名，因此排名可能不是連續的數字。例如，假設兩列都排名 1，則下一個排名為 3。
RANK 函數有一方面不同於 [DENSE\$1RANK 範圍函數](r_WF_DENSE_RANK.md)：對於 DENSE\$1RANK，如果兩列以上繫結在一起，則排名值的序列中沒有間隙。例如，假設兩列都排名 1，則下一個排名為 2。
在相同查詢中，排名函數可以搭配不同的 PARTITION BY 和 ORDER BY 子句。
## 語法
```
RANK () OVER
(
[ PARTITION BY expr_list ]
[ ORDER BY order_list ]
)
```
## 引數
( )
此函數不接受引數，但需要空括號。
OVER
RANK 函數的視窗子句。
PARTITION BY *expr\$1list*
選用。一或多個用於定義視窗的表達式。
ORDER BY *order\$1list*
選用。定義排名值所根據的欄。如果未指定 PARTITION BY，ORDER BY 會使用整個資料表。如果省略 ORDER BY，所有列的傳回值為 1。
如果 ORDER BY 未產生唯一排序，則列的順序不確定。如需詳細資訊，請參閱[範圍函數的資料唯一排序](c_Window_functions.md#r_Examples_order_by_WF)。
## 傳回類型
INTEGER
## 範例
下列範例會依銷售數量排序資料表 (預設為遞增)，並將排名指派給每一列。最高排名的值為 1。套用範圍函數結果之後排序結果：
```
select salesid, qty,
rank() over (order by qty) as rnk
from winsales
order by 2,1;
salesid | qty | rnk
--------+-----+-----
10001 | 10 | 1
10006 | 10 | 1
30001 | 10 | 1
40005 | 10 | 1
30003 | 15 | 5
20001 | 20 | 6
20002 | 20 | 6
30004 | 20 | 6
10005 | 30 | 9
30007 | 30 | 9
40001 | 40 | 11
(11 rows)
```
請注意，此範例中的外圍 ORDER BY 子句包含第 2 欄和第 1 欄，以確保此查詢每次執行時，Amazon Redshift 會傳回一致排序的結果。例如，銷售 ID 為 10001 和 10006 的列有相同的 QTY 和 RNK 值。依第 1 欄排序最終結果集可確保列 10001 一定位於 10006 之前。如需 WINSALES 資料表的描述，請參閱[範圍函數範例的範例資料表](c_Window_functions.md#r_Window_function_example)。
在以下範例中，範圍函數反向排序 (`order by qty desc`)。現在，最高排名值套用至最大 QTY 值。
```
select salesid, qty,
rank() over (order by qty desc) as rank
from winsales
order by 2,1;
salesid | qty | rank
---------+-----+-----
10001 | 10 | 8
10006 | 10 | 8
30001 | 10 | 8
40005 | 10 | 8
30003 | 15 | 7
20001 | 20 | 4
20002 | 20 | 4
30004 | 20 | 4
10005 | 30 | 2
30007 | 30 | 2
40001 | 40 | 1
(11 rows)
```
如需 WINSALES 資料表的描述，請參閱[範圍函數範例的範例資料表](c_Window_functions.md#r_Window_function_example)。
下列範例會依 SELLERID 分割資料表，並依數量排序每一個分割區 (以遞減順序)，然後指派排名給每一列。套用範圍函數結果之後排序結果。
```
select salesid, sellerid, qty, rank() over
(partition by sellerid
order by qty desc) as rank
from winsales
order by 2,3,1;
salesid | sellerid | qty | rank
--------+----------+-----+-----
10001 | 1 | 10 | 2
10006 | 1 | 10 | 2
10005 | 1 | 30 | 1
20001 | 2 | 20 | 1
20002 | 2 | 20 | 1
30001 | 3 | 10 | 4
30003 | 3 | 15 | 3
30004 | 3 | 20 | 2
30007 | 3 | 30 | 1
40005 | 4 | 10 | 2
40001 | 4 | 40 | 1
(11 rows)
```
# RATIO\$1TO\$1REPORT 範圍函數
計算視窗或分割區內值與值總和的比率。使用下列公式決定報告值的比率：
`value of `*ratio\$1expression* `argument for the current row / sum of` *ratio\$1expression* `argument for the window or partition`
以下資料集示範此公式的使用：
```
Row# Value Calculation RATIO_TO_REPORT
1 2500 (2500)/(13900) 0.1798
2 2600 (2600)/(13900) 0.1870
3 2800 (2800)/(13900) 0.2014
4 2900 (2900)/(13900) 0.2086
5 3100 (3100)/(13900) 0.2230
```
傳回值範圍是 0 至 1 (含)。如果 *ratio\$1expressio*n 為 NULL，則傳回值為 `NULL`。如果 *partition\$1expression* 中的值是唯一的，則函數將傳回 `1` 代表該值。
## 語法
```
RATIO_TO_REPORT ( ratio_expression )
OVER ( [ PARTITION BY partition_expression ] )
```
## 引數
*ratio\$1expression*
此表達式 (例如欄名) 提供要決定比率的值。表達式必須為數值資料類型，或可隱含地轉換為數值資料類型。
您不能在 *ratio\$1expression* 中使用其他任何分析函數。
OVER
用於指定視窗分割的子句。OVER 子句不能包含視窗排序或視窗框規格。
PARTITION BY *partition\$1expression*
選用。此表達式針對 OVER 子句中的每一個群組，設定記錄範圍。
## 傳回類型
FLOAT8
## 範例
下列範例使用 WINSALES 資料表。如需有關如何建立 WINSALES 資料表的資訊，請參閱[範圍函數範例的範例資料表](c_Window_functions.md#r_Window_function_example)。
下列範例會計算賣家數量各資料列的報表比率，以及所有賣家數量的總計。
```
select sellerid, qty, ratio_to_report(qty)
over()
from winsales
order by sellerid;
sellerid qty ratio_to_report
--------------------------------------
1 30 0.13953488372093023
1 10 0.046511627906976744
1 10 0.046511627906976744
2 20 0.09302325581395349
2 20 0.09302325581395349
3 30 0.13953488372093023
3 20 0.09302325581395349
3 15 0.06976744186046512
3 10 0.046511627906976744
4 10 0.046511627906976744
4 40 0.18604651162790697
```
以下範例依分割區計算每一個賣方的銷售數量比例。
```
select sellerid, qty, ratio_to_report(qty)
over(partition by sellerid)
from winsales;
sellerid qty ratio_to_report
-------------------------------------------
2 20 0.5
2 20 0.5
4 40 0.8
4 10 0.2
1 10 0.2
1 30 0.6
1 10 0.2
3 10 0.13333333333333333
3 15 0.2
3 20 0.26666666666666666
3 30 0.4
```
# ROW\$1NUMBER 範圍函數
根據 OVER 子句中的 ORDER BY 運算式，指派一組列之內目前列的序數 (從 1 起算)。如果有選用的 PARTITION BY 子句，則會重設每一組列的序數。對於 ORDER BY 表達式，具有相等值的列會獲得非決定性的不同列號。
## 語法
```
ROW_NUMBER() OVER(
[ PARTITION BY expr_list ]
[ ORDER BY order_list ]
)
```
## 引數
( )
此函數不接受引數，但需要空括號。
OVER
ROW\$1NUMBER 函數的範圍函數子句。
PARTITION BY *expr\$1list*
選用。將結果分割成多組列的一或多個欄運算式。
ORDER BY *order\$1list*
選用。定義集合中資料列順序的一或多個資料行運算式。如果未指定 PARTITION BY，ORDER BY 會使用整個資料表。
如果 ORDER BY 未產生唯一排序或被省略，則列的順序不確定。如需詳細資訊，請參閱[範圍函數的資料唯一排序](c_Window_functions.md#r_Examples_order_by_WF)。
## 傳回類型
BIGINT
## 範例
下列範例使用 `WINSALES` 資料表。如需 `WINSALES` 資料表的描述，請參閱[範圍函數範例的範例資料表](c_Window_functions.md#r_Window_function_example)。
下列範例依數量對資料表進行排序 (以遞增順序)，然後將列號指派給每一列。套用範圍函數結果之後排序結果。
```
SELECT salesid, sellerid, qty,
ROW_NUMBER() OVER(
ORDER BY qty ASC) AS row
FROM winsales
ORDER BY 4,1;
salesid sellerid qty row
---------+----------+-----+-----
30001 | 3 | 10 | 1
10001 | 1 | 10 | 2
10006 | 1 | 10 | 3
40005 | 4 | 10 | 4
30003 | 3 | 15 | 5
20001 | 2 | 20 | 6
20002 | 2 | 20 | 7
30004 | 3 | 20 | 8
10005 | 1 | 30 | 9
30007 | 3 | 30 | 10
40001 | 4 | 40 | 11
```
下列範例依 SELLERID 分割資料表，並依 QTY 排序每一個分割區 (以遞增順序)，然後將列號指派給每一列。套用範圍函數結果之後排序結果。
```
SELECT salesid, sellerid, qty,
ROW_NUMBER() OVER(
PARTITION BY sellerid
ORDER BY qty ASC) AS row_by_seller
FROM winsales
ORDER BY 2,4;
salesid | sellerid | qty | row_by_seller
---------+----------+-----+-----
10001 | 1 | 10 | 1
10006 | 1 | 10 | 2
10005 | 1 | 30 | 3
20001 | 2 | 20 | 1
20002 | 2 | 20 | 2
30001 | 3 | 10 | 1
30003 | 3 | 15 | 2
30004 | 3 | 20 | 3
30007 | 3 | 30 | 4
40005 | 4 | 10 | 1
40001 | 4 | 40 | 2
```
下列範例顯示不使用選用子句時的結果。
```
SELECT salesid, sellerid, qty, ROW_NUMBER() OVER() AS row
FROM winsales
ORDER BY 4,1;
salesid sellerid qty row
---------+----------+-----+-----
30001 | 3 | 10 | 1
10001 | 1 | 10 | 2
10005 | 1 | 30 | 3
40001 | 4 | 40 | 4
10006 | 1 | 10 | 5
20001 | 2 | 20 | 6
40005 | 4 | 10 | 7
20002 | 2 | 20 | 8
30003 | 3 | 15 | 9
30004 | 3 | 20 | 10
30007 | 3 | 30 | 11
```
# STDDEV\$1SAMP 和 STDDEV\$1POP 範圍函數
STDDEV\$1SAMP 和 STDDEV\$1POP 範圍函數傳回一組數值 (整數、小數或浮點數) 的樣本標準差和母體標準差。另請參閱[STDDEV\$1SAMP 和 STDDEV\$1POP 函數](r_STDDEV_functions.md)。
STDDEV\$1SAMP 和 STDDEV 是同一個函數的同義詞。
## 語法
```
STDDEV_SAMP | STDDEV | STDDEV_POP
( [ ALL ] expression ) OVER
(
[ PARTITION BY expr_list ]
[ ORDER BY order_list
frame_clause ]
)
```
## 引數
*expression *
函數運算的目標欄或表達式。
ALL
如果指定引數 ALL，函數會保留表達式中的所有重複值。ALL 為預設值。不支援 DISTINCT。
OVER
指定彙總函數的視窗子句。OVER 子句區分視窗彙總函數和正常組彙總函數。
PARTITION BY *expr\$1list*
以一或多個表達式定義函數的視窗。
ORDER BY *order\$1list*
排序每一個分割區內的列。如果未指定 PARTITION BY，ORDER BY 會使用整個資料表。
*frame\$1clause*
如果彙總函數使用 ORDER BY 子句，則需要明確的窗框子句。窗框子句在排序的結果內包含或排除列集，以調整函數視窗中的一個列集。窗框子句包含 ROWS 關鍵字和相關的指定元。請參閱 [範圍函數語法摘要](c_Window_functions.md#r_Window_function_synopsis)。
## 資料類型
STDDEV 函數支援的引數類型包括 SMALLINT、INTEGER、BIGINT、NUMERIC、DECIMAL、REAL 及 DOUBLE PRECISION。
不論表達式的資料類型，STDDEV 函數的傳回類型都是雙精確度數字。
## 範例
下列範例顯示如何使用 STDDEV\$1POP 和 VAR\$1POP 函數做為範圍函數。查詢計算 SALES 資料表中 PRICEPAID 值的母體變異數和母體標準差。
```
select salesid, dateid, pricepaid,
round(stddev_pop(pricepaid) over
(order by dateid, salesid rows unbounded preceding)) as stddevpop,
round(var_pop(pricepaid) over
(order by dateid, salesid rows unbounded preceding)) as varpop
from sales
order by 2,1;
salesid | dateid | pricepaid | stddevpop | varpop
--------+--------+-----------+-----------+---------
33095 | 1827 | 234.00 | 0 | 0
65082 | 1827 | 472.00 | 119 | 14161
88268 | 1827 | 836.00 | 248 | 61283
97197 | 1827 | 708.00 | 230 | 53019
110328 | 1827 | 347.00 | 223 | 49845
110917 | 1827 | 337.00 | 215 | 46159
150314 | 1827 | 688.00 | 211 | 44414
157751 | 1827 | 1730.00 | 447 | 199679
165890 | 1827 | 4192.00 | 1185 | 1403323
...
```
樣本標準差和變異數函數可如法泡製。
# SUM 範圍函數
SUM 範圍函數傳回輸入欄或表達式值的總和。SUM 函數處理數值，且忽略 NULL 值。
## 語法
```
SUM ( [ ALL ] expression ) OVER
(
[ PARTITION BY expr_list ]
[ ORDER BY order_list
frame_clause ]
)
```
## 引數
*expression *
函數運算的目標欄或表達式。
ALL
如果指定引數 ALL，函數會保留表達式中的所有重複值。ALL 為預設值。不支援 DISTINCT。
OVER
指定彙總函數的視窗子句。OVER 子句區分視窗彙總函數和正常組彙總函數。
PARTITION BY *expr\$1list*
以一或多個表達式定義 SUM 函數的視窗。
ORDER BY *order\$1list*
排序每一個分割區內的列。如果未指定 PARTITION BY，ORDER BY 會使用整個資料表。
*frame\$1clause*
如果彙總函數使用 ORDER BY 子句，則需要明確的窗框子句。窗框子句在排序的結果內包含或排除列集，以調整函數視窗中的一個列集。窗框子句包含 ROWS 關鍵字和相關的指定元。請參閱 [範圍函數語法摘要](c_Window_functions.md#r_Window_function_synopsis)。
## 資料類型
SUM 函數支援的引數類型包括 SMALLINT、INTEGER、BIGINT、NUMERIC、DECIMAL、REAL 及 DOUBLE PRECISION。
SUM 函數支援的傳回類型如下：
+ BIGINT 代表 SMALLINT 或 INTEGER 引數
+ NUMERIC 代表 BIGINT 引數
+ DOUBLE PRECISION 代表浮點數引數
## 範例
下列範例會建立銷售數量的累積 (滾動) 總和，依日期和銷售 ID 排序：
```
select salesid, dateid, sellerid, qty,
sum(qty) over (order by dateid, salesid rows unbounded preceding) as sum
from winsales
order by 2,1;
salesid | dateid | sellerid | qty | sum
---------+------------+----------+-----+-----
30001 | 2003-08-02 | 3 | 10 | 10
10001 | 2003-12-24 | 1 | 10 | 20
10005 | 2003-12-24 | 1 | 30 | 50
40001 | 2004-01-09 | 4 | 40 | 90
10006 | 2004-01-18 | 1 | 10 | 100
20001 | 2004-02-12 | 2 | 20 | 120
40005 | 2004-02-12 | 4 | 10 | 130
20002 | 2004-02-16 | 2 | 20 | 150
30003 | 2004-04-18 | 3 | 15 | 165
30004 | 2004-04-18 | 3 | 20 | 185
30007 | 2004-09-07 | 3 | 30 | 215
(11 rows)
```
如需 WINSALES 資料表的描述，請參閱[範圍函數範例的範例資料表](c_Window_functions.md#r_Window_function_example)。
以下範例會依日期建立銷售數量的累積 (滾動) 總和、依賣方 ID 分割結果，然後在分割區內依日期和銷售 ID 排序結果：
```
select salesid, dateid, sellerid, qty,
sum(qty) over (partition by sellerid
order by dateid, salesid rows unbounded preceding) as sum
from winsales
order by 2,1;
salesid | dateid | sellerid | qty | sum
---------+------------+----------+-----+-----
30001 | 2003-08-02 | 3 | 10 | 10
10001 | 2003-12-24 | 1 | 10 | 10
10005 | 2003-12-24 | 1 | 30 | 40
40001 | 2004-01-09 | 4 | 40 | 40
10006 | 2004-01-18 | 1 | 10 | 50
20001 | 2004-02-12 | 2 | 20 | 20
40005 | 2004-02-12 | 4 | 10 | 50
20002 | 2004-02-16 | 2 | 20 | 40
30003 | 2004-04-18 | 3 | 15 | 25
30004 | 2004-04-18 | 3 | 20 | 45
30007 | 2004-09-07 | 3 | 30 | 75
(11 rows)
```
以下範例將結果集的所有列依序編號，依 SELLERID 和 SALESID 欄排序：
```
select salesid, sellerid, qty,
sum(1) over (order by sellerid, salesid rows unbounded preceding) as rownum
from winsales
order by 2,1;
salesid | sellerid | qty | rownum
--------+----------+------+--------
10001 | 1 | 10 | 1
10005 | 1 | 30 | 2
10006 | 1 | 10 | 3
20001 | 2 | 20 | 4
20002 | 2 | 20 | 5
30001 | 3 | 10 | 6
30003 | 3 | 15 | 7
30004 | 3 | 20 | 8
30007 | 3 | 30 | 9
40001 | 4 | 40 | 10
40005 | 4 | 10 | 11
(11 rows)
```
如需 WINSALES 資料表的描述，請參閱[範圍函數範例的範例資料表](c_Window_functions.md#r_Window_function_example)。
以下範例將結果集的所有列依序編號、依 SELLERID 分割結果，然後在分割區內依 SELLERID 和 SALESID 排序結果：
```
select salesid, sellerid, qty,
sum(1) over (partition by sellerid
order by sellerid, salesid rows unbounded preceding) as rownum
from winsales
order by 2,1;
salesid | sellerid | qty | rownum
---------+----------+-----+--------
10001 | 1 | 10 | 1
10005 | 1 | 30 | 2
10006 | 1 | 10 | 3
20001 | 2 | 20 | 1
20002 | 2 | 20 | 2
30001 | 3 | 10 | 1
30003 | 3 | 15 | 2
30004 | 3 | 20 | 3
30007 | 3 | 30 | 4
40001 | 4 | 40 | 1
40005 | 4 | 10 | 2
(11 rows)
```
# VAR\$1SAMP 和 VAR\$1POP 範圍函數
VAR\$1SAMP 和 VAR\$1POP 範圍函數傳回一組數值 (整數、小數或浮點數) 的樣本變異數和母體變異數。另請參閱[VAR\$1SAMP 和 VAR\$1POP 函數](r_VARIANCE_functions.md)。
VAR\$1SAMP 和 VARIANCE 是同一個函數的同義詞。
## 語法
```
VAR_SAMP | VARIANCE | VAR_POP
( [ ALL ] expression ) OVER
(
[ PARTITION BY expr_list ]
[ ORDER BY order_list
frame_clause ]
)
```
## 引數
*expression *
函數運算的目標欄或表達式。
ALL
如果指定引數 ALL，函數會保留表達式中的所有重複值。ALL 為預設值。不支援 DISTINCT。
OVER
指定彙總函數的視窗子句。OVER 子句區分視窗彙總函數和正常組彙總函數。
PARTITION BY *expr\$1list*
以一或多個表達式定義函數的視窗。
ORDER BY *order\$1list*
排序每一個分割區內的列。如果未指定 PARTITION BY，ORDER BY 會使用整個資料表。
*frame\$1clause*
如果彙總函數使用 ORDER BY 子句，則需要明確的窗框子句。窗框子句在排序的結果內包含或排除列集，以調整函數視窗中的一個列集。窗框子句包含 ROWS 關鍵字和相關的指定元。請參閱 [範圍函數語法摘要](c_Window_functions.md#r_Window_function_synopsis)。
## 資料類型
VARIANCE 函數支援的引數類型包括 SMALLINT、INTEGER、BIGINT、NUMERIC、DECIMAL、REAL 及 DOUBLE PRECISION。
不論表達式的資料類型，VARIANCE 函數的傳回類型都是雙精確度數字。