Amazon Redshift는 패치 198부터 새 Python UDF 생성을 더 이상 지원하지 않습니다. 기존 Python UDF는 2026년 6월 30일까지 계속 작동합니다. 자세한 내용은 [블로그 게시물](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/)을 참조하세요.
# 집계 함수
**Topics**
+ [ANY\$1VALUE 함수](r_ANY_VALUE.md)
+ [APPROXIMATE PERCENTILE\$1DISC 함수](r_APPROXIMATE_PERCENTILE_DISC.md)
+ [AVG 함수](r_AVG.md)
+ [COUNT 함수](r_COUNT.md)
+ [LISTAGG 함수](r_LISTAGG.md)
+ [MAX 함수](r_MAX.md)
+ [MEDIAN 함수](r_MEDIAN.md)
+ [MIN 함수](r_MIN.md)
+ [PERCENTILE\$1CONT 함수](r_PERCENTILE_CONT.md)
+ [STDDEV\$1SAMP 및 STDDEV\$1POP 함수](r_STDDEV_functions.md)
+ [SUM 함수](r_SUM.md)
+ [VAR\$1SAMP 및 VAR\$1POP 함수](r_VARIANCE_functions.md)
집계 함수는 입력 값 집합에서 단일 결과 값을 계산합니다.
집계 함수를 사용하는 SELECT 문에는 옵션이지만 GROUP BY와 HAVING, 2가지 절이 포함될 수 있습니다. 이 2가지 절의 구문은 다음과 같습니다(예에서는 COUNT 함수 사용).
```
SELECT count (*) expression FROM table_reference
WHERE condition [GROUP BY expression ] [ HAVING condition]
```
GROUP BY 절은 집계 후 특정 열의 고유 값을 기준으로 결과를 그룹화합니다. HAVING 절은 반환되는 결과를 수량(\$1) > 1처럼 특정 집계 조건이 true인 행으로 제한합니다. 또한 WHERE와 동일한 방식으로 사용되어 열의 값에 따라 행을 제한합니다. 이러한 추가 절의 예는 [COUNT](r_COUNT.md) 섹션을 참조하세요.
집계 함수는 중첩 집계 함수나 창 함수를 인수로 사용하지 않습니다.
# ANY\$1VALUE 함수
ANY\$1VALUE 함수는 입력 표현식 값에서 비결정적으로 값을 반환합니다. 이 함수는 입력 식으로 반환되는 행이 없는 경우 `NULL`을 반환합니다. 입력 식에 `NULL` 값이 있는 경우 함수가 `NULL`을 반환할 수도 있습니다. 입력에 `NULL` 값과 `NULL`이 아닌 값이 혼합된 경우 `NULL`이 반환될 수 있습니다. 모든 값이 `NULL`이면 `NULL`이 반환됩니다. 조건과 일치하는 행이 없으면 `NULL`이 반환됩니다.
## 구문
```
ANY_VALUE( [ DISTINCT | ALL ] expression )
```
## 인수
DISTINCT \$1 ALL
입력 표현식 값에서 값을 반환하려면 DISTINCT 또는 ALL을 지정합니다. DISTINCT 인수는 효과가 없으며 무시됩니다.
* expression*
함수가 실행되는 대상 열 또는 표현식입니다. *표현식*은 다음 데이터 유형 중 하나입니다.
+ SMALLINT
+ INTEGER
+ BIGINT
+ DECIMAL
+ REAL
+ DOUBLE PRECISON
+ BOOLEAN
+ CHAR
+ VARCHAR
+ DATE
+ TIMESTAMP
+ TIMESTAMPTZ
+ TIME
+ TIMETZ
+ INTERVAL YEAR TO MONTH
+ INTERVAL DAY TO SECOND
+ VARBYTE
+ SUPER
+ HLLSKETCH
+ GEOMETRY
+ GEOGRAPHY
## 반환 형식
*expression*과 동일한 데이터 형식을 반환합니다.
## 사용 노트
열에 대한 ANY\$1VALUE 함수를 지정하는 문이 두 번째 열 참조도 포함하는 경우 두 번째 열은 GROUP BY 절에 나타나거나 집계 함수에 포함되어야 합니다.
## 예제
이 예에서는 [Amazon Redshift 시작 안내서](https://docs.aws.amazon.com/redshift/latest/gsg/rs-gsg-create-sample-db.html)의 *4단계: Amazon S3에서 샘플 데이터 로드*에서 생성된 이벤트 테이블을 사용합니다. 다음 예는 eventname이 Eagles인 모든 dateid의 인스턴스를 반환합니다.
```
select any_value(dateid) as dateid, eventname from event where eventname ='Eagles' group by eventname;
```
다음은 결과입니다.
```
dateid | eventname
-------+---------------
1878 | Eagles
```
다음 예는 eventname이 Eagles 또는 Cold War Kids인 모든 dateid의 인스턴스를 반환합니다.
```
select any_value(dateid) as dateid, eventname from event where eventname in('Eagles', 'Cold War Kids') group by eventname;
```
다음은 결과입니다.
```
dateid | eventname
-------+---------------
1922 | Cold War Kids
1878 | Eagles
```
# APPROXIMATE PERCENTILE\$1DISC 함수
APPROXIMATE PERCENTILE\$1DISC는 이산 분포 모델을 가정하는 역분포 함수로서 백분위 값과 정렬 명세를 가지며, 지정된 집합에서 요소를 반환합니다. 이 함수는 근사치를 사용하기 때문에 실행 속도가 더욱 빠르며 상대 오차도 약 0.5%로 낮습니다.
APPROXIMATE PERCENTILE\$1DISC는 임의의 *percentile* 값에 대해 사분위 요약 알고리즘을 사용하여 ORDER BY 절에서 표현식의 이산 백분위에 대한 근사치를 구합니다. 또한 동일한 정렬 명세와 관련하여 가장 작지만 *percentile*보다는 크거나 같은 누적 분포 값을 반환합니다.
## 구문
```
APPROXIMATE PERCENTILE_DISC ( percentile )
WITHIN GROUP (ORDER BY expr)
```
## 인수
*(백분위수*)
0과 1 사이의 숫자 상수입니다. 이 계산에서 Null 값은 무시됩니다.
WITHIN GROUP (ORDER BY *expr*)
숫자 또는 날짜/시간 값을 지정하여 백분위를 정렬 및 계산하는 절입니다.
## 반환 형식
WITHIN GROUP 절의 ORDER BY 표현식과 동일한 데이터 형식
## 사용 노트
APPROXIMATE PERCENTILE\$1DISC 문에 GROUP BY 절이 포함된 경우에는 결과 집합이 제한적입니다. 이러한 제한은 노드 유형과 노드 수에 따라 달라집니다. 제한을 초과하면 함수가 중단되고 다음과 같은 오류를 반환합니다.
```
GROUP BY limit for approximate percentile_disc exceeded.
```
제한을 초과하여 더 많은 그룹을 평가해야 하는 경우에는 [PERCENTILE\$1CONT 함수](r_PERCENTILE_CONT.md)를 사용하는 것이 좋습니다.
## 예제
다음은 상위 10개 날짜일 때 판매 수량과 총 판매액, 그리고 50번째 백분위 값을 반환하는 예입니다.
```
select top 10 date.caldate,
count(totalprice), sum(totalprice),
approximate percentile_disc(0.5)
within group (order by totalprice)
from listing
join date on listing.dateid = date.dateid
group by date.caldate
order by 3 desc;
caldate | count | sum | percentile_disc
-----------+-------+------------+----------------
2008-01-07 | 658 | 2081400.00 | 2020.00
2008-01-02 | 614 | 2064840.00 | 2178.00
2008-07-22 | 593 | 1994256.00 | 2214.00
2008-01-26 | 595 | 1993188.00 | 2272.00
2008-02-24 | 655 | 1975345.00 | 2070.00
2008-02-04 | 616 | 1972491.00 | 1995.00
2008-02-14 | 628 | 1971759.00 | 2184.00
2008-09-01 | 600 | 1944976.00 | 2100.00
2008-07-29 | 597 | 1944488.00 | 2106.00
2008-07-23 | 592 | 1943265.00 | 1974.00
```
# AVG 함수
AVG 함수는 입력 표현식 값의 평균(산술 평균)을 반환합니다. AVG 함수는 숫자 값을 사용하고 NULL 값을 무시합니다.
## 구문
```
AVG ( [ DISTINCT | ALL ] expression )
```
## 인수
* expression*
함수가 실행되는 대상 열 또는 표현식입니다. *표현식*은 다음 데이터 유형 중 하나입니다.
+ SMALLINT
+ INTEGER
+ BIGINT
+ NUMERIC
+ DECIMAL
+ REAL
+ DOUBLE PRECISON
+ SUPER
DISTINCT \$1 ALL
인수가 DISTINCT일 때는 함수가 평균을 계산하기 전에 지정한 표현식에서 중복 값을 모두 제거합니다. 인수가 ALL일 때는 함수가 표현식의 모든 중복 값을 그대로 유지한 채 평균을 계산합니다. ALL이 기본값입니다.
## 데이터 타입
AVG 함수에서 지원되는 인수 형식은 SMALLINT, INTEGER, BIGINT, NUMERIC, DECIMAL, REAL, DOUBLE PRECISION, SUPER입니다.
AVG 함수에서 지원되는 반환 형식은 다음과 같습니다.
+ 모든 정수형 인수일 때 BIGINT
+ 부동 소수점 인수일 때 DOUBLE PRECISION
+ 다른 인수 형식의 표현과 동일한 데이터 형식을 반환합니다.
NUMERIC 또는 DECIMAL 인수가 포함된 AVG 함수 결과의 기본 정밀도는 38입니다. 함수 결과의 비율은 인수 비율과 동일합니다. 예를 들어 DEC(5,2) 열의 AVG는 DEC(38,2) 데이터 형식을 반환합니다.
## 예제
SALES 테이블에서 트랜잭션 1회당 판매된 평균 수량을 구합니다.
```
select avg(qtysold)from sales;
avg
-----
2
(1 row)
```
모든 목록에 나열된 평균 총 가격을 구합니다.
```
select avg(numtickets*priceperticket) as avg_total_price from listing;
avg_total_price
-----------------
3034.41
(1 row)
```
매월 내림차순으로 분류된 평균 지불 가격을 구합니다.
```
select avg(pricepaid) as avg_price, month
from sales, date
where sales.dateid = date.dateid
group by month
order by avg_price desc;
avg_price | month
-----------+-------
659.34 | MAR
655.06 | APR
645.82 | JAN
643.10 | MAY
642.72 | JUN
642.37 | SEP
640.72 | OCT
640.57 | DEC
635.34 | JUL
635.24 | FEB
634.24 | NOV
632.78 | AUG
(12 rows)
```
# COUNT 함수
COUNT 함수는 표현식에서 정의하는 행의 수를 계산합니다.
COUNT 함수는 다음과 같은 변형이 있습니다.
+ COUNT ( \$1 )는 NULL 값의 유무에 상관없이 대상 테이블에서 모든 행의 수를 계산합니다.
+ COUNT ( *expression* )는 특정 열 또는 표현식에서 NULL을 제외한 값이 포함된 행의 수를 계산합니다.
+ COUNT ( DISTINCT *expression* )는 임의의 열 또는 표현식에서 NULL을 제외한 고유 값의 수를 계산합니다.
+ APPROXIMATE COUNT DISTINCT는 임의의 열 또는 표현식에서 NULL을 제외한 고유 값의 수를 대략적으로 구합니다.
## 구문
```
COUNT( * | expression )
```
```
COUNT ( [ DISTINCT | ALL ] expression )
```
```
APPROXIMATE COUNT ( DISTINCT expression )
```
## 인수
* expression*
함수가 실행되는 대상 열 또는 표현식입니다. COUNT 함수는 모든 인수 데이터 형식을 지원합니다.
DISTINCT \$1 ALL
인수가 DISTINCT일 때는 행의 수를 계산하기 전에 지정한 표현식에서 중복 값을 모두 제거합니다. 인수가 ALL일 때는 함수가 표현식의 모든 중복 값을 그대로 유지한 채 행의 수를 계산합니다. ALL이 기본값입니다.
APPROXIMATE
APPROXIMATE와 함께 사용할 때는 COUNT DISTINCT 함수가 HyperLogLog 알고리즘을 사용하여 임의의 열 또는 표현식에서 NULL을 제외한 고유 값의 수를 대략적으로 구합니다. 쿼리에 APPROXIMATE 키워드를 사용하면 실행 속도가 빨라질 뿐만 아니라 상대 오차도 약 2%로 낮습니다. 쿼리마다, 혹은 GROUP BY 절이 있는 경우 그룹마다 수백만 개가 넘는 고유 값을 반환하는 쿼리일 때는 근사치가 타당한 것으로 간주됩니다. 하지만 고유 값이 수천 개로 적을 경우에는 근사치일 때 속도가 정확한 행의 수일 때 보다 느려질 수 있습니다. APPROXIMATE는 COUNT DISTINCT와만 사용할 수 있습니다.
## 반환 타입
COUNT 함수는 BIGINT를 반환합니다.
## 예제
Florida 주의 모든 사용자 수를 계산합니다.
```
select count(*) from users where state='FL';
count
-------
510
```
EVENT 테이블에서 모든 이벤트 이름의 수를 계산합니다.
```
select count(eventname) from event;
count
-------
8798
```
EVENT 테이블에서 모든 이벤트 이름의 수를 계산합니다.
```
select count(all eventname) from event;
count
-------
8798
```
EVENT 테이블에서 고유한 장소 ID의 수를 모두 계산합니다.
```
select count(distinct venueid) as venues from event;
venues
--------
204
```
개별 판매자가 4장 이상의 티켓을 한 묶음으로 판매한 횟수를 계산합니다. 결과는 판매자 ID로 구분합니다.
```
select count(*), sellerid from listing
where numtickets > 4
group by sellerid
order by 1 desc, 2;
count | sellerid
------+----------
12 | 6386
11 | 17304
11 | 20123
11 | 25428
...
```
다음은 COUNT와 APPROXIMATE COUNT의 반환 값 및 실행 시간을 서로 비교한 예입니다.
```
select count(distinct pricepaid) from sales;
count
-------
4528
Time: 48.048 ms
select approximate count(distinct pricepaid) from sales;
count
-------
4553
Time: 21.728 ms
```
# LISTAGG 함수
LISTAGG 집계 함수는 ORDER BY 표현식에 따라 쿼리 내 각 그룹의 행 순서를 지정한 다음, 값을 연결하여 문자열 하나를 만듭니다.
## 구문
```
LISTAGG( [DISTINCT] aggregate_expression [, 'delimiter' ] )
[ WITHIN GROUP (ORDER BY order_list) ]
```
## 인수
DISTINCT
연결하기 전에 지정된 표현식에서 중복 값을 없애는 절입니다. 후행 공백은 무시됩니다. 예를 들어, 문자열 `'a'` 및 `'a '`는 중복으로 처리됩니다. LISTAGG는 발생한 첫 번째 값을 사용합니다. 자세한 내용은 [후행 공백의 중요성](r_Character_types.md#r_Character_types-significance-of-trailing-blanks) 섹션을 참조하세요.
*aggregate\$1expression*
집계할 값을 제공하는 모든 유효 표현식(열 이름 등)입니다. NULL 값과 빈 문자열은 무시됩니다.
*delimiter*
연결된 값을 구분하는 문자열 상수입니다. 기본값은 NULL입니다.
*WITHIN GROUP (ORDER BY order\$1list)*
집계된 값의 정렬 순서를 지정하는 절입니다.
## 반환 형식
VARCHAR(최대). 결과 집합이 최대 VARCHAR 크기보다 클 경우에는 LISTAGG가 다음과 같은 오류를 반환합니다.
```
Invalid operation: Result size exceeds LISTAGG limit
```
## 사용 노트
+ 문에 WITHIN GROUP 절을 사용하는 LISTAGG 함수가 다수 포함된 경우에는 WITHIN GROUP 절마다 동일한 ORDER BY 값을 사용해야 합니다.
예를 들어 다음과 같은 문은 오류를 반환합니다.
```
SELECT LISTAGG(sellerid)
WITHIN GROUP (ORDER BY dateid) AS sellers,
LISTAGG(dateid)
WITHIN GROUP (ORDER BY sellerid) AS dates
FROM sales;
```
다음 문은 성공적으로 실행됩니다.
```
SELECT LISTAGG(sellerid)
WITHIN GROUP (ORDER BY dateid) AS sellers,
LISTAGG(dateid)
WITHIN GROUP (ORDER BY dateid) AS dates
FROM sales;
SELECT LISTAGG(sellerid)
WITHIN GROUP (ORDER BY dateid) AS sellers,
LISTAGG(dateid) AS dates
FROM sales;
```
+ LISTAGG, PERCENTILE\$1CONT 및 MEDIAN 집계 함수는 다른 고유한 집계 함수와 함께 사용할 수 없습니다.
## 예제
다음은 판매자 ID에 따라 순서를 지정하여 판매자 ID를 집계하는 예입니다.
```
SELECT LISTAGG(sellerid, ', ')
WITHIN GROUP (ORDER BY sellerid)
FROM sales
WHERE eventid = 4337;
listagg
----------------------------------------------------------------------------------------------------------------------------------------
380, 380, 1178, 1178, 1178, 2731, 8117, 12905, 32043, 32043, 32043, 32432, 32432, 38669, 38750, 41498, 45676, 46324, 47188, 47188, 48294
```
다음 예에서는 DISTINCT를 사용하여 고유한 판매자 ID 목록을 반환합니다.
```
SELECT LISTAGG(DISTINCT sellerid, ', ')
WITHIN GROUP (ORDER BY sellerid)
FROM sales
WHERE eventid = 4337;
listagg
-------------------------------------------------------------------------------------------
380, 1178, 2731, 8117, 12905, 32043, 32432, 38669, 38750, 41498, 45676, 46324, 47188, 48294
```
다음은 날짜 순으로 판매자 ID를 집계하는 예입니다.
```
SELECT LISTAGG(sellerid, ', ')
WITHIN GROUP (ORDER BY dateid)
FROM sales
WHERE eventid = 4337;
listagg
-----------------------------------------------------------------------------------------------------------------------------------------
41498, 47188, 47188, 1178, 1178, 1178, 380, 45676, 46324, 48294, 32043, 32043, 32432, 12905, 8117, 38750, 2731, 32432, 32043, 380, 38669
```
다음은 ID가 660인 구매자의 판매 날짜 목록을 파이프로 구분하여 반환하는 예입니다.
```
SELECT LISTAGG(
(SELECT caldate FROM date WHERE date.dateid=sales.dateid), ' | '
)
WITHIN GROUP (ORDER BY sellerid DESC, salesid ASC)
FROM sales
WHERE buyerid = 660;
listagg
-------------------------------------------------
2008-07-16 | 2008-07-09 | 2008-01-01 | 2008-10-26
```
다음은 각 구매자 ID 660, 661, 662의 판매 ID 목록을 쉼표로 구분하여 반환하는 예입니다.
```
SELECT buyerid,
LISTAGG(salesid,', ')
WITHIN GROUP (ORDER BY salesid) AS sales_id
FROM sales
WHERE buyerid BETWEEN 660 AND 662
GROUP BY buyerid
ORDER BY buyerid;
buyerid | sales_id
--------+-----------------------------------------------------
660 | 32872, 33095, 33514, 34548
661 | 19951, 20517, 21695, 21931
662 | 3318, 3823, 4215, 51980, 53202, 55908, 57832, 171603
```
# MAX 함수
MAX 함수는 행 집합에서 최댓값을 반환합니다. DISTINCT 또는 ALL은 사용할 수 있지만 결과에 아무런 영향도 끼치지 않습니다.
## 구문
```
MAX ( [ DISTINCT | ALL ] expression )
```
## 인수
* expression*
함수가 실행되는 대상 열 또는 표현식입니다. *표현식*은 다음 데이터 유형 중 하나입니다.
+ SMALLINT
+ INTEGER
+ BIGINT
+ DECIMAL
+ REAL
+ DOUBLE PRECISON
+ CHAR
+ VARCHAR
+ DATE
+ TIMESTAMP
+ TIMESTAMPTZ
+ TIME
+ TIMETZ
+ VARBYTE
+ SUPER
DISTINCT \$1 ALL
인수가 DISTINCT일 때는 함수가 최댓값을 계산하기 전에 지정한 표현식에서 중복 값을 모두 제거합니다. 인수가 ALL일 때는 함수가 표현식의 모든 중복 값을 그대로 유지한 채 최댓값을 계산합니다. ALL이 기본값입니다.
## 데이터 타입
*expression*과 동일한 데이터 형식을 반환합니다. MIN 함수일 때 부울 등가는 [BOOL\$1AND 함수](r_BOOL_AND.md)이고, MAX 함수일 때 부울 등가는 [BOOL\$1OR 함수](r_BOOL_OR.md)입니다.
## 예제
모든 판매에서 지불된 최고 가격을 구합니다.
```
select max(pricepaid) from sales;
max
----------
12624.00
(1 row)
```
모든 판매에서 티켓 1장당 지불된 최고 가격을 구합니다.
```
select max(pricepaid/qtysold) as max_ticket_price
from sales;
max_ticket_price
-----------------
2500.00000000
(1 row)
```
# MEDIAN 함수
값 범위의 중앙값을 계산합니다. 범위의 `NULL` 값은 무시됩니다.
MEDIAN은 연속 분포 모델을 가정하는 역분포 함수입니다.
MEDIAN은 [PERCENTILE\$1CONT](r_PERCENTILE_CONT.md)의 특별 사례입니다.
## 구문
```
MEDIAN(median_expression)
```
## 인수
*median\$1expression*
함수가 실행되는 대상 열 또는 표현식입니다.
## 데이터 타입
반환 형식은 *median\$1expression*의 형식에 따라 결정됩니다. 다음 표는 각 *median\$1expression* 데이터 형식에 따른 반환 형식을 나타낸 것입니다.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/redshift/latest/dg/r_MEDIAN.html)
## 사용 노트
**median\$1expression 인수가 최대 정밀도가 38자리로 정의된 `DECIMAL` 데이터 형식인 경우에는 MEDIAN이 부정확한 결과 또는 오류를 반환합니다. MEDIAN 함수의 반환 값이 38자리를 초과하면 정밀도가 손실될 수도 있기 때문에 알맞은 자리 수로 결과가 잘립니다. 보간 도중 중간 결과가 최대 정밀도를 초과하면 수치 오버플로우가 발생하고 함수는 오류를 반환합니다. 이러한 상황을 방지하려면 정밀도가 낮은 데이터 형식을 사용하거나, 혹은 *median\$1expression* 인수를 낮은 정밀도로 변환합니다.
하나의 문에서 정렬 기반 집계 함수(LISTAGG, PERCENTILE\$1CONT, MEDIAN)를 여러 차례 호출하는 경우에는 모두 동일한 ORDER BY 값을 사용해야 합니다. 단, MEDIAN은 표현식 값에서 묵시적인 ORDER BY를 적용합니다.
예를 들어 다음과 같은 문은 오류를 반환합니다.
```
SELECT TOP 10 salesid, SUM(pricepaid),
PERCENTILE_CONT(0.6) WITHIN GROUP(ORDER BY salesid),
MEDIAN(pricepaid)
FROM sales
GROUP BY salesid, pricepaid;
An error occurred when executing the SQL command:
SELECT TOP 10 salesid, SUM(pricepaid),
PERCENTILE_CONT(0.6) WITHIN GROUP(ORDER BY salesid),
MEDIAN(pricepaid)
FROM sales
GROUP BY salesid, pricepaid;
ERROR: within group ORDER BY clauses for aggregate functions must be the same
```
다음 문은 성공적으로 실행됩니다.
```
SELECT TOP 10 salesid, SUM(pricepaid),
PERCENTILE_CONT(0.6) WITHIN GROUP(ORDER BY salesid),
MEDIAN(salesid)
FROM sales
GROUP BY salesid, pricepaid;
```
## 예제
다음 예제에서는 TICKIT 샘플 데이터베이스를 사용합니다. 자세한 내용은 [샘플 데이터베이스](c_sampledb.md) 섹션을 참조하세요.
다음은 MEDIAN이 PERCENTILE\$1CONT(0.5)와 동일한 결과를 산출하는 예입니다.
```
SELECT TOP 10 DISTINCT sellerid, qtysold,
PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY qtysold),
MEDIAN(qtysold)
FROM sales
GROUP BY sellerid, qtysold;
+----------+---------+-----------------+--------+
| sellerid | qtysold | percentile_cont | median |
+----------+---------+-----------------+--------+
| 2 | 2 | 2 | 2 |
| 26 | 1 | 1 | 1 |
| 33 | 1 | 1 | 1 |
| 38 | 1 | 1 | 1 |
| 43 | 1 | 1 | 1 |
| 48 | 2 | 2 | 2 |
| 48 | 3 | 3 | 3 |
| 77 | 4 | 4 | 4 |
| 85 | 4 | 4 | 4 |
| 95 | 2 | 2 | 2 |
+----------+---------+-----------------+--------+
```
다음 예제에서는 각 sellerid의 판매 수량 중간값을 찾습니다.
```
SELECT sellerid,
MEDIAN(qtysold)
FROM sales
GROUP BY sellerid
ORDER BY sellerid
LIMIT 10;
+----------+--------+
| sellerid | median |
+----------+--------+
| 1 | 1.5 |
| 2 | 2 |
| 3 | 2 |
| 4 | 2 |
| 5 | 1 |
| 6 | 1 |
| 7 | 1.5 |
| 8 | 1 |
| 9 | 4 |
| 12 | 2 |
+----------+--------+
```
첫 번째 sellerid에 대한 이전 쿼리 결과를 확인하려면 다음 예제를 사용합니다.
```
SELECT qtysold
FROM sales
WHERE sellerid=1;
+---------+
| qtysold |
+---------+
| 2 |
| 1 |
+---------+
```
# MIN 함수
MIN 함수는 행 집합에서 최솟값을 반환합니다. DISTINCT 또는 ALL은 사용할 수 있지만 결과에 아무런 영향도 끼치지 않습니다.
## 구문
```
MIN ( [ DISTINCT | ALL ] expression )
```
## 인수
* expression*
함수가 실행되는 대상 열 또는 표현식입니다. *표현식*은 다음 데이터 유형 중 하나입니다.
+ SMALLINT
+ INTEGER
+ BIGINT
+ DECIMAL
+ REAL
+ DOUBLE PRECISON
+ CHAR
+ VARCHAR
+ DATE
+ TIMESTAMP
+ TIMESTAMPTZ
+ TIME
+ TIMETZ
+ VARBYTE
+ SUPER
DISTINCT \$1 ALL
인수가 DISTINCT일 때는 함수가 최솟값을 계산하기 전에 지정한 표현식에서 중복 값을 모두 제거합니다. 인수가 ALL일 때는 함수가 표현식의 모든 중복 값을 그대로 유지한 채 최솟값을 계산합니다. ALL이 기본값입니다.
## 데이터 타입
*expression*과 동일한 데이터 형식을 반환합니다. MIN 함수일 때 부울 등가는 [BOOL\$1AND 함수](r_BOOL_AND.md)이고, MAX 함수일 때 부울 등가는 [BOOL\$1OR 함수](r_BOOL_OR.md)입니다.
## 예제
모든 판매에서 지불된 최저 가격을 구합니다.
```
select min(pricepaid) from sales;
min
-------
20.00
(1 row)
```
모든 판매에서 티켓 1장당 지불된 최저 가격을 구합니다.
```
select min(pricepaid/qtysold)as min_ticket_price
from sales;
min_ticket_price
------------------
20.00000000
(1 row)
```
# PERCENTILE\$1CONT 함수
PERCENTILE\$1CONT는 연속 분포 모델을 가정하는 역분포 함수입니다. 백분위 값과 정렬 명세를 가지며, 정렬 명세와 관련하여 지정된 백분위 값에 해당하는 보간 값을 반환합니다.
PERCENTILE\$1CONT는 순서가 지정된 값 사이의 선형 보간을 계산합니다. 이 함수는 집계 그룹에서 백분위 값`(P)`과 NULL을 제외한 행들의 번호`(N)`를 사용하여 정렬 명세에 따라 행의 순서를 지정한 후 행 번호를 계산합니다. 행 번호`(RN)`를 계산하는 공식은 `RN = (1+ (P*(N-1))`입니다. 이 집계 함수의 최종 결과는 행 번호가 `CRN = CEILING(RN)`과 `FRN = FLOOR(RN)`인 행의 값 사이 선형 보간을 통해 계산됩니다.
최종 결과는 다음과 같습니다.
`(CRN = FRN = RN)`일 때 결과는 `(value of expression from row at RN)`입니다.
그렇지 않다면 다음 결과가 표시됩니다.
`(CRN - RN) * (value of expression for row at FRN) + (RN - FRN) * (value of expression for row at CRN)`.
## 구문
```
PERCENTILE_CONT(percentile)
WITHIN GROUP(ORDER BY expr)
```
## 인수
*(백분위수*)
0에서 1 사이의 숫자 상수입니다. 계산에서 `NULL` 값은 무시됩니다.
*\$1 expr*
숫자 또는 날짜/시간 값을 지정하여 백분위를 정렬 및 계산합니다.
## 반환 형식
반환 형식은 WITHIN GROUP 절에서 ORDER BY 표현식의 데이터 형식에 따라 결정됩니다. 다음 표는 ORDER BY 표현식의 데이터 형식에 따른 반환 형식을 나타낸 것입니다.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/redshift/latest/dg/r_PERCENTILE_CONT.html)
## 사용 노트
ORDER BY 표현식이 최대 정밀도가 38자리로 정의된 DECIMAL 데이터 형식인 경우에는 PERCENTILE\$1CONT가 부정확한 결과 또는 오류를 반환합니다. PERCENTILE\$1CONT 함수의 반환 값이 38자리를 초과하면 정밀도가 손실될 수도 있기 때문에 알맞은 자리 수로 결과가 잘립니다. 보간 도중 중간 결과가 최대 정밀도를 초과하면 수치 오버플로우가 발생하고 함수는 오류를 반환합니다. 이러한 상황을 방지하려면 정밀도가 낮은 데이터 형식을 사용하거나, 혹은 ORDER BY 표현식을 낮은 정밀도로 변환합니다.
하나의 문에서 정렬 기반 집계 함수(LISTAGG, PERCENTILE\$1CONT, MEDIAN)를 여러 차례 호출하는 경우에는 모두 동일한 ORDER BY 값을 사용해야 합니다. 단, MEDIAN은 표현식 값에서 묵시적인 ORDER BY를 적용합니다.
예를 들어 다음과 같은 문은 오류를 반환합니다.
```
SELECT TOP 10 salesid, SUM(pricepaid),
PERCENTILE_CONT(0.6) WITHIN GROUP(ORDER BY salesid),
MEDIAN(pricepaid)
FROM sales
GROUP BY salesid, pricepaid;
An error occurred when executing the SQL command:
SELECT TOP 10 salesid, SUM(pricepaid),
PERCENTILE_CONT(0.6) WITHIN GROUP(ORDER BY salesid),
MEDIAN(pricepaid)
FROM sales
GROUP BY salesid, pricepaid;
ERROR: within group ORDER BY clauses for aggregate functions must be the same
```
다음 문은 성공적으로 실행됩니다.
```
SELECT TOP 10 salesid, SUM(pricepaid),
PERCENTILE_CONT(0.6) WITHIN GROUP(ORDER BY salesid),
MEDIAN(salesid)
FROM sales
GROUP BY salesid, pricepaid;
```
## 예제
다음 예제에서는 TICKIT 샘플 데이터베이스를 사용합니다. 자세한 내용은 [샘플 데이터베이스](c_sampledb.md) 섹션을 참조하세요.
다음은 PERCENTILE\$1CONT(0.5)이 MEDIAN과 동일한 결과를 산출하는 예입니다.
```
SELECT TOP 10 DISTINCT sellerid, qtysold,
PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY qtysold),
MEDIAN(qtysold)
FROM sales
GROUP BY sellerid, qtysold;
+----------+---------+-----------------+--------+
| sellerid | qtysold | percentile_cont | median |
+----------+---------+-----------------+--------+
| 2 | 2 | 2 | 2 |
| 26 | 1 | 1 | 1 |
| 33 | 1 | 1 | 1 |
| 38 | 1 | 1 | 1 |
| 43 | 1 | 1 | 1 |
| 48 | 2 | 2 | 2 |
| 48 | 3 | 3 | 3 |
| 77 | 4 | 4 | 4 |
| 85 | 4 | 4 | 4 |
| 95 | 2 | 2 | 2 |
+----------+---------+-----------------+--------+
```
다음 예제에서는 SALES 테이블의 각 sellerid별로 판매된 수량에 대한 PERCENTILE\$1CONT(0.5) 및 PERCENTILE\$1CONT(0.75)를 찾습니다.
```
SELECT sellerid,
PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY qtysold) as pct_50,
PERCENTILE_CONT(0.75) WITHIN GROUP(ORDER BY qtysold) as pct_75
FROM sales
GROUP BY sellerid
ORDER BY sellerid
LIMIT 10;
+----------+--------+---------+
| sellerid | pct_50 | pct_75 |
+----------+--------+---------+
| 1 | 1.5 | 1.75 |
| 2 | 2 | 2.25 |
| 3 | 2 | 3 |
| 4 | 2 | 2 |
| 5 | 1 | 1.5 |
| 6 | 1 | 1 |
| 7 | 1.5 | 1.75 |
| 8 | 1 | 1 |
| 9 | 4 | 4 |
| 12 | 2 | 3.25 |
+----------+--------+---------+
```
첫 번째 sellerid에 대한 이전 쿼리 결과를 확인하려면 다음 예제를 사용합니다.
```
SELECT qtysold
FROM sales
WHERE sellerid=1;
+---------+
| qtysold |
+---------+
| 2 |
| 1 |
+---------+
```
# STDDEV\$1SAMP 및 STDDEV\$1POP 함수
STDDEV\$1SAMP 및 STDDEV\$1POP 함수는 숫자 값(정수, 소수 또는 부동 소수점) 집합의 표본 표준 편차와 모 표준 편차를 반환합니다. STDDEV\$1SAMP 함수의 결과는 동일한 값 집합의 표본 분산 제곱근과 동일합니다.
STDDEV\$1SAMP와 STDDEV는 동일한 함수이기 때문에 동의어나 마찬가지입니다.
## 구문
```
STDDEV_SAMP | STDDEV ( [ DISTINCT | ALL ] expression)
STDDEV_POP ( [ DISTINCT | ALL ] expression)
```
표현식의 데이터 형식은 정수, 소수 또는 부동 소수점이 되어야 합니다. 표현식의 데이터 형식과 상관없이 이 함수의 반환 형식은 배정밀도 숫자입니다.
**참고**
표준 편차는 부동 소수점 연산을 통해 계산하지만 약간 부정확할 수 있습니다.
## 사용 노트
단일 값으로 구성된 표현식에 대해 표본 표준 편차(STDDEV 또는 STDDEV\$1SAMP)를 계산할 경우 함수 결과는 0이 아닌 NULL이 됩니다.
## 예제
다음 쿼리는 VENUE 테이블에서 VENUESEATS 열의 값 평균과 그 뒤를 이어 동일한 값 집합의 표본 표준 편차 및 모 표준 편차를 반환합니다. VENUESEATS는 INTEGER 열입니다. 결과의 크기는 2자리로 줄어듭니다.
```
select avg(venueseats),
cast(stddev_samp(venueseats) as dec(14,2)) stddevsamp,
cast(stddev_pop(venueseats) as dec(14,2)) stddevpop
from venue;
avg | stddevsamp | stddevpop
-------+------------+-----------
17503 | 27847.76 | 27773.20
(1 row)
```
다음 쿼리는 SALES 테이블에서 COMMISSION 열의 표본 표준 편차를 반환합니다. COMMISSION은 DECIMAL 열입니다. 결과의 크기는 10자리로 줄어듭니다.
```
select cast(stddev(commission) as dec(18,10))
from sales;
stddev
----------------
130.3912659086
(1 row)
```
다음 쿼리는 COMMISSION 열의 표본 표준 편차를 정수로 변환합니다.
```
select cast(stddev(commission) as integer)
from sales;
stddev
--------
130
(1 row)
```
다음 쿼리는 COMMISSION 열의 표본 표준 편차와 표본 분산 제곱근을 모두 반환합니다. 이 두 가지의 계산 결과는 동일합니다.
```
select
cast(stddev_samp(commission) as dec(18,10)) stddevsamp,
cast(sqrt(var_samp(commission)) as dec(18,10)) sqrtvarsamp
from sales;
stddevsamp | sqrtvarsamp
----------------+----------------
130.3912659086 | 130.3912659086
(1 row)
```
# SUM 함수
SUM 함수는 입력 열 또는 표현식 값의 합을 반환합니다. SUM 함수는 숫자 값을 사용하고 NULL 값을 무시합니다.
## 구문
```
SUM ( [ DISTINCT | ALL ] expression )
```
## 인수
* expression*
함수가 실행되는 대상 열 또는 표현식입니다. *표현식*은 다음 데이터 유형 중 하나입니다.
+ SMALLINT
+ INTEGER
+ BIGINT
+ NUMERIC
+ DECIMAL
+ REAL
+ DOUBLE PRECISON
+ SUPER
DISTINCT \$1 ALL
인수가 DISTINCT일 때는 함수가 합을 계산하기 전에 지정한 표현식에서 중복 값을 모두 제거합니다. 인수가 ALL일 때는 함수가 표현식의 모든 중복 값을 그대로 유지한 채 합을 계산합니다. ALL이 기본값입니다.
## 데이터 타입
SUM 함수에서 지원되는 인수 형식은 SMALLINT, INTEGER, BIGINT, NUMERIC, DECIMAL, REAL, DOUBLE PRECISION, SUPER입니다.
SUM 함수에서 지원되는 반환 형식은 다음과 같습니다.
+ BIGINT, SMALLINT 및 INTEGER 인수일 때 BIGINT
+ NUMERIC 인수일 때 NUMERIC
+ 부동 소수점 인수일 때 DOUBLE PRECISION
+ 다른 인수 형식의 표현과 동일한 데이터 형식을 반환합니다.
NUMERIC 또는 DECIMAL 인수가 포함된 SUM 함수 결과의 기본 정밀도는 38입니다. 함수 결과의 비율은 인수 비율과 동일합니다. 예를 들어 DEC(5,2) 열의 SUM은 DEC(38,2) 데이터 형식을 반환합니다.
## 예제
SALES 테이블에서 지불된 모든 수수료의 합을 구합니다.
```
select sum(commission) from sales;
sum
-------------
16614814.65
(1 row)
```
Florida 주에 위치한 모든 장소의 좌석 수를 구합니다.
```
select sum(venueseats) from venue
where venuestate = 'FL';
sum
--------
250411
(1 row)
```
5월에 판매된 좌석 수를 구합니다.
```
select sum(qtysold) from sales, date
where sales.dateid = date.dateid and date.month = 'MAY';
sum
-------
32291
(1 row)
```
# VAR\$1SAMP 및 VAR\$1POP 함수
VAR\$1SAMP 및 VAR\$1POP 함수는 숫자 값(정수, 소수 또는 부동 소수점) 집합의 표본 분산과 모 분산을 반환합니다. VAR\$1SAMP 함수의 결과는 동일한 값 집합의 표본 표준 편차를 제곱한 것과 동일합니다.
VAR\$1SAMP 및 VARIANCE는 동일한 함수이기 때문에 동의어나 마찬가지입니다.
## 구문
```
VAR_SAMP | VARIANCE ( [ DISTINCT | ALL ] expression)
VAR_POP ( [ DISTINCT | ALL ] expression)
```
표현식의 데이터 형식은 정수, 소수 또는 부동 소수점이 되어야 합니다. 표현식의 데이터 형식과 상관없이 이 함수의 반환 형식은 배정밀도 숫자입니다.
**참고**
두 함수의 결과는 데이터 웨어하우스 클러스터에서 각각 클러스터 구성에 따라 다를 수 있습니다.
## 사용 노트
단일 값으로 구성된 표현식에 대해 표본 분산(VARIANCE 또는 VAR\$1SAMP)을 계산할 경우 함수 결과는 0이 아닌 NULL이 됩니다.
## 예제
다음 쿼리는 LISTING 테이블에서 NUMTICKETS 열의 표본 및 모 분산을 반올림하여 반환합니다.
```
select avg(numtickets),
round(var_samp(numtickets)) varsamp,
round(var_pop(numtickets)) varpop
from listing;
avg | varsamp | varpop
-----+---------+--------
10 | 54 | 54
(1 row)
```
다음 쿼리는 동일한 계산을 실행하지만 결과를 소수 값으로 변환합니다.
```
select avg(numtickets),
cast(var_samp(numtickets) as dec(10,4)) varsamp,
cast(var_pop(numtickets) as dec(10,4)) varpop
from listing;
avg | varsamp | varpop
-----+---------+---------
10 | 53.6291 | 53.6288
(1 row)
```