📌 탐색 알고리즘이란?

많은 양의 데이터 중에서 원하는 데이터를 찾는 과정

대표적인 그래프 탐색 알고리즘으로 DFS와 BFS가 있으며, 코딩 테스트에서 매우 자주 등장하므로 반드시 숙지해야 한다.

🗂️ 자료구조 기본기

스택 (Stack)

• 선입후출 (LIFO) — 나중에 들어온 것이 먼저 나온다.
• Python에서는 리스트의 append() / pop()으로 구현한다.

stack = []

stack.append(5)
stack.append(2)
stack.append(3)
stack.append(7)
stack.pop()      # 7 제거
stack.append(1)
stack.append(4)
stack.pop()      # 4 제거

print(stack[::-1])  # 최상단 원소부터 출력: [1, 3, 2, 5]
print(stack)        # 최하단 원소부터 출력: [5, 2, 3, 1]

큐 (Queue)

• 선입선출 (FIFO) — 먼저 들어온 것이 먼저 나온다.
• Python에서는 collections.deque를 사용한다. (리스트보다 효율적)

from collections import deque

queue = deque()

queue.append(5)
queue.append(2)
queue.append(3)
queue.append(7)
queue.popleft()  # 5 제거
queue.append(1)
queue.append(4)
queue.popleft()  # 2 제거

print(queue)         # 먼저 들어온 순서대로: deque([3, 7, 1, 4])
queue.reverse()
print(queue)         # 나중에 들어온 원소부터: deque([4, 1, 7, 3])

🔄 재귀 함수

자기 자신을 다시 호출하는 함수

종료 조건이 반드시 필요하다

종료 조건 없이 재귀를 호출하면 최대 재귀 깊이를 초과해 에러가 발생한다.

def recursive_function(i):
    if i == 100:  # 종료 조건
        return
    print(i, '번째 재귀함수에서', i+1, '번째 재귀함수를 호출합니다.')
    recursive_function(i + 1)
    print(i, '번째 재귀함수를 종료합니다.')

recursive_function(1)

팩토리얼 비교 예시

# 반복문으로 구현
def factorial_iterative(n):
    result = 1
    for i in range(1, n + 1):
        result *= i
    return result

# 재귀로 구현
def factorial_recursive(n):
    if n <= 1:
        return 1
    return n * factorial_recursive(n - 1)

print('반복적으로 구현:', factorial_iterative(5))  # 120
print('재귀적으로 구현:', factorial_recursive(5))  # 120

유클리드 호제법 (최대공약수)

A를 B로 나눈 나머지를 R이라 할 때, GCD(A, B) = GCD(B, R)

def gcd(a, b):
    if a % b == 0:
        return b
    else:
        return gcd(b, a % b)

print(gcd(192, 162))  # 6

재귀 함수 유의사항

• 복잡한 알고리즘을 간결하게 작성할 수 있지만, 가독성이 떨어질 수 있다.
• 모든 재귀 함수는 반복문으로 동일하게 구현 가능하다.
• 함수 호출 시 스택 프레임에 쌓이기 때문에, 스택이 필요한 경우 재귀로 대체하는 경우가 많다.

🔍 DFS (깊이 우선 탐색)

그래프에서 깊은 부분을 우선적으로 탐색하는 알고리즘

동작 과정

1. 탐색 시작 노드를 스택에 삽입하고 방문 처리한다.
2. 스택 최상단 노드에 방문하지 않은 인접 노드가 있으면 → 스택에 넣고 방문 처리
3. 방문하지 않은 인접 노드가 없으면 → 스택에서 최상단 노드를 꺼낸다.
4. 더 이상 반복할 수 없을 때까지 2~3을 반복한다.

핵심

• 스택 또는 재귀 함수를 이용한다.
• 실제 구현에서는 재귀 함수가 더 간결하다.

def dfs(graph, v, visited):
    visited[v] = True
    print(v, end=' ')

    for i in graph[v]:
        if not visited[i]:
            dfs(graph, i, visited)

graph = [
    [],
    [2, 3, 8],  # 1번 노드와 연결
    [1, 7],
    [1, 4, 5],
    [3, 5],
    [3, 4],
    [7],
    [2, 6, 8],
    [1, 7]
]

visited = [False] * 9

dfs(graph, 1, visited)
# 출력: 1 2 7 6 8 3 4 5

🔍 BFS (너비 우선 탐색)

그래프에서 가까운 노드부터 우선적으로 탐색하는 알고리즘

동작 과정

1. 탐색 시작 노드를 큐에 삽입하고 방문 처리한다.
2. 큐에서 노드를 꺼낸 뒤, 인접한 방문하지 않은 노드를 모두 큐에 삽입하고 방문 처리한다.
3. 더 이상 반복할 수 없을 때까지 2를 반복한다.

핵심

• 큐 자료구조를 이용한다.
• 최단 거리 문제에 유리하다. (모든 간선의 비용이 동일할 때)

from collections import deque

def bfs(graph, start, visited):
    queue = deque([start])
    visited[start] = True

    while queue:
        v = queue.popleft()
        print(v, end=' ')

        for i in graph[v]:
            if not visited[i]:
                queue.append(i)
                visited[i] = True

graph = [
    [],
    [2, 3, 8],
    [1, 7],
    [1, 4, 5],
    [3, 5],
    [3, 4],
    [7],
    [2, 6, 8],
    [1, 7]
]

visited = [False] * 9

bfs(graph, 1, visited)
# 출력: 1 2 3 8 7 4 5 6

🆚 DFS vs BFS 비교

🧊 문제 1. 음료수 얼려 먹기

문제

N×M 얼음 틀에서 0은 구멍, 1은 칸막이다. 상하좌우로 연결된 0끼리 하나의 아이스크림이 된다. 총 아이스크림의 개수를 구하라.

아이디어 (DFS)

1. 모든 칸을 순서대로 확인하며 0인 칸에서 DFS를 수행한다.
2. DFS 중에 방문한 0 칸을 1로 바꿔 재방문을 방지한다.
3. DFS가 한 번 성공할 때마다 아이스크림 개수를 +1 한다.

def dfs(x, y):
    # 범위를 벗어나면 종료
    if x <= -1 or x >= n or y <= -1 or y >= m:
        return False

    if graph[x][y] == 0:
        graph[x][y] = 1  # 방문 처리
        dfs(x - 1, y)
        dfs(x + 1, y)
        dfs(x, y - 1)
        dfs(x, y + 1)
        return True
    return False

n, m = map(int, input().split())

graph = []
for i in range(n):
    graph.append(list(map(int, input())))

result = 0
for i in range(n):
    for j in range(m):
        if dfs(i, j) == True:
            result += 1

print(result)

# 입력 예시:
# 4 5
# 00110
# 00011
# 11111
# 00000
# 출력: 3

핵심 포인트

• graph[x][y] = 1로 방문을 표시해 별도의 visited 배열 없이도 동작한다.
• 범위 체크를 먼저 하는 것이 핵심 — 범위 밖이면 False를 반환하고 종료한다.

🌀 문제 2. 미로 탈출

문제

N×M 미로에서 (1,1)에서 출발해 (N,M)까지 이동할 때, 최소 칸의 개수를 구하라. 0은 괴물(이동 불가), 1은 이동 가능한 칸이다.

아이디어 (BFS)

• BFS는 가까운 노드부터 탐색하므로 최단 경로를 보장한다.
• 방문할 때마다 이전 칸의 거리 + 1을 기록한다.
• 별도의 거리 배열 없이 graph 값 자체를 거리로 갱신한다.

from collections import deque

def bfs(x, y):
    queue = deque()
    queue.append((x, y))

    while queue:
        x, y = queue.popleft()

        for i in range(4):
            nx = x + dx[i]
            ny = y + dy[i]

            if nx < 0 or nx >= n or ny < 0 or ny >= m:
                continue
            if graph[nx][ny] == 0:  # 벽이면 무시
                continue
            if graph[nx][ny] == 1:  # 처음 방문하는 경우만 기록
                graph[nx][ny] = graph[x][y] + 1
                queue.append((nx, ny))

    return graph[n - 1][m - 1]

n, m = map(int, input().split())

graph = []
for i in range(n):
    graph.append(list(map(int, input())))

dx = [-1, 1, 0, 0]
dy = [0, 0, -1, 1]

print(bfs(0, 0))

# 입력 예시:
# 3 3
# 110
# 010
# 011
# 출력: 5

핵심 포인트

• graph[nx][ny] == 1 조건으로 처음 방문하는 칸만 거리를 갱신한다.
• 이미 거리가 기록된 칸(값 > 1)은 다시 큐에 넣지 않아 중복 탐색을 방지한다.
• graph[n-1][m-1]을 반환하면 자연스럽게 최단 거리가 나온다.

📝 정리

📌 그리디 알고리즘이란?

현재 상황에서 지금 당장 좋은 것만 고르는 방법

• 문제를 풀기 위한 최소한의 아이디어를 떠올리는 능력이 필요하다.
• 정당성 분석이 중요 — 단순히 가장 좋아 보이는 선택을 반복해도 최적의 해가 나오는지 검토해야 한다.
• 일반적인 상황에서는 최적의 해를 보장할 수 없는 경우가 많다.
• 단, 코딩 테스트에서는 탐욕법으로 얻은 해가 최적의 해가 되는 상황으로 출제된다.

🪙 문제 1. 거스름돈

아이디어

큰 단위의 화폐부터 최대한 사용하면 항상 최소 동전 개수를 보장한다.

n = 1260
count = 0

array = [500, 100, 50, 10]

for coin in array:
    count += n // coin  # 해당 화폐로 거슬러 줄 수 있는 동전의 개수
    n %= coin

print(count)

시간 복잡도

• 화폐의 종류가 K개일 때 O(K)
• 거슬러줘야 하는 금액과 무관하고, 동전의 종류 수에만 영향을 받는다.

🔢 문제 2. 1이 될 때까지

문제

N과 K가 주어졌을 때, N에서 1을 빼거나 K로 나누는 연산을 반복해 1로 만드는 최소 연산 횟수를 구하라.

아이디어

• K로 나누는 것이 1을 빼는 것보다 훨씬 빠르게 N을 줄인다.
• 따라서 최대한 많이 나누기를 수행하는 것이 최적이다.
• K로 나누어 떨어지지 않을 때는 나누어 떨어지는 수까지 1씩 뺀다.

정당성

K가 2 이상이기만 하면, K로 나누는 것이 1을 빼는 것보다 항상 빠르게 N을 줄인다. N은 항상 1에 도달하게 된다.

n, k = map(int, input().split())

result = 0

while True:
    # N이 K로 나누어 떨어지는 수가 될 때까지 빼기
    target = (n // k) * k  # K의 배수 중 N보다 작거나 같은 가장 큰 수
    result += (n - target)
    n = target

    # N이 K보다 작을 때 (더 이상 나눌 수 없을 때) 반복문 탈출
    if n < k:
        break

    # K로 나누기
    result += 1
    n //= k

# 마지막으로 남은 수에 대하여 1씩 빼기
result += (n - 1)
print(result)

핵심 포인트

target = (n // k) * k → K로 나누어 떨어지는 가장 가까운 수를 한 번에 계산해, 1씩 빼는 횟수를 줄인다.

✖️ 문제 3. 곱하기 혹은 더하기

문제

숫자로 이루어진 문자열이 주어졌을 때, 각 숫자 사이에 + 또는 ×를 넣어 결과값을 최대로 만들어라.

아이디어

• 대부분의 경우 +보다 ×가 더 값을 크게 만든다. (ex. 5+6=11, 5×6=30)
• 단, 두 수 중 하나라도 0 또는 1이면 더하기가 유리하다.

data = input()

result = int(data[0])

for i in range(1, len(data)):
    num = int(data[i])
    if num <= 1 or result <= 1:
        result += num
    else:
        result *= num

print(result)

🧙 문제 4. 모험가 길드

문제

공포도가 X인 모험가는 반드시 X명 이상으로 구성된 그룹에 참여해야 한다. 최대 몇 개의 그룹을 만들 수 있는지 구하라.

아이디어

• 그룹 수를 최대화하려면 각 그룹을 최대한 작게 만들어야 한다.
• 오름차순 정렬 후 공포도가 낮은 모험가부터 확인한다.
• 현재 그룹 인원 수 ≥ 현재 모험가의 공포도가 되는 순간 그룹을 결성한다.

n = int(input())
data = list(map(int, input().split()))
data.sort()

result = 0  # 총 그룹의 수
count = 0   # 현재 그룹에 포함된 모험가의 수

for i in data:
    count += 1
    if count >= i:  # 현재 그룹 인원이 공포도 이상이면 그룹 결성
        result += 1
        count = 0

print(result)

핵심 포인트

오름차순 정렬 덕분에 현재 i가 그룹 내 최대 공포도임이 보장된다. 따라서 count >= i 조건 하나로 그룹 결성 가능 여부를 판단할 수 있다.

📌 구현(Implementation)이란?

풀이를 떠올리는 것은 쉽지만, 소스코드로 옮기기 어려운 문제

• 코드가 지나치게 길어지는 문제
• 실수 연산 및 특정 소수점 자리 출력 문제
• 문자열을 특정 기준으로 끊어 처리하는 문제
• 적절한 라이브러리를 찾아 사용해야 하는 문제

💡 시뮬레이션 및 완전 탐색 문제에서는 2차원 방향 벡터가 자주 활용된다.

# 상하좌우 방향 벡터
dx = [0, 0, -1, 1]   # 행 변화량 (L, R, U, D)
dy = [-1, 1, 0, 0]   # 열 변화량

🗺️ 문제 5. 상하좌우

문제

N×N 격자에서 (1,1)부터 시작해 L/R/U/D 명령어를 따라 이동할 때, 격자를 벗어나는 이동은 무시한다. 최종 위치를 구하라.

아이디어

요구사항대로 구현하는 시뮬레이션 문제. 방향 벡터를 리스트로 정의해 이동을 처리한다.

n = int(input())
x, y = 1, 1
plans = input().split()

dx = [0, 0, -1, 1]
dy = [-1, 1, 0, 0]
move_types = ['L', 'R', 'U', 'D']

for plan in plans:
    for i in range(len(move_types)):
        if plan == move_types[i]:
            nx = x + dx[i]
            ny = y + dy[i]
    # 공간을 벗어나는 경우 무시
    if nx < 1 or ny < 1 or nx > n or ny > n:
        continue
    x, y = nx, ny

print(x, y)

⏰ 문제 6. 시각

문제

00:00:00부터 N:59:59까지의 모든 시각 중 숫자 3이 하나라도 포함된 경우의 수를 구하라.

아이디어

하루는 86,400초. 모든 경우의 수를 직접 탐색하는 완전 탐색 문제.

h = int(input())

count = 0
for i in range(h + 1):
    for j in range(60):
        for k in range(60):
            if '3' in str(i) + str(j) + str(k):
                count += 1

print(count)

핵심 포인트

'3' in str(i) + str(j) + str(k) → 시/분/초를 문자열로 합쳐서 '3'이 포함되는지 한 번에 확인한다.

♞ 문제 7. 왕실의 나이트

문제

8×8 체스판에서 나이트의 위치가 주어졌을 때, 이동 가능한 경우의 수를 구하라. 나이트는 L자로만 이동한다.

아이디어

나이트의 8가지 이동 방향을 모두 시도하고, 체스판을 벗어나지 않는 경우만 카운트한다.

input_data = input()
row = int(input_data[1])
column = int(ord(input_data[0])) - int(ord('a')) + 1

# 나이트의 8가지 이동 방향
steps = [(-2,-1), (-1,-2), (1,-2), (2,-1),
         (2,1), (1,2), (-1,2), (-2,1)]

result = 0
for step in steps:
    next_row = row + step[0]
    next_column = column + step[1]
    if 1 <= next_row <= 8 and 1 <= next_column <= 8:
        result += 1

print(result)

핵심 포인트

ord(input_data[0]) - ord('a') + 1 → 알파벳 열 좌표를 숫자로 변환한다. (a→1, b→2, ...)

🔤 문제 8. 문자열 재정렬

문제

알파벳 대문자와 숫자로 구성된 문자열이 주어졌을 때, 알파벳은 오름차순 정렬, 숫자는 모두 더해서 뒤에 붙여 출력하라.

• 예시: K1KA5CB7 → ABCKK13

아이디어

문자를 하나씩 확인하며 알파벳과 숫자를 분리한 뒤, 알파벳은 정렬하고 숫자 합계를 뒤에 붙인다.

data = input()
result = []
value = 0

for x in data:
    if x.isalpha():
        result.append(x)
    else:
        value += int(x)

result.sort()

if value != 0:
    result.append(str(value))

print(''.join(result))

📝 정리

들어가며

캡스톤디자인 프로젝트 GANADI(반려동물 안구질환 AI 스크리닝 플랫폼) 백엔드 개발에 처음으로 참여했다. 개발 자체도 처음이고 FastAPI도 처음이라 모르는 것투성이였는데, 첫날부터 팀원분께 버그를 잡아주시는 상황이 생겼다. 부끄럽지만 다음에 같은 실수를 반복하지 않기 위해 기록으로 남긴다.

오늘 한 작업

• 로그인 응답에 name, role 필드 추가
• GET /api/diagnosis/history 전체 진단 이력 API 추가
• 알림 API 구현 (GET, PATCH /read-all, PATCH /{id})

실수 1 - 마이그레이션 파일이 비어있었다

무슨 일이 있었나?

알림 API를 구현하면서 Notification 모델을 추가하고 아래 명령어를 실행했다.

alembic revision --autogenerate -m "add notifications table"
alembic upgrade head

언뜻 보면 정상적으로 실행된 것처럼 보였다. 하지만 팀원분께서 확인해보니 실제로 DB에 notifications 테이블이 생성되지 않았다.

원인

alembic revision --autogenerate는 실제 DB에 연결해서 현재 DB 상태와 모델 코드를 비교해 차이점을 감지하는 명령어다.

현재 DB 상태: notifications 테이블 없음
모델 코드: Notification 클래스 있음
→ 차이 감지 → upgrade()에 create_table 코드 자동 생성

근데 나는 MySQL이 꺼져있는 상태에서 실행했다. 그러다보니:

MySQL 꺼져있음
→ alembic revision --autogenerate 실행
→ DB 연결 실패
→ DB랑 비교를 못함
→ upgrade() 함수가 비어있는 파일만 생성됨
→ alembic upgrade head 해도 아무것도 안됨

올바른 마이그레이션 파일

# ❌ 내가 만든 파일 (비어있음)
def upgrade():
    pass

def downgrade():
    pass

# ✅ 올바른 파일
def upgrade():
    op.create_table('notifications',
        sa.Column('id', sa.Integer(), nullable=False),
        sa.Column('user_id', sa.Integer(), nullable=False),
        sa.Column('message', sa.String(500), nullable=False),
        sa.Column('type', sa.String(50), nullable=False),
        sa.Column('is_read', sa.Boolean(), nullable=False),
        sa.Column('created_at', sa.DateTime(), nullable=True),
    )

def downgrade():
    op.drop_table('notifications')

앞으로는 이렇게

1. MySQL 먼저 켜기 ← 핵심!
2. alembic revision --autogenerate -m "설명"
3. 생성된 파일 열어서 upgrade() 안에 코드 있는지 확인 ← 필수!
4. alembic upgrade head

upgrade() 함수가 비어있으면 MySQL이 꺼져있었던 것!

실수 2 - 라우터 순서를 잘못 선언했다

무슨 일이 있었나?

알림 전체 읽음 처리 API(PATCH /read-all)를 호출하면 422 에러가 발생했다.

원인

FastAPI는 라우터를 위에서 아래로 순서대로 매칭한다.

# ❌ 내가 작성한 잘못된 순서
@router.patch("/{notification_id}")  # 변수 경로 먼저
@router.patch("/read-all")           # 고정 경로 나중에

/read-all 요청이 오면 FastAPI가 위에서부터 확인하는데, read-all이 {notification_id} 자리에 들어갈 수 있다고 판단해버린다. 그래서 /read-all 까지 못 가고 /{notification_id}에서 걸려 422 에러가 발생한 것이다.

# ✅ 올바른 순서
@router.patch("/read-all")           # 고정 경로 먼저
@router.patch("/{notification_id}")  # 변수 경로 나중에

규칙

고정 경로는 항상 변수 경로보다 위에 선언해야 한다!

오늘 배운 것들

HTTP 메서드

알림 읽음 처리에 PATCH를 쓰는 이유

읽음 처리는 is_read 필드 하나만 False → True로 바꾸는 것이기 때문에 일부 수정인 PATCH가 적합하다. PUT을 쓰면 모든 필드를 다 보내야 하지만 PATCH는 변경할 필드만 보내면 된다.

마치며

개발도 처음, FastAPI도 처음인 상태에서 팀 프로젝트에 참여하다 보니 당연히 실수가 있을 수밖에 없다. 중요한 건 같은 실수를 반복하지 않는 것이라고 생각한다.

팀원분이 꼼꼼하게 버그를 잡아주셔서 오히려 덕분에 마이그레이션과 라우터 개념을 확실하게 이해할 수 있었다. 앞으로는 코드를 작성하고 나서 직접 눈으로 확인하는 습관을 들여야겠다.

MySQL 먼저 켜고, 마이그레이션 파일 열어서 확인하고, 고정 경로는 변수 경로보다 위에!

캡스톤디자인 프로젝트 - 2026.04.14

마당서점 데이터베이스를 이용한 SQL 기초 쿼리 연습

📦 사용 테이블

Book

Orders

Customer

01 고객 요구 질문

1.1 도서번호가 1인 도서의 이름

SELECT bookname FROM book
WHERE bookid = 1;

1.2 가격이 20,000원 이상인 도서의 이름

SELECT bookname FROM book
WHERE price >= 20000;

1.3 박지성의 총구매액

SELECT SUM(saleprice) FROM orders
WHERE custid = 1;

박지성의 custid를 모를 경우 서브쿼리 사용

SELECT SUM(saleprice) FROM orders
WHERE custid = (SELECT custid FROM customer WHERE name = '박지성');

1.4 박지성이 구매한 도서의 수

SELECT COUNT(*) FROM orders
WHERE custid = 1;

1.5 박지성이 구매한 도서의 출판사 수

SELECT COUNT(DISTINCT b.publisher)
FROM orders o JOIN book b ON o.bookid = b.bookid
WHERE o.custid IN (SELECT custid FROM customer WHERE name = '박지성');

= vs IN 차이

• = : 서브쿼리 결과가 1개일 때만 사용 가능, 2개 이상이면 오류
• IN : 결과가 여러 개여도 정상 작동 → 동명이인 등을 고려하면 IN이 더 안전

1.6 박지성이 구매한 도서의 이름, 가격, 정가와 판매가격의 차이

SELECT b.bookname, b.price, o.saleprice, (b.price - o.saleprice) AS difference
FROM orders o JOIN book b ON o.bookid = b.bookid
WHERE o.custid IN (SELECT custid FROM customer WHERE name = '박지성');

1.7 박지성이 구매하지 않은 도서의 이름

SELECT bookname
FROM book
WHERE bookid NOT IN (
    SELECT bookid FROM orders
    WHERE custid IN (SELECT custid FROM customer WHERE name = '박지성')
);

⚠️ 주의: FROM orders JOIN book으로 시작하면 안 됨

• "박지성이 구매하지 않은 도서" → 기준이 전체 도서(book)
• FROM book에서 시작해서 박지성의 주문 목록을 NOT IN으로 제외해야 함
• FROM orders로 시작하면 "다른 사람들이 주문한 책"이 나와버려 결과가 틀림

02 운영자·경영자 요구 질문

2.1 마당서점 도서의 총개수

SELECT COUNT(*) FROM book;

2.2 마당서점에 도서를 출고하는 출판사의 총개수

SELECT COUNT(DISTINCT publisher) FROM book;

DISTINCT 없이 쓰면 중복 출판사가 여러 번 카운트됨

2.3 모든 고객의 이름, 주소

SELECT name, address FROM customer;

2.4 2024년 7월 4일~7월 7일 사이에 주문받은 도서의 주문번호

SELECT orderid FROM orders
WHERE orderdate BETWEEN '2024-07-04' AND '2024-07-07';

⚠️ IN ('2024-07-04', '2024-07-07')은 4일과 7일만 조회됨, 사이 날짜 누락

2.5 2024년 7월 4일~7월 7일 사이에 주문받은 도서를 제외한 도서의 주문번호

SELECT orderid FROM orders
WHERE orderdate NOT BETWEEN '2024-07-04' AND '2024-07-07';

2.6 성이 '김' 씨인 고객의 이름과 주소

SELECT name, address FROM customer
WHERE name LIKE '김%';

2.7 성이 '김' 씨이고 이름이 '아'로 끝나는 고객의 이름과 주소

SELECT name, address FROM customer
WHERE name LIKE '김%아';

⚠️ '김_아'는 이름이 3글자(김X아)인 경우만 해당됨

• _ : 딱 1글자만 대체
• % : 0글자 이상 대체 → 4글자 이상 이름도 포함

2.8 주문하지 않은 고객의 이름 (부속질의 사용)

SELECT name FROM customer
WHERE custid NOT IN (SELECT custid FROM orders);

2.9 주문 금액의 총액과 주문의 평균 금액

SELECT SUM(saleprice) AS 총액, AVG(saleprice) AS 평균금액
FROM orders;

2.10 고객의 이름과 고객별 구매액

SELECT c.name, SUM(o.saleprice) AS 구매액
FROM customer c JOIN orders o ON c.custid = o.custid
GROUP BY c.custid, c.name;

"고객별" 이라는 단어가 나오면 GROUP BY 사용

GROUP BY c.custid, c.name 으로 쓰는 이유: 동명이인이 있을 경우 이름만으로 묶으면 합산될 수 있어서 custid를 함께 명시하는 것이 안전

2.11 고객의 이름과 고객이 구매한 도서 목록

SELECT c.name, b.bookname
FROM customer c
JOIN orders o ON c.custid = o.custid
JOIN book b ON o.bookid = b.bookid;

customer와 book은 직접 연결되는 컬럼이 없음 orders가 중간 테이블 역할 → JOIN을 두 번 해야 함

customer --- orders --- book
   custid      custid
               bookid   bookid

2.12 도서의 가격(Book)과 판매가격(Orders)의 차이가 가장 많은 주문

SELECT b.bookname, b.price, o.saleprice, (b.price - o.saleprice) AS difference
FROM book b JOIN orders o ON b.bookid = o.bookid
WHERE (b.price - o.saleprice) = (
    SELECT MAX(b.price - o.saleprice)
    FROM book b JOIN orders o ON b.bookid = o.bookid
);

MAX()만 쓰면 최댓값 숫자만 나옴 해당 주문 정보 전체를 가져오려면 서브쿼리로 최댓값을 구한 뒤 WHERE로 해당 행을 찾아야 함

2.13 도서의 판매액 평균보다 자신의 구매액 평균이 더 높은 고객의 이름

SELECT c.name
FROM customer c JOIN orders o ON c.custid = o.custid
GROUP BY c.custid, c.name
HAVING AVG(o.saleprice) > (SELECT AVG(saleprice) FROM orders);

WHERE vs HAVING

구분	사용 위치
일반 조건	WHERE
집계함수 조건	HAVING

HAVING은 항상 GROUP BY 뒤에 위치

💡 핵심 개념 정리

FROM 테이블 선택 기준

핵심: "무엇을" 조회하는지가 FROM/기준 테이블을 결정한다

LIKE 패턴

집계함수와 GROUP BY

• COUNT(*) : NULL 포함 전체 행 수
• COUNT(컬럼) : NULL 제외 행 수
• COUNT(DISTINCT 컬럼) : 중복 제외 고유값 수
• 집계함수 조건은 반드시 HAVING 사용

서브쿼리

-- 단일 결과 → = 사용 가능
WHERE custid = (SELECT custid FROM customer WHERE name = '박지성')

-- 복수 결과 가능성 → IN 사용 권장
WHERE custid IN (SELECT custid FROM customer WHERE name = '박지성')

📥 입력 방법

기본 입력 - map()

# 공백으로 구분된 여러 데이터 입력받기
data = list(map(int, input().split()))

# 개수가 적은 경우 변수에 바로 할당
a, b, c = map(int, input().split())

빠른 입력 - sys.stdin.readline()

입력 데이터가 많을 때 input() 대신 사용. 엔터가 줄 바꿈 기호로 포함되므로 rstrip() 필수!

import sys

data = sys.stdin.readline().rstrip()
print(data)

🖨️ 출력 방법

f-string (Python 3.6+)

문자열 앞에 f를 붙이고 중괄호 안에 변수명을 넣어 간편하게 출력

answer = 7
print(f"정답은 {answer}입니다.")

🔧 유용한 문법

in / not in 연산자

리스트, 튜플, 문자열, 딕셔너리 모두에서 사용 가능

a = [1, 2, 3]
print(3 in a)      # True
print(5 not in a)  # True

조건문 간소화 (삼항 연산자)

score = 85
result = "Success" if score >= 80 else "Fail"
print(result)  # Success

global 키워드

함수 내부에서 외부 변수를 직접 참조할 때 사용

a = 0

def func():
    global a
    a += 1

for i in range(10):
    func()

print(a)  # 10

여러 개의 반환값

파이썬 함수는 여러 값을 동시에 반환할 수 있다 (튜플로 반환됨)

def operator(a, b):
    return a + b, a - b, a * b, a / b

a, b, c, d = operator(7, 3)
print(a, b, c, d)  # 10 4 21 2.333...

⚡ 람다 표현식 (Lambda)

함수를 한 줄로 간결하게 표현

# 일반 함수
def add(a, b):
    return a + b

# 람다 표현식
print((lambda a, b: a + b)(3, 7))  # 10

sorted()와 함께 사용

array = [('홍길동', 50), ('이순신', 32), ('아무개', 74)]

# 두 번째 원소(점수)를 기준으로 정렬
print(sorted(array, key=lambda x: x[1]))
# [('이순신', 32), ('홍길동', 50), ('아무개', 74)]

map()과 함께 여러 리스트에 적용

list1 = [1, 2, 3, 4, 5]
list2 = [6, 7, 8, 9, 10]

result = list(map(lambda a, b: a + b, list1, list2))
print(result)  # [7, 9, 11, 13, 15]

📚 자주 쓰는 내장 함수

# sum() - 합계
print(sum([1, 2, 3, 4, 5]))  # 15

# min(), max() - 최솟값, 최댓값
print(min(7, 3, 5, 2))  # 2
print(max(7, 3, 5, 2))  # 7

# eval() - 문자열 수식 계산
print(eval("(3+5)*7"))  # 56

# sorted() - 정렬 (원본 변경 없음)
print(sorted([9, 1, 8, 5, 4]))              # [1, 4, 5, 8, 9]
print(sorted([9, 1, 8, 5, 4], reverse=True))  # [9, 8, 5, 4, 1]

# sorted() with key
array = [('홍길동', 35), ('이순신', 75), ('아무개', 50)]
result = sorted(array, key=lambda x: x[1], reverse=True)
print(result)
# [('이순신', 75), ('아무개', 50), ('홍길동', 35)]

🗂️ 실전 표준 라이브러리

🔀 순열과 조합 (itertools)

순열 (permutations)

from itertools import permutations

data = ['A', 'B', 'C']
result = list(permutations(data, 3))
print(result)
# [('A','B','C'), ('A','C','B'), ('B','A','C'),
#  ('B','C','A'), ('C','A','B'), ('C','B','A')]

조합 (combinations)

from itertools import combinations

data = ['A', 'B', 'C']
result = list(combinations(data, 2))
print(result)
# [('A', 'B'), ('A', 'C'), ('B', 'C')]

중복 순열 (product)

from itertools import product

data = ['A', 'B', 'C']
result = list(product(data, repeat=2))
print(result)
# [('A','A'), ('A','B'), ('A','C'),
#  ('B','A'), ('B','B'), ('B','C'),
#  ('C','A'), ('C','B'), ('C','C')]

중복 조합 (combinations_with_replacement)

from itertools import combinations_with_replacement

data = ['A', 'B', 'C']
result = list(combinations_with_replacement(data, 2))
print(result)
# [('A','A'), ('A','B'), ('A','C'),
#  ('B','B'), ('B','C'), ('C','C')]

🧮 collections - Counter

리스트 내 원소의 등장 횟수를 자동으로 카운팅

from collections import Counter

counter = Counter(['red', 'blue', 'red', 'green', 'blue', 'blue'])

print(counter['blue'])   # 3
print(counter['green'])  # 1
print(dict(counter))     # {'red': 2, 'blue': 3, 'green': 1}

➗ math - 최대공약수 & 최소공배수

import math

def lcm(a, b):
    return a * b // math.gcd(a, b)

a, b = 21, 14

print(math.gcd(a, b))  # 최대공약수(GCD): 7
print(math.lcm(a, b))       # 최소공배수(LCM): 42

💡 Python 3.9부터는 math.lcm(a, b)로 바로 사용 가능!

📌 알고리즘 설계 Tip

언어별 연산 속도 기준

연산 횟수가 5억을 넘어가는 경우, C언어 기준 13초, Python 기준 515초 소요
코딩 테스트의 시간제한은 보통 1~5초. 명시되지 않은 경우 5초로 가정하자.

n의 범위에 따른 시간 복잡도 기준 (시간제한 1초)

알고리즘 문제 해결 과정

1. 지문 읽기 및 컴퓨터적 사고
2. 요구사항(복잡도) 분석
3. 문제 해결을 위한 아이디어 찾기
4. 소스코드 설계 및 코딩

💡 핵심 아이디어를 캐치하면 코드는 간결해진다. 문제에서 가장 먼저 시간제한을 확인하자!

수행 시간 측정 코드

import time

start_time = time.time()  # 측정 시작

# 프로그램 소스코드

end_time = time.time()    # 측정 종료
print("time:", end_time - start_time)  # 수행 시간 출력

📦 파이썬 자료형

1. 실수형 (Float)

실수형은 부동소수점 오차가 있으므로 비교 시 round() 를 사용하자.

a = 0.3 + 0.6
print(round(a, 4))  # 0.9

if round(a, 4) == 0.9:
    print(True)
else:
    print(False)

2. 리스트 (List)

인덱싱 & 슬라이싱

끝 인덱스는 실제보다 1 크게 설정한다.

a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(a[1:4])  # [2, 3, 4]

리스트 컴프리헨션

# 0부터 9까지
array = [i for i in range(10)]

# 0~19 중 홀수만
array = [i for i in range(20) if i % 2 == 1]

# 1~9의 제곱값
array = [i * i for i in range(1, 10)]

2차원 리스트 초기화

# ✅ 올바른 방법
array = [[0] * m for _ in range(n)]

# ❌ 잘못된 방법 (모든 행이 같은 객체를 참조함)
array = [[0] * m] * n

리스트 주요 메서드

a = [1, 4, 3]

a.append(2)           # [1, 4, 3, 2]
a.sort()              # [1, 2, 3, 4]
a.sort(reverse=True)  # [4, 3, 2, 1]
a.reverse()           # [1, 2, 3, 4]
a.insert(2, 3)        # [1, 2, 3, 3, 4]
a.count(3)            # 2
a.remove(1)           # [2, 3, 3, 4]

특정 값 원소 모두 제거하기

a = [1, 2, 3, 4, 5, 5, 5]
remove_set = {3, 5}

result = [i for i in a if i not in remove_set]
print(result)  # [1, 2, 4]

3. 문자열 (String)

• + : 문자열 연결
• * : 문자열 반복
• 인덱싱/슬라이싱 가능, 단 Immutable (특정 인덱스 값 변경 불가)

a = "Hello"
b = "World"
print(a + " " + b)  # Hello World

a = "String"
print(a * 3)        # StringStringString

a = "ABCDEF"
print(a[2:4])       # CD

4. 튜플 (Tuple)

리스트와 유사하지만 변경 불가(Immutable), 소괄호 () 사용

a = (1, 2, 3, 4, 5, 6, 7, 8, 9)

print(a[3])    # 4
print(a[1:4])  # (2, 3, 4)
# a[2] = 7  ← 오류 발생!

튜플을 사용하면 좋은 경우

• 서로 다른 성질의 데이터를 묶을 때 → ex. (비용, 노드번호) 형태로 최단경로 알고리즘에서 활용
• 해싱의 키(key) 로 사용해야 할 때 (리스트는 키로 사용 불가)
• 메모리를 더 효율적으로 사용해야 할 때

5. 사전 자료형 (Dictionary)

• 키(key) - 값(value) 쌍으로 데이터 저장
• 해시 테이블 기반 → 조회 및 수정 O(1)
• 키는 Immutable 자료형만 사용 가능

data = dict()
data['사과'] = 'Apple'
data['바나나'] = 'Banana'
data['코코넛'] = 'Coconut'

print(data)  # {'사과': 'Apple', '바나나': 'Banana', '코코넛': 'Coconut'}

if '사과' in data:
    print("'사과'를 키로 가지는 데이터가 존재합니다.")

# 키/값 리스트 추출
key_list = data.keys()
value_list = data.values()

for key in key_list:
    print(data[key])

# 딕셔너리 선언 방법
b = {
    '홍길동': 97,
    '이순신': 98
}

print(b['이순신'])           # 98
print(list(b.keys()))       # ['홍길동', '이순신']

6. 집합 자료형 (Set)

• 중복 허용 X, 순서 없음
• 조회 및 수정 O(1)

a = set([1, 2, 3, 4, 5])
b = set([3, 4, 5, 6, 7])

print(a | b)  # 합집합: {1, 2, 3, 4, 5, 6, 7}
print(a & b)  # 교집합: {3, 4, 5}
print(a - b)  # 차집합: {1, 2}

data = set([1, 2, 3])

data.add(4)         # 원소 하나 추가
data.update([5, 6]) # 원소 여러 개 추가
data.remove(3)      # 특정 원소 삭제

🔑 자료형 핵심 정리

사전과 집합은 순서가 없어 인덱싱 불가. 대신 O(1) 의 빠른 조회 속도가 장점!

1. SQL JOIN

두 개의 테이블을 공통 컬럼을 기준으로 연결해서 조회하는 기능입니다.

예시

User 테이블:

ToDo 테이블:

JOIN 쿼리:

SELECT u.username, t.contents
FROM user u
JOIN todo t ON u.id = t.user_id;

결과:

user.id = todo.user_id 라는 공통 컬럼을 기준으로 두 테이블을 연결합니다.

2. User 모델링

ORM 클래스 → SQL 변환 확인 (Python 콘솔)

from sqlalchemy.schema import CreateTable
from database.orm import ToDo
from database.connection import engine

# ORM 클래스가 어떤 SQL CREATE TABLE로 변환되는지 확인
print(CreateTable(ToDo.__table__).compile(engine))

출력 결과:

CREATE TABLE todo (
    id INTEGER NOT NULL AUTO_INCREMENT,
    contents VARCHAR(256) NOT NULL,
    is_done BOOL NOT NULL,
    PRIMARY KEY (id)
)

database/orm.py — User 모델 추가

from sqlalchemy import Boolean, Column, Integer, String, ForeignKey
from sqlalchemy.orm import declarative_base, relationship
from schema.request import CreateToDoRequest

Base = declarative_base()

class ToDo(Base):
    __tablename__ = "todo"

    id = Column(Integer, primary_key=True, index=True)
    contents = Column(String(256), nullable=False)
    is_done = Column(Boolean, nullable=False)
    # ForeignKey: todo.user_id가 user.id를 참조함 (외래키 설정)
    user_id = Column(Integer, ForeignKey("user.id"))

    def __repr__(self):
        return f"ToDo(id={self.id}, contents={self.contents}, is_done={self.is_done})"

    @classmethod
    def create(cls, request: CreateToDoRequest) -> "ToDo":
        return cls(
            contents=request.contents,
            is_done=request.is_done,
        )

    def done(self) -> "ToDo":
        self.is_done = True
        return self

    def undone(self) -> "ToDo":
        self.is_done = False
        return self


class User(Base):
    __tablename__ = "user"

    id = Column(Integer, primary_key=True, index=True)
    username = Column(String(256), nullable=False)
    password = Column(String(256), nullable=False)

    # relationship: User 객체에서 user.todos로 연관된 ToDo 목록에 바로 접근 가능
    # lazy="joined": Eager Loading 방식 (User 조회 시 ToDo도 함께 JOIN해서 가져옴)
    todos = relationship("ToDo", lazy="joined")

    @classmethod
    def create(cls, username: str, hashed_password: str) -> "User":
        return cls(
            username=username,
            password=hashed_password,
        )

3. User 테이블 생성 (MySQL DDL)

-- Docker MySQL 접속
-- docker exec -it todos bash
-- mysql -u root -p

USE todos;

-- User 테이블 생성
CREATE TABLE user (
    id INTEGER NOT NULL AUTO_INCREMENT,
    username VARCHAR(256) NOT NULL,
    password VARCHAR(256) NOT NULL,
    PRIMARY KEY (id)
);

-- todo 테이블에 user_id 컬럼 추가
ALTER TABLE todo ADD COLUMN user_id INTEGER;

-- 외래키 설정 (todo.user_id → user.id)
ALTER TABLE todo ADD FOREIGN KEY(user_id) REFERENCES user(id);

-- 샘플 유저 삽입
INSERT INTO user(username, password) VALUES ("admin", "password");

-- 기존 todo에 user_id 연결
UPDATE todo SET user_id=1 WHERE id=1;
UPDATE todo SET user_id=1 WHERE id=2;
UPDATE todo SET user_id=1 WHERE id=3;

-- JOIN 확인
SELECT u.username, t.contents, t.is_done
FROM todo t
JOIN user u ON t.user_id = u.id;

4. Lazy Loading vs Eager Loading

데이터를 언제 가져오는지에 대한 전략입니다.

Lazy Loading (지연 로딩)

연관된 데이터가 실제로 필요한 시점에 조회합니다.

• 장점: 첫 조회 속도가 빠름
• 단점: N+1 문제 발생 가능

N+1 문제 예시:

# todos를 조회하는 쿼리 1번 + 각 todo마다 user 조회 N번 = 총 N+1번 쿼리 실행
for todo in todos:
    print(todo.user.username)  # 이 시점마다 DB 조회 발생

Eager Loading (즉시 로딩)

데이터를 조회할 때 처음부터 연관 객체를 JOIN해서 함께 가져옵니다.

• 장점: N+1 문제 방지, 데이터를 효율적으로 가져옴
• 단점: 필요 없는 데이터까지 JOIN해서 가져올 수 있음

# lazy="joined" → Eager Loading 설정
todos = relationship("ToDo", lazy="joined")

ORM JOIN 동작 확인 (Python 콘솔)

from database.connection import SessionFactory
from database.orm import User
from sqlalchemy import select

session = SessionFactory()
user = session.scalar(select(User))

# user.todos로 연관된 ToDo 목록 바로 접근 (이미 JOIN해서 가져왔으므로 추가 쿼리 없음)
user.todos
# [ToDo(id=1, ...), ToDo(id=2, ...), ToDo(id=3, ...)]

5. 회원가입 API

패키지 설치

pip install bcrypt  # 비밀번호 해싱 라이브러리

bcrypt 동작 확인 (Python 콘솔)

import bcrypt

password = "password"
byte_password = password.encode("UTF-8")  # bytes로 변환

# 같은 비밀번호도 매번 다른 해시값이 생성됨 (salt 때문)
hash_1 = bcrypt.hashpw(byte_password, salt=bcrypt.gensalt())
hash_2 = bcrypt.hashpw(byte_password, salt=bcrypt.gensalt())

# 검증은 checkpw로 → 내부적으로 동일한 원문인지 확인
bcrypt.checkpw(byte_password, hash_1)  # True
bcrypt.checkpw(byte_password, hash_2)  # True

bcrypt는 같은 비밀번호도 매번 다른 해시값을 만들기 때문에 단순히 값을 비교하면 안 됩니다. checkpw()로만 검증해야 합니다.

schema/request.py

from pydantic import BaseModel

class CreateToDoRequest(BaseModel):
    contents: str
    is_done: bool

class SignUpRequest(BaseModel):
    username: str
    password: str

service/user.py

import bcrypt

class UserService:
    encoding: str = "UTF-8"

    def hash_password(self, plain_password: str) -> str:
        # 문자열 → bytes 변환 후 해싱
        hashed_password: bytes = bcrypt.hashpw(
            plain_password.encode(self.encoding),
            salt=bcrypt.gensalt()  # 매번 랜덤한 salt 생성
        )
        # bytes → 문자열로 변환해서 반환 (DB에 저장하기 위해)
        return hashed_password.decode(self.encoding)

database/repository.py — UserRepository 추가

class UserRepository:
    def __init__(self, session: Session = Depends(get_db)):
        self.session = session

    def save_user(self, user: User) -> User:
        self.session.add(instance=user)
        self.session.commit()           # DB 저장
        self.session.refresh(instance=user)  # 자동 생성된 id 반영
        return user

schema/response.py — UserSchema 추가

class UserSchema(BaseModel):
    id: int
    username: str  # password는 보안상 응답에 포함하지 않음

    class Config:
        from_attributes = True

api/user.py — 회원가입 핸들러

from fastapi import APIRouter, Depends
from database.orm import User
from database.repository import UserRepository
from schema.response import UserSchema
from schema.request import SignUpRequest
from service.user import UserService

router = APIRouter(prefix="/users")

@router.post("/sign-up", status_code=201)
def user_sign_up_handler(
    request: SignUpRequest,
    user_service: UserService = Depends(),
    user_repo: UserRepository = Depends(),
):
    # 1. 요청에서 username, password 받기
    # 2. 비밀번호 해싱
    hashed_password: str = user_service.hash_password(
        plain_password=request.password
    )
    # 3. User 객체 생성 (id=None, DB 저장 전)
    user: User = User.create(
        username=request.username,
        hashed_password=hashed_password,
    )
    # 4. DB에 저장 (id=int, DB 저장 후)
    user: User = user_repo.save_user(user=user)
    # 5. id, username만 반환 (password 제외)
    return UserSchema.from_orm(user)

회원가입 테스트

from service.user import UserService
from database.orm import User
from database.repository import UserRepository

def test_user_sign_up(client, mocker):
    # hash_password를 mock으로 교체 → "hashed" 문자열 반환
    hash_password = mocker.patch.object(
        UserService,
        "hash_password",
        return_value="hashed"
    )
    # User.create를 mock으로 교체 → id=None인 User 반환
    user_create = mocker.patch.object(
        User,
        "create",
        return_value=User(id=None, username="test", password="hashed")
    )
    # save_user를 mock으로 교체 → id=1인 User 반환 (DB 저장 후 상태)
    mocker.patch.object(
        UserRepository,
        "save_user",
        return_value=User(id=1, username="test", password="hashed")
    )

    body = {"username": "test", "password": "plain"}
    response = client.post("/users/sign-up", json=body)

    # hash_password가 plain 비밀번호로 호출됐는지 검증
    hash_password.assert_called_once_with(plain_password="plain")
    # User.create가 올바른 인자로 호출됐는지 검증
    user_create.assert_called_once_with(username="test", hashed_password="hashed")

    assert response.status_code == 201
    assert response.json() == {"id": 1, "username": "test"}

6. 로그인 API & JWT 인증

JWT란?

JWT(JSON Web Token) 는 사용자 인증에 사용되는 JSON 포맷의 토큰입니다.

장점:

• 토큰 자체에 유저 정보가 담겨 있어 별도의 DB 조회 없이 인증 처리 가능
• 토큰 변조를 검증할 수 있어 내장 데이터를 신뢰 가능
• 토큰에 만료 시간 설정 가능

인증 절차

클라이언트                         서버
    │                               │
    │──── id & password ──────────▶│
    │                          id&password 검증
    │                          JWT 생성
    │◀─── JWT 반환(access_token) ───│
    │                               │
    │ JWT 저장 (localStorage 등)    │
    │                               │
    │──── API 요청 (헤더: JWT) ───▶│
    │                          JWT 검증
    │◀─── 응답 ─────────────────────│

패키지 설치

pip install python-jose  # JWT 생성 및 검증 라이브러리

Secret Key 생성

# 터미널에서 랜덤한 비밀 키 생성
openssl rand -hex 32
# 출력 예: 8db9665caeab0ead6ebdf79150b7e4976a62e11e8cb15779fe06b64834b36dea

이 키는 JWT를 서명하고 검증하는 데 사용됩니다. 절대 외부에 노출하면 안 됩니다.

service/user.py — JWT 관련 메서드 추가

import bcrypt
from datetime import datetime, timedelta
from jose import jwt

class UserService:
    encoding: str = "UTF-8"
    secret_key: str = "8db9665caeab0ead6ebdf79150b7e4976a62e11e8cb15779fe06b64834b36dea"
    jwt_algorithm: str = "HS256"  # 서명 알고리즘

    def hash_password(self, plain_password: str) -> str:
        hashed_password: bytes = bcrypt.hashpw(
            plain_password.encode(self.encoding),
            salt=bcrypt.gensalt()
        )
        return hashed_password.decode(self.encoding)

    def verify_password(self, plain_password: str, hashed_password: str) -> bool:
        # 입력한 비밀번호와 DB의 해시값을 비교
        return bcrypt.checkpw(
            plain_password.encode(self.encoding),
            hashed_password.encode(self.encoding)
        )

    def create_jwt(self, username: str) -> str:
        return jwt.encode(
            {
                "sub": username,       # 토큰의 주체 (유저 식별자)
                "exp": datetime.now() + timedelta(days=1)  # 만료 시간: 1일
            },
            self.secret_key,
            algorithm=self.jwt_algorithm
        )

    def decode_jwt(self, access_token: str) -> str:
        # 토큰을 복호화해서 payload(dict)를 꺼냄
        payload: dict = jwt.decode(
            access_token,
            self.secret_key,
            algorithms=[self.jwt_algorithm]
        )
        # sub 필드에서 username 반환
        return payload["sub"]

database/repository.py — get_user_by_username 추가

class UserRepository:
    def __init__(self, session: Session = Depends(get_db)):
        self.session = session

    def get_user_by_username(self, username: str) -> User | None:
        # username으로 유저 조회
        return self.session.scalar(
            select(User).where(User.username == username)
        )

    def save_user(self, user: User) -> User:
        self.session.add(instance=user)
        self.session.commit()
        self.session.refresh(instance=user)
        return user

schema/response.py — JWTResponse 추가

class JWTResponse(BaseModel):
    access_token: str  # 로그인 성공 시 반환할 JWT 토큰

api/user.py — 로그인 핸들러 추가

@router.post("/login-in")
def user_login_handler(
    request: LoginRequest,
    user_service: UserService = Depends(),
    user_repo: UserRepository = Depends(),
):
    # 1. username으로 DB에서 유저 조회
    user: User | None = user_repo.get_user_by_username(username=request.username)
    if not user:
        raise HTTPException(status_code=404, detail="User Not Found")

    # 2. 입력한 비밀번호와 DB의 해시 비밀번호 비교
    verified: bool = user_service.verify_password(
        plain_password=request.password,
        hashed_password=user.password,
    )
    if not verified:
        raise HTTPException(status_code=401, detail="Not Authorized")

    # 3. JWT 생성
    access_token: str = user_service.create_jwt(username=user.username)

    # 4. JWT 반환
    return JWTResponse(access_token=access_token)

7. JWT 인증 적용

로그인 이후 API 요청 시 JWT 토큰을 헤더에 담아 보내고, 서버에서 검증합니다.

security.py

from fastapi import HTTPException, Depends
from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer

def get_access_token(
    # HTTPBearer: Authorization 헤더에서 Bearer 토큰을 자동으로 파싱
    # auto_error=False: 토큰이 없어도 에러를 자동으로 내지 않고 None 반환
    auth_header: HTTPAuthorizationCredentials | None = Depends(HTTPBearer(auto_error=False))
) -> str:
    if auth_header is None:
        raise HTTPException(
            status_code=401,
            detail="Not Authorized",
        )
    return auth_header.credentials  # Bearer 뒤의 실제 토큰 문자열 반환

api/todo.py — GET 전체 조회에 JWT 인증 적용

@router.get("", status_code=200)
def get_todos_handler(
    access_token: str = Depends(get_access_token),  # JWT 토큰 검증
    order: str | None = None,
    user_service: UserService = Depends(),
    user_repo: UserRepository = Depends(),
) -> ToDoListSchema:
    # 토큰에서 username 추출
    username: str = user_service.decode_jwt(access_token=access_token)

    # username으로 유저 조회
    user: User | None = user_repo.get_user_by_username(username=username)
    if not user:
        raise HTTPException(status_code=404, detail="User Not Found")

    # Eager Loading으로 이미 가져온 todos 사용 (추가 DB 조회 없음)
    todos: List[ToDo] = user.todos

    if order and order == "DESC":
        return ToDoListSchema(
            todos=[ToDoSchema.from_orm(todo) for todo in todos[::-1]]
        )
    return ToDoListSchema(
        todos=[ToDoSchema.from_orm(todo) for todo in todos]
    )

테스트 코드 변경 — JWT 헤더 추가

def test_get_todos(client, mocker):
    # 실제 JWT를 생성해서 테스트 헤더에 포함
    access_token: str = UserService().create_jwt(username="test")
    headers = {"Authorization": f"Bearer {access_token}"}

    # 유저 객체에 todos를 직접 할당 (Eager Loading 시뮬레이션)
    user = User(id=1, username="test", password="hashed")
    user.todos = [
        ToDo(id=1, contents="FastAPI Section 0", is_done=True),
        ToDo(id=2, contents="FastAPI Section 1", is_done=False),
    ]

    mocker.patch.object(
        UserRepository,
        "get_user_by_username",
        return_value=user
    )

    # 헤더에 JWT 포함해서 요청
    response = client.get("/todos", headers=headers)
    assert response.status_code == 200
    assert response.json() == {
        "todos": [
            {"id": 1, "contents": "FastAPI Section 0", "is_done": True},
            {"id": 2, "contents": "FastAPI Section 1", "is_done": False},
        ]
    }

    response = client.get("/todos?order=DESC", headers=headers)
    assert response.status_code == 200
    assert response.json() == {
        "todos": [
            {"id": 2, "contents": "FastAPI Section 1", "is_done": False},
            {"id": 1, "contents": "FastAPI Section 0", "is_done": True},
        ]
    }

8. 캐싱 & OTP

캐싱(Caching)이란?

데이터를 임시 저장소에 저장해서 빠르게 조회하는 기술입니다.

OTP(One-Time Password)란?

일회용 비밀번호로, 캐싱의 대표적인 활용 사례입니다.

• 이메일 인증 시 4자리 랜덤 숫자 생성
• Redis에 {email: otp} 형태로 저장
• 3분 후 자동 만료

Redis란?

캐싱에 자주 사용되는 key-value 데이터 스토어 (NoSQL의 일종)

pip install redis

Redis 동작 확인 (Python 콘솔)

import redis

redis_client = redis.Redis(
    host="127.0.0.1", port=6379, db=0,
    encoding="UTF-8", decode_responses=True
)

redis_client.set("key", "value")   # 저장
redis_client.get("key")            # 조회 → 'value'
redis_client.expire("key", 10)     # 10초 후 만료 설정

cache.py

import redis

redis_client = redis.Redis(
    host="127.0.0.1",
    port=6379,
    db=0,
    encoding="utf-8",
    decode_responses=True  # bytes가 아닌 str로 반환
)

service/user.py — OTP 생성 메서드 추가

import random

@staticmethod
def create_otp() -> int:
    # 1000~9999 사이의 랜덤 4자리 숫자 반환
    return random.randint(1000, 9999)

schema/request.py — OTP 요청 모델 추가

class CreateOTPRequest(BaseModel):
    email: str

class VerifyOTPRequest(BaseModel):
    email: str
    otp: int

9. OTP 생성 & 검증 API

api/user.py — OTP 관련 핸들러

from schema.request import CreateOTPRequest, VerifyOTPRequest
from cache import redis_client

# OTP 생성 API
# POST /users/email/otp
@router.post("/email/otp")
def create_otp_handler(
    request: CreateOTPRequest,
    _: str = Depends(get_access_token),   # 로그인한 유저만 접근 가능 (토큰 검증만 하고 값은 사용 안 함)
    user_service: UserService = Depends(),
):
    # 1. 4자리 OTP 생성
    otp: int = user_service.create_otp()

    # 2. Redis에 저장 (key: email, value: otp, 만료: 3분)
    redis_client.set(request.email, otp)
    redis_client.expire(request.email, 3 * 60)

    # 3. 실제 서비스에서는 이메일로 전송, 현재는 응답으로 반환
    return {"otp": otp}


# OTP 검증 API
# POST /users/email/otp/verify
@router.post("/email/otp/verify")
def verify_otp_handler(
    request: VerifyOTPRequest,
    access_token: str = Depends(get_access_token),
    user_service: UserService = Depends(),
    user_repo: UserRepository = Depends(),
):
    # 1. Redis에서 해당 이메일의 OTP 조회
    otp: str | None = redis_client.get(request.email)

    if not otp:
        # Redis에 OTP가 없음 = 만료됐거나 요청하지 않은 이메일
        raise HTTPException(status_code=400, detail="Bad Request")

    if request.otp != int(otp):
        # 입력한 OTP가 저장된 OTP와 다름
        raise HTTPException(status_code=400, detail="Bad Request")

    # 2. 토큰에서 username 추출 후 유저 조회
    username: str = user_service.decode_jwt(access_token=access_token)
    user: User | None = user_repo.get_user_by_username(username)
    if not user:
        raise HTTPException(status_code=404, detail="User Not Found")

    # 3. 이메일 저장 (실제 구현은 생략)
    return UserSchema.from_orm(user)

_: str = Depends(get_access_token) : 토큰 검증만 하고 값은 사용하지 않겠다는 의미로 변수명을 _로 씁니다.

10. Background Task (백그라운드 작업)

이메일 전송처럼 시간이 오래 걸리는 작업을 응답 이후에 백그라운드에서 처리하는 기능입니다.

일반 처리 vs 백그라운드 처리

# 일반 처리 (응답이 느림)
요청 → OTP 검증 → 이메일 전송(10초) → 응답

# 백그라운드 처리 (응답이 빠름)
요청 → OTP 검증 → 응답
                 → 이메일 전송(10초, 백그라운드에서 별도 처리)

api/user.py — Background Task 적용

from fastapi import BackgroundTasks

@router.post("/email/otp/verify")
def verify_otp_handler(
    request: VerifyOTPRequest,
    background_tasks: BackgroundTasks,   # FastAPI가 자동으로 주입해주는 백그라운드 작업 큐
    access_token: str = Depends(get_access_token),
    user_service: UserService = Depends(),
    user_repo: UserRepository = Depends(),
):
    otp: str | None = redis_client.get(request.email)
    if not otp:
        raise HTTPException(status_code=400, detail="Bad Request")
    if request.otp != int(otp):
        raise HTTPException(status_code=400, detail="Bad Request")

    username: str = user_service.decode_jwt(access_token=access_token)
    user: User | None = user_repo.get_user_by_username(username)
    if not user:
        raise HTTPException(status_code=404, detail="User Not Found")

    # 응답을 먼저 보내고, 이메일 전송은 백그라운드에서 처리
    background_tasks.add_task(
        user_service.send_email_to_user,  # 실행할 함수
        email="admin@fastapi.com"         # 함수에 전달할 인자
    )

    return UserSchema.from_orm(user)

11. 전체 흐름 정리

회원가입
클라이언트 → POST /users/sign-up (username, password)
           → 비밀번호 bcrypt 해싱
           → DB 저장
           → UserSchema 반환 (id, username)

로그인
클라이언트 → POST /users/login-in (username, password)
           → DB에서 유저 조회
           → bcrypt로 비밀번호 검증
           → JWT 생성 (유효기간 1일)
           → JWTResponse(access_token) 반환

인증이 필요한 API 요청
클라이언트 → GET /todos (헤더: Authorization: Bearer {token})
           → JWT 검증 (security.py)
           → 토큰에서 username 추출
           → DB에서 유저 조회
           → 유저의 todos 반환

OTP 이메일 인증
클라이언트 → POST /users/email/otp (email)
           → 4자리 OTP 생성
           → Redis 저장 (만료: 3분)
           → OTP 반환 (실제로는 이메일 전송)

           → POST /users/email/otp/verify (email, otp)
           → Redis에서 OTP 조회 및 검증
           → 이메일 저장
           → 이메일 전송 (Background Task)

12. 핵심 개념 요약

1. FastAPI Router

API가 많아지면 main.py 하나에 모든 코드를 넣으면 관리하기 어렵습니다. Router를 사용하면 API를 기능별로 파일을 분리해서 관리할 수 있습니다.

파일 구조:

src/
├── api/
│   └── todo.py       ← Todo 관련 API를 여기로 분리
├── main.py           ← router만 등록하는 진입점

api/todo.py

from typing import List
from database.connection import get_db
from database.orm import ToDo
from database.repository import get_todos, get_todo_by_todo_id, create_todo, update_todo, delete_todo
from fastapi import Depends, HTTPException, Body, APIRouter
from schema.request import CreateToDoRequest
from schema.response import ToDoListSchema, ToDoSchema
from sqlalchemy.orm import Session

# prefix="/todos" : 이 router의 모든 경로 앞에 /todos가 자동으로 붙음
# 덕분에 각 핸들러에서 "/todos"를 반복해서 쓰지 않아도 됨
router = APIRouter(prefix="/todos")

@router.get("", status_code=200)
def get_todos_handler(
    order: str | None = None,
    session: Session = Depends(get_db),
) -> ToDoListSchema:
    todos: List[ToDo] = get_todos(session=session)
    if order and order == "DESC":
        return ToDoListSchema(
            todos=[ToDoSchema.from_orm(todo) for todo in todos[::-1]]
        )
    return ToDoListSchema(
        todos=[ToDoSchema.from_orm(todo) for todo in todos]
    )

@router.get("/{todo_id}", status_code=200)
def get_todo_handler(
    todo_id: int,
    session: Session = Depends(get_db),
) -> ToDoSchema:
    todo: ToDo | None = get_todo_by_todo_id(session=session, todo_id=todo_id)
    if todo:
        return ToDoSchema.from_orm(todo)
    raise HTTPException(status_code=404, detail="ToDo Not Found")

@router.post("", status_code=201)
def create_todo_handler(
    request: CreateToDoRequest,
    session: Session = Depends(get_db),
) -> ToDoSchema:
    todo: ToDo = ToDo.create(request=request)  # id=None (DB 저장 전)
    todo: ToDo = create_todo(session=session, todo=todo)  # id=int (DB 저장 후)
    return ToDoSchema.from_orm(todo)

@router.patch("/{todo_id}", status_code=200)
def update_todo_handler(
    todo_id: int,
    is_done: bool = Body(..., embed=True),
    session: Session = Depends(get_db),
):
    todo: ToDo | None = get_todo_by_todo_id(session=session, todo_id=todo_id)
    if todo:
        todo.done() if is_done else todo.undone()
        todo: ToDo = update_todo(session=session, todo=todo)
        return ToDoSchema.from_orm(todo)
    raise HTTPException(status_code=404, detail="ToDo Not Found")

@router.delete("/{todo_id}", status_code=204)
def delete_todo_handler(
    todo_id: int,
    session: Session = Depends(get_db),
):
    todo: ToDo | None = get_todo_by_todo_id(session=session, todo_id=todo_id)
    if not todo:
        raise HTTPException(status_code=404, detail="ToDo Not Found")
    delete_todo(session=session, todo_id=todo_id)

main.py (router 등록)

from fastapi import FastAPI
from api.todo import router as todo_router

app = FastAPI()

# main.py에서는 router만 등록
app.include_router(todo_router)

Before vs After:

• Before: @app.get("/todos"), @app.get("/todos/{todo_id}") ... 모두 main.py에
• After: @router.get(""), @router.get("/{todo_id}") ... api/todo.py로 분리

2. 의존성 주입 (Dependency Injection)

개념 이해

Coupling(결합) : 두 컴포넌트가 강하게 연결되어 있으면 하나를 바꿀 때 다른 것도 바꿔야 합니다.

Dependency(의존성) : 한 컴포넌트가 올바르게 동작하기 위해 다른 요소에 의존하는 것입니다.

Dependency Injection(의존성 주입) : 컴포넌트가 직접 의존성을 만들지 않고 외부에서 주입받는 방식입니다.

예시 코드

class Body:
    def __init__(self, color):
        self.color = color

class Car:
    def __init__(self, body):
        # Car가 직접 Body를 만들지 않고, 외부에서 주입받음
        self.body = body

    def drive(self):
        pass

# 외부에서 Body를 만들어 Car에 주입
red_car = Car(body=Body(color='red'))
blue_car = Car(body=Body(color='blue'))

Car가 Body를 직접 생성하지 않기 때문에 색상이 바뀌어도 Car 코드를 수정할 필요가 없습니다. FastAPI에서 Depends()가 바로 이 역할을 합니다.

3. Repository Pattern (레포지토리 패턴)

개념

Repository Pattern 은 데이터를 다루는 부분을 비즈니스 로직과 분리하는 기술입니다.

• DB 조회/저장 같은 구체적인 구현을 캡슐화하여 숨깁니다.
• 비즈니스 로직(API 핸들러)은 데이터가 어디서 오는지 몰라도 됩니다.
• 나중에 DB를 바꿔도 Repository만 수정하면 됩니다.

Before (함수 방식):

# 함수들이 흩어져 있고, session을 매번 직접 넘겨야 함
todos = get_todos(session=session)
todo = get_todo_by_todo_id(session=session, todo_id=todo_id)

After (Repository 클래스 방식):

# 하나의 클래스로 묶여 있고, session 관리도 내부에서 처리
todos = todo_repo.get_todos()
todo = todo_repo.get_todo_by_todo_id(todo_id=todo_id)

database/repository.py

from typing import List
from sqlalchemy import select, delete
from sqlalchemy.orm import Session
from fastapi import Depends
from database.orm import ToDo
from database.connection import get_db

class ToDoRepository:
    def __init__(self, session: Session = Depends(get_db)):
        # FastAPI의 Depends로 세션을 자동 주입받음
        # 직접 세션을 생성하거나 닫을 필요 없음
        self.session = session

    def get_todos(self) -> List[ToDo]:
        return list(self.session.scalars(select(ToDo)))

    def get_todo_by_todo_id(self, todo_id: int) -> ToDo | None:
        return self.session.scalar(select(ToDo).where(ToDo.id == todo_id))

    def create_todo(self, todo: ToDo) -> ToDo:
        self.session.add(instance=todo)
        self.session.commit()           # DB에 저장
        self.session.refresh(instance=todo)  # 저장 후 DB에서 최신 상태 반영 (id 등)
        return todo

    def update_todo(self, todo: ToDo) -> ToDo:
        self.session.add(instance=todo)
        self.session.commit()
        self.session.refresh(instance=todo)
        return todo

    def delete_todo(self, todo_id: int) -> None:
        self.session.execute(delete(ToDo).where(ToDo.id == todo_id))
        self.session.commit()

api/todo.py (Repository 패턴 적용 후)

from typing import List
from database.orm import ToDo
from database.repository import ToDoRepository
from fastapi import Depends, HTTPException, Body, APIRouter
from schema.request import CreateToDoRequest
from schema.response import ToDoListSchema, ToDoSchema

router = APIRouter(prefix="/todos")

@router.get("", status_code=200)
def get_todos_handler(
    order: str | None = None,
    todo_repo: ToDoRepository = Depends(),  # ToDoRepository 자동 생성 및 주입
) -> ToDoListSchema:
    todos: List[ToDo] = todo_repo.get_todos()
    if order and order == "DESC":
        return ToDoListSchema(
            todos=[ToDoSchema.from_orm(todo) for todo in todos[::-1]]
        )
    return ToDoListSchema(
        todos=[ToDoSchema.from_orm(todo) for todo in todos]
    )

@router.get("/{todo_id}", status_code=200)
def get_todo_handler(
    todo_id: int,
    todo_repo: ToDoRepository = Depends(),
) -> ToDoSchema:
    todo: ToDo | None = todo_repo.get_todo_by_todo_id(todo_id=todo_id)
    if todo:
        return ToDoSchema.from_orm(todo)
    raise HTTPException(status_code=404, detail="ToDo Not Found")

@router.post("", status_code=201)
def create_todo_handler(
    request: CreateToDoRequest,
    todo_repo: ToDoRepository = Depends(),
) -> ToDoSchema:
    todo: ToDo = ToDo.create(request=request)       # id=None (DB 저장 전)
    todo: ToDo = todo_repo.create_todo(todo=todo)   # id=int  (DB 저장 후)
    return ToDoSchema.from_orm(todo)

@router.patch("/{todo_id}", status_code=200)
def update_todo_handler(
    todo_id: int,
    is_done: bool = Body(..., embed=True),
    todo_repo: ToDoRepository = Depends(),
):
    todo: ToDo | None = todo_repo.get_todo_by_todo_id(todo_id=todo_id)
    if todo:
        todo.done() if is_done else todo.undone()
        todo: ToDo = todo_repo.update_todo(todo=todo)
        return ToDoSchema.from_orm(todo)
    raise HTTPException(status_code=404, detail="ToDo Not Found")

@router.delete("/{todo_id}", status_code=204)
def delete_todo_handler(
    todo_id: int,
    todo_repo: ToDoRepository = Depends(),
):
    todo: ToDo | None = todo_repo.get_todo_by_todo_id(todo_id=todo_id)
    if not todo:
        raise HTTPException(status_code=404, detail="ToDo Not Found")
    todo_repo.delete_todo(todo_id=todo_id)

Depends() 안에 아무것도 넣지 않으면 FastAPI가 타입 힌트(ToDoRepository)를 보고 자동으로 인스턴스를 생성하고 주입해줍니다.

database/connection.py

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

DATABASE_URL = "mysql+pymysql://root:todos@127.0.0.1:3306/todos"
engine = create_engine(DATABASE_URL, echo=True)
SessionFactory = sessionmaker(autocommit=False, autoflush=False, bind=engine)

def get_db():
    session = SessionFactory()
    try:
        yield session   # 요청 처리 동안 세션 제공
    finally:
        session.close() # 요청이 끝나면 반드시 세션 닫기

4. Repository 패턴 적용 후 테스트 코드

기존에는 mocker.patch("main.get_todos", ...) 처럼 함수 경로를 직접 지정했지만, Repository 패턴 적용 후에는 mocker.patch.object(ToDoRepository, "메서드명", ...) 으로 클래스의 메서드를 mock합니다.

tests/test_main.py

from database.orm import ToDo
from database.repository import ToDoRepository

def test_health_check(client):
    response = client.get("/")
    assert response.status_code == 200
    assert response.json() == {"ping": "pong"}


def test_get_todos(client, mocker):
    # mocker.patch.object(클래스, "메서드명", return_value=가짜데이터)
    # ToDoRepository의 get_todos 메서드를 가짜 데이터로 대체
    mocker.patch.object(ToDoRepository, "get_todos", return_value=[
        ToDo(id=1, contents="FastAPI Section 0", is_done=True),
        ToDo(id=2, contents="FastAPI Section 1", is_done=False),
    ])

    # order=ASC
    response = client.get("/todos")
    assert response.status_code == 200
    assert response.json() == {
        "todos": [
            {"id": 1, "contents": "FastAPI Section 0", "is_done": True},
            {"id": 2, "contents": "FastAPI Section 1", "is_done": False},
        ]
    }

    # order=DESC (순서 반전)
    response = client.get("/todos?order=DESC")
    assert response.status_code == 200
    assert response.json() == {
        "todos": [
            {"id": 2, "contents": "FastAPI Section 1", "is_done": False},
            {"id": 1, "contents": "FastAPI Section 0", "is_done": True},
        ]
    }


def test_get_todo(client, mocker):
    # 200 성공
    mocker.patch.object(
        ToDoRepository,
        "get_todo_by_todo_id",
        return_value=ToDo(id=1, contents="todo", is_done=True),
    )
    response = client.get("/todos/1")
    assert response.status_code == 200
    assert response.json() == {"id": 1, "contents": "todo", "is_done": True}

    # 404 실패 (존재하지 않는 todo)
    mocker.patch.object(
        ToDoRepository,
        "get_todo_by_todo_id",
        return_value=None,
    )
    response = client.get("/todos/1")
    assert response.status_code == 404
    assert response.json() == {"detail": "ToDo Not Found"}


def test_create_todo(client, mocker):
    # ToDo.create가 어떤 값으로 호출됐는지 추적 (실제로 실행은 됨)
    create_spy = mocker.spy(ToDo, "create")

    # DB 저장 함수는 mock으로 대체
    mocker.patch.object(
        ToDoRepository,
        "create_todo",
        return_value=ToDo(id=1, contents="todo", is_done=True),
    )

    body = {"contents": "test", "is_done": False}
    response = client.post("/todos", json=body)

    # DB 저장 전 ToDo.create의 반환값 검증 (이 시점엔 id가 None이어야 함)
    assert create_spy.spy_return.id is None
    assert create_spy.spy_return.contents == "test"
    assert create_spy.spy_return.is_done is False

    # DB 저장 후 응답값 검증 (mock이 반환한 값 기준)
    assert response.status_code == 201
    assert response.json() == {"id": 1, "contents": "todo", "is_done": True}


def test_update_todo(client, mocker):
    # 200 성공
    mocker.patch.object(
        ToDoRepository,
        "get_todo_by_todo_id",
        return_value=ToDo(id=1, contents="todo", is_done=True),
    )

    # ToDo.undone()이 실제로 호출됐는지 검증하기 위해 mock으로 교체
    undone = mocker.patch.object(ToDo, "undone")

    mocker.patch.object(
        ToDoRepository,
        "update_todo",
        return_value=ToDo(id=1, contents="todo", is_done=False),
    )

    response = client.patch("/todos/1", json={"is_done": False})

    # is_done=False이므로 undone()이 정확히 1번 호출됐어야 함
    undone.assert_called_once_with()
    assert response.status_code == 200
    assert response.json() == {"id": 1, "contents": "todo", "is_done": False}

    # 404 실패
    mocker.patch.object(
        ToDoRepository,
        "get_todo_by_todo_id",
        return_value=None,
    )
    response = client.patch("/todos/1", json={"is_done": True})
    assert response.status_code == 404
    assert response.json() == {"detail": "ToDo Not Found"}


def test_delete_todo(client, mocker):
    # 204 성공
    mocker.patch.object(
        ToDoRepository,
        "get_todo_by_todo_id",
        return_value=ToDo(id=1, contents="todo", is_done=True),
    )
    mocker.patch.object(ToDoRepository, "delete_todo", return_value=None)

    response = client.delete("/todos/1")
    assert response.status_code == 204
    # 204 No Content: 응답 본문 없음 → json() 검증 없음

    # 404 실패
    mocker.patch.object(
        ToDoRepository,
        "get_todo_by_todo_id",
        return_value=None,
    )
    response = client.delete("/todos/1")
    assert response.status_code == 404
    assert response.json() == {"detail": "ToDo Not Found"}

5. 전체 흐름 정리

클라이언트 요청
     ↓
main.py (router 등록)
     ↓
api/todo.py (APIRouter) ← 기능별 API 분리
     ↓
ToDoRepository (Depends로 자동 주입) ← DB 로직 캡슐화
     ↓
database/orm.py (ORM 모델)
     ↓
database/connection.py (DB 세션)
     ↓
MySQL

6. 핵심 개념 요약

1. 테스트 코드란?

시스템의 품질과 신뢰성을 검증하기 위한 코드입니다.

장점:

• 코드 변경 → 기능 점검 과정을 자동화하여 반복 작업을 줄이고 생산성 향상
• 시스템에 대한 안정성 확신 → 유연한 코드 변경 및 리팩터링 가능

심화 키워드: Unit Test, Integration Test, Regression Test, TDD, BDD 등 다양한 테스트 종류와 방법론이 존재합니다.

2. PyTest란?

테스트 코드 작성을 위한 Python 라이브러리입니다.

기본 Unittest 대비 장점:

• 간결한 문법 (assert 문)
• 함수 단위 테스트 지원
• fixture 지원 (테스트 데이터 관리)

3. PyTest 세팅

pip install pytest       # 테스트 라이브러리
pip install httpx        # TestClient가 내부적으로 사용하는 HTTP 클라이언트
pip install pytest-mock  # mocker 기능 사용 (Mocking)

파일 구조:

src/
└── test/          ← Python Package로 생성
    └── test_*.py  ← 파일명 반드시 test_ 로 시작해야 PyTest가 인식함

4. Fixture란?

테스트마다 반복되는 공통 준비 작업을 함수로 분리하는 기능입니다.

예를 들어 TestClient를 매 테스트마다 만들지 않고, fixture로 한 번만 정의하고 재사용합니다.

# conftest.py
import pytest
from fastapi.testclient import TestClient
from main import app

@pytest.fixture
def client():
    # 이 함수가 반환하는 값이 테스트 함수의 인자로 자동 주입됨
    return TestClient(app=app)

@pytest.fixture 로 정의한 함수는 테스트 함수의 인자 이름과 일치하면 자동으로 주입됩니다.

5. Mocking이란?

실제 DB나 외부 서비스에 의존하지 않고, 가짜 데이터를 반환하도록 함수를 대체하는 기술입니다.

• 테스트가 DB 상태에 영향을 받지 않아서 독립적이고 빠른 테스트 가능
• mocker.patch("경로.함수명", return_value=가짜데이터) 형태로 사용

6. Health Check 테스트

from database.orm import ToDo

def test_health_check(client):
    response = client.get("/")
    assert response.status_code == 200
    assert response.json() == {"ping": "pong"}

서버가 정상적으로 실행되고 있는지 확인하는 가장 기본적인 테스트입니다.

7. GET 전체 조회 테스트

def test_get_todos(client, mocker):
    # mocker.patch로 실제 DB 조회 함수를 가짜 데이터로 대체
    # "main.get_todos" : main.py 안의 get_todos 함수를 mock으로 교체
    mocker.patch("main.get_todos", return_value=[
        ToDo(id=1, contents="FastAPI Section 0", is_done=True),
        ToDo(id=2, contents="FastAPI Section 1", is_done=False),
    ])

    # order=ASC (기본값)
    response = client.get("/todos")
    assert response.status_code == 200
    assert response.json() == {
        "todos": [
            {"id": 1, "contents": "FastAPI Section 0", "is_done": True},
            {"id": 2, "contents": "FastAPI Section 1", "is_done": False},
        ]
    }

    # order=DESC (순서 반전)
    response = client.get("/todos?order=DESC")
    assert response.status_code == 200
    assert response.json() == {
        "todos": [
            {"id": 2, "contents": "FastAPI Section 1", "is_done": False},
            {"id": 1, "contents": "FastAPI Section 0", "is_done": True},
        ]
    }

mocker.patch로 대체한 데이터를 기준으로 DESC는 단순히 순서를 뒤집은 결과를 검증합니다.

8. GET 단일 조회 테스트

def test_get_todo(client, mocker):
    # --- 200 성공 케이스 ---
    mocker.patch(
        "main.get_todo_by_todo_id",
        return_value=ToDo(id=1, contents="todo", is_done=True),
    )
    response = client.get("/todos/1")
    assert response.status_code == 200
    assert response.json() == {"id": 1, "contents": "todo", "is_done": True}

    # --- 404 실패 케이스 ---
    # return_value=None : 해당 id의 ToDo가 없는 상황을 mock으로 재현
    mocker.patch(
        "main.get_todo_by_todo_id",
        return_value=None,
    )
    response = client.get("/todos/1")
    assert response.status_code == 404
    assert response.json() == {"detail": "ToDo Not Found"}

하나의 테스트 함수 안에서 성공(200)과 실패(404) 케이스를 모두 검증합니다. return_value=None으로 설정하면 핸들러에서 HTTPException이 발생하는 경로를 테스트할 수 있습니다.

9. POST 생성 테스트

def test_create_todo(client, mocker):
    # mocker.spy: 함수를 대체하지 않고 호출 결과를 추적(감시)하는 기능
    # ToDo.create 메서드가 어떤 값으로 호출됐는지 확인하기 위해 사용
    create_spy = mocker.spy(ToDo, "create")

    # create_todo(DB 저장 함수)는 mock으로 대체 → 실제 DB 저장 없이 결과만 반환
    mocker.patch(
        "main.create_todo",
        return_value=ToDo(id=1, contents="todo", is_done=True),
    )

    body = {
        "contents": "test",
        "is_done": False,
    }
    response = client.post("/todos", json=body)

    # spy_return: ToDo.create가 반환한 객체 (DB 저장 전 상태)
    # DB 저장 전이라 id는 None이어야 함
    assert create_spy.spy_return.id is None
    assert create_spy.spy_return.contents == "test"
    assert create_spy.spy_return.is_done is False

    # DB 저장 후 응답은 mock이 반환한 값 기준
    assert response.status_code == 201
    assert response.json() == {"id": 1, "contents": "todo", "is_done": True}

mocker.patch vs mocker.spy 차이:

• mocker.patch : 함수를 완전히 가짜로 교체 (실제 함수 실행 안 함)
• mocker.spy : 함수를 그대로 실행하되 호출 결과를 추적 (spy_return으로 확인 가능)

10. PATCH 수정 테스트

def test_update_todo(client, mocker):
    # --- 200 성공 케이스 ---
    mocker.patch(
        "main.get_todo_by_todo_id",
        return_value=ToDo(id=1, contents="todo", is_done=True),
    )

    # mocker.patch.object: 특정 클래스의 메서드를 mock으로 교체
    # ToDo.undone() 이 실제로 호출됐는지 검증하기 위해 spy처럼 활용
    undone = mocker.patch.object(ToDo, "undone")

    mocker.patch(
        "main.update_todo",
        return_value=ToDo(id=1, contents="todo", is_done=False),
    )

    response = client.patch("/todos/1", json={"is_done": False})

    # is_done=False를 보냈으므로 undone()이 정확히 한 번 호출됐어야 함
    undone.assert_called_once_with()
    assert response.status_code == 200
    assert response.json() == {"id": 1, "contents": "todo", "is_done": False}

    # --- 404 실패 케이스 ---
    mocker.patch(
        "main.get_todo_by_todo_id",
        return_value=None,
    )
    response = client.patch("/todos/1", json={"is_done": True})
    assert response.status_code == 404
    assert response.json() == {"detail": "ToDo Not Found"}

undone.assert_called_once_with() : mock으로 교체된 undone 메서드가 정확히 1번 호출됐는지 검증합니다. 이를 통해 is_done=False일 때 undone()이 실행되는 로직을 테스트할 수 있습니다.

11. DELETE 삭제 테스트

def test_delete_todo(client, mocker):
    # --- 204 성공 케이스 ---
    mocker.patch(
        "main.get_todo_by_todo_id",
        return_value=ToDo(id=1, contents="todo", is_done=True),
    )
    # delete_todo는 반환값이 없으므로 return_value=None
    mocker.patch("main.delete_todo", return_value=None)

    response = client.delete("/todos/1")
    assert response.status_code == 204
    # 204 No Content: 성공했지만 응답 본문이 없으므로 json() 검증 없음

    # --- 404 실패 케이스 ---
    mocker.patch(
        "main.get_todo_by_todo_id",
        return_value=None,
    )
    response = client.delete("/todos/1")
    assert response.status_code == 404
    assert response.json() == {"detail": "ToDo Not Found"}

DELETE 성공 시 상태코드는 204 No Content로, 응답 본문이 없기 때문에 response.json() 검증을 하지 않습니다.

12. 전체 흐름 정리

테스트 함수 실행
     ↓
fixture(client) 자동 주입 → TestClient 생성
     ↓
mocker.patch로 DB 함수를 가짜 데이터로 대체
     ↓
client.get/post/patch/delete 로 API 호출
     ↓
response.status_code / response.json() 검증
     ↓
assert 통과 → 테스트 성공 ✅ / 실패 → 테스트 실패 ❌

13. 핵심 개념 요약

1. SQLAlchemy란?

SQLAlchemy는 Python에서 관계형 데이터베이스를 편리하게 사용할 수 있도록 도와주는 라이브러리입니다.

주요 기능:

• ORM (Object-Relational Mapping)
• Query (쿼리 생성)
• Transaction (트랜잭션 처리)
• Connection Pooling (DB 연결 관리)

2. ORM이란?

ORM(Object-Relational Mapping) 은 관계형 데이터베이스의 테이블을 Python 클래스(객체)처럼 다룰 수 있게 해주는 기술입니다.

예시:

데이터베이스 테이블:

Python ORM 코드:

user = User(id=1, username='qu3vipon')

즉, SQL을 직접 쓰지 않고 Python 코드로 DB를 조작할 수 있게 됩니다.

3. Docker로 MySQL 실행하기

로컬에 MySQL을 직접 설치하지 않고, Docker를 이용해 간편하게 실행합니다.

# MySQL 컨테이너 실행
docker run -p 3306:3306 \
  -e MYSQL_ROOT_PASSWORD=todos \
  -e MYSQL_DATABASE=todos \
  -d \
  -v todos:/db \
  --name todos \
  mysql:8.0

# 실행 중인 컨테이너 확인
docker ps

# 컨테이너 로그 확인
docker logs todos

# 볼륨 목록 확인
docker volume ls

명령어 옵션 설명:

• -p 3306:3306 : 로컬 포트 3306 ↔ 컨테이너 포트 3306 연결
• -e MYSQL_ROOT_PASSWORD=todos : root 비밀번호 설정
• -e MYSQL_DATABASE=todos : 기본 DB 이름 설정
• -d : 백그라운드 실행
• -v todos:/db : 데이터 영속성을 위한 볼륨 마운트
• --name todos : 컨테이너 이름 지정

4. MySQL 접속 & 테이블 생성 (DDL)

# MySQL 컨테이너 내부 접속
docker exec -it todos bash

# MySQL 로그인
mysql -u root -p

-- 데이터베이스 목록 확인
SHOW databases;

-- todos DB 선택
USE todos;

-- todo 테이블 생성
CREATE TABLE todo(
    id INT NOT NULL AUTO_INCREMENT,
    contents VARCHAR(256) NOT NULL,
    is_done BOOLEAN NOT NULL,
    PRIMARY KEY (id)
);

-- 샘플 데이터 삽입
INSERT INTO todo (contents, is_done) VALUES ("FastAPI Section 0", true);

-- 데이터 조회
SELECT * FROM todo;

5. 데이터베이스 연결 설정

패키지 설치

pip install SQLAlchemy   # ORM 라이브러리
pip install pyMySQL      # Python ↔ MySQL 연결 드라이버
pip install cryptography # MySQL 인증/암호화 처리

database/connection.py

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

# DB 연결 주소 (형식: mysql+pymysql://유저:비밀번호@호스트:포트/DB명)
DATABASE_URL = "mysql+pymysql://root:todos@127.0.0.1:3306/todos"

# 엔진 생성 (실제 DB와 연결하는 핵심 객체, echo=True는 실행된 SQL을 콘솔에 출력)
engine = create_engine(DATABASE_URL, echo=True)

# 세션 팩토리 생성 (DB와 대화하는 세션을 만드는 공장)
# autocommit=False : 명시적으로 commit() 해야 DB에 반영됨
# autoflush=False  : 명시적으로 flush() 하기 전까지 쿼리를 DB에 보내지 않음
SessionFactory = sessionmaker(autocommit=False, autoflush=False, bind=engine)

연결 확인 (Python 콘솔)

>>> from database.connection import SessionFactory
>>> session = SessionFactory()
>>> from sqlalchemy import select
>>> session.scalar(select(1))  # 1이 반환되면 연결 성공!

6. ORM 모델링

database/orm.py

from sqlalchemy import Boolean, Column, Integer, String
from sqlalchemy.orm import declarative_base

Base = declarative_base()  # 모든 ORM 모델의 부모 클래스

class ToDo(Base):
    __tablename__ = "todo"  # 연결할 실제 DB 테이블 이름

    # 컬럼 정의 (DB 테이블의 각 컬럼과 1:1 매핑)
    id = Column(Integer, primary_key=True, index=True)
    contents = Column(String(256), nullable=False)
    is_done = Column(Boolean, nullable=False)

    def __repr__(self):
        # 객체를 출력할 때 보여줄 문자열 형식
        return f"ToDo(id={self.id}, contents={self.contents}, is_done={self.is_done})"

ORM 모델 동작 확인 (Python 콘솔)

>>> from database.connection import SessionFactory
>>> session = SessionFactory()
>>> from sqlalchemy import select
>>> from database.orm import ToDo

# 모든 ToDo 조회
>>> todos = list(session.scalars(select(ToDo)))
>>> todos

# 하나씩 출력
>>> for todo in todos:
...     print(todo)

7. scalar vs scalars 차이

SQLAlchemy에서 헷갈리기 쉬운 두 메서드의 차이입니다.

# scalars() - 여러 행을 ORM 객체 리스트로 반환
session.scalars(select(ToDo))
# → [ToDo(id=1, ...), ToDo(id=2, ...), ...]

# scalar() - 단일 행 하나만 반환
session.scalar(select(ToDo).where(ToDo.id == 1))
# → ToDo(id=1, ...) 객체 하나

쿼리 결과는 원래 행/열의 2차원 테이블 형태인데, 첫 번째 열만 뽑아서 단순하게(scalar) 만들어줍니다. 덕분에 Row 객체가 아니라 바로 ToDo 객체로 받을 수 있습니다.

8. ORM 적용 — CRUD API 구현

사전 준비: 의존성 주입 (DB 세션)

FastAPI의 Depends를 이용해 각 API 핸들러에 DB 세션을 자동으로 주입합니다.

# database/connection.py 에 추가
from sqlalchemy.orm import Session

def get_db():
    # 요청마다 새 세션을 열고, 요청이 끝나면 자동으로 닫아줌
    db = SessionFactory()
    try:
        yield db
    finally:
        db.close()

Response 스키마 정의

API가 반환할 데이터 형식을 Pydantic으로 정의합니다.

# schema/response.py
from pydantic import BaseModel
from typing import List

class ToDoSchema(BaseModel):
    id: int
    contents: str
    is_done: bool

    class Config:
        from_attributes = True  # ORM 객체 → Pydantic 변환 허용 (구버전: orm_mode = True)

class ListToDoResponse(BaseModel):
    todos: List[ToDoSchema]

GET — 전체 조회

# database/repository.py
from typing import List
from sqlalchemy import select
from sqlalchemy.orm import Session
from database.orm import ToDo

def get_todos(session: Session) -> List[ToDo]:
    return list(session.scalars(select(ToDo)))

# main.py
@app.get("/todos", status_code=200)
def get_todos_handler(
    order: str | None = None,
    session: Session = Depends(get_db),  # DB 세션 자동 주입
) -> ListToDoResponse:
    todos: List[ToDo] = get_todos(session=session)

    if order and order == "DESC":
        return ListToDoResponse(
            todos=[ToDoSchema.from_orm(todo) for todo in todos[::-1]]
        )
    return ListToDoResponse(
        todos=[ToDoSchema.from_orm(todo) for todo in todos]
    )

ToDoSchema.from_orm(todo) : ORM 객체(ToDo)를 Pydantic 스키마(ToDoSchema)로 변환합니다.

GET — 단일 조회

# database/repository.py 에 추가
def get_todo_by_todo_id(session: Session, todo_id: int) -> ToDo | None:
    # where 조건으로 특정 id를 가진 행 하나만 반환
    return session.scalar(select(ToDo).where(ToDo.id == todo_id))

# main.py
@app.get("/todos/{todo_id}", status_code=200)
def get_todo_handler(
    todo_id: int,
    session: Session = Depends(get_db),
) -> ToDoSchema:
    todo: ToDo | None = get_todo_by_todo_id(session=session, todo_id=todo_id)
    if todo:
        return ToDoSchema.from_orm(todo)
    raise HTTPException(status_code=404, detail="ToDo Not Found")

POST — 생성

# schema/request.py
from pydantic import BaseModel

class CreateToDoRequest(BaseModel):
    contents: str
    is_done: bool
    # id는 DB가 AUTO_INCREMENT로 자동 생성하므로 요청에 포함하지 않음

# database/repository.py 에 추가
def create_todo(session: Session, todo: ToDo) -> ToDo:
    session.add(instance=todo)   # 세션에 객체 추가 (아직 DB에 저장 안 됨)
    session.commit()              # DB에 실제로 저장 (INSERT 실행)
    session.refresh(instance=todo)  # DB에서 최신 상태 다시 읽어오기 (자동 생성된 id 반영)
    return todo

# main.py
@app.post("/todos", status_code=201)
def create_todo_handler(
    request: CreateToDoRequest,
    session: Session = Depends(get_db),
) -> ToDoSchema:
    todo: ToDo = ToDo.create(request=request)  # ORM 객체 생성 (id=None 상태)
    todo: ToDo = create_todo(session=session, todo=todo)  # DB 저장 후 id 할당됨
    return ToDoSchema.from_orm(todo)

session.refresh() 가 중요한 이유: DB에 저장 후 AUTO_INCREMENT로 생성된 id 값을 Python 객체에 반영하기 위해 필요합니다.

PATCH — 수정

# database/repository.py 에 추가
def update_todo(session: Session, todo: ToDo) -> ToDo:
    session.add(instance=todo)   # 변경된 객체를 세션에 반영
    session.commit()              # DB에 UPDATE 실행
    session.refresh(instance=todo)  # 최신 상태 다시 읽기
    return todo

# main.py
@app.patch("/todos/{todo_id}", status_code=200)
def update_todo_handler(
    todo_id: int,
    is_done: bool = Body(..., embed=True),
    session: Session = Depends(get_db),
):
    todo: ToDo | None = get_todo_by_todo_id(session=session, todo_id=todo_id)
    if todo:
        # is_done 값에 따라 done() 또는 undone() 메서드 호출
        todo.done() if is_done else todo.undone()
        todo: ToDo = update_todo(session=session, todo=todo)
        return ToDoSchema.from_orm(todo)
    raise HTTPException(status_code=404, detail="ToDo Not Found")

DELETE — 삭제

# database/repository.py 에 추가
from sqlalchemy import delete

def delete_todo(session: Session, todo_id: int) -> None:
    # DELETE FROM todo WHERE id = todo_id 실행
    session.execute(delete(ToDo).where(ToDo.id == todo_id))
    session.commit()

# main.py
@app.delete("/todos/{todo_id}", status_code=204)
def delete_todo_handler(
    todo_id: int,
    session: Session = Depends(get_db),
):
    todo: ToDo | None = get_todo_by_todo_id(session=session, todo_id=todo_id)
    if not todo:
        raise HTTPException(status_code=404, detail="ToDo Not Found")
    delete_todo(session=session, todo_id=todo_id)
    # 204 No Content: 성공했지만 반환할 데이터 없음 → return 생략

9. 리팩토링 팁 (PyCharm / IDE)

코드가 길어지면 파일을 분리해서 관리하는 게 중요합니다.

• Move : 클래스/함수를 드래그 후 우클릭 → 다른 파일로 이동
• Rename : 클래스/변수 이름 변경 시 사용된 모든 곳에 자동 반영

10. 전체 흐름 정리

클라이언트 요청
     ↓
FastAPI 라우터 (main.py)
     ↓
Repository 함수 (database/repository.py) ← DB 쿼리 로직 분리
     ↓
ORM 모델 (database/orm.py) ← 테이블 구조 정의
     ↓
SQLAlchemy Engine (database/connection.py) ← 실제 DB 연결
     ↓
MySQL (Docker)

1. 기본 CRUD API

웹 서버 실행 후 코드를 변경하면, 웹 서버를 재시작해야 변경사항이 Swagger UI에 반영됩니다.

FastAPI 서버 종료: Ctrl + C

전체 조회 (GET)

@app.get("/todos")

단일 조회 (GET)

@app.get("/todos/{todo_id}")

생성 (POST)

from pydantic import BaseModel

class CreateToDoRequest(BaseModel):
    id: int
    contents: str
    is_done: bool

@app.post("/todos")
def create_todo_handler(request: CreateToDoRequest):
    todo_data[request.id] = request.dict()
    return todo_data[request.id]

수정 (PATCH)

from fastapi import FastAPI, Body

@app.patch("/todos/{todo_id}")
def update_todo_handler(
    todo_id: int,
    is_done: bool = Body(..., embed=True),
):
    todo = todo_data.get(todo_id)
    if todo:
        todo["is_done"] = is_done
        return todo
    return {}

삭제 (DELETE)

@app.delete("/todos/{todo_id}")
def delete_todo_handler(todo_id: int):
    todo_data.pop(todo_id, None)
    return todo_data

2. HTTP Status Code

2xx — 성공

4xx — 클라이언트 오류

5xx — 서버 오류

3. 상태 코드 & 에러 처리 실습

전체 조회 — 상태 코드 적용

@app.get("/todos", status_code=200)
def get_todos_handler(order: str | None = None):
    ret = list(todo_data.values())
    if order and order == "DESC":
        return ret[::-1]
    return ret

단일 조회 — 에러 처리

from fastapi import FastAPI, Body, HTTPException

@app.get("/todos/{todo_id}", status_code=200)
def get_todo_handler(todo_id: int):
    todo = todo_data.get(todo_id)
    if todo:
        return todo
    raise HTTPException(status_code=404, detail="ToDo Not Found")

생성 (POST) — 상태 코드 적용

@app.post("/todos", status_code=201)
def create_todo_handler(request: CreateToDoRequest):
    todo_data[request.id] = request.dict()
    return todo_data[request.id]

수정 (PATCH) — 에러 처리

@app.patch("/todos/{todo_id}", status_code=200)
def update_todo_handler(
    todo_id: int,
    is_done: bool = Body(..., embed=True),
):
    todo = todo_data.get(todo_id)
    if todo:
        todo["is_done"] = is_done
        return todo
    raise HTTPException(status_code=404, detail="ToDo Not Found")

삭제 (DELETE) — 에러 처리

@app.delete("/todos/{todo_id}", status_code=204)
def delete_todo_handler(todo_id: int):
    todo = todo_data.pop(todo_id, None)
    if todo:
        return
    raise HTTPException(status_code=404, detail="ToDo Not Found")

DDL, 정규화, JOIN, INSERT/UPDATE/DELETE, UNION, VIEW

1. 테이블과 컬럼 생성 — DDL

DDL(Data Definition Language) : 데이터베이스 구조를 정의하는 SQL 문법

데이터베이스 생성 / 삭제

CREATE DATABASE 데이터베이스명;
DROP DATABASE 데이터베이스명;

테이블 생성 / 삭제

-- 테이블 생성
CREATE TABLE 데이터베이스명.테이블명 (
    id INT,
    이름 VARCHAR(100) DEFAULT '홍길동',  -- 값 미입력 시 '홍길동'으로 저장
    나이 INT
);

-- 테이블 삭제
DROP TABLE 테이블명;

컬럼 추가 / 수정 / 삭제 — ALTER TABLE

-- 컬럼 추가
ALTER TABLE 테이블명 ADD 성별 VARCHAR(10);

-- 컬럼 타입 수정
-- ⚠️ 이미 데이터가 저장되어 있으면 타입 변경 불가
ALTER TABLE 테이블명 MODIFY COLUMN 나이 VARCHAR(100);

-- 컬럼 삭제
ALTER TABLE 테이블명 DROP COLUMN 컬럼명;

2. 제약 조건 — Constraints

컬럼에 잘못된 데이터가 들어오는 것을 방지하는 규칙

NOT NULL — NULL 입력 금지

CREATE TABLE 테이블명 (
    id INT NOT NULL,
    이름 VARCHAR(100),
    나이 INT
);

UNIQUE — 중복값 방지

-- 단일 컬럼
CREATE TABLE 테이블명 (
    id INT UNIQUE,
    이름 VARCHAR(100)
);

-- 복합 컬럼 (두 컬럼의 조합이 유일해야 함)
CREATE TABLE 테이블명 (
    id INT,
    이름 VARCHAR(100),
    UNIQUE(컬럼1, 컬럼2)
);

CHECK — 입력값 조건 검사

CREATE TABLE 테이블명 (
    id INT,
    나이 INT CHECK(나이 > 0)  -- 0 이하의 나이 입력 불가
);

PRIMARY KEY — 행 식별자

NOT NULL + UNIQUE 를 자동으로 포함

CREATE TABLE 테이블명 (
    id INT PRIMARY KEY,
    이름 VARCHAR(100)
);

AUTO_INCREMENT — 자동 증가

값을 직접 입력하지 않아도 1씩 자동 증가하는 정수를 넣어줌
주로 PRIMARY KEY와 함께 사용

CREATE TABLE 테이블명 (
    id INT AUTO_INCREMENT PRIMARY KEY,
    이름 VARCHAR(100)
);

3. 정규화 — 1NF, 2NF, 3NF

제1정규화 (1NF)

"한 칸엔 하나의 데이터만"

• 하나의 셀에 여러 값이 들어있으면 분리해야 함
• 제1정규형 : 제1정규화가 완료된 테이블

제2정규화 (2NF)

"현재 테이블의 주제와 관련없는 컬럼을 다른 테이블로 빼는 작업"
= 복합 기본키의 일부에만 종속되는 컬럼 분리 (부분 함수 종속 제거)

• 복합 기본키(Composite Primary Key) : 단일 컬럼으로 행을 식별할 수 없을 때 2개 이상의 컬럼을 합쳐 기본키로 사용
• 기본키 설정 시 현재 데이터뿐 아니라 미래에 들어올 수 있는 데이터까지 고려해야 함

💡 종속관계 판단 팁
하나의 컬럼 값을 바꿨을 때 다른 컬럼도 따라서 바뀌어야 한다면 → 종속관계

제2정규형 : 제2정규화가 완료된 테이블

제3정규화 (3NF)

"기본키가 아닌 일반 컬럼에 종속되는 컬럼 분리" (이행 함수 종속 제거)

쉽게 이해하는 방법 : 기본키가 아닌 잔챙이 컬럼에 종속되는 컬럼을 분리

제3정규형 : 제3정규화가 완료된 테이블

4. Foreign Key (외래키)

다른 테이블의 Primary Key를 참조하는 컬럼

테이블을 쪼갤 때 유의사항

1. 첫 컬럼은 항상 PRIMARY KEY 넣는 게 좋음
2. 다른 테이블의 데이터를 사용할 때 해당 테이블의 PRIMARY KEY를 적기 (Foreign Key)

Foreign Key 장점

• DBeaver에서 화살표 클릭으로 연결된 테이블 행 바로 확인 가능
• 다른 테이블에서 참조 중인 데이터 실수로 삭제하는 것을 방지

⚠️ 단, 삭제/수정이 번거로워지고 테이블 구조 변경도 까다로워져서 등록하지 않는 곳도 있음

SQL로 Foreign Key 등록하기

-- 테이블 생성 시 인라인으로 등록
CREATE TABLE 테이블명 (
    id INT PRIMARY KEY,
    프로그램 VARCHAR(100),
    강사id INT REFERENCES 다른테이블명(참조할컬럼명)
);

-- CONSTRAINT 문법으로 등록
CREATE TABLE 테이블명 (
    id INT,
    프로그램 VARCHAR(100),
    강사id INT,
    CONSTRAINT pk_name PRIMARY KEY (id),
    CONSTRAINT fk_name FOREIGN KEY (강사id) REFERENCES 다른테이블명(참조할컬럼명)
);

-- 이미 생성된 테이블에 추가
ALTER TABLE 테이블명 ADD
CONSTRAINT fk_name FOREIGN KEY (강사id) REFERENCES teacher(id);

5. 테이블 합쳐서 출력 — JOIN

정규화로 쪼개놓은 테이블을 다시 합쳐서 출력할 때 사용

INNER JOIN

두 테이블에서 조건이 일치하는 행만 출력

SELECT * FROM program
INNER JOIN teacher
ON 강사id = teacher.id;

-- 3개 이상 테이블 붙이기
SELECT * FROM 테이블1
INNER JOIN 테이블2 ON 조건식
INNER JOIN 테이블3 ON 조건식;

CROSS JOIN

두 테이블의 모든 행의 조합 출력

SELECT * FROM program CROSS JOIN teacher;

LEFT JOIN / RIGHT JOIN

-- LEFT JOIN : INNER JOIN 결과 + 왼쪽 테이블의 모든 행
-- RIGHT JOIN : INNER JOIN 결과 + 오른쪽 테이블의 모든 행
SELECT * FROM program
RIGHT JOIN teacher
ON 강사id = teacher.id;

💡 활용 팁 : 접점이 없는 행(빵꾸)을 찾을 때 유용

-- teacher 테이블에 있지만 program 테이블에서 참조되지 않는 강사 찾기
SELECT * FROM program
RIGHT JOIN teacher
ON 강사id = teacher.id
WHERE 강사id IS NULL;

JOIN vs UNION 차이

6. 데이터 삽입 — INSERT

-- 특정 컬럼에만 삽입
INSERT INTO stock(id, 상품명, 가격)
VALUES (1, '김치', 500);

-- 전체 컬럼에 삽입 (컬럼명 생략 가능)
INSERT INTO stock
VALUES (1, '김치', 500);

응용 — 테이블 간 데이터 복사

-- 기존 테이블에 다른 테이블 데이터 복사
INSERT INTO stock
SELECT * FROM stock2;

-- 새 테이블 생성과 동시에 복사
CREATE TABLE 새테이블명 SELECT * FROM 기존테이블명;

💡 테이블 복사는 언제?

• 쿼리 결과를 잠깐 저장할 때
• 테이블에 작업하기 전 테스트용으로 먼저 확인할 때

DB 접속 계정별 권한 설정 (MySQL Workbench)

삽입/수정/삭제는 위험한 작업이므로 계정별 권한을 제한할 수 있음

1. MySQL Workbench 접속
2. 상단 Server > Users and Privileges
3. ID, PW 생성
4. Administrative Roles에서 권한 설정 (예: SELECT, INSERT만 체크)
5. Apply로 계정 생성
6. 해당 계정으로 접속하면 설정한 권한만 사용 가능

7. 데이터 수정 / 삭제 — UPDATE / DELETE

UPDATE

UPDATE stock
SET 상품명 = '사과'
WHERE id = 2;

-- 여러 컬럼 동시 수정
UPDATE stock
SET 상품명 = '사과', 가격 = 가격 + 100
WHERE id = 2;

⚠️ WHERE 빠뜨리면 모든 행이 수정됨 — 반드시 확인!

DELETE

DELETE FROM stock
WHERE id = 100;

⚠️ WHERE 빠뜨리면 모든 행이 삭제됨 — 반드시 확인!
⚠️ 다른 테이블에서 Foreign Key로 참조 중인 행은 삭제 불가

JOIN한 테이블 수정 / 삭제

-- 수정
UPDATE a INNER JOIN b ON 조건식
SET 컬럼 = 값
WHERE 조건식;

-- 삭제 (a만, b만, 또는 a,b 둘 다 삭제 가능)
DELETE a FROM a
INNER JOIN b ON 조건식
WHERE 조건식;

8. SELECT 결과 합치기 — UNION

-- 중복 제거하며 합치기
SELECT * FROM stock
UNION
SELECT * FROM stock2;

-- 중복 허용하며 합치기
SELECT * FROM stock
UNION ALL
SELECT * FROM stock2;

⚠️ 컬럼 개수가 다르면 실행 안 됨

9. 가상 테이블 — VIEW

자주 쓰는 SELECT 쿼리를 테이블처럼 저장해두고 재사용할 때 사용
실제 데이터를 저장하는 게 아닌 가상 테이블

CREATE VIEW 뷰이름 AS
SELECT 컬럼1, 컬럼2
FROM 테이블명
WHERE 조건식;

-- 이후 일반 테이블처럼 사용 가능
SELECT * FROM 뷰이름;

💡 VIEW를 쓰는 이유

• 자주 쓰는 복잡한 쿼리를 매번 다시 짜지 않아도 됨
• 실제 테이블로 저장하기엔 무겁고, 그냥 두기엔 매번 쿼리 짜기 번거로울 때 사용

📋 SQL 문법 실행 순서 요약

FROM → JOIN → WHERE → GROUP BY → HAVING → SELECT → ORDER BY → LIMIT

MySQL 기준으로 작성된 SQL 기초 학습 노트입니다.

1. 데이터베이스 설치

• DBeaver 사용 권장 — 깔끔하고 직관적이며, MySQL 외 다른 DBMS(PostgreSQL, Oracle 등)도 쉽게 연결 가능

2. 테이블 만들기 & 데이터 타입

• database = 폴더 개념
• table = 파일 개념
• 테이블을 만들기 전에 어떤 컬럼(열)이 들어갈지 미리 설계해야 함
  • 예) 상품 테이블 → 가격, 이름, 카테고리 컬럼

📌 주요 데이터 타입

3. 데이터 출력과 정렬 — SELECT, ORDER BY

기본 출력

-- 전체 컬럼 출력
SELECT * FROM 테이블이름;

-- 데이터베이스명 명시
SELECT * FROM 데이터베이스이름.테이블이름;

-- 특정 컬럼만 출력
SELECT 컬럼1, 컬럼2 FROM 테이블이름;

정렬

-- 오름차순(기본값)
SELECT * FROM 테이블이름 ORDER BY 컬럼 ASC;

-- 내림차순
SELECT * FROM 테이블이름 ORDER BY 컬럼 DESC;

-- 다중 정렬 (첫 번째 기준 정렬 후, 같은 값 내에서 두 번째 기준으로 다시 정렬)
SELECT * FROM 테이블이름 ORDER BY 컬럼1 ASC, 컬럼2 DESC;

4. 데이터 필터링 — WHERE

CSV 파일을 테이블에 가져오는 방법 (DBeaver)

1. 기존 데이터 전체 선택 후 삭제 & 저장
2. 테이블 우클릭 → 데이터 가져오기
3. CSV에서 가져오기 클릭 후 파일 업로드
4. 한글 데이터가 있다면 인코딩을 EUC-KR로 변경
5. 파일명과 동일한 이름의 테이블이 생성됨 (기존 동일 이름 테이블은 미리 삭제 권장)

기본 필터링

SELECT * FROM product WHERE 컬럼 = '값';

-- 비교 연산자: =, !=, >, <, >=, <=
SELECT * FROM product WHERE 상품명 > '가';  -- 문자 비교도 가능

BETWEEN (범위 조건)

SELECT * FROM product WHERE 가격 BETWEEN 5000 AND 8000;

5. 복합 조건 — AND, OR, NOT, IN

AND / OR

SELECT * FROM product
WHERE 가격 = 5000 AND 카테고리 = '가구';

-- 괄호로 우선순위 지정
SELECT * FROM product
WHERE 가격 = 5000 AND (카테고리 = '가구' OR 카테고리 = '옷');

NOT (조건 제외)

SELECT * FROM product
WHERE NOT 카테고리 = '가구' AND NOT 가격 = 5000;

IN (여러 값 조건 축약 — 단일 컬럼에만 사용 가능)

-- 아래 두 쿼리는 동일한 결과
SELECT * FROM product
WHERE 카테고리 = '신발' OR 카테고리 = '가전' OR 카테고리 = '식품';

SELECT * FROM product
WHERE 카테고리 IN ('신발', '가전', '식품');

💡 코드 잘 짜는 팁: SQL을 바로 짜지 말고, 원하는 조건을 먼저 한글로 정리한 뒤 SQL로 변환하세요.

6. 패턴 검색 — LIKE, %, _

-- 특정 단어 포함 검색
SELECT * FROM product WHERE 상품명 LIKE '%소파%';

-- % : 임의의 문자열
-- _ : 임의의 문자 1개
-- __ : 임의의 문자 2개

⚠️ 주의사항

• %를 남용하면 인덱스를 활용하지 못해 성능 이슈 발생 가능
• LIKE와 %는 주로 VARCHAR 컬럼에 사용
• CHAR 컬럼은 공백으로 패딩되어 저장되므로 예상과 다르게 작동할 수 있음

7. 집계 함수 — MIN, MAX, AVG, SUM, COUNT

SELECT MAX(결제횟수) FROM card;
SELECT MIN(결제횟수) FROM card;
SELECT AVG(결제횟수) FROM card;
SELECT SUM(결제횟수) FROM card;
SELECT COUNT(*) FROM card;

-- 여러 집계 동시에
SELECT MAX(결제횟수), MAX(사용금액) FROM card;

-- AS로 컬럼명 변경
SELECT MAX(사용금액) AS 최대사용금액 FROM card;

-- WHERE와 함께 일부 행만 집계
SELECT AVG(사용금액) FROM card WHERE 고객등급 = 'vip';

중복 제거 — DISTINCT

SELECT DISTINCT 연체횟수 FROM card;

-- 집계와 함께 사용
SELECT AVG(DISTINCT 연체횟수) FROM card;

ORDER BY + LIMIT으로 최대/최소 구하기

-- 사용금액 상위 1개 행 출력 (일부 상황에서 MAX()보다 빠를 수 있음)
SELECT 사용금액 FROM card ORDER BY 사용금액 DESC LIMIT 1;

8. 컬럼 연산 & 문자 함수

사칙연산

SELECT 사용금액 * 10 FROM card;
SELECT 사용금액 / 결제횟수 FROM card;  -- 컬럼끼리 연산도 가능

문자 함수

-- 문자 이어붙이기
SELECT CONCAT(고객명, ' is ', 고객등급) FROM card;

-- 좌우 공백 제거
SELECT TRIM('  hello  ') FROM card;

-- 문자 치환
SELECT REPLACE(고객등급, '패', '훼') FROM card;

-- 일부 문자열 추출 (시작위치, 길이)
SELECT SUBSTR(고객명, 3, 2) FROM card;

-- 일부 문자열 교체 (시작위치, 교체할길이, 바꿀단어)
SELECT INSERT('test@naver.com', 1, 4, 'hello') FROM card;
-- 결과: 'hello@naver.com'

9. 숫자 함수

💡 MAX() / MIN()은 한 컬럼 안에서 최대·최소를 구하고,
GREATEST() / LEAST()는 한 행 안의 여러 값 중에서 최대·최소를 구합니다.

💡 Oracle, PostgreSQL에서는 TRUNCATE() 대신 TRUNC()를 사용합니다.

10. 서브쿼리

SELECT 안에 또 다른 SELECT를 넣는 문법입니다.

-- 사용금액이 평균보다 높은 사람만 출력
SELECT * FROM card
WHERE 사용금액 > (SELECT AVG(사용금액) FROM card);

-- SELECT 절에서 활용
SELECT 사용금액, (SELECT AVG(사용금액) FROM card) FROM card;

-- IN 절에서 활용
SELECT * FROM card
WHERE 고객명 IN (SELECT 이름 FROM blacklist);

⚠️ 서브쿼리 주의사항

1. 서브쿼리는 숫자·문자(데이터) 위치에 넣을 수 있음
2. 반드시 1개의 값만 반환하는 쿼리여야 함 (여러 행 반환 시 오류)
3. 반드시 소괄호로 감싸야 함

11. 그룹별 집계 — GROUP BY, HAVING

-- 고객등급별 평균 사용금액
SELECT 고객등급, AVG(사용금액) FROM card GROUP BY 고객등급;

-- 고객등급별 최대 사용금액
SELECT 고객등급, MAX(사용금액) FROM card GROUP BY 고객등급;

-- 고객등급별 인원 수
SELECT 고객등급, COUNT(사용금액) FROM card GROUP BY 고객등급;

💡 GROUP BY 뒤에는 주로 카테고리성 컬럼 사용 (예: 고객등급, 지역, 성별)

WHERE vs HAVING

-- HAVING으로 그룹 결과 필터링
SELECT 고객등급, MAX(사용금액) FROM card
GROUP BY 고객등급
HAVING 고객등급 = 'vip' OR 고객등급 = '패밀리';

-- WHERE + GROUP BY + HAVING 함께 사용
SELECT 고객등급, MAX(사용금액) FROM card
WHERE 연체횟수 = 0
GROUP BY 고객등급
HAVING 고객등급 = 'vip' OR 고객등급 = '패밀리';

-- AS로 작명한 컬럼으로도 HAVING 필터링 가능
SELECT 연체횟수, COUNT(*) AS 인원수 FROM card
GROUP BY 연체횟수
HAVING 인원수 != 1
ORDER BY 연체횟수;

12. 조건 분기 — IF, CASE

IF (양자택일)

-- 기본 구조: IF(조건식, 참일 때 값, 거짓일 때 값)
SELECT IF(1 + 2 = 4, 'aaa', 'bbb');  -- 결과: bbb

SELECT 사용금액, IF(사용금액 > 200000, '우수', '거지') FROM card;

CASE (3가지 이상 분기)

SELECT 사용금액,
  CASE
    WHEN 사용금액 >= 200000 THEN '우수'
    WHEN 사용금액 >= 100000 THEN '준수'
    ELSE '거지'
  END AS 평가
FROM card;

💡 WHEN 조건은 위에서부터 순서대로 평가되므로, 범위가 큰 조건일수록 먼저 써주세요.

CASE + 집계 함수 응용

-- 고객등급에 따라 가중치 점수 합산
SELECT SUM(
  CASE
    WHEN 고객등급 = 'vip'  THEN 3
    WHEN 고객등급 = '로열' THEN 2
    ELSE 1
  END
) AS 총점수
FROM card;

📋 SQL 실행 순서 요약

FROM → WHERE → GROUP BY → HAVING → SELECT → ORDER BY → LIMIT

FastAPI란?

Python 기반의 API 생성 툴로, 프레임워크보다는 API 생성에 특화된 도구다. Micro Service 방식으로 서버를 기능별로 분할해서 만든다.

특징

• 매우 빠른 속도
• 코드가 간결함
• 비동기 처리 지원 → 특정 코드가 오래 걸리면 일단 제끼고 다른 코드 실행 가능
• 요청이 많은 사이트에 강점

주요 기능

• GET / POST 요청 처리
• DB 입출력
• 회원 인증
• 데이터 Validation
• 웹소켓
• async / await (비동기)
• 타입 힌트
• API 문서 자동 생성

환경 세팅

가상환경은 폴더마다 따로 만들어야 한다. 폴더가 바뀔 때마다 아래 순서를 진행한다.

# 1. 폴더 만들고 이동
cd C:\work
mkdir board
cd board

# 2. 가상환경 생성
py -m venv .venv

# 3. 가상환경 활성화 (앞에 (.venv) 붙으면 성공)
.venv\Scripts\activate

# 4. 패키지 설치
pip install fastapi uvicorn

# 5. 서버 실행
uvicorn main:app --reload

팀 프로젝트에서는

팀원이 requirements.txt 를 넘겨주면 한 번에 환경 세팅 가능하다.

pip install -r requirements.txt

src 폴더 생성

폴더에src디렉터리를 만들고 그 안에 .py파일들을 생성한다. src폴더는 mark directory as에서 source root으로 바꿔준다.

기본 서버 만들기

from fastapi import FastAPI

app = FastAPI()

메인 페이지 접속 시 데이터 반환

@app.get("/")
def root():
    return "hello"

특정 경로로 데이터 반환

@app.get("/data")
def get_data():
    return {"hello": 1234}

메인 페이지에서 HTML 파일 전송

from fastapi.responses import FileResponse

@app.get("/")
def root():
    return FileResponse("index.html")

API 문서 자동 생성

서버 실행 후 아래 주소로 접속하면 API 문서를 자동으로 확인할 수 있다.

• Swagger UI: http://localhost:8000/docs
• ReDoc: http://localhost:8000/redoc

유저 데이터 받기 (POST)

유저에게 데이터를 받을 때는 Pydantic으로 모델을 생성해야 한다.

Pydantic이란?

유저가 데이터를 보낼 때 타입이 맞는지 자동으로 검사해주는 도구. 잘못된 데이터가 서버에 들어오는 걸 막아준다. Spring의 @Valid, @NotNull 같은 Bean Validation과 같은 역할이다.

from pydantic import BaseModel

class Model(BaseModel):
    name: str   # 타입 지정
    phone: int

@app.post("/send")
def send_data(data: Model):  # /send로 보낸 데이터가 담김
    print(data)
    return "전송완료"

비동기 처리 (async / await)

@app.get("/")
async def root():
    await 오래_걸리는_코드()  # 이 코드가 끝날 때까지 기다림
    return FileResponse("index.html")

SQLAlchemy (ORM)

ORM이란?

SQL을 직접 쓰지 않고 Python 코드로 DB를 다룰 수 있게 해주는 도구다. Spring의 JPA / Hibernate와 똑같은 역할이다.

# SQL 직접 쓰면
SELECT * FROM posts WHERE id = 1

# SQLAlchemy 쓰면
db.query(Post).filter(Post.id == 1).first()

Spring이랑 비교

JPA 써봤으면 개념은 이미 알고 있다. 문법만 다를 뿐이다.

DB 입출력

추후 작성 예정

Java Arrays 라이브러리 사용법

📌 Arrays 클래스란?

java.util.Arrays에 포함된 클래스로, 배열을 다루는 유틸리티 메서드들을 제공한다. C에서 직접 구현하던 것들을 한 줄로 처리할 수 있다.

import java.util.Arrays;

✂️ Arrays.copyOfRange() — 배열 자르기

배열의 일부를 잘라서 새 배열로 복사한다.

Arrays.copyOfRange(원본배열, 시작인덱스, 끝인덱스)

⚠️ 끝인덱스는 포함되지 않는다 (exclusive)

예시

int[] arr = {1, 2, 3, 4, 5};

int[] result = Arrays.copyOfRange(arr, 1, 4);
// → {2, 3, 4}   (index 1 이상, index 4 미만)

코테 적용 포인트

문제가 1-indexed 기준일 때, Java는 0-indexed라서 시작값에 -1 해줘야 한다. 끝값은 exclusive이기 때문에 -1 없이 그대로 넣으면 딱 맞게 잘린다.

// commands[i] = [2, 5, 3] 이면
int[] temp = Arrays.copyOfRange(array, commands[i][0]-1, commands[i][1]);
//                                     2-1 = 1부터       5 미만까지 → index 1~4

🔃 Arrays.sort() — 배열 정렬

배열을 오름차순으로 정렬한다.

int[] arr = {3, 1, 4, 1, 5};
Arrays.sort(arr);
// → {1, 1, 3, 4, 5}

내림차순 정렬

기본 int[]로는 내림차순 직접 지정이 안 되고, Integer[]로 바꿔야 한다.

Integer[] arr = {3, 1, 4, 1, 5};
Arrays.sort(arr, (a, b) -> b - a);
// → {5, 4, 3, 1, 1}

일부 범위만 정렬

int[] arr = {5, 3, 1, 4, 2};
Arrays.sort(arr, 1, 4);  // index 1 이상, 4 미만만 정렬
// → {5, 1, 3, 4, 2}

🧩 실전 예제 — 프로그래머스 "K번째 수"

문제 요약

배열에서 i번째부터 j번째까지 자르고, 정렬 후 k번째 수를 구한다.

풀이

import java.util.Arrays;

class Solution {
    public int[] solution(int[] array, int[][] commands) {
        int[] answer = new int[commands.length];

        for (int i = 0; i < commands.length; i++) {
            // 1. i번째 ~ j번째 자르기 (1-indexed → 0-indexed 변환)
            int[] temp = Arrays.copyOfRange(array, commands[i][0] - 1, commands[i][1]);

            // 2. 오름차순 정렬
            Arrays.sort(temp);

            // 3. k번째 수 저장 (1-indexed → 0-indexed 변환)
            answer[i] = temp[commands[i][2] - 1];
        }

        return answer;
    }
}

흐름 시각화

array    = [1, 5, 2, 6, 3, 7, 4]
command  = [2, 5, 3]

1. copyOfRange(array, 1, 5)  →  temp = [5, 2, 6, 3]
2. sort(temp)                →  temp = [2, 3, 5, 6]
3. temp[2]                   →  answer = 5

📚 Arrays 주요 메서드 요약

팀 프로젝트(3~5인)에서 Fork 과정 없이 하나의 원본 저장소에서 직접 브랜치를 나누어 작업하는 효율적인 협업 모델입니다.

1. 초기 설정 (방장 권한)

방장(소유자)은 팀원들에게 저장소 수정 권한을 부여해야 합니다.

1. Collaborator 초대: Settings > Collaborators > Add people에서 팀원 계정 추가.
2. 브랜치 보호 규칙 설정: Settings > Branches > Add branch protection rule
   • Branch name pattern: main 입력
   • Check: Require a pull request before merging (직접 푸시 방지)
   • Check: Require approvals (1명 이상의 승인 필요)
   • Check: Require review from Code Owners (방장 승인 필수 시)

코드 오너 설정 (CODEOWNERS 파일 생성)

이 파일이 있어야 특정 인원의 승인을 강제할 수 있습니다.

1. 프로젝트 최상위 폴더(root)에 확장자 없이 CODEOWNERS 파일을 만듭니다.
2. 파일 내용에 아래와 같이 입력합니다.

Bash # 모든 파일(*)에 대해 방장의 승인을 필수로 지정함 * @방장의_GitHub_ID

3. 이 파일을 main 브랜치에 push 합니다.

2. 표준 협업 워크플로우 (팀원 공통)

STEP 1. 로컬 저장소 연결 (Clone)

팀원 모두가 방장의 원본 저장소 주소를 클론받습니다.

Bash

git clone https://github.com/방장계정/프로젝트명.git

STEP 2. 새로운 기능 브랜치 생성 (Branch)

main에서 직접 작업하지 않고, 항상 새로운 가지(Branch)를 쳐서 나갑니다.

Bash

git checkout -b feature/login # 'login' 기능을 위한 새 브랜치 생성 및 이동

STEP 3. 작업 및 원격 푸시 (Push)

코드 수정 후 내 브랜치를 서버에 올립니다.

Bash

git add . git commit -m "로그인 기능 구현" git push origin feature/login

STEP 4. 풀 리퀘스트 생성 (Pull Request)

GitHub 웹사이트에서 feature/login → main으로 합쳐달라는 요청(PR)을 보냅니다. 이때 팀원이나 방장에게 리뷰를 요청합니다.

STEP 5. 코드 리뷰 및 승인 (Approve)

방장 혹은 리뷰어는 코드를 검토한 후 [Review changes] 버튼을 눌러 Approve를 제출합니다. (단순 댓글이 아닌 공식 승인 버튼 클릭 필수!)

STEP 6. 병합 및 브랜치 삭제 (Merge & Delete)

승인이 완료되면 Merge 버튼을 눌러 main에 합칩니다. 합쳐진 후에는 서버와 로컬에서 사용한 브랜치를 삭제하여 정리합니다.

Bash

`# 원격 브랜치 삭제 (GitHub 웹에서 버튼 클릭 또는 명령어) git push origin --delete feature/login

로컬 브랜치 삭제

git checkout main git pull origin main # 최신화된 main 받아오기 git branch -d feature/login git remote prune origin # 유령 브랜치 정리`

3. 실무 필수 팁 (Best Practices)

• main은 언제나 Ready: main 브랜치는 항상 실행 가능한 상태(Stable)를 유지해야 합니다.
• Pull Before Start: 새로운 작업을 시작하기 전에는 항상 git pull origin main을 받아 최신 상태를 유지하세요.
• 브랜치 네이밍: feature/기능명, bugfix/이슈명 처럼 용도를 명확히 적으면 소스트리에서 폴더처럼 묶여 관리하기 편합니다.
• Conflict(충돌) 발생 시: 당황하지 말고 pull을 받아 인텔리제이의 Merge 도구를 활용해 코드를 합친 후 다시 push 하세요.

브랜치를 사용하는 경우

• 새로운 기능 추가 (브랜치를 생성해서 기능 추가 후 main 브랜치로 병합)
• 버그 수정 (브랜치를 생성해서 버그 수정 후 main 브랜치로 병합)
• 병합과 리베이스 테스트
• 이전 코드 개선
• 특정 커밋으로 돌아가고 싶을 때

💡 현재 연결된 원격 저장소 확인: git remote -v

브랜치 만들기

git branch                        # 현재 브랜치 확인
git branch <생성할 브랜치 이름>     # 새로운 브랜치 생성
git log --oneline --graph --all --decorate  # 변경된 브랜치 확인

💡 HEAD는 현재 작업 중인 브랜치를 가리킨다.

switch : 브랜치 변경하기

[main] 브랜치에서 [mybranch1] 브랜치로 변경하고 새로운 커밋 생성 후 결과 확인

git switch <브랜치 이름>           # 브랜치 변경
git branch                        # 현재 브랜치 확인
git log --oneline --graph --all --decorate  # HEAD 변경 확인

# 파일 수정 후
git status                        # 스테이지 상태 확인
git add .                         # 스테이지에 변경 사항 추가
git commit -m "<message>"         # 커밋
git log --oneline --graph --all --decorate  # 변경된 브랜치 확인

fast-forward merge : 빨리 감기 병합

main과 mybranch1 병합하기

git switch main          # main 브랜치로 변경
git merge mybranch1      # 빨리 감기 병합
git log --oneline --graph --all --decorate  # 확인

reset --hard : 브랜치 되돌리기

현재 브랜치를 지정한 커밋으로 옮긴다. 작업 폴더의 내용도 함께 변경된다.

git reset --hard <이동할 커밋 체크섬>

체크섬 대신 아래 약칭 사용 가능:

git reset --hard HEAD~2                     # 두 단계 이전으로 되돌리기
git log --oneline --graph --all --decorate  # 로그 확인

rebase : 리베이스

리베이스 원리:

1. HEAD와 대상 브랜치의 공통 조상을 찾는다.
2. 공통 조상 이후에 생성한 커밋들을 대상 브랜치 뒤로 재배치한다.

⚠️ 주의: 이미 원격 저장소(GitHub)에 푸시한 브랜치는 절대 Rebase 하지 말 것!

tag : 배포 버전에 태그 달기

git tag -a -m "첫 번째 태그 생성" v0.1        # 주석 있는 태그 작성
git log --oneline --graph --all --decorate    # 태그 생성 확인
git push origin v0.1                          # 태그 푸시

3-way 병합

긴급 버그 처리 시나리오

1. (옵션) 오류가 없는 버전(주로 Tag가 있는 커밋)으로 롤백
2. [main] 브랜치로부터 [hotfix] 브랜치 생성
3. 빠르게 소스코드 수정 및 테스트 완료
4. [main] 브랜치로 빨리 감기 병합 및 배포
5. 개발 중인 브랜치에도 병합 (단, 충돌 발생 가능성 높음)

새로운 브랜치 및 커밋 생성 (기능 개발)

git switch main                  # main 브랜치로 변경
git switch -c feature1           # feature1 브랜치 생성 및 변경

# 파일 수정 후
git add .
git commit -m "<message>"
git log --oneline --graph --all --decorate

hotfix 브랜치 생성 및 main에 병합

git switch -c hotfix main        # main에서 hotfix 브랜치 생성 후 변경

# 버그 파일 수정 후
git add .
git commit -m "<message>"
git log --oneline --graph --all --decorate

* db531ae (HEAD -> hotfix) test3 버그수정
| * dc53cc3 (feature1) test3
|/
* 3ab375f (tag: v0.1, origin/main, origin/HEAD, main) test2
* 96abff0 test
* 73850bd 코딩테스트 기록 시작

git switch main
git merge hotfix     # 빨리 감기 병합

* db531ae (HEAD -> main, hotfix) test3 버그수정
| * dc53cc3 (feature1) test3
|/
* 3ab375f (tag: v0.1, origin/main, origin/HEAD) test2
* 96abff0 test
* 73850bd 코딩테스트 기록 시작

hotfix 커밋(버그 수정)은 현재 개발 중인 [feature1] 브랜치에도 반영해야 한다. [feature1]과 [main]은 서로 다른 분기이므로 3-way 병합을 수행한다.

병합 및 충돌 해결

git switch feature1    # feature1 브랜치로 변경
git merge main         # main 브랜치와 병합 시도 → 충돌 발생

Auto-merging src/programmers/test3.java
CONFLICT (add/add): Merge conflict in src/programmers/test3.java
Automatic merge failed; fix conflicts and then commit the result.

git status             # 충돌 파일 확인 (both added: ...)

충돌 파일을 직접 열어 수동으로 수정한 뒤:

cat <파일>             # 최종 변경 내용 확인
git add .
git status             # modified: src/programmers/test3.java
git commit             # 병합 커밋 생성
git log --oneline --graph --all --decorate

*   997db09 (HEAD -> feature1) 병합
|\
| * db531ae (origin/main, origin/HEAD, main, hotfix) test3 버그수정
* | dc53cc3 test3
|/
* 3ab375f (tag: v0.1) test2
* 96abff0 test
* 73850bd 코딩테스트 기록 시작

3-way 병합은 병합 커밋이 생성되어 트리가 복잡해진다. 히스토리를 깔끔하게 유지하고 싶다면 리베이스를 사용한다.

GUI(SourceTree 등) 환경을 넘어, 터미널(Git Bash)에서 직접 명령어를 입력하며 Git 저장소를 관리하는 필수 방법들을 정리했습니다.

1. 터미널 기본 개념 및 이동

• Git Bash: 윈도우 환경에서 리눅스 스타일의 명령어를 사용할 수 있게 해주는 도구입니다.
• 프롬프트($): 명령어를 입력할 수 있는 상태임을 나타냅니다. 앞에 표시되는 경로는 현재 작업 중인 폴더의 위치를 의미합니다.

자주 사용하는 기본 명령어

• pwd: 현재 작업 중인 폴더의 전체 경로 확인
• ls -a: 현재 폴더의 파일 목록 확인 (숨김 파일 포함)
• mkdir <폴더명>: 새로운 폴더 생성
• cd <폴더명>: 해당 폴더로 이동 (cd ..은 상위 폴더로 이동, cd ~은 홈 폴더로 이동)

2. 로컬 저장소 생성 및 초기화

주의: 바탕화면 자체를 저장소로 만들지 말고, 별도의 작업 폴더를 생성한 뒤 내부에서 실행하세요.

• git init -b main: 현재 폴더를 Git 로컬 저장소로 초기화하며, 기본 브랜치 이름을 main으로 설정합니다.
• .git 폴더: 이 명령을 실행하면 숨김 폴더인 .git이 생성됩니다. 여기가 Git의 모든 이력이 기록되는 로컬 저장소입니다.
• 워킹 트리(Working Tree): 실제로 파일을 수정하고 작성하는 현재 작업 폴더를 의미합니다.

3. 스테이징과 커밋 (Add & Commit)

파일 추적 및 스테이징

• git status: 현재 워킹 트리의 상태(수정된 파일, 스테이지에 올라간 파일 등)를 확인합니다.
• git add <파일명>: 파일을 스테이지(Stage)에 올립니다. (커밋 대기 상태)
• git reset <파일명>: 스테이지에 올린 파일을 다시 내립니다. (언스테이징)

커밋 생성 및 이력 확인

• git commit -m "메시지": 스테이지에 올라온 파일들을 하나의 버전(커밋)으로 기록합니다.
• git log --oneline --graph --all --decorate: 커밋 히스토리를 한 줄씩, 그래프 형태로 보기 좋게 출력합니다.

4. 원격 저장소(GitHub) 협업

원격 저장소 등록 및 푸시(Push)

• git remote add origin <주소>: 로컬 저장소에 origin이라는 이름으로 원격 저장소 주소를 등록합니다.
• git remote -v: 연결된 원격 저장소 목록과 주소를 확인합니다.
• git push -u origin main: 로컬의 main 브랜치 내용을 원격(origin)으로 업로드합니다. -u 옵션은 업스트림 설정을 통해 이후 git push만 입력해도 동작하게 만듭니다.

저장소 복제(Clone)와 반영(Pull)

• git clone <주소> [폴더명]: 원격 저장소의 전체 내용을 복제하여 새로운 로컬 저장소를 만듭니다. (반드시 저장소를 만들 상위 디렉터리에서 실행하세요.)
• git pull: 원격 저장소의 새로운 변경 사항을 내려받아 현재 내 워킹 트리에 합칩니다.

💡 작업 흐름 요약 (Workflow)

1. git add .: 변경된 모든 파일을 스테이지에 올림
2. git commit -m "feat: 기능 추가": 로컬에 버전 기록
3. git push: 원격 저장소에 공유
4. (다른 환경에서) git pull: 최신 상태 업데이트

#Git #GitBash #CLI #Github #버전관리 #백엔드공부

개요

1. 발신인 계좌에서 지정된 금액을 인출한다.
2. 수취인 계좌에 해당 금액을 입금한다.

Model

public class Account {

    @Id
    private long id;

    private String name;
    private BigDecimal amount;

    // getter, setter 생략
}

Repository

public interface AccountRepository extends CrudRepository<Account, Long> {

    @Query("SELECT * FROM account WHERE name = :name")
    List<Account> findAccountsByName(String name);

    @Modifying
    @Query("UPDATE account SET amount = :amount WHERE id = :id")
    void changeAmount(long id, BigDecimal amount);
}

Service

• 변동성 있는 서비스 메서드에 @Transactional 애너테이션을 붙여 애스펙트를 사용한다.

• Spring Data에서 기본적으로 findById(), findAll() 등의 메서드를 제공한다.

• Iterable은 List의 상위 타입이다.

  @Service
  public class TransferService {
  
    private final AccountRepository accountRepository;
  
    public TransferService(AccountRepository accountRepository) {
        this.accountRepository = accountRepository;
    }
  
    @Transactional
    public void transferMoney(
            long idSender,
            long idReceiver,
            BigDecimal amount
    ) {
        Account sender = accountRepository.findById(idSender)
                .orElseThrow(() -> new AccountNotFoundException());
  
        Account receiver = accountRepository.findById(idReceiver)
                .orElseThrow(() -> new AccountNotFoundException());
  
        BigDecimal senderNewAmount = sender.getAmount().subtract(amount);
        BigDecimal receiverNewAmount = receiver.getAmount().add(amount);
  
        accountRepository.changeAmount(idSender, senderNewAmount);
        accountRepository.changeAmount(idReceiver, receiverNewAmount);
    }
  
    public Iterable<Account> getAllAccounts() {
        return accountRepository.findAll();
    }
  
    public List<Account> findAccountsByName(String name) {
        return accountRepository.findAccountsByName(name);
    }
  }

Exception

public class AccountNotFoundException extends RuntimeException {
}

Controller

• 계좌 상세 정보를 반환할 때 비필수 매개변수(required = false)로 이름을 받아 조건부로 조회한다.

  @RestController
  public class AccountController {
  
    private final TransferService transferService;
  
    public AccountController(TransferService transferService) {
        this.transferService = transferService;
    }
  
    @PostMapping("/transfer")
    public void transferMoney(
            @RequestBody TransferRequest request
    ) {
        transferService.transferMoney(
                request.getSenderAccountId(),
                request.getReceiverAccountId(),
                request.getAmount()
        );
    }
  
    @GetMapping("/accounts")
    public Iterable<Account> getAllAccounts(
            @RequestParam(required = false) String name
    ) {
        if (name == null) return transferService.getAllAccounts(); // 모든 계좌 반환
        else return transferService.findAccountsByName(name);     // 이름으로 필터링
    }
  }

DTO

public class TransferRequest {
    private long senderAccountId;
    private long receiverAccountId;
    private BigDecimal amount;

    // getter 생략
}

스프링 데이터는 반복되는 CRUD 코드를 획기적으로 줄여주고, 다양한 영속성 기술(RDBMS, NoSQL 등)을 공통된 방식으로 다룰 수 있게 해주는 강력한 라이브러리입니다.

1. 스프링 데이터(Spring Data)란?

• 정의: 영속성 기술에 맞는 구현을 제공하여, 최소한의 코드 작성만으로 리포지터리를 정의할 수 있게 돕는 도구입니다.
• 다양한 선택지: JDBC를 통한 직접 연결뿐만 아니라 MongoDB, Neo4J 같은 NoSQL이나 하이버네이트(Hibernate) 같은 ORM 프레임워크와도 연동 가능합니다.
• 구현 단순화 방법:
  1. 공통 추상화: 다양한 기술에 대해 일관된 인터페이스 집합을 제공하여 사용법을 유사하게 유지합니다.
  2. 자동 구현: 사용자가 인터페이스(추상화)만 정의하면, 스프링 데이터가 백그라운드에서 실제 구현체를 생성하여 제공합니다.

2. 스프링 데이터의 작동 방식 및 주요 인터페이스

스프링 데이터는 앱의 영속성 기능을 정의하기 위해 확장(extends)해야 하는 공통 인터페이스 계약을 제공합니다.

• 주요 인터페이스:
  • Repository: 마커 인터페이스로, 가장 기본적인 계층을 나타냅니다.
  • CrudRepository: 기본적인 생성, 조회, 수정, 삭제(CRUD) 연산을 제공합니다.
  • PagingAndSortingRepository: CRUD 기능에 정렬 및 페이지네이션 기능이 추가됩니다.
  • JpaRepository: 스프링 데이터 JPA 모듈에서 제공하며, 하이버네이트 같은 ORM 전용 연산이 추가된 인터페이스입니다.

3. 스프링 데이터 JDBC 사용 및 모델링

기본 규칙

• @Id: 어떤 필드가 테이블의 기본 키(Primary Key)인지 표시합니다.

• 제네릭 타입 설정: 리포지터리 인터페이스 확장 시 두 개의 제네릭 타입을 지정해야 합니다.

  1. 엔티티(Entity): 리포지터리가 관리할 모델 클래스.

  2. ID 타입: 기본 키(@Id) 필드의 데이터 타입.

     public class Account {
     
     @Id
     private long id;
     
     private String name;
     private BigDecimal amount;
     

//getter setter 생략 }

```java
public interface AccountRepository 
extends CrudRepository<Account, Long//엔티티, 기본키 타입> {
}

4. 쿼리 생성 전략 (Query Methods)

스프링 데이터는 SQL을 직접 작성하지 않아도 메서드 이름을 해석하여 자동으로 쿼리를 생성해 줍니다.

메서드 이름 해석 규칙 예시: findAccountByName(String name)

1. List: 결과가 0개 이상일 수 있음을 알리며 리스트로 매핑됩니다.

2. find: SELECT 절로 변환됩니다.

3. Accounts: 대상 테이블(FROM account)을 지정합니다.

4. ByName: 조회 조건(WHERE name = ?)을 지정합니다.

5. (String name): 매개변수 값이 쿼리의 바인딩 변수가 됩니다.

   public interface AccountRepository extends CrudRepository<Account, Long> {
   
    List<Account> findAccountsByName(String name);
   }

   @Query 애너테이션 활용

   메서드 이름이 지나치게 길어지거나 성능 최적화가 필요한 경우, @Query를 통해 SQL을 직접 명시할 수 있습니다.

• 특징: 메서드 이름 명명 규칙에서 자유로워집니다.

• @Modifying: UPDATE, INSERT, DELETE와 같이 데이터를 변경하는 쿼리를 사용할 때는 반드시 이 애너테이션을 함께 추가해야 합니다.

  public interface AccountRepository extends CrudRepository<Account, Long> {
  
    @Query("SELECT * FROM account WHERE name = :name")
    //쿼리의 매개변수 이름은 메서드 매개변수 이름과 동일해야 한다. 
    //콜론(:)과 매개변수 이름 사이에 공백이 없어야 한다.
    List<Account> findAccountsByName(String name);
  }

  public interface AccountRepository extends CrudRepository<Account, Long> {
  
    @Query("SELECT * FROM account WHERE name = :name")
    List<Account> findAccountsByName(String name);
  
    @Modifying //데이터를 변경하는 연산을 정의하는 메서드에 @Modifying 애너테이션을 추가한다.
    @Query("UPDATE account SET amount = :amount WHERE id = :id")
    void changeAmount(long id, BigDecimal amount);
  }

🎯 요약

1. 스프링 데이터는 인터페이스만 정의하면 구현체를 자동으로 생성하여 개발 속도를 높여준다.
2. CrudRepository 등을 확장하여 필요한 수준의 연산을 선택적으로 사용할 수 있다.
3. 쿼리 메서드 기능을 통해 메서드 이름만으로 SQL 쿼리를 자동 생성할 수 있다.
4. 복잡한 쿼리는 @Query를 사용하며, 데이터 변경 시에는 @Modifying을 잊지 말아야 한다.

#Spring #SpringData #SpringDataJDBC #Repository #CrudRepository #QueryMethod #백엔드공부