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/)을 참조하세요.
# 윈도우 함수
창 함수를 사용하면 사용자가 분석 비즈니스 쿼리를 보다 효율적으로 생성할 수 있습니다. 창 함수는 결과 집합의 파티션, 즉 "창"에서 실행되어 해당 창에 속하는 모든 행에 대한 값을 반환합니다. 이와는 반대로 창이 없는 함수는 결과 집합의 모든 행에 대해 계산을 실행합니다. 그 밖에도 결과 행을 집계하는 그룹 함수와 달리 창 함수에서는 테이블 표현식의 모든 행이 그대로 유지됩니다.
반환 값은 해당 창에 속한 행 집합의 값을 사용하여 계산됩니다. 창은 테이블의 각 행마다 추가 속성을 계산하는 데 사용되는 행 집합을 정의합니다. 창은 창 명세(OVER 절)를 사용하여 정의되며, 다음과 같이 세 가지 주요 개념을 근거로 합니다.
+ *창 파티션* - 행 그룹을 형성합니다(PARTITION 절).
+ *창 순서 지정* - 각 파티션의 행 순서 또는 시퀀스를 정의합니다(ORDER BY 절).
+ *창 프레임* - 행 집합을 제한하기 위해 각 행마다 정의됩니다(ROWS 명세).
창 함수는 최종 ORDER BY 절을 제외하고 쿼리에서 실행되는 마지막 연산 집합입니다. 창 함수를 처리할 때는 그 전에 모든 조인을 비롯한 WHERE, GROUP BY 및 HAVING 절까지 모두 완료됩니다. 따라서 창 함수는 선택 목록 또는 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;
```
## 창 함수 구문 요약
Window 함수는 다음과 같은 표준 구문을 따릅니다.
```
function (expression) OVER (
[ PARTITION BY expr_list ]
[ ORDER BY order_list [ frame_clause ] ] )
```
여기서 *함수*는 이 섹션에서 설명하는 함수 중 하나입니다.
*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) 섹션을 참조하세요.
order list에는 열 식별자, 또는 열 식별자로 평가되는 표현식이 필요합니다. 열 이름 대신에 상수나 상수 표현식을 사용할 수도 없습니다.
NULLS 값은 자체 그룹으로 처리되어 NULLS FIRST 또는 NULLS LAST 옵션에 따라 정렬 후 순위가 결정됩니다. 기본적으로 NULL 값은 ASC 순서에서는 마지막에 정렬 후 순위가 결정되며, 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 값 이외의 값 이전에 결정할지, 혹은 이후에 결정할지 지정하는 옵션입니다. 기본적으로 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은 오프셋 값에 해당하는 행의 수만큼 현재 행 앞에서 창이 시작된다는 것을 나타냅니다. 기본값은 UNBOUNDED PRECEDING입니다.
CURRENT ROW는 창이 현재 행에서 시작하거나 끝난다는 것을 나타냅니다.
UNBOUNDED FOLLOWING은 파티션의 마지막 행에서 창이 끝나는 것을 나타내고, *offset* FOLLOWING은 오프셋 값에 해당하는 행의 수만큼 현재 행 뒤에서 창이 끝난다는 것을 나타냅니다.
*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)
## 창 함수 예제를 위한 샘플 테이블
각 함수 설명과 함께 특정 창 함수 예제를 찾을 수도 있습니다. 일부 예는 다음과 같은 11개의 행이 포함된 WINSALES라는 테이블을 사용합니다.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/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 함수에서 지원되는 반환 형식은 다음과 같습니다.
+ SMALLINT 또는 INTEGER 인수일 때 BIGINT
+ BIGINT 인수일 때 NUMERIC
+ 부동 소수점 인수일 때 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)
```
요청 데이터에 대한 설명은 [창 함수 예제를 위한 샘플 테이블](c_Window_functions.md#r_Window_function_example) 섹션을 참조하세요.
# COUNT 창 함수
COUNT 창 함수는 표현식에서 정의하는 행의 수를 계산합니다.
COUNT 함수는 2가지 변형이 있습니다. COUNT(\$1)는 NULL 값의 유무에 상관없이 대상 테이블에서 모든 행의 수를 계산합니다. COUNT(expression)는 특정 열 또는 표현식에서 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)
```
요청 데이터에 대한 설명은 [창 함수 예제를 위한 샘플 테이블](c_Window_functions.md#r_Window_function_example) 섹션을 참조하세요.
다음 예에서는 데이터 윈도의 시작부터 판매 ID, 수량 및 null이 아닌 행의 수를 보여줍니다. 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까지입니다(1 포함).
## 구문
```
CUME_DIST ()
OVER (
[ PARTITION BY partition_expression ]
[ ORDER BY order_list ]
)
```
## 인수
OVER
창 파티션을 지정하는 절입니다. OVER 절에는 창 프레임 명세가 포함될 수 없습니다.
PARTITION BY *partition\$1expression*
선택 사항입니다. OVER 절에서 각 그룹의 레코드 범위를 설정하는 표현식입니다.
ORDER BY *order\$1list*
누적 분포를 계산하기 위한 표현식입니다. 이 표현식은 숫자 데이터 형식을 갖거나, 혹은 묵시적으로 1로 변환될 수 있어야 합니다. 즉 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
```
요청 데이터에 대한 설명은 [창 함수 예제를 위한 샘플 테이블](c_Window_functions.md#r_Window_function_example) 섹션을 참조하세요.
# DENSE\$1RANK 창 함수
DENSE\$1RANK 창 함수는 OVER 절의 ORDER BY 표현식을 기준으로 값 그룹에 속한 값의 순위를 결정합니다. PARTITION BY 절(옵션)이 존재하면 각 행 그룹의 순위가 재설정됩니다. 순위 기준 값이 같은 행은 순위도 동일하게 결정됩니다. DENSE\$1RANK 함수는 한 가지 측면에서 RANK와 다릅니다. 즉 2개 이상의 행에서 순위가 동일하면 순위 값의 순서에서도 빈 자리가 없습니다. 예를 들어 두 행의 순위가 `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 테이블에 행을 삽입합니다. 이 행은 다른 행과 동일한 buyerid, 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 VALUE 함수는 창 프레임의 첫 번째 행과 관련하여 지정된 표현식의 값을 반환합니다.
프레임의 마지막 행 선택에 대한 자세한 내용은 [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 ]
)
```
## 인수
* expression*
함수가 실행되는 대상 열 또는 표현식입니다.
IGNORE NULLS
FIRST\$1VALUE에서 이 옵션을 사용하면 프레임에서 NULL이 아닌 첫 번째 값을 반환합니다(또는 모든 값이 NULL이면 NULL을 반환합니다).
RESPECT NULLS
Amazon Redshift에서 사용할 행을 결정할 때 null 값을 포함시켜야 한다는 것을 의미합니다. RESPECT NULLS는 IGNORE NULLS를 지정하지 않은 경우 기본적으로 지원됩니다.
OVER
함수에서 창 절을 삽입합니다.
PARTITION BY *expr\$1list*
하나 이상의 표현식과 관련하여 함수의 창을 정의합니다.
ORDER BY *order\$1list*
각 파티션의 행을 정렬합니다. PARTITION BY 절을 지정하지 않으면 ORDER BY가 전체 테이블을 정렬합니다. ORDER BY 절을 지정하면 *frame\$1clause* 역시 지정해야 합니다.
FIRST\$1VALUE 함수의 결과는 데이터 순서에 따라 결정됩니다. 다음과 같은 경우 함수 결과는 비확정적입니다.
+ ORDER BY 절이 지정되지 않고 파티션에 다른 표현식 값 2개가 포함된 경우
+ 표현식이 ORDER BY 목록에서는 동일한 값이지만 다른 값으로 평가되는 경우
*frame\$1clause*
집계 함수에서 ORDER BY 절이 사용되면 명시적인 프레임 절이 필요합니다. 프레임 절은 순서가 지정된 결과에 행 집합을 추가하거나 제거함으로써 함수의 창에 포함되는 행 집합을 정제하는 역할을 하며, ROWS 키워드와 관련 지정자로 구성됩니다. [창 함수 구문 요약](c_Window_functions.md#r_Window_function_synopsis)을(를) 참조하세요.
## 반환 타입
이 두 함수는 기본 Amazon Redshift 데이터 형식을 사용하는 표현식을 지원합니다. 반환 형식은 *expression* 데이터 형식과 동일합니다.
## 예제
다음 예시에서는 샘플 TICKIT 데이터의 VENUE 테이블을 사용합니다. 자세한 내용은 [샘플 데이터베이스](c_sampledb.md) 섹션을 참조하세요.
다음은 VENUE 테이블에서 각 장소의 좌석 수용 능력을 반환하는 예로서 함수 결과의 순서(내림차순)는 좌석 수용 능력에 따라 지정됩니다. FIRST\$1VALUE 함수는 프레임에서 첫 번째 행에 해당하는 장소의 이름을 선택할 때 사용됩니다. 이 경우에는 좌석 수가 가장 많은 행이 여기에 해당합니다. 결과가 주를 기준으로 분할되어 있으므로 VENUESTATE 값이 바뀌면 첫 번째 값도 새롭게 선택됩니다. 여기에서는 창 프레임의 경계가 없기 때문에 각 파티션의 행마다 선택되는 첫 번째 값이 동일합니다.
California를 예로 들면, `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 값을 포함시켜야 한다는 것을 의미합니다. RESPECT NULLS는 IGNORE 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 VALUE 함수는 프레임의 마지막 행과 관련하여 표현식의 값을 반환합니다.
프레임의 첫 번째 행 선택에 대한 자세한 내용은 [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 ]
)
```
## 인수
* expression*
함수가 실행되는 대상 열 또는 표현식입니다.
IGNORE NULLS
프레임에서 NULL이 아닌 마지막 값을 반환합니다(또는 모든 값이 NULL이면 NULL을 반환합니다).
RESPECT NULLS
Amazon Redshift에서 사용할 행을 결정할 때 null 값을 포함시켜야 한다는 것을 의미합니다. RESPECT NULLS는 IGNORE NULLS를 지정하지 않은 경우 기본적으로 지원됩니다.
OVER
함수에서 창 절을 삽입합니다.
PARTITION BY *expr\$1list*
하나 이상의 표현식과 관련하여 함수의 창을 정의합니다.
ORDER BY *order\$1list*
각 파티션의 행을 정렬합니다. PARTITION BY 절을 지정하지 않으면 ORDER BY가 전체 테이블을 정렬합니다. ORDER BY 절을 지정하면 *frame\$1clause* 역시 지정해야 합니다.
결과는 데이터 순서에 따라 달라집니다. 다음과 같은 경우 함수 결과는 비확정적입니다.
+ ORDER BY 절이 지정되지 않고 파티션에 다른 표현식 값 2개가 포함된 경우
+ 표현식이 ORDER BY 목록에서는 동일한 값이지만 다른 값으로 평가되는 경우
*frame\$1clause*
집계 함수에서 ORDER BY 절이 사용되면 명시적인 프레임 절이 필요합니다. 프레임 절은 순서가 지정된 결과에 행 집합을 추가하거나 제거함으로써 함수의 창에 포함되는 행 집합을 정제하는 역할을 하며, ROWS 키워드와 관련 지정자로 구성됩니다. [창 함수 구문 요약](c_Window_functions.md#r_Window_function_synopsis)을(를) 참조하세요.
## 반환 타입
이 두 함수는 기본 Amazon Redshift 데이터 형식을 사용하는 표현식을 지원합니다. 반환 형식은 *expression* 데이터 형식과 동일합니다.
## 예제
다음 예시에서는 샘플 TICKIT 데이터의 VENUE 테이블을 사용합니다. 자세한 내용은 [샘플 데이터베이스](c_sampledb.md) 섹션을 참조하세요.
다음은 VENUE 테이블에서 각 장소의 좌석 수용 능력을 반환하는 예로서 함수 결과의 순서(내림차순)는 좌석 수용 능력에 따라 지정됩니다. LAST\$1VALUE 함수는 프레임에서 마지막 행에 해당하는 장소의 이름을 선택할 때 사용됩니다. 이 경우에는 좌석 수가 가장 적은 행이 여기에 해당합니다. 결과가 주를 기준으로 분할되어 있으므로 VENUESTATE 값이 바뀌면 마지막 값도 새롭게 선택됩니다. 여기에서는 창 프레임의 경계가 없기 때문에 각 파티션의 행마다 선택되는 마지막 값이 동일합니다.
California를 보면, 파티션의 모든 행에 대해서 좌석 수(`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 값을 포함시켜야 한다는 것을 의미합니다. RESPECT NULLS는 IGNORE NULLS를 지정하지 않은 경우 기본적으로 지원됩니다.
OVER
창 파티션 및 순서를 지정합니다. OVER 절에는 창 프레임 명세가 포함될 수 없습니다.
PARTITION BY *window\$1partition*
OVER 절에서 각 그룹의 레코드 범위를 설정하는 인수(옵션)입니다.
ORDER BY *window\$1ordering*
각 파티션의 행을 정렬합니다.
LEAD 윈도 함수는 Amazon Redshift 데이터 형식을 모두 사용하는 표현식을 지원합니다. 반환 형식은 *value\$1expr* 형식과 동일합니다.
## 예제
다음은 SALES 테이블의 이벤트에 대해 2008년 1월 1일과 동년 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 테이블에 있는 이벤트의 커미션과 동일한 이벤트의 후속 티켓 판매에 대해 지불한 커미션의 최대 차이를 보여줍니다. 이 예에서는 GROUP BY 절과 함께 LEAD를 사용하는 방법을 보여줍니다. 집계 절에서는 창 함수를 사용할 수 없으므로 이 예제에서는 하위 쿼리를 사용합니다. 다음 예제에서는 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 테이블을 사용합니다. 요청 데이터에 대한 설명은 [창 함수 예제를 위한 샘플 테이블](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 |
+---------+-------------------------+
```
다음 예제에서는 최대 16,000,000바이트의 연결된 결과를 사용한 LISTAGG 지원을 보여줍니다.
```
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)
```
요청 데이터에 대한 설명은 [창 함수 예제를 위한 샘플 테이블](c_Window_functions.md#r_Window_function_example) 섹션을 참조하세요.
다음 예에서는 제한적 프레임 내에서 판매 ID, 수량 및 최대 수량을 보여줍니다.
```
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*
중간을 결정할 값을 제공하는 표현식(열 이름 등)입니다. 이 표현식은 숫자 또는 날짜/시간 데이터 형식을 갖거나, 혹은 묵시적으로 1로 변환될 수 있어야 합니다.
OVER
창 파티션을 지정하는 절입니다. OVER 절에는 창 순서 또는 창 프레임 명세가 포함될 수 없습니다.
PARTITION BY *partition\$1expression*
선택 사항입니다. OVER 절에서 각 그룹의 레코드 범위를 설정하는 표현식입니다.
## 데이터 타입
반환 형식은 *median\$1expression*의 형식에 따라 결정됩니다. 다음 표는 각 *median\$1expression* 데이터 형식에 따른 반환 형식을 나타낸 것입니다.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/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
```
요청 데이터에 대한 설명은 [창 함수 예제를 위한 샘플 테이블](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)
```
요청 데이터에 대한 설명은 [창 함수 예제를 위한 샘플 테이블](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 ] )
```
## 인수
*\$1 expr*
함수가 실행되는 대상 열 또는 표현식입니다.
*offset*
창에서 표현식을 반환할 첫 번째 행에 대한 행 번호를 결정합니다. *offset*은 상수 또는 0보다 큰 양의 정수이어야 하는 표현식이 될 수 있습니다.
IGNORE NULLS
Amazon Redshift에서 사용할 행을 결정할 때 null 값을 건너뛰어야 한는 것을 의미하는 명세(옵션)입니다. IGNORE NULLS를 지정하지 않으면 NULL 값이 포함됩니다.
RESPECT NULLS
Amazon Redshift에서 사용할 행을 결정할 때 null 값을 포함시켜야 한다는 것을 의미합니다. RESPECT NULLS는 IGNORE 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* 형식과 동일합니다.
## 예제
다음은 California, Florida 및 New York 주에서 세 번째로 가장 큰 장소의 좌석 수를 동일한 주에서 나머지 장소의 좌석 수와 비교하는 예입니다.
```
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 ]
)
```
## 인수
*\$1 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 공연 티켓 가격을 4개 순위 그룹으로 구분하는 예입니다. 결과 집합에서는 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까지입니다(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*
선택 사항입니다. 백분율 순위를 계산하기 위한 표현식입니다. 이 표현식은 숫자 데이터 형식을 갖거나, 혹은 묵시적으로 1로 변환될 수 있어야 합니다. 즉 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
```
요청 데이터에 대한 설명은 [창 함수 예제를 위한 샘플 테이블](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)`.
PARTITION 절은 OVER 절에서만 지정할 수 있습니다. 각 행마다 PARTITION을 지정하면 PERCENTILE\$1CONT가 임의의 파티션에 속한 값 집합 중에서 지정한 백분위에 해당하는 값을 반환합니다.
## 구문
```
PERCENTILE_CONT ( percentile )
WITHIN GROUP (ORDER BY expr)
OVER ( [ PARTITION BY expr_list ] )
```
## 인수
*(백분위수*)
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/ko_kr/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 테이블을 사용합니다. 요청 데이터에 대한 설명은 [창 함수 예제를 위한 샘플 테이블](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)
```
다음은 Washington 주에 거주하는 판매자의 티켓 판매에 대한 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보다는 크거나 같은 누적 분포 값을 반환합니다.
PARTITION 절은 OVER 절에서만 지정할 수 있습니다.
## 구문
```
PERCENTILE_DISC ( percentile )
WITHIN GROUP (ORDER BY expr)
OVER ( [ PARTITION BY expr_list ] )
```
## 인수
*(백분위수*)
0과 1 사이의 숫자 상수입니다. 이 계산에서 Null 값은 무시됩니다.
WITHIN GROUP (ORDER BY *expr*)
숫자 또는 날짜/시간 값을 지정하여 백분위를 정렬 및 계산합니다.
OVER
창 파티션을 지정합니다. OVER 절에는 창 순서 또는 창 프레임 명세가 포함될 수 없습니다.
PARTITION BY *expr*
OVER 절에서 각 그룹의 레코드 범위를 설정하는 인수(옵션)입니다.
## 반환 형식
WITHIN GROUP 절의 ORDER BY 표현식과 동일한 데이터 형식
## 예제
아래 예에서는 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에서는 2개 이상의 행에서 순위가 동일하면 순위 값의 순서에서도 빈 자리가 없습니다. 예를 들어 두 행의 순위가 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 행보다 앞에 위치할 수 있습니다. 요청 데이터에 대한 설명은 [창 함수 예제를 위한 샘플 테이블](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)
```
요청 데이터에 대한 설명은 [창 함수 예제를 위한 샘플 테이블](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까지입니다(0과 1 포함). *ratio\$1expression*이 NULL이면 반환 값은 `NULL`입니다. *partition\$1expression*의 값이 고유한 경우 함수는 해당 값에 대해 `1`을 반환합니다.
## 구문
```
RATIO_TO_REPORT ( ratio_expression )
OVER ( [ PARTITION BY partition_expression ] )
```
## 인수
*ratio\$1expression*
비율을 결정할 값을 제공하는 표현식(열 이름 등)입니다. 이 표현식은 숫자 데이터 형식을 갖거나, 혹은 묵시적으로 1로 변환될 수 있어야 합니다.
그 외에 다른 분석 함수는 *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) 섹션을 참조하세요.
다음 예제에서는 테이블을 QTY(오름차순)로 정렬한 다음 각 행에 행 번호를 할당합니다. 결과는 창 함수 결과를 적용한 후에 정렬됩니다.
```
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를 기준으로 테이블을 분할하여 수량에 따라 각 파티션의 순서(오름차순)를 지정한 후 행 번호를 각 행에 할당하는 예입니다. 결과는 창 함수 결과를 적용한 후에 정렬됩니다.
```
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 함수에서 지원되는 반환 형식은 다음과 같습니다.
+ SMALLINT 또는 INTEGER 인수일 때 BIGINT
+ BIGINT 인수일 때 NUMERIC
+ 부동 소수점 인수일 때 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)
```
요청 데이터에 대한 설명은 [창 함수 예제를 위한 샘플 테이블](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)
```
요청 데이터에 대한 설명은 [창 함수 예제를 위한 샘플 테이블](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 함수의 반환 형식은 배정밀도 숫자입니다.