SQL 완전 정복 2025: 개발자 면접에 나오는 SQL — JOIN부터 Window Function, 쿼리 최적화까지

┌──────────────────────────────────────────────┐
│          SQL이 여전히 최강인 이유 (2025)       │
├──────────────────────────────────────────────┤
│  Stack Overflow  → 사용 언어 TOP 3           │
│  PostgreSQL      → 2년 연속 올해의 DBMS      │
│  AI/LLM          → Text-to-SQL 핵심 기술     │
│  클라우드         → Aurora, AlloyDB, Neon     │
│  면접 빈도        → 백엔드 면접 80%+ 출제     │
└──────────────────────────────────────────────┘

-- 직원 테이블
CREATE TABLE employees (
    id    INT PRIMARY KEY,
    name  VARCHAR(50),
    dept_id INT
);

INSERT INTO employees VALUES
(1, 'Alice',   10),
(2, 'Bob',     20),
(3, 'Charlie', 10),
(4, 'Diana',   30),
(5, 'Eve',     NULL);

-- 부서 테이블
CREATE TABLE departments (
    id    INT PRIMARY KEY,
    name  VARCHAR(50)
);

INSERT INTO departments VALUES
(10, 'Engineering'),
(20, 'Marketing'),
(40, 'HR');

SELECT e.name AS employee, d.name AS department
FROM employees e
INNER JOIN departments d ON e.dept_id = d.id;

┌──────────┬─────────────┐
│ employee │ department  │
├──────────┼─────────────┤
│ Alice    │ Engineering │
│ Bob      │ Marketing   │
│ Charlie  │ Engineering │
└──────────┴─────────────┘
-- Diana(dept_id=30)와 Eve(dept_id=NULL)는 매칭 없어 제외
-- HR(id=40)도 매칭 직원 없어 제외

┌─────────┐   ┌─────────┐
│Employees│   │  Depts  │
│    ┌────┼───┼────┐    │
│    │████│███│████│    │
│    │████│███│████│    │
│    └────┼───┼────┘    │
└─────────┘   └─────────┘
      INNER JOIN = 교집합

SELECT e.name AS employee, d.name AS department
FROM employees e
LEFT JOIN departments d ON e.dept_id = d.id;

┌──────────┬─────────────┐
│ employee │ department  │
├──────────┼─────────────┤
│ Alice    │ Engineering │
│ Bob      │ Marketing   │
│ Charlie  │ Engineering │
│ Diana    │ NULL        │
│ Eve      │ NULL        │
└──────────┴─────────────┘

SELECT e.name AS employee, d.name AS department
FROM employees e
RIGHT JOIN departments d ON e.dept_id = d.id;

┌──────────┬─────────────┐
│ employee │ department  │
├──────────┼─────────────┤
│ Alice    │ Engineering │
│ Bob      │ Marketing   │
│ Charlie  │ Engineering │
│ NULL     │ HR          │
└──────────┴─────────────┘

SELECT e.name AS employee, d.name AS department
FROM employees e
FULL OUTER JOIN departments d ON e.dept_id = d.id;

┌──────────┬─────────────┐
│ employee │ department  │
├──────────┼─────────────┤
│ Alice    │ Engineering │
│ Bob      │ Marketing   │
│ Charlie  │ Engineering │
│ Diana    │ NULL        │
│ Eve      │ NULL        │
│ NULL     │ HR          │
└──────────┴─────────────┘

SELECT e.name, d.name
FROM employees e
CROSS JOIN departments d;
-- 5명 x 3부서 = 15행

-- 관리자-직원 관계 조회
CREATE TABLE staff (
    id         INT PRIMARY KEY,
    name       VARCHAR(50),
    manager_id INT
);

INSERT INTO staff VALUES
(1, 'CEO',     NULL),
(2, 'CTO',     1),
(3, 'Alice',   2),
(4, 'Bob',     2);

SELECT
    s.name AS employee,
    m.name AS manager
FROM staff s
LEFT JOIN staff m ON s.manager_id = m.id;

┌──────────┬─────────┐
│ employee │ manager │
├──────────┼─────────┤
│ CEO      │ NULL    │
│ CTO      │ CEO     │
│ Alice    │ CTO     │
│ Bob      │ CTO     │
└──────────┴─────────┘

┌──────────────────────────────────────────────────┐
│              JOIN 최적화 체크리스트                │
├──────────────────────────────────────────────────┤
│ 1. JOIN 컬럼에 인덱스가 있는가?                   │
│ 2. 불필요한 컬럼을 SELECT하고 있지 않은가?        │
│ 3. WHERE 조건을 JOIN 전에 적용할 수 있는가?       │
│ 4. EXPLAIN으로 실행 계획을 확인했는가?             │
│ 5. 데이터 크기에 따라 JOIN 순서를 조정했는가?      │
└──────────────────────────────────────────────────┘

-- 부서별 직원 수와 평균 급여
SELECT
    dept_id,
    COUNT(*) AS emp_count,
    AVG(salary) AS avg_salary,
    MAX(salary) AS max_salary,
    MIN(salary) AS min_salary
FROM employees
GROUP BY dept_id
HAVING COUNT(*) >= 2
ORDER BY avg_salary DESC;

-- 부서별, 전체 합계 포함
SELECT
    COALESCE(dept_name, '전체') AS department,
    COALESCE(job_title, '소계') AS job,
    COUNT(*) AS emp_count,
    SUM(salary) AS total_salary
FROM employees e
JOIN departments d ON e.dept_id = d.id
GROUP BY ROLLUP(dept_name, job_title);

┌──────────────┬──────────┬───────────┬──────────────┐
│ department   │ job      │ emp_count │ total_salary │
├──────────────┼──────────┼───────────┼──────────────┤
│ Engineering  │ Senior   │    3      │   300000     │
│ Engineering  │ Junior   │    2      │   140000     │
│ Engineering  │ 소계     │    5      │   440000     │
│ Marketing    │ Senior   │    1      │    90000     │
│ Marketing    │ Junior   │    2      │   120000     │
│ Marketing    │ 소계     │    3      │   210000     │
│ 전체         │ 소계     │    8      │   650000     │
└──────────────┴──────────┴───────────┴──────────────┘

-- CUBE: 모든 조합의 소계
SELECT dept_name, job_title, SUM(salary)
FROM employees e JOIN departments d ON e.dept_id = d.id
GROUP BY CUBE(dept_name, job_title);

-- GROUPING SETS: 원하는 조합만 선택
SELECT dept_name, job_title, SUM(salary)
FROM employees e JOIN departments d ON e.dept_id = d.id
GROUP BY GROUPING SETS (
    (dept_name, job_title),  -- 부서+직급별
    (dept_name),              -- 부서별
    ()                        -- 전체
);

-- GROUP BY: 행 축소 (부서별 1행)
SELECT dept_id, AVG(salary) FROM employees GROUP BY dept_id;

-- Window Function: 행 유지 (모든 직원 + 부서 평균)
SELECT
    name,
    dept_id,
    salary,
    AVG(salary) OVER (PARTITION BY dept_id) AS dept_avg
FROM employees;

SELECT
    name,
    dept_id,
    salary,
    ROW_NUMBER() OVER (ORDER BY salary DESC) AS row_num,
    RANK()       OVER (ORDER BY salary DESC) AS rank,
    DENSE_RANK() OVER (ORDER BY salary DESC) AS dense_rank
FROM employees;

┌─────────┬─────────┬────────┬─────────┬──────┬────────────┐
│  name   │ dept_id │ salary │ row_num │ rank │ dense_rank │
├─────────┼─────────┼────────┼─────────┼──────┼────────────┤
│ Alice   │   10    │ 120000 │    1    │  1   │     1      │
│ Charlie │   10    │ 120000 │    2    │  1   │     1      │
│ Bob     │   20    │ 100000 │    3    │  3   │     2      │
│ Diana   │   30    │  80000 │    4    │  4   │     3      │
│ Eve     │   20    │  80000 │    5    │  4   │     3      │
└─────────┴─────────┴────────┴─────────┴──────┴────────────┘

ROW_NUMBER: 항상 고유한 번호 (동점에도 다른 번호)
RANK:       동점은 같은 번호, 다음은 건너뜀 (1, 1, 3)
DENSE_RANK: 동점은 같은 번호, 다음은 연속  (1, 1, 2)

-- 급여 기준 4분위로 나누기
SELECT
    name,
    salary,
    NTILE(4) OVER (ORDER BY salary) AS quartile
FROM employees;

-- 전월 대비 매출 변화
SELECT
    month,
    revenue,
    LAG(revenue, 1) OVER (ORDER BY month) AS prev_month,
    revenue - LAG(revenue, 1) OVER (ORDER BY month) AS change,
    LEAD(revenue, 1) OVER (ORDER BY month) AS next_month
FROM monthly_sales;

┌───────┬─────────┬────────────┬────────┬────────────┐
│ month │ revenue │ prev_month │ change │ next_month │
├───────┼─────────┼────────────┼────────┼────────────┤
│ 01    │  50000  │   NULL     │  NULL  │   60000    │
│ 02    │  60000  │   50000    │  10000 │   45000    │
│ 03    │  45000  │   60000    │ -15000 │   70000    │
│ 04    │  70000  │   45000    │  25000 │   NULL     │
└───────┴─────────┴────────────┴────────┴────────────┘

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

-- 각 부서에서 급여 TOP 3
WITH ranked AS (
    SELECT
        name,
        dept_id,
        salary,
        ROW_NUMBER() OVER (
            PARTITION BY dept_id
            ORDER BY salary DESC
        ) AS rn
    FROM employees
)
SELECT name, dept_id, salary
FROM ranked
WHERE rn <= 3;

-- 상관 서브쿼리: 자기 부서 평균보다 급여가 높은 직원
SELECT name, salary, dept_id
FROM employees e1
WHERE salary > (
    SELECT AVG(salary)
    FROM employees e2
    WHERE e2.dept_id = e1.dept_id
);

-- 비상관 서브쿼리: 전체 평균보다 급여가 높은 직원
SELECT name, salary
FROM employees
WHERE salary > (SELECT AVG(salary) FROM employees);

-- CTE: 가독성 향상
WITH dept_avg AS (
    SELECT dept_id, AVG(salary) AS avg_salary
    FROM employees
    GROUP BY dept_id
),
high_earners AS (
    SELECT e.name, e.salary, e.dept_id, d.avg_salary
    FROM employees e
    JOIN dept_avg d ON e.dept_id = d.dept_id
    WHERE e.salary > d.avg_salary
)
SELECT * FROM high_earners ORDER BY salary DESC;

┌──────────────┬───────────────┬───────────────┬────────────────┐
│    항목       │  서브쿼리      │     CTE       │  파생 테이블    │
├──────────────┼───────────────┼───────────────┼────────────────┤
│ 가독성       │ 낮음 (중첩)    │ 높음          │ 보통           │
│ 재사용       │ 불가          │ 같은 쿼리 내   │ 불가           │
│ 재귀 지원    │ 불가          │ 가능 (WITH REC)│ 불가           │
│ 성능         │ DB마다 다름    │ DB마다 다름    │ 인라인 뷰      │
│ 디버깅       │ 어려움        │ 쉬움          │ 보통           │
└──────────────┴───────────────┴───────────────┴────────────────┘

-- 조직도 테이블
CREATE TABLE org (
    id         INT PRIMARY KEY,
    name       VARCHAR(50),
    manager_id INT REFERENCES org(id)
);

INSERT INTO org VALUES
(1, 'CEO',      NULL),
(2, 'VP Eng',   1),
(3, 'VP Sales', 1),
(4, 'Dir Eng',  2),
(5, 'Lead Dev', 4),
(6, 'Dev 1',    5),
(7, 'Dev 2',    5);

-- 재귀 CTE로 CEO부터 전체 조직도 탐색
WITH RECURSIVE org_tree AS (
    -- 기저 조건: CEO (manager 없음)
    SELECT id, name, manager_id, 0 AS depth, name::TEXT AS path
    FROM org
    WHERE manager_id IS NULL

    UNION ALL

    -- 재귀 조건: 부하 직원 탐색
    SELECT o.id, o.name, o.manager_id,
           t.depth + 1,
           t.path || ' > ' || o.name
    FROM org o
    JOIN org_tree t ON o.manager_id = t.id
)
SELECT
    REPEAT('  ', depth) || name AS hierarchy,
    depth,
    path
FROM org_tree
ORDER BY path;

┌────────────────────┬───────┬──────────────────────────────┐
│ hierarchy          │ depth │ path                         │
├────────────────────┼───────┼──────────────────────────────┤
│ CEO                │   0   │ CEO                          │
│   VP Eng           │   1   │ CEO > VP Eng                 │
│     Dir Eng        │   2   │ CEO > VP Eng > Dir Eng       │
│       Lead Dev     │   3   │ CEO > VP Eng > Dir Eng > ... │
│         Dev 1      │   4   │ CEO > VP Eng > Dir Eng > ... │
│         Dev 2      │   4   │ CEO > VP Eng > Dir Eng > ... │
│   VP Sales         │   1   │ CEO > VP Sales               │
└────────────────────┴───────┴──────────────────────────────┘

-- 1부터 10까지 수열
WITH RECURSIVE nums AS (
    SELECT 1 AS n
    UNION ALL
    SELECT n + 1 FROM nums WHERE n < 10
)
SELECT n FROM nums;

-- 날짜 시리즈 생성
WITH RECURSIVE dates AS (
    SELECT DATE '2025-01-01' AS dt
    UNION ALL
    SELECT dt + INTERVAL '1 day' FROM dates WHERE dt < '2025-01-31'
)
SELECT dt FROM dates;

CREATE INDEX idx_employees_name ON employees(name);

-- 효과적인 쿼리
SELECT * FROM employees WHERE name = 'Alice';          -- 등호
SELECT * FROM employees WHERE name BETWEEN 'A' AND 'M'; -- 범위
SELECT * FROM employees ORDER BY name;                  -- 정렬
SELECT * FROM employees WHERE name LIKE 'Al%';         -- 접두사

B-Tree 구조:
              [M]
             /   \
          [D,H]  [P,T]
         /  |  \  / | \
       [A-C][E-G][I-L][N-O][Q-S][U-Z]
       (리프 노드: 실제 데이터 포인터)

CREATE INDEX idx_employees_email_hash
ON employees USING HASH (email);

-- 효과적
SELECT * FROM employees WHERE email = 'alice@example.com';

-- 비효과적 (Hash로는 범위 검색 불가)
-- SELECT * FROM employees WHERE email > 'a@' AND email < 'b@';

-- JSONB 필드 인덱싱
CREATE INDEX idx_products_tags ON products USING GIN (tags);

SELECT * FROM products WHERE tags @> '["electronics"]';

-- 전문 검색
CREATE INDEX idx_articles_search ON articles
USING GIN (to_tsvector('english', title || ' ' || body));

-- 지리 데이터 인덱싱
CREATE INDEX idx_locations_geom ON locations USING GiST (geom);

-- 반경 내 검색
SELECT * FROM locations
WHERE ST_DWithin(geom, ST_MakePoint(127.0, 37.5)::geography, 1000);

-- 시계열 데이터에 최적
CREATE INDEX idx_logs_created ON logs USING BRIN (created_at);

-- 컬럼 순서가 중요!
CREATE INDEX idx_emp_dept_salary ON employees(dept_id, salary);

-- 효과적: dept_id만 사용, 또는 dept_id + salary 둘 다 사용
SELECT * FROM employees WHERE dept_id = 10;
SELECT * FROM employees WHERE dept_id = 10 AND salary > 50000;

-- 비효과적: salary만 사용 (첫 번째 컬럼 건너뜀)
-- SELECT * FROM employees WHERE salary > 50000;

복합 인덱스의 순서 규칙 (Leftmost Prefix):

인덱스: (A, B, C)

WHERE A = ?                → 사용 O
WHERE A = ? AND B = ?      → 사용 O
WHERE A = ? AND B = ? AND C = ? → 사용 O
WHERE B = ?                → 사용 X (A 없음)
WHERE B = ? AND C = ?      → 사용 X (A 없음)
WHERE A = ? AND C = ?      → A만 사용 (B 건너뜀)

EXPLAIN ANALYZE
SELECT e.name, d.name AS dept
FROM employees e
JOIN departments d ON e.dept_id = d.id
WHERE e.salary > 50000;

Hash Join  (cost=1.09..2.24 rows=3 width=36) (actual time=0.05..0.06 rows=3 loops=1)
  Hash Cond: (e.dept_id = d.id)
  ->  Seq Scan on employees e  (cost=0.00..1.12 rows=3 width=22) (actual time=0.01..0.02 rows=3 loops=1)
        Filter: (salary > 50000)
        Rows Removed by Filter: 2
  ->  Hash  (cost=1.03..1.03 rows=3 width=18) (actual time=0.01..0.01 rows=3 loops=1)
        Buckets: 1024  Batches: 1  Memory Usage: 9kB
        ->  Seq Scan on departments d  (cost=0.00..1.03 rows=3 width=18) (actual time=0.00..0.00 rows=3 loops=1)
Planning Time: 0.15 ms
Execution Time: 0.09 ms

┌──────────────────┬──────────────────────────────────────┐
│ 스캔 타입         │ 설명                                  │
├──────────────────┼──────────────────────────────────────┤
│ Seq Scan         │ 전체 테이블 순차 스캔 (풀 스캔)        │
│ Index Scan       │ 인덱스로 조건 행 찾고 테이블 접근       │
│ Index Only Scan  │ 인덱스만으로 결과 반환 (테이블 안 봄)   │
│ Bitmap Index Scan│ 인덱스로 비트맵 만들고 테이블 접근      │
│ Bitmap Heap Scan │ 비트맵 기반 테이블 접근                │
└──────────────────┴──────────────────────────────────────┘

cost=시작비용..총비용  rows=예상행수  width=행크기(bytes)

- 시작 비용: 첫 번째 행을 반환하기까지의 비용
- 총 비용: 모든 행을 반환하는 데 드는 총 비용
- actual time: 실제 실행 시간 (ms)
- rows: 실제 반환 행 수
- loops: 해당 노드 반복 실행 횟수

┌──────────────────────────────────────────────────┐
│          쿼리 최적화 진단 플로우                    │
├──────────────────────────────────────────────────┤
│ 1. EXPLAIN ANALYZE 실행                           │
│    ↓                                              │
│ 2. Seq Scan이 대형 테이블에 있는가?               │
│    → 인덱스 추가 고려                              │
│    ↓                                              │
│ 3. 예상 rows와 실제 rows 차이가 큰가?             │
│    → ANALYZE 실행하여 통계 갱신                     │
│    ↓                                              │
│ 4. Nested Loop이 대량 데이터에 사용되는가?         │
│    → Hash Join이나 Merge Join이 더 적합할 수 있음  │
│    ↓                                              │
│ 5. Sort가 디스크에서 실행되는가?                   │
│    → work_mem 증가 또는 인덱스 추가                 │
└──────────────────────────────────────────────────┘

-- 나쁜 예: 각 주문마다 별도 쿼리 (애플리케이션에서)
-- 1. SELECT * FROM orders WHERE user_id = 1;
-- 2. SELECT * FROM order_items WHERE order_id = 101;
-- 3. SELECT * FROM order_items WHERE order_id = 102;
-- ... (N개 주문이면 N+1번 쿼리)

-- 좋은 예: JOIN으로 한 번에
SELECT o.id, o.total, oi.product_name, oi.quantity
FROM orders o
JOIN order_items oi ON o.id = oi.order_id
WHERE o.user_id = 1;

-- 인덱스 생성
CREATE INDEX idx_emp_dept_name_salary
ON employees(dept_id, name, salary);

-- Index Only Scan 가능 (테이블 접근 불필요)
SELECT name, salary FROM employees WHERE dept_id = 10;

-- 활성 사용자만 인덱싱 (대부분의 쿼리가 활성 사용자 대상)
CREATE INDEX idx_active_users
ON users(email)
WHERE status = 'active';

-- 효과적으로 사용됨
SELECT * FROM users WHERE status = 'active' AND email = 'alice@example.com';

-- 대소문자 무시 검색을 위한 인덱스
CREATE INDEX idx_users_lower_email
ON users(LOWER(email));

SELECT * FROM users WHERE LOWER(email) = 'alice@example.com';

-- JSON 필드 인덱싱
CREATE INDEX idx_data_category
ON products((data->>'category'));

-- 1. EXISTS vs IN: 대량 데이터에서는 EXISTS가 보통 빠름
-- 느린
SELECT * FROM orders WHERE customer_id IN (
    SELECT id FROM customers WHERE country = 'KR'
);
-- 빠른
SELECT * FROM orders o WHERE EXISTS (
    SELECT 1 FROM customers c
    WHERE c.id = o.customer_id AND c.country = 'KR'
);

-- 2. LIMIT과 함께 사용하면 불필요한 스캔 방지
SELECT * FROM logs ORDER BY created_at DESC LIMIT 100;

-- 3. UNION ALL vs UNION: 중복 제거 불필요 시 ALL 사용
SELECT name FROM employees_2024
UNION ALL
SELECT name FROM employees_2025;

-- 4. 불필요한 ORDER BY 제거 (서브쿼리 내에서)
-- 5. SELECT *보다 필요한 컬럼만 명시

┌──────────────────┬───────────┬──────────────┬──────────────┬─────────────┐
│ 격리 수준         │Dirty Read │Non-Repeatable│Phantom Read  │ 성능        │
│                  │           │    Read      │              │             │
├──────────────────┼───────────┼──────────────┼──────────────┼─────────────┤
│ Read Uncommitted │ 가능      │ 가능         │ 가능          │ 가장 빠름   │
│ Read Committed   │ 방지      │ 가능         │ 가능          │ 빠름        │
│ Repeatable Read  │ 방지      │ 방지         │ 가능          │ 보통        │
│ Serializable     │ 방지      │ 방지         │ 방지          │ 가장 느림   │
└──────────────────┴───────────┴──────────────┴──────────────┴─────────────┘

PostgreSQL 기본값: Read Committed
MySQL InnoDB 기본값: Repeatable Read

-- Transaction A
UPDATE accounts SET balance = 0 WHERE id = 1;
-- (아직 COMMIT 안 함)

-- Transaction B (Read Uncommitted)
SELECT balance FROM accounts WHERE id = 1;
-- balance = 0 (커밋 안 된 값!)

-- Transaction A
ROLLBACK;
-- 실제로는 balance가 원래 값으로 복원됨
-- Transaction B는 잘못된 데이터를 기반으로 결정을 내릴 수 있음

-- Transaction A
SELECT balance FROM accounts WHERE id = 1;  -- 1000

-- Transaction B
UPDATE accounts SET balance = 500 WHERE id = 1;
COMMIT;

-- Transaction A (같은 트랜잭션 내에서)
SELECT balance FROM accounts WHERE id = 1;  -- 500 (결과가 다름!)

-- Transaction A
SELECT COUNT(*) FROM orders WHERE status = 'pending';  -- 5

-- Transaction B
INSERT INTO orders (status) VALUES ('pending');
COMMIT;

-- Transaction A
SELECT COUNT(*) FROM orders WHERE status = 'pending';  -- 6 (유령 행!)

┌──────────────────────────────────────────────────┐
│                    MVCC 원리                      │
├──────────────────────────────────────────────────┤
│                                                  │
│  Transaction 100 (Read):                         │
│  "나는 xmin 100 이하의 버전만 본다"               │
│                                                  │
│  Transaction 101 (Write):                        │
│  "새 버전을 xmin=101로 생성, 기존 행에 xmax=101" │
│                                                  │
│  → Transaction 100은 여전히 이전 버전을 봄        │
│  → 읽기와 쓰기가 서로 블로킹하지 않음             │
│                                                  │
└──────────────────────────────────────────────────┘

-- JSONB 데이터 저장
CREATE TABLE products (
    id   SERIAL PRIMARY KEY,
    name TEXT,
    data JSONB
);

INSERT INTO products (name, data) VALUES
('Laptop', '{"brand": "Dell", "specs": {"ram": 16, "cpu": "i7"}, "tags": ["electronics", "computer"]}'),
('Phone',  '{"brand": "Apple", "specs": {"ram": 8, "cpu": "A17"}, "tags": ["electronics", "mobile"]}');

-- JSONB 쿼리
SELECT name, data->>'brand' AS brand
FROM products
WHERE data->'specs'->>'ram' = '16';

-- 배열 포함 검색
SELECT * FROM products WHERE data->'tags' @> '"mobile"';

-- JSONB 경로 쿼리 (PostgreSQL 12+)
SELECT * FROM products
WHERE data @? '$.specs ? (@.ram > 10)';

-- 배열 타입 사용
CREATE TABLE articles (
    id   SERIAL PRIMARY KEY,
    title TEXT,
    tags  TEXT[]
);

INSERT INTO articles (title, tags) VALUES
('SQL Guide', ARRAY['sql', 'database', 'backend']),
('React Tips', ARRAY['react', 'frontend', 'javascript']);

-- 배열 포함 검색
SELECT * FROM articles WHERE tags @> ARRAY['sql'];
SELECT * FROM articles WHERE 'react' = ANY(tags);
SELECT * FROM articles WHERE tags && ARRAY['sql', 'react'];  -- 겹침 확인

-- 각 부서의 최근 주문 3개씩 조회
SELECT d.name, recent.*
FROM departments d
CROSS JOIN LATERAL (
    SELECT o.id, o.amount, o.created_at
    FROM orders o
    WHERE o.dept_id = d.id
    ORDER BY o.created_at DESC
    LIMIT 3
) recent;

-- 복잡한 집계 결과를 미리 계산해 저장
CREATE MATERIALIZED VIEW monthly_sales_summary AS
SELECT
    DATE_TRUNC('month', order_date) AS month,
    dept_id,
    COUNT(*) AS order_count,
    SUM(amount) AS total_amount,
    AVG(amount) AS avg_amount
FROM orders
GROUP BY DATE_TRUNC('month', order_date), dept_id;

-- 인덱스 추가
CREATE INDEX idx_monthly_sales ON monthly_sales_summary(month, dept_id);

-- 데이터 갱신
REFRESH MATERIALIZED VIEW CONCURRENTLY monthly_sales_summary;

SELECT * FROM A CROSS JOIN B;
-- A: 5행, B: 3행

SELECT name, salary,
       AVG(salary) OVER () AS dept_avg
FROM employees;
-- employees: Alice 100, Bob 200, Charlie 300