ROW_NUMBER, LAG

SQL 윈도우 함수 — ROW_NUMBER, RANK, LAG의 마법

💡 코딩테스트 단골! 윈도우 함수를 완벽하게 정리한다.

---

🤔 윈도우 함수가 뭐야?

GROUP BY 없이 집계하면서 개별 행도 유지하는 함수.

GROUP BY vs 윈도우 함수

-- GROUP BY: 행이 합쳐짐
SELECT user_id, SUM(amount)
FROM orders
GROUP BY user_id;
-- 결과: 3행 (유저 수만큼)

-- 윈도우 함수: 행이 유지됨
SELECT 
    user_id, 
    amount,
    SUM(amount) OVER(PARTITION BY user_id) AS user_total
FROM orders;
-- 결과: 6행 (원본 그대로)

→ 원본 데이터 + 집계 결과를 동시에!

---

📊 예제 테이블

[orders]
| order_id | user_id | amount | order_date |
|----------|---------|--------|------------|
| 1 | 101 | 150000 | 2024-01-10 |
| 2 | 101 | 50000 | 2024-01-20 |
| 3 | 101 | 100000 | 2024-02-05 |
| 4 | 102 | 200000 | 2024-01-15 |
| 5 | 102 | 80000 | 2024-02-10 |
| 6 | 103 | 300000 | 2024-02-15 |

---

🔧 윈도우 함수 기본 문법

함수명() OVER (
    PARTITION BY 그룹_컬럼    -- 그룹 나누기 (선택)
    ORDER BY 정렬_컬럼        -- 정렬 기준 (선택)
)

---

📈 윈도우 함수 종류

1. 순위 함수

함수	설명
ROW_NUMBER()	순차 번호 (1,2,3,4,5)
RANK()	동점 시 같은 순위, 다음 순위 건너뜀 (1,2,2,4,5)
DENSE_RANK()	동점 시 같은 순위, 다음 순위 연속 (1,2,2,3,4)

2. 집계 함수

함수	설명
SUM()	합계
AVG()	평균
COUNT()	개수
MAX() / MIN()	최대/최소

3. 값 참조 함수

함수	설명
LAG()	이전 행 값
LEAD()	다음 행 값
FIRST_VALUE()	첫 번째 값
LAST_VALUE()	마지막 값

---

1️⃣ ROW_NUMBER — 순차 번호

기본 사용

SELECT 
    *,
    ROW_NUMBER() OVER(ORDER BY amount DESC) AS rn
FROM orders;

order_id	user_id	amount	rn
6	103	300000	1
4	102	200000	2
1	101	150000	3
3	101	100000	4
5	102	80000	5
2	101	50000	6

PARTITION BY와 함께 — 그룹별 번호

SELECT 
    *,
    ROW_NUMBER() OVER(PARTITION BY user_id ORDER BY amount DESC) AS rn
FROM orders;

order_id	user_id	amount	rn
1	101	150000	1
3	101	100000	2
2	101	50000	3
4	102	200000	1
5	102	80000	2
6	103	300000	1

→ 유저별로 금액 순위!

💡 실전 활용: 그룹별 Top 1

-- 각 유저의 가장 큰 주문만 가져오기
WITH ranked AS (
    SELECT 
        *,
        ROW_NUMBER() OVER(PARTITION BY user_id ORDER BY amount DESC) AS rn
    FROM orders
)
SELECT * FROM ranked WHERE rn = 1;

order_id	user_id	amount	rn
1	101	150000	1
4	102	200000	1
6	103	300000	1

코테 단골 패턴! 🔥

---

2️⃣ RANK vs DENSE_RANK

비교

SELECT 
    amount,
    ROW_NUMBER() OVER(ORDER BY amount DESC) AS row_num,
    RANK() OVER(ORDER BY amount DESC) AS rank,
    DENSE_RANK() OVER(ORDER BY amount DESC) AS dense_rank
FROM (
    SELECT 300000 AS amount UNION ALL
    SELECT 200000 UNION ALL
    SELECT 200000 UNION ALL
    SELECT 100000 UNION ALL
    SELECT 50000
) t;

amount	row_num	rank	dense_rank
300000	1	1	1
200000	2	2	2
200000	3	2	2
100000	4	4	3
50000	5	5	4

차이점:

• ROW_NUMBER: 무조건 1,2,3,4,5
• RANK: 동점 시 같은 순위, 다음 건너뜀 (2등 2명 → 4등)
• DENSE_RANK: 동점 시 같은 순위, 다음 연속 (2등 2명 → 3등)

---

3️⃣ SUM OVER — 누적합

전체 합계 추가

SELECT 
    *,
    SUM(amount) OVER() AS total
FROM orders;

order_id	amount	total
1	150000	880000
2	50000	880000
...	...	880000

유저별 합계

SELECT 
    *,
    SUM(amount) OVER(PARTITION BY user_id) AS user_total
FROM orders;

order_id	user_id	amount	user_total
1	101	150000	300000
2	101	50000	300000
3	101	100000	300000
4	102	200000	280000
...	...	...	...

누적합 (Running Total)

SELECT 
    *,
    SUM(amount) OVER(ORDER BY order_date) AS running_total
FROM orders;

order_id	order_date	amount	running_total
1	2024-01-10	150000	150000
4	2024-01-15	200000	350000
2	2024-01-20	50000	400000
3	2024-02-05	100000	500000
5	2024-02-10	80000	580000
6	2024-02-15	300000	880000

→ 날짜 순으로 누적!

---

4️⃣ LAG / LEAD — 이전/다음 행

LAG: 이전 행 값

SELECT 
    order_id,
    order_date,
    amount,
    LAG(amount) OVER(ORDER BY order_date) AS prev_amount
FROM orders;

order_id	order_date	amount	prev_amount
1	2024-01-10	150000	NULL
4	2024-01-15	200000	150000
2	2024-01-20	50000	200000
3	2024-02-05	100000	50000
...	...	...	...

LEAD: 다음 행 값

SELECT 
    order_id,
    amount,
    LEAD(amount) OVER(ORDER BY order_date) AS next_amount
FROM orders;

LAG 활용: 증감 계산

SELECT 
    order_date,
    amount,
    LAG(amount) OVER(ORDER BY order_date) AS prev_amount,
    amount - LAG(amount) OVER(ORDER BY order_date) AS diff
FROM orders;

order_date	amount	prev_amount	diff
2024-01-10	150000	NULL	NULL
2024-01-15	200000	150000	50000
2024-01-20	50000	200000	-150000

LAG 파라미터

LAG(컬럼, N, 기본값)
-- N: 몇 행 전? (기본 1)
-- 기본값: NULL 대신 사용할 값

SELECT 
    amount,
    LAG(amount, 1, 0) OVER(ORDER BY order_date) AS prev_1,
    LAG(amount, 2, 0) OVER(ORDER BY order_date) AS prev_2
FROM orders;

---

5️⃣ FIRST_VALUE / LAST_VALUE

FIRST_VALUE: 그룹 첫 번째 값

SELECT 
    user_id,
    order_date,
    amount,
    FIRST_VALUE(amount) OVER(
        PARTITION BY user_id 
        ORDER BY order_date
    ) AS first_order_amount
FROM orders;

user_id	order_date	amount	first_order_amount
101	2024-01-10	150000	150000
101	2024-01-20	50000	150000
101	2024-02-05	100000	150000

---

6️⃣ 프레임 지정 (ROWS/RANGE)

이동 평균

SELECT 
    order_date,
    amount,
    AVG(amount) OVER(
        ORDER BY order_date
        ROWS BETWEEN 2 PRECEDING AND CURRENT ROW
    ) AS moving_avg_3
FROM orders;

→ 현재 행 포함 최근 3개의 평균

프레임 옵션

ROWS BETWEEN 시작 AND 끝

-- 시작/끝 옵션
UNBOUNDED PRECEDING  -- 처음부터
N PRECEDING          -- N행 전
CURRENT ROW          -- 현재 행
N FOLLOWING          -- N행 후
UNBOUNDED FOLLOWING  -- 끝까지

예시:

-- 현재 행 기준 앞뒤 1행씩 포함
ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING

-- 처음부터 현재까지 (누적)
ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW

---

🎯 실전 문제

문제 1: 그룹별 Top 2

각 유저별 주문 금액 상위 2개를 구하세요.

정답 보기

WITH ranked AS (
    SELECT 
        *,
        ROW_NUMBER() OVER(
            PARTITION BY user_id 
            ORDER BY amount DESC
        ) AS rn
    FROM orders
)
SELECT * FROM ranked WHERE rn <= 2;

---

문제 2: 누적합

날짜 순으로 누적 매출을 구하세요.

정답 보기

SELECT 
    order_date,
    amount,
    SUM(amount) OVER(ORDER BY order_date) AS cumulative_sum
FROM orders;

---

문제 3: 전일 대비 증감

각 주문의 전일 주문 대비 금액 차이를 구하세요.

정답 보기

SELECT 
    order_date,
    amount,
    LAG(amount) OVER(ORDER BY order_date) AS prev_amount,
    amount - LAG(amount) OVER(ORDER BY order_date) AS diff
FROM orders;

---

문제 4: 비율 계산

각 주문이 해당 유저 총 주문금액에서 차지하는 비율을 구하세요.

정답 보기

SELECT 
    user_id,
    order_id,
    amount,
    SUM(amount) OVER(PARTITION BY user_id) AS user_total,
    ROUND(amount * 100.0 / SUM(amount) OVER(PARTITION BY user_id), 2) AS pct
FROM orders;

---

문제 5: 연속 증가 찾기

주문 금액이 이전보다 증가한 주문을 찾으세요.

정답 보기

WITH with_prev AS (
    SELECT 
        *,
        LAG(amount) OVER(ORDER BY order_date) AS prev_amount
    FROM orders
)
SELECT *
FROM with_prev
WHERE amount > prev_amount;

---

💡 윈도우 함수 팁

1. 별칭은 못 씀

-- ❌ 에러
SELECT 
    SUM(amount) OVER() AS total,
    amount / total AS ratio  -- total 사용 불가!
FROM orders;

-- ✅ CTE 사용
WITH totals AS (
    SELECT *, SUM(amount) OVER() AS total
    FROM orders
)
SELECT *, amount * 1.0 / total AS ratio
FROM totals;

2. WHERE에서 못 씀

-- ❌ 에러
SELECT *
FROM orders
WHERE ROW_NUMBER() OVER(ORDER BY amount) <= 3;

-- ✅ CTE 사용
WITH ranked AS (
    SELECT *, ROW_NUMBER() OVER(ORDER BY amount) AS rn
    FROM orders
)
SELECT * FROM ranked WHERE rn <= 3;

3. 성능 주의

• PARTITION BY 컬럼에 인덱스 고려
• 너무 많은 윈도우 함수는 성능 저하 가능

---

📝 핵심 정리

[순위]
ROW_NUMBER: 순차 번호
RANK: 동점 시 같은 순위, 건너뜀
DENSE_RANK: 동점 시 같은 순위, 연속

[집계]
SUM/AVG/COUNT OVER(): 그룹 유지하며 집계

[값 참조]
LAG: 이전 행
LEAD: 다음 행
FIRST_VALUE: 첫 번째 값

[문법]
OVER(PARTITION BY 그룹 ORDER BY 정렬)

---

🔗 다음 포스트

[SQL 시리즈 #5] 실전 패턴 — 코테 자주 나오는 유형 총정리

---

📝 윈도우 함수는 코딩테스트의 핵심이다.
ROW_NUMBER + CTE 패턴만 확실히 알아도 많은 문제를 풀 수 있다!