튜플(Tuple)은 데이터베이스에서 하나의 행(Row) 또는 여러 컬럼의 묶음을 의미합니다. 튜플 비교는 여러 개의 컬럼 값을 하나의 단위로 묶어서, 다른 값의 묶음과 한 번에 비교하는 문법입니다.

가장 기본적인 형태는 다음과 같습니다.

-- 기존 방식
WHERE col1 = 10 AND col2 = 20

-- 튜플 비교 방식
WHERE (col1, col2) = (10, 20)

위와 같이 (와 )로 컬럼들을 묶어 하나의 세트처럼 비교할 수 있습니다. 동등 비교(=)에서는 기존 방식과 큰 차이가 없어 보이지만, 부등호(>, <)를 사용할 때 튜플 비교의 진가가 발휘됩니다.

2. 부등호 비교에서의 동작 원리 (핵심 ⭐)

튜플 비교에서 > 나 < 같은 부등호를 사용할 때, 데이터베이스는 왼쪽 컬럼부터 오른쪽 컬럼 순서대로(Lexicographical order, 사전식 순서) 값을 평가합니다.

가장 헷갈리기 쉬운 (A, B) > (C, D) 의 동작 원리를 풀어서 설명해 보겠습니다.

💡 (A, B) > (C, D) 의 논리적 의미

이 조건은 다음의 복합 조건과 완전히 동일하게 동작합니다.

WHERE A > C 
   OR (A = C AND B > D)

해석하자면:

1. 먼저 첫 번째 값인 A와 C를 비교합니다. A가 C보다 크면, 두 번째 값(B, D)은 볼 필요도 없이 조건이 참(True)이 됩니다.
2. 만약 A와 C가 같다면, 그제야 두 번째 값인 B와 D를 비교하여 B가 D보다 큰지 확인합니다.

이러한 원리는 3개 이상의 컬럼을 묶을 때도 동일하게 확장됩니다.

• (A, B, C) > (X, Y, Z)
• $\Leftrightarrow$ A > X OR (A = X AND B > Y) OR (A = X AND B = Y AND C > Z)

3. 실무 활용 예시: 커서 기반 페이지네이션 (No Offset)

튜플 비교가 실무에서 가장 빛을 발하는 순간은 커서 기반 페이지네이션(Cursor-based Pagination)을 구현할 때입니다.

예를 들어, 게시판에서 "조회수(view_count)가 높은 순, 조회수가 같다면 최신 글(id) 순"으로 정렬된 데이터를 페이징 처리한다고 가정해 보겠습니다.

이전 페이지의 마지막 게시글 정보가 조회수: 100, ID: 50 이었다면, 다음 페이지를 조회하기 위해 어떻게 쿼리를 짜야 할까요?

❌ 기존 방식 (AND, OR 조합)

SELECT *
  FROM board
 WHERE view_count < 100 
    OR (view_count = 100 AND id < 50)
 ORDER BY view_count DESC, id DESC
 LIMIT 10;

조건이 길어지고, 괄호가 들어가면서 쿼리를 한눈에 파악하기 어렵습니다. 만약 정렬 조건이 3개로 늘어난다면 WHERE 절은 훨씬 더 복잡해집니다.

⭕ 튜플 비교 적용

SELECT *
  FROM board
 WHERE (view_count, id) < (100, 50)
 ORDER BY view_count DESC, id DESC
 LIMIT 10;

쿼리가 놀랍도록 간결해졌습니다! (view_count, id)를 하나의 커서(Cursor) 튜플로 취급하여, 이전 커서보다 '작은' 데이터들을 가져오라는 의미가 직관적으로 전달됩니다.

4. 인덱스(Index) 활용과 성능

튜플 비교를 사용한다고 해서 성능이 떨어지지는 않습니다. 오히려 복합 인덱스(Composite Index)가 적절히 구성되어 있다면 매우 효율적으로 동작합니다.

위의 게시판 예시에서 (view_count, id) 로 복합 인덱스가 걸려있다면, 데이터베이스의 옵티마이저는 튜플 비교 조건을 보고 인덱스를 순차적으로(Range Scan) 잘 타게 됩니다. 기존의 OR 조건보다 실행 계획을 최적화하기 더 유리한 경우가 많습니다.

주의사항: 다만, 데이터베이스 제품이나 버전에 따라 IN 절 내에서 튜플 비교를 사용하거나, 특정 복잡한 조건이 섞일 경우 인덱스를 제대로 타지 못하는 엣지 케이스가 있을 수 있으므로 실행 계획(Explain Plan)을 확인하는 습관을 들이는 것이 좋습니다.

5. 데이터베이스 지원 여부

튜플 비교는 SQL-92 표준에 정의된 문법이므로, 현대의 대부분의 RDBMS에서 지원합니다.

• Oracle: 9i 이상부터 완벽하게 지원 (12c, 19c 등 최신 버전 모두 원활하게 동작)
• MySQL: 5.7 이상, 8.0에서 잘 지원됨
• PostgreSQL: 완벽하게 지원

단, SQL Server(MSSQL)의 경우 버전에 따라 튜플 비교 문법 지원이 제한적이거나 불완전할 수 있으므로, MSSQL 환경이라면 기존의 AND/OR 방식을 사용해야 할 수도 있습니다.

📝 요약

1. 튜플 비교는 여러 컬럼을 (A, B) 형태로 묶어 비교하는 SQL 표준 문법이다.
2. 부등호(>, <) 비교 시 사전식 순서(Lexicographical order)로 논리가 전개된다.
3. 쿼리의 가독성을 극대화하며, 복잡한 AND/OR 조건을 깔끔하게 대체할 수 있다.
4. 커서 기반 페이지네이션(무한 스크롤 등)을 구현할 때 특히 유용하다.

복잡한 다중 정렬 조건으로 인해 쿼리가 지저분해져서 고민이었다면, 지금 바로 튜플 비교를 도입해 보세요!

페이지네이션이란?

전체 결과 집합을 페이지 단위로 나눠, 요청된 페이지에 해당하는 행만 조회하는것을 말한다.

가장 쉬운 페이지네이션은 OFFSET을 이용한 페이지네이션이다.

SELECT 
    *
FROM
    table
WHERE 
    ~
LIMIT <페이지당 보여줄 개수> OFFSET (<현재 페이지> - 1) * <페이지당 보여줄 개수>

OFFSET 키워드는 SELECT 결과에서 앞쪽 N개 행을 읽어 버리고, 그다음 행부터 반환하게 한다.

1. OFFSET의 문제

SELECT * FROM posts
ORDER BY created_at DESC
OFFSET 100000 LIMIT 20;

OFFSET 100000은 조건에 맞는 행을 처음부터 100,000건 읽어서 전부 버린 뒤, 그다음 20건을 반환한다. 즉 버려질 행도 전부 읽어야 하므로 비용이 OFFSET 값에 비례해서 커진다. 1페이지는 빠르지만 5000페이지는 느린 이유가 이것이다.

해결방안

1. 지연 조인 (Deferred Join / Late Row Lookup)

아이디어

버려질 행에 대해서는 무거운 본문 데이터까지 읽지 말고, 좁은 커버링 인덱스에서 id(키)만 빠르게 얻어 스킵한다.

커버링 인덱스란?

쿼리가 필요로 하는 컬럼을 인덱스 자체가 전부 들고 있어서, 테이블 본문(힙)까지 가지 않고 인덱스만 읽어 답하는 것이 커버링 인덱스

최종적으로 살아남은 20건에 대해서만 본 테이블에 접근해 실제 데이터를 가져온다.

SELECT p.*
FROM posts p
JOIN (
    SELECT id
    FROM posts
    ORDER BY created_at DESC
    OFFSET 100000 LIMIT 20
) AS sub ON p.id = sub.id
ORDER BY p.created_at DESC;

반드시 짚을 점 (오해 주의)

지연 조인은 여전히 100,000개의 인덱스 엔트리를 스캔해서 버린다. 따라서 시간 복잡도는 O(N) 그대로이고, 줄어드는 것은 "버려질 행 1건당 비용(상수 인자)"뿐이다. 페이지가 충분히 깊어지면 지연 조인도 결국 느려진다. 이건 OFFSET 회피가 아니라 OFFSET 최적화다.

2. 커서 기반 / 키셋 페이지네이션 (Keyset Pagination, Seek Method)

아이디어

OFFSET을 아예 쓰지 않는다. 직전 페이지의 마지막 행의 정렬 기준값을 다음 페이지의 시작 조건으로 넘긴다. 인덱스를 타고 시작 위치로 곧장 "점프"하므로, 몇 페이지째인지와 무관하게 항상 LIMIT 건수만큼만 읽는다.

(A) 정렬 기준이 고유 컬럼(예: PK id)일 때

SELECT * FROM posts
WHERE id < :last_id        -- 직전 페이지 마지막 행의 id
ORDER BY id DESC
LIMIT 20;

이때만 "마지막 id를 커서로 쓴다"는 설명이 정확히 성립한다.

(B) 정렬 기준이 비고유 컬럼(예: created_at)일 때 — 실전에서 더 흔함

created_at은 중복될 수 있으므로 id를 타이브레이커로 함께 넘겨야 경계에서 행이 누락/중복되지 않는다.

-- row-value 비교 (PostgreSQL이 복합 인덱스로 잘 최적화함)
SELECT * FROM posts
WHERE (created_at, id) < (:last_created_at, :last_id)
ORDER BY created_at DESC, id DESC
LIMIT 20;

• 필요한 인덱스: (created_at, id) (또는 (created_at DESC, id DESC)).
• (a, b) < (c, d)는 a < c OR (a = c AND b < d)를 의미한다. 직접 OR로 풀어 써도 되지만 row-value 비교가 더 깔끔하고 인덱스 활용도 좋다.

한계와 적합한 UI

keyset의 빠른 속도는 "직전 페이지의 마지막 행"을 알아야 다음 페이지를 구할 수 있다는 구조에서 나온다. 즉 순차적으로만 이동할 수 있다. 이 특성이 UI 선택을 가른다.

• 페이지 번호 UI([1][2][3]...[1000])에는 부적합하다. "7페이지로 바로 점프"하려면 6페이지 마지막 행의 커서값이 필요한데, 그 페이지를 거치지 않으면 알 수 없다. 임의 페이지로의 직접 점프가 구조적으로 불가능하다. 또한 전체 페이지 수를 알려면 별도의 COUNT(*)가 필요한데, 이는 keyset이 피하려던 비용을 다시 불러온다.
• "다음 / 이전" 버튼이나 무한 스크롤(infinite scroll)에는 최적이다. 두 방식 모두 "지금 보고 있는 마지막 행 다음"만 요구하므로 keyset의 동작 방식과 정확히 맞는다. 페이지가 깊어져도 속도가 일정하다는 장점이 그대로 살아난다. SNS 피드, 타임라인, 무한 스크롤 목록이 대부분 이 방식을 쓰는 이유다.

정리하면, 임의 페이지 점프가 필요하면 OFFSET, 순방향 탐색만 필요하면 keyset이다. 깊은 페이지에서의 성능 때문에 무조건 keyset이 정답인 것은 아니고, UI 요구사항이 먼저다.

각 항목마다 이 프로젝트의 실제 코드를 예시로 사용합니다.

목차

1. 변수 선언 — val vs var
2. 타입 추론
3. 함수 선언 — fun
4. 표현식 함수 (단일 표현식)
5. 기본 파라미터값 & 이름 있는 인수
6. 클래스와 주 생성자
7. data class
8. companion object
9. Null 안전성 — ?, ?:, !!
10. 문자열 템플릿 — $
11. 람다와 고차 함수 — map, it
12. 스코프 함수 — also
13. require() — 전제 조건 검사
14. mapOf() & to 중위 함수
15. 범위 연산자 — .. & in
16. 멀티라인 문자열 — """ & trimIndent()
17. 숫자 리터럴의 밑줄 — 1_000_000
18. 인터페이스 — interface
19. 와일드카드 import — *
20. 코틀린에서 자바 클래스 참조 — ::class.java
21. Unit vs Void
22. 후행 쉼표 (Trailing Comma)

1. 변수 선언 — val vs var

// PostService.kt
val offset = (page - 1) * size   // 이후 바꿀 일 없음 → val
val posts  = postMapper.findAll(offset, size)

// Post.kt (domain)
// MyBatis 가 리플렉션으로 값을 채워넣어야 하므로 var 사용
var id: Long = 0
var title: String = ""

// PostService.kt — updatePost()
// 조회 후 값을 바꿔야 하므로 var 이어야 가능
post.title   = request.title    // Post.title 이 var 이기 때문에 가능
post.content = request.content

원칙: 바꿀 필요가 없으면 val, 바꿔야 한다면 var. DTO(요청/응답 객체)는 한 번 만들고 끝이니 val, 도메인 객체는 DB에서 값을 주입받아야 하니 var.

2. 타입 추론

Kotlin 컴파일러가 오른쪽 값을 보고 타입을 자동으로 알아냅니다.

val offset = (page - 1) * size   // Int 로 추론
val start  = System.currentTimeMillis()  // Long 으로 추론
val posts  = postMapper.findAll(offset, size)  // List<Post> 로 추론

타입을 명시할 수도 있습니다 (선택 사항).

val offset: Int  = (page - 1) * size   // 명시적으로 써도 됨
val start: Long  = System.currentTimeMillis()

3. 함수 선언 — fun

// 기본 형태
fun 함수이름(파라미터: 타입): 반환타입 {
    // 본문
}

// PostService.kt
fun getPosts(page: Int, size: Int): PostListResponse {
    val offset = (page - 1) * size
    val posts  = postMapper.findAll(offset, size)
    // ...
    return PostListResponse(...)
}

반환값이 없으면 반환 타입을 생략하거나 Unit 을 씁니다.

fun deletePost(id: Long) {           // 반환 타입 생략 = Unit
    postMapper.delete(id)
}

4. 표현식 함수 (단일 표현식)

함수 본문이 return 표현식 딱 한 줄이면, = 으로 줄여 쓸 수 있습니다.

// PostController.kt — 일반 형태
fun getPost(@PathVariable id: Long): ResponseEntity<PostResponse> {
    return ResponseEntity.ok(postService.getPost(id))
}

// ↓ 표현식 함수로 줄이면
fun getPost(@PathVariable id: Long): ResponseEntity<PostResponse> =
    ResponseEntity.ok(postService.getPost(id))

이 프로젝트의 Controller 메서드 대부분이 이 형태입니다.

5. 기본 파라미터값 & 이름 있는 인수

기본 파라미터값 (Default Parameter)

Java 의 메서드 오버로딩 없이, 파라미터에 기본값을 지정할 수 있습니다.

// PostController.kt
fun getPosts(
    @RequestParam(defaultValue = "1")  page: Int = 1,
    @RequestParam(defaultValue = "20") size: Int = 20,
): ResponseEntity<PostListResponse>

// Post.kt (domain) — 모든 파라미터에 기본값 → "인수 없는 생성자" 효과
data class Post(
    var id: Long = 0,
    var title: String = "",
    var content: String = "",
    // ...
)

이름 있는 인수 (Named Argument)

함수를 호출할 때 파라미터 이름을 명시해서 가독성을 높입니다.

// PostService.kt — createPost()
val post = Post(
    title   = request.title,    // 이름을 붙여서 호출
    content = request.content,
    author  = request.author,
)

이름을 붙이면 순서를 바꿔도 되고, 어떤 값이 어떤 파라미터인지 한눈에 보입니다.

6. 클래스와 주 생성자

Kotlin 클래스는 선언과 동시에 생성자를 정의합니다.

// 클래스 이름 뒤 괄호가 "주 생성자(Primary Constructor)"
class PostController(private val postService: PostService) {
    // postService 는 클래스 전체에서 사용 가능한 필드가 됨
}

private val postService 처럼 생성자 파라미터 앞에 접근 제어자를 붙이면, 생성자 파라미터이자 클래스 필드 가 됩니다.

Java 로 표현하면:

// Java
public class PostController {
    private final PostService postService;  // 필드 선언

    public PostController(PostService postService) {  // 생성자
        this.postService = postService;
    }
}

Spring 은 이 생성자를 보고 PostService 빈을 자동 주입(DI)합니다.

7. data class

data 키워드를 붙이면 컴파일러가 아래 메서드를 자동 생성합니다.

// Post.kt
data class Post(
    var id: Long = 0,
    var title: String = "",
    var content: String = "",
    var author: String = "",
    var viewCount: Int = 0,
    var createdAt: LocalDateTime = LocalDateTime.now(),
    var updatedAt: LocalDateTime = LocalDateTime.now(),
)

copy() 활용 예시

val original = Post(title = "제목", content = "내용", author = "홍길동")

// title 만 바꾼 새 Post 객체 생성 (original 은 그대로)
val updated = original.copy(title = "새 제목")

data class 는 언제 쓰나?
데이터를 담는 것이 주 목적인 클래스 (DTO, 도메인 객체 등). 비즈니스 로직이 많은 클래스는 일반 class 가 낫습니다.

8. companion object

Java 의 static 에 해당하는 개념입니다.
Kotlin 에는 static 키워드가 없고, 대신 클래스 안에 companion object 블록을 만듭니다.

// PostDto.kt
data class PostResponse(
    val id: Long,
    val title: String,
    // ...
) {
    companion object {                         // ← 여기
        fun from(post: Post) = PostResponse(   // 정적 팩토리 메서드
            id    = post.id,
            title = post.title,
            // ...
        )
    }
}

호출 방법

// Java 의 PostResponse.from(post) 와 동일하게 호출
val response = PostResponse.from(post)

Java 와 비교

// Java
public class PostResponse {
    // ...
    public static PostResponse from(Post post) {   // static 메서드
        return new PostResponse(post.getId(), post.getTitle(), ...);
    }
}

왜 팩토리 메서드 패턴을 쓰나?
도메인 객체(Post)를 응답 DTO(PostResponse)로 변환하는 로직을 한 곳에 모아두면,
변환 방식이 바뀔 때 from() 만 수정하면 됩니다.

9. Null 안전성 — ?, ?:, !!

Kotlin 은 null 이 될 수 있는 타입과 없는 타입을 컴파일 시점에 구분합니다.

? — nullable 타입

// PostMapper.kt
fun findById(@Param("id") id: Long): Post?
//                                       ↑ DB에 없으면 null 을 반환할 수 있음

?: — 엘비스 연산자 (Elvis Operator)

"null 이면 오른쪽을 실행해라" 라는 뜻입니다.

// PostService.kt
val post = postMapper.findById(id)
    ?: throw NoSuchElementException("게시글을 찾을 수 없습니다. id=$id")
//  ↑ findById 가 null 을 반환하면 예외를 던짐

// DataSeederController.kt
val totalCount = jdbc.queryForObject("SELECT COUNT(*) FROM posts", Long::class.java) ?: 0
//                                                                                    ↑ null 이면 0 으로 대체

!! — non-null 단언 (강제 언박싱)

"나는 이 값이 null 이 아님을 확신한다" 는 선언입니다.
null 이면 NullPointerException 이 발생하므로, 사용에 주의해야 합니다.

val name: String? = "홍길동"
val length = name!!.length   // null 이 아님을 개발자가 보장

이 프로젝트에서는 !! 대신 ?: 로 안전하게 처리하고 있습니다.

10. 문자열 템플릿 — $

문자열 안에 변수나 표현식을 직접 삽입할 수 있습니다.

// PostService.kt
throw NoSuchElementException("게시글을 찾을 수 없습니다. id=$id")
//                                                            ↑ $변수명

중괄호로 감싸면 더 복잡한 표현식도 넣을 수 있습니다.

// DataSeederController.kt
"rate" to "${count * 1000 / elapsed.coerceAtLeast(1)} 건/초"
//          ↑ ${ 표현식 }

Java 와 비교하면:

// Java
throw new NoSuchElementException("게시글을 찾을 수 없습니다. id=" + id);

// Kotlin
throw NoSuchElementException("게시글을 찾을 수 없습니다. id=$id")

11. 람다와 고차 함수 — map, it

람다 (Lambda)

중괄호 { } 로 감싼 코드 블록입니다. 함수의 인수로 전달할 수 있습니다.

// PostService.kt
posts.map { PostResponse.from(it) }
//    ↑ map 에 람다를 전달

it — 암묵적 파라미터

람다 파라미터가 하나뿐일 때, 이름을 직접 지어주는 대신 it 으로 참조합니다.

posts.map { it -> PostResponse.from(it) }  // it 명시적으로 쓴 것
posts.map { PostResponse.from(it) }        // it 생략한 것 (같은 의미)

map

컬렉션의 각 요소를 변환해서 새 리스트를 만드는 함수입니다.

// [Post, Post, Post] → [PostResponse, PostResponse, PostResponse]
val responses: List<PostResponse> = posts.map { PostResponse.from(it) }

Java 의 Stream 으로 표현하면:

// Java
List<PostResponse> responses = posts.stream()
    .map(PostResponse::from)
    .collect(Collectors.toList());

함수 참조 (::)

람다 대신 메서드 참조를 쓸 수도 있습니다.

posts.map { PostResponse.from(it) }  // 람다
posts.map(PostResponse::from)        // 함수 참조 (동일한 의미)

12. 스코프 함수 — also

스코프 함수는 객체에 대해 코드 블록을 실행하는 함수들입니다.
이 프로젝트에서는 also 를 사용합니다.

also

"이것도 해라" 라는 의미입니다.
객체 자신을 it 으로 받아 부수 작업을 한 뒤, 원래 객체를 그대로 반환합니다.

// PostService.kt
return PostResponse.from(post.also { it.viewCount++ })
//                            ↑ post.viewCount 를 증가시키고, post 자체를 반환
//                       ↑ 증가된 post 를 from() 에 전달

흐름을 풀어 쓰면:

// also 없이 쓴다면
post.viewCount++
return PostResponse.from(post)

// also 를 쓰면 한 줄로
return PostResponse.from(post.also { it.viewCount++ })

스코프 함수 한눈에 비교

13. require() — 전제 조건 검사

파라미터의 유효성을 검사할 때 씁니다.
조건이 false 이면 IllegalArgumentException 을 자동으로 던집니다.

// DataSeederController.kt
require(count in 1..10_000_000) { "count 는 1 ~ 10,000,000 사이여야 합니다." }
//      ↑ 조건                    ↑ 실패 시 메시지를 반환하는 람다

Java 로 표현하면:

// Java
if (!(count >= 1 && count <= 10_000_000)) {
    throw new IllegalArgumentException("count 는 1 ~ 10,000,000 사이여야 합니다.");
}

비슷한 함수: check() 는 상태 검사 (IllegalStateException), error() 는 무조건 예외.

14. mapOf() & to 중위 함수

mapOf()

불변 Map 을 만드는 표준 함수입니다.

// DataSeederController.kt
return mapOf(
    "inserted"   to count,
    "totalPosts" to totalCount,
    "elapsedMs"  to elapsed,
)

to — 중위 함수 (Infix Function)

A to B 는 Pair(A, B) 와 같습니다.
mapOf() 는 Pair 들을 받아 Map 을 만듭니다.

"inserted" to count        // Pair<String, Int>
// = Pair("inserted", count)  // 동일한 의미

Java 로 표현하면:

// Java
Map<String, Object> result = new HashMap<>();
result.put("inserted", count);
result.put("totalPosts", totalCount);

15. 범위 연산자 — .. & in

.. — 범위 생성

1..10          // 1 이상 10 이하 (IntRange)
1..10_000_000  // 1 이상 천만 이하

in — 범위 포함 여부 검사

// DataSeederController.kt
require(count in 1..10_000_000) { "..." }
//             ↑ count 가 1~10,000,000 범위 안에 있는지 확인

Java 로 표현하면:

// Java
count >= 1 && count <= 10_000_000

컬렉션에도 사용할 수 있습니다.

val list = listOf("a", "b", "c")
"b" in list    // true

16. 멀티라인 문자열 — """ & trimIndent()

""" — 삼중 따옴표 문자열

줄바꿈과 들여쓰기를 그대로 포함한 문자열입니다.

// DataSeederController.kt
jdbc.execute("""
    INSERT INTO posts (title, content, author, ...)
    SELECT
        CASE (i % 10)
            WHEN 0 THEN '공지사항: ...' || i
            ...
        END
    FROM generate_series(1, $count) AS t(i)
""".trimIndent())

trimIndent()

삼중 따옴표 문자열에서 공통 들여쓰기를 제거합니다.
붙이지 않으면 SQL 앞에 공백이 그대로 포함됩니다.

val sql = """
    SELECT *
    FROM posts
""".trimIndent()

// trimIndent() 적용 결과:
// "SELECT *\nFROM posts\n"
// (앞의 공백 4칸이 사라짐)

17. 숫자 리터럴의 밑줄 — 1_000_000

긴 숫자를 읽기 쉽게 구분하는 문법입니다. 값 자체에는 영향이 없습니다.

// DataSeederController.kt
require(count in 1..10_000_000) { "..." }
//                  ↑ 10,000,000 과 완전히 같은 값

val million = 1_000_000   // 1000000 과 동일
val billion = 1_000_000_000

18. 인터페이스 — interface

Java 와 거의 같습니다. 구현 없이 메서드 시그니처만 선언합니다.

// PostMapper.kt
@Mapper
interface PostMapper {

    fun findAll(
        @Param("offset") offset: Int,
        @Param("limit")  limit: Int,
    ): List<Post>

    fun findById(@Param("id") id: Long): Post?   // null 반환 가능

    fun insert(post: Post)   // 반환값 없음 (Unit)
}

MyBatis 의 @Mapper 어노테이션을 붙이면,
Spring 이 시작할 때 이 인터페이스의 구현체를 자동으로 만들어줍니다.

19. 와일드카드 import — *

패키지 안의 모든 것을 한 번에 가져옵니다.

// PostController.kt
import me.study.index.dto.*   // dto 패키지의 모든 클래스를 가져옴

// 덕분에 아래를 따로 import 하지 않아도 됨:
// import me.study.index.dto.PostCreateRequest
// import me.study.index.dto.PostUpdateRequest
// import me.study.index.dto.PostResponse
// import me.study.index.dto.PostListResponse

20. 코틀린에서 자바 클래스 참조 — ::class.java

Kotlin 의 타입 시스템과 Java 의 타입 시스템을 연결할 때 씁니다.

// DataSeederController.kt
jdbc.queryForObject("SELECT COUNT(*) FROM posts", Long::class.java)
//                                                ↑ Java 의 Long.class 에 해당

// javaClass 프로퍼티: 현재 인스턴스의 Java 클래스를 반환
private val log = LoggerFactory.getLogger(javaClass)
//                                        ↑ this.getClass() 와 동일

21. Unit vs Void

// 함수 반환값이 없으면 Unit (보통 생략)
fun deletePost(id: Long): Unit { ... }
fun deletePost(id: Long)       { ... }  // 위와 동일

// ResponseEntity 에서 반환 바디가 없을 때 Java 의 Void 를 써야 하는 경우
// PostController.kt
fun deletePost(@PathVariable id: Long): ResponseEntity<Void> {
    postService.deletePost(id)
    return ResponseEntity.noContent().build()
}

Spring 의 ResponseEntity 는 Java 클래스라 Void 를 사용합니다.
순수 Kotlin 코드에서 "반환값 없음"은 Unit 입니다.

22. 후행 쉼표 (Trailing Comma)

마지막 파라미터/요소 뒤에 쉼표를 붙여도 됩니다.

// PostDto.kt
data class PostCreateRequest(
    val title: String,
    val content: String,
    val author: String,   // ← 마지막에도 쉼표 OK
)

Java 에서는 문법 오류지만 Kotlin 에서는 허용됩니다.
나중에 줄을 추가하거나 순서를 바꿀 때 git diff 가 깔끔해지는 장점이 있습니다.

전체 흐름으로 보는 문법 총정리

HTTP 요청
   ↓
[Controller]  — 표현식 함수(=), @PathVariable, @RequestParam, 기본 파라미터값
   ↓
[Service]     — val/var, 엘비스 연산자(?:), also, map, require
   ↓
[Mapper]      — interface, nullable 반환(Post?), @Param
   ↓
[Domain/DTO]  — data class, companion object, val/var, 기본값
   ↓
DB (PostgreSQL + MyBatis)

공개키 암호화 시스템 핵심 개념 노트

1. RSA란?

RSA는 1977년 Rivest, Shamir, Adleman 세 사람이 만든 공개키 암호화 알고리즘입니다. HTTPS, 디지털 서명, SSH 등 인터넷 보안의 근간이 되는 기술입니다.

핵심 아이디어

• 두 개의 키 사용: 누구나 아는 공개키(Public Key) + 나만 아는 개인키(Private Key)
• 비대칭 암호화: 암호화와 복호화에 서로 다른 키를 사용
• 수학적 근거: 큰 수의 소인수분해는 현실적으로 불가능

2. 수학적 원리

키 생성 과정

1. 두 소수 p, q를 선택 → 예: p=13, q=7
2. n = p × q 계산 → 예: n = 91
3. φ(n) = (p−1)(q−1) 계산 → 예: φ(91) = 72
4. gcd(e, φ(n)) = 1 인 e 선택 → 공개키 지수
5. e × d ≡ 1 (mod φ(n)) 를 만족하는 d 계산 → 개인키 지수

암호화 / 복호화 공식

보안 근거

n은 공개되지만, n에서 p와 q를 역으로 구하는 소인수분해는 현재 컴퓨터로 불가능합니다. 2048비트 RSA 키 기준, 인수분해에 우주 나이보다 긴 시간이 소요됩니다.

3. 키의 실제 형태

수학적 본질은 숫자

• 공개키: 숫자 쌍 (n, e)
• 개인키: 숫자 쌍 (n, d)
• 모든 암복호화 연산은 결국 정수 연산(mod)

파일로 저장 시

실제 키 파일을 열면 Base64로 인코딩된 문자열로 보입니다:

-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A...
-----END PUBLIC KEY-----

이 문자열을 디코딩하면 결국 수천 자리의 정수 (n, e)가 나옵니다. PEM, DER 등 표준 포맷으로 감싸는 이유는 다루기 편하고 명확한 경계를 표시하기 위해서입니다.

4. 암호화 vs 디지털 서명

RSA는 두 가지 방향으로 사용할 수 있습니다. 목적이 다르면 키 사용 방향도 반대입니다.

헷갈리지 않는 법

• 암호화: "영희만 열 수 있게" → 영희의 공개키로 잠근다
• 서명: "나만 만들 수 있음을 증명" → 나의 개인키로 서명한다
• 핵심: 암호화는 받는 사람 공개키 / 서명은 보내는 사람 개인키

5. 실제 활용

HTTPS (TLS 핸드셰이크)

RSA는 느리기 때문에 모든 데이터를 직접 암호화하지 않습니다.

• RSA로 AES 대칭키를 안전하게 교환
• 본 통신은 빠른 AES로 암호화
• 이를 하이브리드 암호화 방식이라 합니다

SSH

• 서버에 공개키를 등록해두고, 개인키로 인증
• 비밀번호 없이 안전하게 서버에 접속 가능

이메일 서명 (PGP/GPG)

• 개인키로 이메일에 서명 → 수신자가 공개키로 검증
• 메일이 위조되지 않았음을 보장

6. RSA의 한계와 미래

현재 한계

• 속도: AES 등 대칭키 대비 수백 배 느림 → 직접 암호화에 비효율적
• 키 크기: 보안을 위해 2048비트 이상 필요 → 저장/전송 용량 부담

양자컴퓨터 위협

양자컴퓨터의 Shor 알고리즘은 소인수분해를 빠르게 풀 수 있어 RSA를 이론적으로 깰 수 있습니다. 현재 NIST를 중심으로 양자내성 암호(Post-Quantum Cryptography) 표준화가 진행 중입니다.

7. 핵심 요약 한눈에 보기

다항식 전체가 어떤 식의 제곱 형태로 묶이는 식.

$$ (x+3)^2 \ (2a-b)^2 $$

부호에 따른 전개 형태

(앞항)² ± 2×(앞항)×(뒷항) + (뒷항)² 형태로 전개된다.

$$ (x+a)^2 = x^2 + 2ax + a^2 \ (x-a)^2 = x^2 - 2ax + a^2 $$

부호가 결정되는 위치는 가운데 항(2ax)뿐이며, 양 끝의 제곱항은 항상 양수다.

완전제곱식이 되는 조건

이차식 $x^2 + ax + b$ 가 완전제곱식이 되려면, 상수항 $b$ 가 일차항 계수의 절반의 제곱과 같아야 한다.

$$ b = \left(\frac{a}{2}\right)^2 $$

유도 과정

$(x+k)^2 = x^2 + 2kx + k^2$ 이므로, $x^2 + ax + b$ 와 비교하면:

• 일차항 계수 비교: $a = 2k \Rightarrow k = \dfrac{a}{2}$
• 상수항 비교: $b = k^2 = \left(\dfrac{a}{2}\right)^2$

예시

$x^2 + 6x + 9$ 에서 $a = 6$, $\left(\dfrac{6}{2}\right)^2 = 9$ 이므로 완전제곱식이다.
$\Rightarrow (x+3)^2$

HMAC + SHA-256 을 의미하는 서명 알고리즘 SHA-256을 사용하여 HMAC한 서명 알고리즘

서명 과정

서명 = HMAC-SHA256(
  Base64url(Header) + "." + Base64url(Payload),
  비밀키(Secret Key)
)

검증 과정

받은 토큰의 서명 == 서버가 직접 계산한 서명?
  → 같으면: 유효한 토큰 ✅
  → 다르면: 위변조된 토큰 ❌

HMAC이 필요한 이유

단순히, SHA-256만으로 서명을 하면 payload가 조작된 것을 감지할 수 없음.

서명 = SHA256("header.payload") 

탈취된 토큰의 payload를 위조하여, 재서명하여도 조작된것을 검증 할 수 없음.
재서명 = SHA256(header.변경된payload)

HMAC

Hash-based Message Authentication Code 의 줄임말로 키를 받아 해시값을 만들어내는 방식을 말한다.

HMAC 동작방식

HMAC(K, M) = SHA256(
                (K ⊕ opad) +           ← 바깥 패딩과 키를 XOR
                SHA256(
                  (K ⊕ ipad) + M       ← 안쪽 패딩과 키를 XOR한 뒤 메시지 붙이기
                )
             )

• K : 비밀키
• M : 서명할 메시지 (header.payload)
• ipad : 0x36(6) 반복 (inner padding)
• opad : 0x5C(\) 반복 (outer padding)

패딩은 key의 길이만큼 반복하여 생성한다.

key가 5글자라면, 바깥 패딩은 "66666" 이 된다.

같은 키를 그대로 두 번 쓰면 내부/외부 해시가 너무 비슷한 구조가 되어서 수학적 취약점이 생기기때문에, key를 패딩과 XOR연산하여 한번 더 꼬아주는게 핵심이다.

길이 확장 공격 (Length Extension Attack)

SHA-256은 Merkle-Damgård 구조로, 최종 해시값이 곧 마지막 내부 상태값이다. 따라서 SHA256(K + M)의 결과를 알면, K를 모르더라도 SHA256(K + M + 추가데이터)를 계산할 수 있다.

HMAC은 내부 해시값을 외부 SHA256의 입력으로 한번 더 감싸기 때문에 공격자가 내부 상태를 이어서 계산할 수 있는 접점 자체가 사라진다.

같은 키를 두 번 쓰면 안 되는 이유

내부/외부 해시에 동일한 키가 반복되면, 여러 서명값을 수집했을 때 두 해시 계산 사이의 수학적 관계를 추론할 수 있게 된다. ipad/opad로 키를 XOR 변형하면, 내부/외부가 수학적으로 독립된 키를 쓰는 것과 같은 효과가 나서 이 관계를 끊어낼 수 있다.

1. with
2. 함수
3. global / nonlocal
4. 클래스
5. 예외처리
6. raise
7. import
8. name
9. Decorator
10. Generator & yield

with

Java의 try-with-resources 와 완전히 동일한 개념입니다.
블록이 끝나면 예외가 발생하더라도 자원을 자동으로 해제합니다.

// Java
try (FileReader f = new FileReader("file.txt")) {
    // 블록 끝나면 자동으로 close()
}

# Python
with open("file.txt", "r") as f:
    # 블록 끝나면 자동으로 close()
    data = f.read()

with 없이 쓰면 위험한 이유

# with 없이 - 예외 발생 시 close() 가 실행 안 될 수 있음 💥
f = open("file.txt", "r")
data = f.read()   # 여기서 예외 발생하면?
f.close()         # 실행 안 됨 → 파일이 열린 채로 남음!

# with 사용 - 예외 발생해도 반드시 close() 실행 ✅
with open("file.txt", "r") as f:
    data = f.read()

동작 원리 - dunder method

내부적으로는 __enter__, __exit__ 라는 특수 메서드로 동작합니다.

# with 는 사실 이것과 동일
f = open("file.txt", "r")
f.__enter__()
try:
    data = f.read()
finally:
    f.__exit__()   # 항상 실행 → close()

__init__ 처럼 __ 로 감싸진 Python의 특수 메서드(dunder method) 중 하나입니다.

함수

Default Parameter (기본값 매개변수)

매개변수에 기본값을 지정하면, 호출 시 해당 인자를 생략할 수 있습니다.
Java에서는 오버로딩으로 해결해야 했지만, Python은 기본값으로 한 번에 처리합니다.

# Java - 오버로딩 필요
void greet(String name) { greet(name, "안녕하세요"); }
void greet(String name, String message) { ... }

# Python - 기본값으로 한 번에
def greet(name, message="안녕하세요"):
    print(f"{message}, {name}!")

greet("Alice")               # 안녕하세요, Alice!
greet("Bob", "반갑습니다")    # 반갑습니다, Bob!

Keyword Argument (키워드 인자)

함수 호출 시 매개변수명=값 형태로 전달하면, 순서와 무관하게 인자를 넘길 수 있습니다.
Java에는 없는 개념으로, 매개변수가 많을 때 코드 가독성이 크게 높아집니다.

def introduce(name, age, city):
    print(f"이름: {name}, 나이: {age}, 도시: {city}")

introduce("Alice", 30, "서울")                # 순서대로 전달
introduce(age=30, city="서울", name="Alice")  # 이름으로 전달 - 순서 무관
introduce("Alice", city="서울", age=30)       # 혼합 가능 (positional이 먼저)

혼합 사용 시 주의: 위치 인자(positional)는 반드시 키워드 인자보다 앞에 와야 합니다.

Multiple Return & Unpacking

Python 함수는 여러 값을 동시에 반환할 수 있습니다.
내부적으로는 값들을 tuple로 묶어서 반환하는 것입니다.

def min_max(numbers):
    return min(numbers), max(numbers)  # 내부적으로 (min, max) tuple 반환

result = min_max([3, 1, 4, 1, 5, 9])
print(result)        # (1, 9)
print(type(result))  # <class 'tuple'>

반환된 tuple을 각 변수에 바로 분해하는 것을 Unpacking 이라고 합니다.

a, b = min_max([3, 1, 4, 1, 5, 9])
print(a)  # 1
print(b)  # 9

Java였다면 별도 클래스나 배열로 감싸야 했지만, Python은 자연스럽게 처리됩니다.

Unpacking 활용

# swap - temp 변수 없이 한 줄로
a, b = b, a

# * 로 나머지를 한 번에 받기
first, *rest = [1, 2, 3, 4, 5]
print(first)  # 1
print(rest)   # [2, 3, 4, 5]

*head, last = [1, 2, 3, 4, 5]
print(head)   # [1, 2, 3, 4]
print(last)   # 5

args, *kwargs

인자의 개수가 정해지지 않을 때 사용합니다.

• *args: 위치 인자를 tuple 로 받음
• **kwargs: 키워드 인자를 dict 로 받음

def func(*args, **kwargs):
    print(args)    # tuple
    print(kwargs)  # dict

func(1, 2, 3, name="Alice", age=30)
# (1, 2, 3)
# {'name': 'Alice', 'age': 30}

활용 예시

# 개수에 상관없이 합산
def my_sum(*args):
    return sum(args)

my_sum(1, 2, 3)        # 6
my_sum(1, 2, 3, 4, 5)  # 15

# dict를 ** 로 풀어서 함수 인자로 전달
options = {"reverse": True, "key": lambda x: x}
sorted(numbers, **options)
# == sorted(numbers, reverse=True, key=lambda x: x)

Decorator를 만들 때 wrapper(*args, **kwargs) 로 자주 쓰입니다.
어떤 함수든 인자를 그대로 받아 전달할 수 있기 때문입니다.

lambda

이름 없이 한 줄로 정의하는 익명 함수입니다.
Java의 람다식과 유사하며, 주로 sorted() 의 key 인자처럼 간단한 함수가 필요할 때 사용합니다.

# 기본 문법
lambda 매개변수: 표현식

# 예시
add = lambda a, b: a + b
add(3, 4)  # 7

sorted()의 key와 함께 사용

key 는 각 요소를 어떤 기준으로 비교할지 변환 함수를 넘기는 것입니다.
실제 값을 변환하는 게 아니라 정렬 기준만 바꿉니다.

words = ["banana", "apple", "kiwi"]

sorted(words)                          # 알파벳 순 → ["apple", "banana", "kiwi"]
sorted(words, key=lambda x: len(x))   # 길이 순 → ["kiwi", "apple", "banana"]
sorted(words, key=lambda x: x[-1])    # 마지막 글자 순 정렬

numbers = [3, 1, 4, 1, 5]

sorted(numbers)                      # 오름차순 → [1, 1, 3, 4, 5]
sorted(numbers, reverse=True)        # 내림차순 → [5, 4, 3, 1, 1]
sorted(numbers, key=lambda x: -x)   # 내림차순 (동일한 결과)

key=lambda x: -x 는 -x 를 기준으로 오름차순 정렬합니다.
큰 수에 - 가 붙어 작아지므로 앞으로 오게 됩니다.
반환값은 원본 값 그대로입니다.

global / nonlocal

Python 함수 안에서 외부 변수에 값을 할당(=)하는 순간, 그 변수를 지역 변수로 간주합니다.
외부 변수를 수정하려면 global 또는 nonlocal 을 명시해야 합니다.

왜 에러가 발생할까?

count = 0

def increment():
    count += 1   # UnboundLocalError 발생 💥

# count += 1 은 count = count + 1 과 동일
# 오른쪽 count를 읽으려는데, 이미 지역변수로 간주해서
# "아직 할당 안 된 지역변수를 읽으려 했다!" → 에러

단순히 읽기만 할 때는 괜찮습니다.

count = 0

def print_count():
    print(count)   # 읽기만 함 → 전역변수 접근 가능 ✅

def increment():
    count += 1     # 할당 시도 → 지역변수로 간주 → 에러 💥

global - 전역 변수 접근

count = 0

def increment():
    global count   # 전역 변수 count를 사용하겠다고 선언
    count += 1

increment()
increment()
print(count)  # 2

nonlocal - 바깥 함수 변수 접근

global 이 전역 변수라면, nonlocal 은 바로 바깥 함수의 변수에 접근할 때 사용합니다.

def outer():
    count = 0

    def inner():
        nonlocal count   # 바깥 함수의 count를 사용
        count += 1

    inner()
    inner()
    print(count)  # 2

outer()

클래스

self와 메서드

Python 클래스의 메서드는 반드시 첫 번째 매개변수로 self를 선언해야 합니다.
self는 Java의 this와 동일하게, 인스턴스 자기 자신을 가리킵니다.

class MyClass:
    def my_method(self):       # 클래스 메서드 - self 필요
        print(self)

def my_function():             # 클래스 밖 일반 함수 - self 불필요
    print("일반 함수")

self는 컨벤션일 뿐 다른 이름을 써도 동작하지만, 반드시 첫 번째 매개변수여야 합니다.
Python이 메서드를 호출할 때 인스턴스를 첫 번째 인자로 자동 전달하기 때문입니다.

생성자 __init__

Python의 생성자는 반드시 __init__ 이라는 이름을 사용합니다.
클래스를 ClassName() 형태로 호출하면 자동으로 실행됩니다.

Java와 가장 큰 차이는 별도의 필드 선언부가 없다는 점입니다.
__init__ 안에서 self.변수명 = 값 으로 쓰는 순간, 그 변수가 인스턴스 변수로 생성됩니다.

# Java
class Car {
    private String name;  // 필드 선언
    private String color;

    public Car(String name, String color) {
        this.name = name;
        this.color = color;
    }
}

# Python - 별도 선언 없이 __init__ 에서 바로 생성
class Car:
    def __init__(self, name, color):
        self.name = name    # 이 순간 인스턴스 변수 생성
        self.color = color

# new 없이 클래스 이름 호출 → __init__ 자동 실행
my_car = Car("Sonata", "White")

__init__ 이 없어도 클래스 선언은 가능합니다.

class MyClass:
    pass          # 빈 클래스

obj = MyClass()   # 빈 객체 생성

클래스 변수 vs 인스턴스 변수

class Car:
    count = 0        # 클래스 변수 - 모든 인스턴스가 공유 (Java의 static 변수)

    def __init__(self, name):
        Car.count += 1
        self.name = name   # 인스턴스 변수 - 각 인스턴스마다 독립적

car1 = Car("Sonata")
car2 = Car("Avante")

print(Car.count)    # 2 - 클래스 변수는 클래스명으로 접근
print(car1.name)    # "Sonata"
print(car2.name)    # "Avante"

상속

class 자식클래스(부모클래스) 형태로 상속을 나타냅니다.
Java의 extends 와 동일한 역할입니다.

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        return f"{self.name}이 소리를 냅니다"


class Dog(Animal):              # Animal 상속
    def speak(self):            # 메서드 오버라이딩
        return f"{self.name}이 짖습니다"


dog = Dog("멍멍이")
print(dog.speak())              # 멍멍이이 짖습니다
print(isinstance(dog, Animal))  # True - Java의 instanceof

super() 로 부모 클래스의 메서드를 호출할 수 있습니다. Java와 동일합니다.

class Dog(Animal):
    def speak(self):
        parent_result = super().speak()   # 부모의 speak() 호출
        return f"{self.name}이 짖습니다"

Python은 다중 상속도 지원합니다.

class MyClass:              # 상속 없음
    pass

class MyClass(ParentClass): # 단일 상속
    pass

class MyClass(A, B):        # 다중 상속 - Java에는 없는 기능
    pass

타입 힌트

Python은 동적 타이핑 언어라 타입 선언이 필요 없습니다.
하지만 코드 가독성과 IDE 자동완성 지원을 위해 타입 힌트를 사용할 수 있습니다.

# 변수 타입 힌트
age: int = 10
name: str = "jay"

# 함수 매개변수 + 반환 타입 힌트
def greet(name: str, age: int) -> str:
    return f"{name}은 {age}살입니다"

# 반환값 없을 때
def print_hello(name: str) -> None:
    print(f"안녕, {name}")

주의: 타입 힌트는 강제성이 없습니다.
age: int = 10 으로 선언해도 age = "열" 로 바꿔도 에러가 발생하지 않습니다.
단지 힌트일 뿐이며, 강제하려면 별도 라이브러리(예: pydantic)를 사용해야 합니다.

예외처리

Java의 try-catch-finally와 유사하지만, Python에는 else 블록이 추가됩니다.

try:
    result = 10 / 2          # 예외 가능성 있는 코드
except ZeroDivisionError:    # 특정 예외 처리
    print("0으로 나눌 수 없어요")
else:
    print(f"결과: {result}") # 예외가 발생하지 않았을 때만 실행
finally:
    print("항상 실행")        # 예외 여부와 관계없이 항상 실행

else 블록의 장점

else 블록 덕분에 "예외 가능성 있는 코드" 와 "성공했을 때 실행할 코드" 를 명확히 분리할 수 있습니다.

# else 없이 - 예외와 무관한 코드가 try 안에 섞임 ❌
try:
    result = 10 / 2
    print(f"결과: {result}")   # 이 코드는 예외 위험이 없는데 try 안에 있음
except ZeroDivisionError:
    print("0으로 나눌 수 없어요")

# else 사용 - 역할이 명확하게 분리됨 ✅
try:
    result = 10 / 2            # 예외 가능성 있는 코드만
except ZeroDivisionError:
    print("0으로 나눌 수 없어요")
else:
    print(f"결과: {result}")   # 성공했을 때 실행할 코드
finally:
    print("항상 실행")

여러 예외 처리

try:
    value = int(input())
    result = 10 / value
except ValueError:
    print("숫자를 입력해주세요")
except ZeroDivisionError:
    print("0은 입력할 수 없어요")
except Exception as e:        # 모든 예외를 잡는 catch-all
    print(f"알 수 없는 오류: {e}")

raise

Java의 throw 와 동일한 역할입니다.
예외를 강제로 발생시킬 때 사용합니다.

기본 사용법

# Java
throw new IllegalArgumentException("나이는 0 이상이어야 합니다");

# Python
raise ValueError("나이는 0 이상이어야 합니다")

new 키워드 없이 예외 클래스를 바로 호출하면 됩니다.

커스텀 예외

Java처럼 직접 예외 클래스를 만들 수 있습니다.

# Java
class AgeException extends RuntimeException {
    public AgeException(String message) {
        super(message);
    }
}

# Python
class AgeException(Exception):
    def __init__(self, age):
        self.age = age
        super().__init__(f"{age}는 유효하지 않은 나이입니다")

실전 활용 패턴

def set_age(age):
    if not isinstance(age, int):
        raise TypeError("나이는 정수여야 합니다")
    if age < 0:
        raise ValueError("나이는 0 이상이어야 합니다")
    return age

raise 단독 사용 - 예외 다시 던지기

raise 를 단독으로 쓰면 현재 예외를 그대로 다시 던집니다.
Java의 throw e 와 동일합니다.

try:
    set_age(-1)
except ValueError as e:
    print(f"로그 기록: {e}")
    raise   # 잡은 예외를 그대로 다시 던짐

예외 체이닝

Python에는 Java에 없는 예외 체이닝 문법도 있습니다.
원인 예외를 명시적으로 연결할 수 있습니다.

try:
    int("abc")
except ValueError as e:
    raise RuntimeError("변환 실패") from e

# RuntimeError: 변환 실패
#   caused by
# ValueError: invalid literal for int()...

Java의 new RuntimeException("변환 실패", e) 와 동일한 개념입니다.

import

Java의 import 와 유사하지만, Python은 모듈(파일) 단위로 import합니다.

기본 import

# Java - 클래스 단위
import java.util.ArrayList;

# Python - 모듈 단위
import math

math.sqrt(16)   # 4.0 - 모듈명.함수명 으로 접근
math.pi         # 3.14159...

from import - 특정 대상만 가져오기

from math import sqrt, pi

sqrt(16)   # 4.0 - 모듈명 없이 바로 사용
pi         # 3.14159...

# 전부 가져오기 - 권장하지 않음 ⚠️
from math import *
# 어디서 온 함수인지 불분명해져 가독성이 떨어짐

as - 별칭

import numpy as np              # 긴 이름을 줄여서 사용
from math import sqrt as sq     # 이름 충돌 방지

np.array([1, 2, 3])
sq(16)   # 4.0

모듈 vs 패키지

# Java
패키지 = com.example.project
클래스 = Calculator.java

# Python
모듈   = .py 파일
패키지 = 폴더 (+ __init__.py)

my_project/
├── main.py
├── calculator.py        # 모듈
└── utils/               # 패키지 (폴더)
    ├── __init__.py      # 이 파일이 있어야 패키지로 인식
    ├── string_utils.py
    └── math_utils.py

# 모듈 import
import calculator
from calculator import add

# 패키지 import
from utils.math_utils import multiply
from utils import string_utils

__init__.py

패키지 폴더 안에 있는 특수 파일입니다.
이 파일이 있어야 Python이 해당 폴더를 패키지로 인식합니다.

# utils/__init__.py 에 아래처럼 작성하면
from .string_utils import trim
from .math_utils import multiply

# 외부에서 이렇게 바로 접근 가능
from utils import trim, multiply

Python 3.3 부터는 __init__.py 없어도 패키지로 인식되지만,
명시적으로 두는 것이 관례입니다.

절대 import vs 상대 import

# 절대 import - 프로젝트 루트 기준 (권장 ✅)
from utils.math_utils import multiply

# 상대 import - 현재 파일 위치 기준
from .math_utils import multiply    # 같은 패키지 내
from ..main import something        # 상위 패키지

내장 모듈 vs 외부 라이브러리

# 내장 모듈 - Python 설치 시 기본 포함 (Java의 java.util.* 과 동일)
import math
import os
import sys
import json
import datetime

# 외부 라이브러리 - pip 로 설치 필요 (Java의 Maven/Gradle 과 동일)
# pip install numpy
import numpy as np

자주 쓰는 내장 모듈

__name__

__name__ 은 Python이 자동으로 관리하는 특수 변수(dunder variable) 입니다.
현재 파일이 직접 실행되는지, import 되는지에 따라 값이 달라집니다.

왜 쓸까?

# calculator.py

def add(a, b):
    return a + b

# if __name__ 없이 - import 시에도 print 가 실행돼버림 💥
print(add(3, 4))

# calculator.py

def add(a, b):
    return a + b

# if __name__ 사용 - 직접 실행할 때만 실행 ✅
if __name__ == "__main__":
    print(add(3, 4))

Java의 main() 메서드와 비슷한 역할로,
"이 파일이 직접 실행될 때만 이 코드를 실행해라" 는 진입점 역할을 합니다.

Decorator

함수를 인자로 받아 기능을 추가한 새로운 함수를 반환하는 문법입니다.
Spring의 AOP(관점 지향 프로그래밍) 와 매우 유사한 개념입니다.

로깅, 실행 시간 측정, 권한 체크 등 핵심 로직과 부가 기능을 분리할 때 사용합니다.

def logger(func):
    def wrapper(*args, **kwargs):
        print(f"{func.__name__} 호출됨")   # 함수 실행 전
        result = func(*args, **kwargs)      # 원래 함수 실행
        print(f"{func.__name__} 종료됨")   # 함수 실행 후
        return result
    return wrapper

@logger
def add(a, b):
    return a + b

print(add(3, 4))
# add 호출됨
# add 종료됨
# 7

동작 원리

@logger 는 아래 코드와 완전히 동일합니다.

add = logger(add)
# add 함수를 logger로 감싸서 재할당
# 이후 add() 를 호출하면 실제로는 wrapper() 가 실행됨

즉, @ 문법은 "이 함수를 decorator로 감싸라" 는 문법적 설탕(syntactic sugar)입니다.

wrapper에서 args, *kwargs를 쓰는 이유

def wrapper(*args, **kwargs):
    result = func(*args, **kwargs)

decorator는 어떤 함수에도 붙을 수 있어야 합니다.
*args, **kwargs 로 인자를 그대로 받아서 그대로 전달하면,
인자 형태가 어떻든 상관없이 범용적으로 동작합니다.

Generator & yield

일반 함수는 return 으로 값을 반환하면 함수가 종료됩니다.
반면 yield 는 값을 반환한 뒤 함수 실행을 일시정지하고, 다음 호출 시 그 자리에서 재개합니다.

이런 함수를 Generator 함수라고 하며, 호출하면 Generator 객체를 반환합니다.

def countdown(n):
    while n > 0:
        yield n    # 값 반환 후 "일시정지"
        n -= 1     # next() 호출 시 여기서 재개

gen = countdown(3)   # Generator 객체 생성 (아직 실행 안 됨)

next(gen)   # 3 반환 → yield 지점에서 일시정지
next(gen)   # n -= 1 실행 → n=2 → 2 반환 → 다시 일시정지
next(gen)   # n -= 1 실행 → n=1 → 1 반환 → 다시 일시정지
next(gen)   # n=0 → while 조건 False → StopIteration 예외 발생

for 문으로도 자연스럽게 사용할 수 있습니다.

for num in countdown(3):
    print(num)
# 3
# 2
# 1

Java와 비교

// Java - Iterator 직접 구현
class Countdown implements Iterator<Integer> {
    private int n;
    Countdown(int n) { this.n = n; }
    public boolean hasNext() { return n > 0; }
    public Integer next() { return n--; }
}

# Python - yield 한 줄로 끝
def countdown(n):
    while n > 0:
        yield n
        n -= 1

메모리 효율

Generator의 핵심 장점은 메모리 효율입니다.
리스트는 모든 요소를 한 번에 메모리에 올리지만,
Generator는 next() 호출 시마다 값을 하나씩 계산합니다.

# 리스트 - 100만 개를 한 번에 메모리에 올림 💥
result = [x * 2 for x in range(1000000)]

# Generator - 필요할 때 하나씩 계산 ✅
result = (x * 2 for x in range(1000000))

List Comprehension의 [] 를 () 로 바꾸면 Generator가 됩니다.
데이터가 매우 크거나, 전체를 한 번에 쓰지 않을 때 유용합니다.

Java 개발자 관점에서 꼭 알아야 할 Python 핵심 개념 정리 완료!

1. pass
2. 자료구조
3. == vs is
4. 삼항연산자 대체
5. 슬라이싱
6. List Comprehension
7. 딕셔너리 (Dictionary)
8. f-string
9. enumerate
10. zip
11. for-else

pass

블록 안에 아무것도 하지 않겠다 는 의미입니다.

Python은 Java와 달리 빈 블록 {} 을 허용하지 않습니다.
Python은 들여쓰기로 블록을 구분하기 때문에, 블록 안에 반드시 뭔가 있어야 합니다.

// Java - 빈 블록 허용
class MyClass {}
void myFunction() {}

# Python - 빈 블록 불가 → SyntaxError 발생
class MyClass:
    # 아무것도 없으면 에러!

# pass 로 해결
class MyClass:
    pass

def my_function():
    pass

if True:
    pass

나중에 구현할 예정인 코드 자리를 잡아둘 때 자주 사용합니다.

# 인터페이스처럼 구조만 잡아두기
class Animal:
    def speak(self):
        pass   # 나중에 구현 예정

    def move(self):
        pass   # 나중에 구현 예정

자료구조

리스트 (List)

Java의 ArrayList와 유사한 mutable(가변) 자료형입니다.
[] 로 표기하며, 서로 다른 타입의 요소도 함께 담을 수 있습니다.

a = [1, 2, 3]
a.append(4)        # [1, 2, 3, 4] - 요소 추가
a + [5, 6]         # [1, 2, 3, 4, 5, 6] - 리스트 합치기
a * 2              # [1, 2, 3, 4, 1, 2, 3, 4] - 반복

Java였다면 리스트 합치기에 addAll(), 반복은 루프를 직접 돌려야 했지만
Python은 +, * 연산자로 직관적으로 표현할 수 있습니다.

참조 타입 주의

리스트는 참조 타입이므로 단순 대입은 복사가 아닙니다.
Java의 객체 참조와 동일하게 동작합니다.

a = [1, 2, 3]
b = a           # b는 a와 동일한 리스트를 가리킴
b.append(4)
print(a)        # [1, 2, 3, 4] - a도 같이 변경됨!

# 진짜 복사를 원한다면
b = a.copy()    # shallow copy
b = a[:]        # 슬라이싱으로 복사 (Python스러운 방식)
b = list(a)     # list() 생성자 활용

튜플 (Tuple)

() 로 표기하며, immutable(불변) 자료형입니다.
한 번 생성하면 요소를 추가, 수정, 삭제할 수 없습니다.

a = (1, 2, 3)
a[0] = 99   # TypeError: 'tuple' object does not support item assignment

Java의 final List는 참조만 못 바꾸는 것이지만,
Python의 tuple은 내부 요소 자체를 아예 변경할 수 없습니다.

언제 튜플을 쓸까요?
변경되면 안 되는 데이터(좌표, 설정값 등)를 담을 때, 또는 함수에서 여러 값을 반환할 때 자연스럽게 사용됩니다.

point = (10, 20)           # 좌표처럼 변하면 안 되는 값
return min(a), max(a)      # 함수의 다중 반환값 (내부적으로 tuple)

== vs is

Python의 == 와 is 는 전혀 다른 비교를 합니다.

a = [1, 2, 3]
b = [1, 2, 3]

print(a == b)   # True  - 값이 같음
print(a is b)   # False - 서로 다른 객체

None 비교는 is 를 권장

None 은 전역에 딱 하나만 존재하는 객체이기 때문에,
값 비교보다 객체 동일성 비교가 더 정확하고 빠릅니다.

a = None

if a is None:      # ✅ 권장
    pass
if a == None:      # 동작하지만 비권장
    pass

주의 - 정수 캐싱

Python은 -5 ~ 256 사이의 정수를 미리 캐싱해두기 때문에,
해당 범위 안의 숫자는 is 비교가 True 로 나옵니다.

a = 1
b = 1
print(a is b)     # True  - 캐싱 범위 내

a = 1000
b = 1000
print(a is b)     # False - 캐싱 범위 밖, 다른 객체

Java의 Integer 캐싱(-128 ~ 127)과 동일한 개념입니다.
따라서 숫자, 문자열에는 is 를 쓰지 않는 것이 원칙이고,
is 는 None, True, False 비교에만 쓰는 것이 관례입니다.

삼항연산자 대체

Java의 삼항연산자 ? : 를 Python에서는 아래와 같이 표현합니다.

# 기본 문법
참일때의_값 if 조건식 else 거짓일때의_값

// Java
String result = x > 5 ? "크다" : "작다";

# Python
result = "크다" if x > 5 else "작다"

Java와 순서가 반대라는 점을 주의하세요.
Java는 조건 ? 참 : 거짓 이지만, Python은 참 if 조건 else 거짓 입니다.

f-string 안에서도 사용할 수 있습니다.

age = 20
print(f"{'성인' if age >= 18 else '미성년자'}")  # "성인"

슬라이싱

순서가 있는 자료형(list, tuple, string)의 일부를 잘라내는 기법입니다.
Java의 subList(), substring() 을 훨씬 간결하게 표현할 수 있습니다.

기본 문법

[start:end:step]

• start: 시작 인덱스 (포함, 기본값 0)
• end: 끝 인덱스 (미포함, 기본값 len(a))
• step: 간격 (기본값 1, 생략 가능)

end가 미포함이라는 점을 꼭 기억하세요.
a[1:4] 는 index 1, 2, 3 까지이고 4는 포함되지 않습니다.

생략 예시

a = [0, 1, 2, 3, 4]

a[1:4]    # [1, 2, 3]       - index 1~3 (4 미포함)
a[:3]     # [0, 1, 2]       - start 생략 → 0부터
a[2:]     # [2, 3, 4]       - end 생략 → 끝까지
a[:]      # [0, 1, 2, 3, 4] - 전체 복사
a[::2]    # [0, 2, 4]       - 하나씩 건너뜀 (step=2)
a[::-1]   # [4, 3, 2, 1, 0] - 역순 (step=-1)

step이 음수일 때

step이 음수이면 역방향으로 순회하기 때문에 기본값이 바뀝니다.

a = [0, 1, 2, 3, 4]
a[::-1]     # [4, 3, 2, 1, 0] - 끝에서 처음까지 역순
a[3::-1]    # [3, 2, 1, 0]    - index 3부터 역순

슬라이싱 가능한 자료형

순서가 있는(sequential) 자료형이면 모두 슬라이싱이 가능합니다.

[1, 2, 3][1:]    # 리스트 ✅ → [2, 3]
(1, 2, 3)[1:]    # 튜플 ✅  → (2, 3)
"hello"[1:3]     # 문자열 ✅ → "el"

# Java와 비교
"hello".substring(1, 3)  // Java  → "el"
"hello"[1:3]             # Python → "el"

List Comprehension

리스트를 간결하게 생성하는 Python의 핵심 문법입니다.
Java의 Stream API와 개념이 유사하지만, 훨씬 짧게 표현할 수 있습니다.

기본 문법

[표현식 for 변수 in 반복가능객체 if 조건]

읽는 순서대로 해석하면 이렇습니다.

"반복가능객체에서 변수를 하나씩 꺼내서, 조건을 만족하는 것만, 표현식으로 변환해 리스트로 만든다"

if 조건 은 생략 가능합니다.

예시

numbers = [1, 2, 3, 4, 5]

# 조건 없이 - 모든 요소에 *2
[x * 2 for x in numbers]
# → [2, 4, 6, 8, 10]

# 조건 있이 - 짝수만 추출 후 *2
[x * 2 for x in numbers if x % 2 == 0]
# → [4, 8]

Java Stream API와 비교

// Java
numbers.stream()
    .filter(x -> x % 2 == 0)
    .map(x -> x * 2)
    .collect(Collectors.toList());

# Python - 한 줄로 끝
[x * 2 for x in numbers if x % 2 == 0]

중첩 List Comprehension

2차원 리스트를 1차원으로 펼칠 때도 사용할 수 있습니다.

matrix = [[1, 2, 3], [4, 5, 6]]

# "matrix의 각 row에서 x를 꺼내 펼친다"
[x for row in matrix for x in row]
# → [1, 2, 3, 4, 5, 6]

딕셔너리

Java의 HashMap에 해당하는 자료형입니다.
{key: value} 형태로 표기하며, key-value 쌍으로 데이터를 저장합니다.

기본 사용법

person = {
    "name": "Alice",
    "age": 30
}

# 요소 추가 / 수정
person["email"] = "alice@example.com"

# 요소 삭제
del person["age"]

요소 접근

딕셔너리에서 값을 꺼내는 방법은 두 가지입니다.

person["name"]              # "Alice"
person["email"]             # 키가 없으면 KeyError 발생 💥

person.get("email")         # 키가 없으면 None 반환 ✅
person.get("email", "없음") # 키가 없으면 기본값 반환 ✅

[] 접근 vs .get() 접근
키가 반드시 존재한다고 확신할 때 → []
키가 없을 수도 있을 때 → .get() (안전)

Python의 None은 Java의 null에 해당합니다.

f-string

Python 3.6부터 도입된 문자열 포맷팅 방법으로,
Java의 String.format() 보다 훨씬 직관적입니다.

문자열 앞에 f 를 붙이고, {} 안에 변수나 표현식을 넣으면 됩니다.

name = "Alice"
age = 30

# Java
String.format("이름: %s, 나이: %d", name, age)  // "이름: Alice, 나이: 30"

# Python f-string
f"이름: {name}, 나이: {age}"                     # "이름: Alice, 나이: 30"

{} 안에 표현식도 사용 가능

단순 변수 삽입뿐 아니라, 연산이나 메서드 호출도 바로 넣을 수 있습니다.

f"{2 + 3}"                                    # "5"
f"{name.upper()}"                             # "ALICE"
f"{'짝수' if age % 2 == 0 else '홀수'}"       # "짝수"
f"원주율: {3.14159:.2f}"                      # "원주율: 3.14" - 소수점 2자리

enumerate

리스트를 순회할 때 인덱스와 요소를 함께 가져올 수 있게 해줍니다.

fruits = ["apple", "banana", "kiwi"]

# Java
for (int i = 0; i < fruits.size(); i++) {
    System.out.println(i + " " + fruits.get(i));
}

# Python - enumerate 없이
for i in range(len(fruits)):
    print(i, fruits[i])

# Python - enumerate 사용 ✅
for i, fruit in enumerate(fruits):
    print(i, fruit)
# 0 apple
# 1 banana
# 2 kiwi

동작 원리

enumerate 는 내부적으로 (index, 요소) 형태의 tuple 을 반환하는 iterator입니다.
for i, fruit in 은 이 tuple을 Unpacking 하는 것입니다.

enumerate(fruits)
# → (0, "apple"), (1, "banana"), (2, "kiwi") 를 하나씩 반환하는 iterator

# 즉, 아래와 동일
for item in enumerate(fruits):
    i, fruit = item   # Unpacking
    print(i, fruit)

시작 인덱스 지정

기본값은 0이지만, 시작 인덱스를 변경할 수 있습니다.

for i, fruit in enumerate(fruits, start=1):
    print(i, fruit)
# 1 apple
# 2 banana
# 3 kiwi

zip

여러 iterable을 같은 인덱스끼리 묶어서 tuple로 반환합니다.
두 리스트를 동시에 순회할 때 유용합니다.

fruits = ["apple", "banana", "kiwi"]
prices = [1000, 2000, 3000]

# Java - 인덱스로 직접 접근
for (int i = 0; i < fruits.size(); i++) {
    System.out.println(fruits.get(i) + " " + prices.get(i));
}

# Python - zip 사용 ✅
for fruit, price in zip(fruits, prices):
    print(fruit, price)
# apple 1000
# banana 2000
# kiwi 3000

동작 원리

zip 은 내부적으로 같은 인덱스의 요소를 tuple로 묶은 iterator입니다.

zip(fruits, prices)
# → ("apple", 1000), ("banana", 2000), ("kiwi", 3000) 을 하나씩 반환

# for fruit, price in 은 tuple을 Unpacking 하는 것

길이가 다를 때

리스트 길이가 다르면 짧은 쪽에 맞춰서 끊깁니다.

a = [1, 2, 3, 4, 5]
b = [10, 20, 30]

for x, y in zip(a, b):
    print(x, y)
# 1 10
# 2 20
# 3 30   ← b가 끝나면 중단

enumerate + zip 함께 사용

for i, (fruit, price) in enumerate(zip(fruits, prices)):
    print(f"{i}번: {fruit} - {price}원")
# 0번: apple - 1000원
# 1번: banana - 2000원
# 2번: kiwi - 3000원

for-else

반복문이 break 없이 정상적으로 끝났을 때 else 블록이 실행됩니다.
break 로 탈출하면 else 는 실행되지 않습니다.

numbers = [1, 2, 3, 4, 5]

# break 없이 끝난 경우 → else 실행
for n in numbers:
    print(n)
else:
    print("반복 완료!")   # 실행됨

# break로 탈출한 경우 → else 실행 안 됨
for n in numbers:
    if n == 3:
        break
else:
    print("반복 완료!")   # 실행 안 됨

예외처리의 try-else 와 같은 철학입니다.

실전 활용 - "찾으면 break, 못 찾으면 else" 패턴

# Java - 별도 flag 변수 필요
boolean found = false;
for (int n : numbers) {
    if (n == 3) { found = true; break; }
}
if (!found) System.out.println("못 찾았어요");

# Python - flag 변수 없이 깔끔하게
for n in numbers:
    if n == 3:
        break
else:
    print("못 찾았어요")  # break 없이 끝나면 실행

→ 2편에서 with, 함수, 클래스, 예외처리, import, Decorator, Generator 를 이어서 다룹니다.

크기와 방향을 동시에 갖는 양

평면 위의 화살표 하나를 떠올려 봐요. 시작점은 원점(0,0)이고, 끝점이 (3, 2)인 화살표예요.

y
│
2 ─ ─ ─ •  ← 끝점 (3, 2)
│      ╱
│     ╱
│    ╱   ← 화살표
│   ╱
│  ╱
│ ╱
└────────── x
0    3

이 화살표를 묘사하는 두 가지 방법:

방법 A (기하학적): "원점에서 출발해서, 길이 $\sqrt{13}$만큼, 오른쪽 위 약 33.7도 방향으로 뻗은 화살표"

방법 B (대수적): "오른쪽으로 3, 위로 2 가는 화살표" → $(3, 2)$

$$$ \vec{b} = \begin{pmatrix} 3 \ 2 \end{pmatrix} $$$

벡터의 기본 연산

1) 덧셈 — "이어 붙이기"

두 벡터를 더하면 같은 자리끼리 더합니다.

$$\begin{pmatrix} 3 \ 2 \end{pmatrix} + \begin{pmatrix} 1 \ 4 \end{pmatrix} = \begin{pmatrix} 4 \ 6 \end{pmatrix}$$

2) 스칼라 곱 — "늘이기/줄이기"

벡터에 숫자(스칼라)를 곱하면 모든 성분에 그 숫자가 곱해집니다.

$$2 \cdot \begin{pmatrix} 3 \ 2 \end{pmatrix} = \begin{pmatrix} 6 \ 4 \end{pmatrix}$$

기하학적으로는 방향은 그대로, 길이만 2배가 됩니다. 음수를 곱하면 방향이 반대가 되고요.

$$-1 \cdot \begin{pmatrix} 3 \ 2 \end{pmatrix} = \begin{pmatrix} -3 \ -2 \end{pmatrix} \quad (\text{반대 방향})$$

3) 크기 (길이) 구하기

벡터의 "크기"는 피타고라스 정리로 구합니다.

$$\vec{v} = \begin{pmatrix} 3 \ 4 \end{pmatrix} \Rightarrow |\vec{v}| = \sqrt{3^2 + 4^2} = \sqrt{25} = 5$$

직각삼각형의 빗변 길이를 구하는 것과 똑같아요!

숫자나 기호를 직사각형 모양으로 배열한 것. m개의 행(row)과 n개의 열(column)로 이루어진 행렬을 m × n 행렬이라고 한다.

ex) 2 × 3 행렬

$$A = \begin{pmatrix} 1 & 2 & 3 \ 4 & 5 & 6 \end{pmatrix}$$

단위행렬 (Identity Matrix, $I$)

n × n 정사각행렬로, 대각선 원소가 1이고 그 외 나머지 원소는 0인 행렬.

$$I_3 = \begin{pmatrix} 1 & 0 & 0 \ 0 & 1 & 0 \ 0 & 0 & 1 \end{pmatrix}$$

단위행렬과의 곱셈

어떤 수에 1을 곱하면 그대로인 것처럼, 어떤 행렬에 단위행렬을 곱하면 그대로이다. $$AI = IA = A$$

행렬 곱셈

"앞 행렬의 가로줄(행)과 뒤 행렬의 세로줄(열)을 짝지어, 곱하고 더한다" "i번째 줄, j번째 칸"의 값은 → A의 i번째 가로줄과 B의 j번째 세로줄의 만남으로 만들어진다.

계산 예시

$$\begin{pmatrix} 1 & 2 \ 3 & 4 \end{pmatrix} \begin{pmatrix} 5 & 6 \ 7 & 8 \end{pmatrix} = \begin{pmatrix} 19 & 22 \ 43 & 50 \end{pmatrix}$$

(예: 좌상단 19 = 1×5 + 2×7)

행렬 곱셈 가능 조건

$$\underbrace{(m \times \boxed{n})}{\text{앞 행렬}} \cdot \underbrace{(\boxed{n} \times p)}{\text{뒤 행렬}} = (m \times p)$$

→ 가운데 숫자는 같아야 하고(곱셈 가능 조건), 바깥 숫자가 결과 크기가 된다.

행렬 곱셈의 성질

• 교환법칙 ❌: 일반적으로 $AB \neq BA$
• 결합법칙 ✅: $(AB)C = A(BC)$
• 분배법칙 ✅: $A(B+C) = AB + AC$

• 모델 (Model): 아키텍처(Architecture) + 파라미터(Parameters)
  • 아키텍처: 모델의 뼈대이자 구조. (비유: 함수의 코드 로직)
  • 파라미터 (가중치): 아키텍처 내부를 채우는 수많은 숫자들. 학습을 통해 얻어진 결과물. (비유: 그 함수가 사용하는 거대한 상수 테이블)
• 사전 학습된 모델 (Pre-trained Model): 아키텍처의 구조는 그대로 둔 채, 방대한 텍스트 데이터를 학습시켜 파라미터 값을 최적의 상태로 채워 넣은 완성된 모델.

2. 모델은 어떻게 배우는가? (학습 프로세스)

비어있던 파라미터를 똑똑하게 갱신하여 모델을 만드는 과정입니다.

1. Forward Pass (순전파): 입력값을 모델에 통과시켜 결과 예측값인 Logits을 반환받음.
   • 예) 입력: "오늘 저녁에 밥" $\rightarrow$ 모델 통과 $\rightarrow$ Logits 출력
2. Loss 계산 (오차 측정): 모델의 예측(Logits)과 실제 정답 토큰(예: " 먹었어")을 비교.
   • 정답 토큰에 모델이 매긴 점수가 낮다면 틀렸다고 판정하고, 그 격차만큼 오차(Loss)를 계산함.
3. Backward Pass (역전파): 이 오차(Loss)를 줄이기 위해, 수많은 파라미터 각각을 '어느 방향으로, 얼마나 바꿔야 하는지' 역으로 계산하며 내려감.
4. 파라미터 갱신: 계산된 방향대로 파라미터(숫자들)를 미세하게 조정함.

(이 과정을 수만 번 반복하며, 학습이 완전히 끝나면 파라미터는 고정됨)

3. 모델은 어떻게 글을 생성하는가? (추론 프로세스)

학습이 끝나고 고정된 파라미터를 이용해 실제로 답변을 만들어내는 과정입니다.

핵심 동작 원리

• 자기회귀 생성 (Autoregressive Generation): 모델이 입력을 받아 바로 다음에 올 '가장 적절한 토큰 1개'를 생성하고, 그것을 다시 기존 입력 뒤에 붙여서(append) 다음 토큰을 예측하는 행위. 이를 지정된 횟수(max_new_tokens)만큼 반복하여 문장을 완성함.
• 추론 시의 Forward Pass: 입력을 모델에 한 번 통과시켜 다음 토큰에 대한 점수판(Logits)을 얻어내는 1회성 과정.

점수에서 확률로 (Logits & Softmax)

• Logits (로짓): 모델이 어휘집(Vocabulary) 전체의 모든 토큰 각각에 대해 매긴 원시 점수 벡터.
  • 벡터의 길이는 어휘집 크기와 동일.
  • 확률이 아니므로 음수도 될 수 있고, 총합이 1도 아님.
• Softmax (소프트맥스): 다루기 힘든 Logits 점수들을 "총합이 1인 확률 분포"로 예쁘게 변환해 주는 수학 함수.

어떤 단어를 선택할 것인가? (디코딩 전략)

Softmax를 통해 확률 분포가 나왔다면, 이제 다음 토큰을 뽑을 차례입니다.

• Greedy (탐욕 탐색): 1등만 뽑는다. 확률 분포 중 무조건 가장 확률이 높은 토큰만 선택. (항상 똑같은 답변이 나옴)
• Sampling (샘플링): 확률대로 뽑는다. 분포 비율에 비례한 '추첨'을 통해 토큰을 선택. (창의적이고 다양한 답변이 나옴)

💡 다양한 샘플링 기법 (Temperature & Top-p)

• Temperature (온도 조절): Softmax를 적용하기 전, Logits 값을 $T$로 나누어 분포의 모양 자체를 바꿈.
  • $T > 1$ 일 때 (예: 2로 나눔): 값들이 전체적으로 작아지며 토큰 간의 점수 격차가 줄어듦 $\rightarrow$ 확률 분포가 평탄해짐 (다양하고 엉뚱한 단어가 나올 확률 증가).
  • $T < 1$ 일 때 (예: 0.5로 나눔): 0.5로 나누는 것은 2를 곱하는 것과 같음. 값들이 커지며 점수 격차가 벌어짐 $\rightarrow$ 확률 분포가 뾰족해짐 (1등 단어가 뽑힐 확률이 압도적으로 높아짐).
• Top-p (후보 압축): 확률이 높은 순서대로 누적합을 구하다가, 지정한 $p$값(예: 0.9)에 도달하면 그 아래의 꼬리(확률이 낮은 토큰들)를 추첨 후보에서 아예 잘라버림.
  • 분포의 모양(비율)은 유지하되, 지나치게 엉뚱한 단어가 나오는 것을 막아주는 보수적인 추첨 방식.

4. 완성된 모델을 입맛에 맞게 쓰는 법

• 프롬프트 엔지니어링 (Prompt Engineering):
  • 파라미터 변경 없음.
  • 원하는 응답의 형태나 맥락을 입력값(프롬프트)에 잘 적어서 원하는 결과를 유도하는 방식.
  • In-context Learning (문맥 내 학습): 프롬프트 엔지니어링의 핵심 원리로, 모델이 문맥을 읽고 그 패턴을 따라 하도록 만드는 것.
  • Few-shot (퓨샷): 모델에게 소수의 예시(2~5개)를 직접 프롬프트에 제공하여 새로운 작업에 빠르게 적응하도록 유도하는 대표적인 기법.
• 파인튜닝 (Fine-Tuning):
  • 파라미터 변경 있음 (영구적).
  • 특정 도메인이나 말투에 맞게 모델을 '추가 학습' 시켜 내부 파라미터를 살짝 깎고 다듬는 작업.

복호화가 가능한 암호화 방식

대칭키 VS 비대칭키

• 대칭키: 암/복호화시 사용하는 키가 동일한 방식
• 비대칭키: 암호화 -> 공개키, 복호화 -> 비밀(개인)키를 사용하는 방식

AES

대표적인 대칭키 양방향 암호화 방식

블록 암호

평문을 고정된 크기의 블록으로 잘라서 한 블록씩 암호화 하는방식 AES의 블록크기는 16바이트로 고정되어있다.

예를들어, 평문의 길이가 32바이트라면 2개의 암호화블록으로 구성된 암호가 생성된다. 만약, 평문의 길이가 16의 배수가 아니라면 마지막 블록은 빈 자리를 채워넣어 16바이트로 맞춘다. 이것을 패딩 이라고 부른다.

운영모드

암호화하는 여러가지 방식이 있다.

ECB모드

가장 직관적인 방법으로

블록1 → AES(키) → 암호화 블록1
블록2 → AES(키) → 암호화 블록2
블록3 → AES(키) → 암호화 블록3

문제는, 같은 평문 블록은 항상 같은 암호문 블록이 되니, 암호안에서 동일한 암호문 블록이 반복될 수 있다. 이러한 패턴이 읽혀 암호가 풀릴 수 있기에 사용하면 안되는 방식으로 분류된다.

CBC모드

IV를 이용해 암호화블록을 한번더 꼬는 방식

IV란? 암호화에 사용되는 랜덤한 초기값이다. 같은 평문이 매번 다른 암호문이 되도록 보장해준다. 해시의 Salt와 동일한 역할이다.

암호화 프로세스

블록1: 평문블록1 XOR IV       → AES(키) → 암호문블록1
블록2: 평문블록2 XOR 암호문블록1 → AES(키) → 암호문블록2
블록3: 평문블록3 XOR 암호문블록2 → AES(키) → 암호문블록3
저장형식: [IV(16바이트)] [암호문] //Salt처럼 공개되어도 상관이없다. 

실제로 IV가 사용되는건 첫번째 평문블록을 암호화할때만이다. 매 암호화마다 IV를 수정해서 암호화해줘야 한다. 동일한 IV를 지속적으로 사용하면, 동일한 입력에 동일한 암호가 생성되어진다.

복호화 프로세스

평문블록1 = AES_decrypt(암호문블록1, 키) XOR IV
평문블록2 = AES_decrypt(암호문블록2, 키) XOR 암호문블록1
평문블록3 = AES_decrypt(암호문블록3, 키) XOR 암호문블록2

AES는 암호화보다 복호화가 더 빠르다. 왜냐하면 복호화는 병렬로 실행이 가능하기때문이다. 평문블록으로 복호화하는데 필요한건 자기 블록과 이전 블록뿐이기때문이다. 이러한 이유로, 특정 블록이 손상되어도 손상이 전파되지않는다. 필요한건 자기 자신과 이전 블록 뿐이기때문이다.

대표적인 해시함수 SHA-256은 입력값을 아주 빠르게 해시값으로 변환할 수 있다. 요즘 GPU는 SHA-256을 초당 수십억 번 계산할 수 있어서, 입력값을 Salting해도 무차별 대입으로 암호를 풀 가능성이 있다.

이러한 경우를 보완하기위해 고안된것이 비밀번호 저장 전용 해시 알고리즘인 bcrypt이다.

bcrypt의 핵심 아이디어

"느리게 만든다."

내부적으로 해시 연산을 수천 ~ 수십만번 반복시켜 한 번의 해싱에 더 많은 시간이 걸리게 만든다. 그래서, 무차별 대입시 SHA-256보다 훨씬 더 많은 시간이 소요된다.

이때, cost factor는 해당 해시값에 해시연산이 몇번 반복되었는지를 나타낸다. cost factor가 12라면 $2^{12}$ 번만큼 해시 연산되었다는 의미이다.

초기 테이블 → 비밀번호+salt로 1번 변형 → 비밀번호로 다시 변형 → salt로 다시 변형 → ...
                                          (이걸 무수히 반복)
                ↓
            최종 테이블로 입력값 암호화 → 해시 결과

bcrypt 출력 형식

$2b$12$N9qo8uLOickgx2ZMRZoMyeIjZAgcfl7p92ldGxad68LJZdL17lhWy
│  │  │  └────── salt(22자) ──────┘└────── hash(31자) ──────┘
│  │  └ cost factor (12)
│  └ 알고리즘 식별자 (2b = bcrypt)
└ 구분자

• bcrypt의 해시값은 60자로 고정되어있다.
• hash안에 salt와 cost factor가 포함되어있다.

bcrypt 해싱 프로세스

bcrypt에선 특정값을 해싱할때, 매번 랜덤한 salt값을 적용하여 해싱한다. 그래서, 같은 입력에도 매번 다른 해시값을 반환한다.

그럼 bcrypt은 어떻게 해시값을 검증할까?

bcrypt 검증방식

bcrypt은 일반 해시처럼 단순 해시값끼리 비교하여 검증하지않는다. 검증하기위해 입력값과 해시값이 필요하다.

bcrypt.verify(입력_비밀번호, 저장 해시값)

해시값안에 salt와 cost factor가 저장되는 이유가 여기에 있다. 파라미터로 받은 해시값에서 salt와 cost factor를 추출해, 입력값에 동일하게 해싱하여 해싱된 값을 비교하여 검증한다.

임의 길이의 입력값을 받아 고정 길이의 출력으로 반환하는 함수.

왜 쓰는가?

• 비밀번호 저장 (원본 없이 검증)
• 무결성 검증 (데이터 변조 확인)
• 데이터 식별 (Git 커밋 ID, 중복 제거)
• 디지털 서명, HMAC 등 더 큰 암호 시스템의 빌딩 블록

※ 흔히 "단방향 암호화"라고 부르지만 엄밀히는 암호화 아님. 복원 불가능한 변환이라 정확한 용어는 "암호학적 해시 함수".

핵심 성질

1. 결정성 (Deterministic)

   • 같은 입력은 항상 같은 출력.
   • 해시값 비교로 사용자 인증이 가능한 이유.

2. 단방향성 (One-way)

   • 출력에서 입력을 역산할 수 없음.
   • 비밀번호를 해시값으로 저장하는 이유.

3. 충돌 저항성 (Collision Resistance)

   • 다른 입력이 같은 출력을 내는 경우 = 충돌.
   • 입력은 무한, 출력은 고정 길이라 충돌은 이론적으로 존재.
   • 하지만 좋은 해시 함수는 그 충돌을 "찾는 것"이 사실상 불가능해야 함.
   • 충돌이 쉬우면 디지털 서명 위조, 인증 우회 같은 공격이 가능해짐.
   • MD5(2004), SHA-1(2017)은 이미 깨짐. 현재는 SHA-256 이상 사용 권장.

레인보우테이블

특정 입력값에는 특정 해시값이 나오는것을 미리 계산하여 저장해둔 테이블이다. 공격자들은 레인보우테이블을 미리 만들어 해시값을 유추하여 해킹공격을 할 수 있었다.

이러한 공격을 어렵게 만들기 위한 방법이 salting이다.

Salt

Salt란 해시값을 꼬기 위해 입력값에 추가로 붙이는 랜덤 값. 해시할_값 = {사용자 비밀번호} + salt

효과

1. 레인보우 테이블 무력화

   • 사용자마다 고유한 salt를 부여하면, 공격자는 사용자 수만큼 별도의 테이블을 만들어야 함 → 비용이 비현실적으로 커짐

2. 같은 비밀번호 사용자 식별 방지

   • 사용자 A와 B가 우연히 같은 비밀번호를 써도, salt가 다르면 DB에 저장된 해시값이 완전히 달라짐
   • 한 명이 뚫려도 다른 사람은 영향 없음

중요: Salt는 비밀이 아님

• DB에 평문으로 저장됨 (검증 시 다시 사용해야 하므로)
• Salt의 목적은 "비밀 유지"가 아니라 "각 비밀번호를 유일하게 만드는 것"

대표 해시 함수

• 안전: SHA-256, SHA-512, SHA-3
• 깨짐: MD5, SHA-1 (보안 용도 사용 금지)

비밀번호 저장 전용

• 일반 해시 함수는 너무 빠름 → 무차별 대입에 취약
• bcrypt, scrypt, Argon2 같은 의도적으로 느린 함수 사용

인덱스는 데이터를 빨리 찾기 위해, 미리 정렬해서 따로 저장해둔 자료구조다.

도서관에 비유하면 이렇다.

• 테이블 = 책장 전체. 1만 권의 책이 꽂혀 있다.
• 인덱스 = 검색용 컴퓨터. 책 자체는 없고, "책 제목 → 위치"만 정렬해서 보관한다.

책을 찾으려면 두 가지 방법이 있다.

1. 1층부터 5층까지 모든 책장을 한 권씩 다 뒤진다 → 풀 테이블 스캔
2. 검색 컴퓨터로 위치를 먼저 찾고, 그곳으로 간다 → 인덱스 조회

당연히 2번이 빠르다. 인덱스는 "검색 컴퓨터를 만들어두는 작업"이라고 생각하면 된다.

인덱스는 언제 쓰이는가

아래에서 각 트리거를 예제와 함께 하나씩 본다. 예제는 모두 같은 인덱스를 가정한다.

-- 이 섹션 전체에서 가정하는 인덱스
CREATE INDEX idx_orders ON orders(user_id, created_at);

트리거 1 — 필터링 (WHERE / JOIN ON)

가장 익숙한 경우다. 조건에 맞는 행만 골라내기 위해 인덱스로 점프한다.

-- O 선두 컬럼 user_id로 바로 좁힌다
SELECT * FROM orders WHERE user_id = 100;

-- O JOIN ON도 결국 필터링이다 (조인 키로 인덱스를 탄다)
SELECT *
FROM users u
JOIN orders o ON o.user_id = u.id
WHERE u.id = 100;

여기까지가 "WHERE가 있어야 인덱스를 쓴다"는 직관에 들어맞는 영역이다. 문제는 인덱스가 이것만 하는 게 아니라는 점이다.

트리거 2 — 정렬 (ORDER BY)

ORDER BY 컬럼이 인덱스의 정렬 순서와 일치하면, DB는 인덱스를 순서대로 읽기만 하면 된다. 즉 정렬 연산(filesort) 자체가 사라진다.

-- O WHERE 없이 정렬 용도로만 인덱스 사용
--   인덱스가 (user_id, created_at)로 이미 정렬돼 있으니
--   그 순서 그대로 읽으면 정렬 끝
SELECT * FROM orders ORDER BY user_id, created_at LIMIT 10;

-- O 역방향도 가능 (인덱스를 거꾸로 읽으면 됨)
SELECT * FROM orders ORDER BY user_id DESC, created_at DESC LIMIT 10;

-- X 인덱스 정렬 순서와 어긋나면 정렬 연산이 다시 필요
--   (created_at만으로는 선두 컬럼 user_id 순서가 보장되지 않음)
SELECT * FROM orders ORDER BY created_at LIMIT 10;

트리거 3 — 커버링 (SELECT 컬럼)

SELECT 에 필요한 컬럼이 전부 인덱스 안에 들어 있으면, 테이블 본체를 읽으러 갈 필요가 없다. 이걸 커버링(Index Only Scan)이라 한다.

-- O 필요한 컬럼(user_id, created_at)이 인덱스에 다 있다 → 테이블 룩업 생략
SELECT user_id, created_at FROM orders ORDER BY user_id, created_at;

-- X amount는 인덱스에 없다 → 결국 테이블로 가야 함 (커버링 깨짐)
SELECT user_id, created_at, amount FROM orders WHERE user_id = 100;

확인하는 법: InnoDB는 EXPLAIN의 Extra에 Using index가 뜨면 커버링이다. PostgreSQL은 Index Only Scan으로 표기된다.

InnoDB 보너스: 세컨더리 인덱스 리프에 PK가 자동으로 붙으므로, (user_id, created_at) 인덱스는 사실상 (user_id, created_at, id)처럼 동작한다. 그래서 SELECT id나 SELECT user_id, created_at, id도 커버링이 된다.

그리고 — 트리거는 겹쳐서 발동한다

실전에서는 한 쿼리가 여러 트리거를 동시에 건다. 이게 인덱스 설계의 묘미다.

-- 필터링(WHERE user_id) + 정렬(ORDER BY created_at)을 한 인덱스로 동시에 처리
-- (user_id, created_at) 인덱스 하나로 둘 다 공짜
SELECT * FROM orders
WHERE user_id = 100
ORDER BY created_at DESC
LIMIT 10;

user_id = 100 으로 구간을 좁힌 뒤, 그 구간 안은 이미 created_at 순으로 정렬돼 있으니 정렬도 따라온다.

데이터를 읽는 4가지 방식

DB가 SELECT 쿼리를 처리할 때 데이터를 읽어오는 방식은 크게 4가지다. 빠른 순서로 정리하면 이렇다.

1. 풀 테이블 스캔 (Seq Scan)

테이블의 모든 행을 처음부터 끝까지 읽는 방식이다.

도서관 비유: 모든 책장의 모든 책을 한 권씩 다 꺼내본다. 1만 권을 다 보는 것.

인덱스가 없거나, 있어도 활용할 수 없을 때 이 방식이 쓰인다. 또는 옵티마이저가 "어차피 거의 모든 행을 가져와야 하니 그냥 다 읽는 게 빠르다"고 판단할 때도 발생한다.

용어 메모: Seq Scan 은 PostgreSQL의 실행계획 표기다. MySQL/InnoDB 계열에서는 EXPLAIN 의 type 이 ALL 로 나오는 것이 이에 해당한다.

2. 인덱스 풀 스캔 (Index Scan)

인덱스의 처음부터 끝까지 다 훑는 방식이다.

도서관 비유: 검색 컴퓨터에 키워드를 입력하지 않고, 전체 도서 목록을 처음부터 끝까지 스크롤해서 본다.

테이블 자체보다 인덱스가 작기 때문에, 풀 테이블 스캔보다는 빠르다. 하지만 정상적인 인덱스 활용에 비하면 여전히 비효율적이다.

3. 인덱스 액세스 + 테이블 룩업

가장 일반적인 인덱스 활용 방식이다. 두 단계로 진행된다.

1. 인덱스에서 조건에 맞는 행의 위치를 찾는다
2. 그 위치를 들고 실제 테이블로 가서 행 데이터를 읽어온다

도서관 비유: 검색 컴퓨터로 "해리포터 → 3층 F구역"을 알아낸 뒤, 실제로 3층까지 가서 책을 꺼낸다.

여기서 2단계, 즉 "테이블로 다시 가는 행위"를 테이블 룩업 또는 북마크 룩업이라고 부른다. 룩업이 많아지면 디스크 I/O 비용이 커져서 느려진다.

용어 메모: PostgreSQL은 테이블 본체를 힙(heap) 이라 부르고, 인덱스는 힙의 위치를 가리키는 포인터만 갖는다. 그래서 "힙 방문(heap fetch)"이라는 표현을 쓴다. 반면 InnoDB(MariaDB 기본 엔진)에는 힙 개념이 없다. InnoDB는 테이블 자체가 PK 기준으로 정렬된 클러스터드 인덱스라서, 세컨더리 인덱스 → 클러스터드 인덱스 순으로 타고 들어간다. 같은 "룩업"이라도 엔진별 내부 구조가 다르다.

4. 커버링 인덱스 (Index Only Scan)

쿼리에 필요한 모든 컬럼이 이미 인덱스 안에 들어있는 경우, 테이블 룩업 자체를 생략할 수 있다.

도서관 비유: 검색 컴퓨터에 "위치, 작가, 출판년도"가 다 표시돼 있어서 굳이 책장까지 안 가도 답이 나온다.

이런 인덱스를 커버링 인덱스라고 한다. 4가지 방식 중 가장 빠르다.

-- 인덱스: (user_id, name, email)
SELECT name, email FROM users WHERE user_id = 100;
-- → 인덱스에 name, email이 다 있으니 테이블 안 봐도 됨

엔진 차이 주의: InnoDB는 세컨더리 인덱스의 리프에 PK가 자동으로 따라붙는다. 그래서 인덱스를 (created_at) 으로만 만들어도 사실상 (created_at, id) 처럼 동작해서 SELECT id 가 저절로 커버된다. PostgreSQL은 그렇지 않다. 진짜 Index Only Scan을 원하면 (created_at, id) 또는 created_at INCLUDE (id) 처럼 명시해야 한다.

복합 인덱스

복합 인덱스는 여러 컬럼을 묶어서 만든 인덱스다.

예를 들어, 아래와 같은 복합 인덱스를 생성한다고 하면

CREATE INDEX idx_user_created ON orders(user_id, created_at);

1순위로 user_id 기준 정렬, 같은 user_id 안에서 2순위로 created_at 기준 정렬하여 인덱싱한다는 의미다.

비유하자면 전화번호부와 같다. 성으로 먼저 정렬되고, 같은 성을 가진 사람들끼리 다시 이름순으로 정렬된다.

전화번호부:
  김민수
  김지영
  김철수
  박서준
  박혜수

이 구조에서 어떤 검색이 가능할까?

• "김씨 찾기" → 가능. 정렬돼 있으니 한 번에 점프
• "김씨 중 가나다순 첫 사람" → 가능. 이미 정렬돼 있음
• "전체에서 '철수' 찾기" → 어렵다. 이름으로 정렬된 게 아니라서

이걸 SQL로 옮기면 이렇다.

-- 인덱스: (user_id, created_at)

-- O 인덱스 잘 활용 (필터링 용도)
SELECT * FROM orders WHERE user_id = 100;

-- O 정렬도 공짜 (같은 user_id 안에서 이미 시간순)
SELECT * FROM orders WHERE user_id = 100 ORDER BY created_at DESC LIMIT 10;

-- O WHERE가 아예 없어도 인덱스가 켜진다 (정렬 + 커버링 용도)
--   ORDER BY가 인덱스 정렬 순서와 일치 → 정렬 연산 생략
--   SELECT 컬럼이 인덱스로 전부 덮임 → 테이블 룩업 생략
SELECT user_id, created_at FROM orders ORDER BY user_id, created_at LIMIT 10;

-- X 인덱스 활용 못 함 (선두 컬럼 user_id가 조건/정렬에 없음)
SELECT * FROM orders WHERE created_at > '2025-01-01';

세 번째 쿼리가 핵심이다. WHERE 없이도, ORDER BY와 SELECT 컬럼만으로 인덱스가 쓰인다.

Leftmost Prefix Rule

위 패턴에서 발견할 수 있는 규칙이 "왼쪽 컬럼부터 순서대로 써야 인덱스가 효율적으로 동작한다"는 원칙이다. 흔히 Leftmost Prefix Rule이라고 부른다.

이 규칙 때문에 복합 인덱스를 설계할 때는 첫 번째 컬럼이 항상 조건(또는 정렬)으로 들어온다는 전제로 만들어야 한다. 첫 번째 컬럼 없이 두 번째 컬럼만으로 조회하면, 앞서 설명한 인덱스 풀 스캔으로 떨어지거나 풀 테이블 스캔으로 떨어진다.

인덱스 설계 시 고려할 점

카디널리티

카디널리티(Cardinality)는 컬럼 값의 다양성을 의미한다.

• gender 컬럼: M / F 두 가지 → 카디널리티 낮음
• email 컬럼: 사용자마다 거의 다름 → 카디널리티 높음

일반적으로 카디널리티가 높은 컬럼을 첫 번째에 두는 것이 유리하다. 검색 결과를 더 좁게 좁힐 수 있기 때문이다.

-- (board_id, user_id) vs (user_id, board_id)
-- 게시판이 10개, 유저가 10만 명일 때
-- → user_id를 앞에 두는 게 일반적으로 유리

다만 절대적인 규칙은 아니다. 실제 쿼리 패턴에 따라 달라진다. "항상 board_id로만 조회한다면" board_id를 앞에 둬야 한다.

인덱스의 비용

인덱스는 공짜가 아니다.

• 저장 공간을 추가로 차지한다
• INSERT, UPDATE, DELETE 시 인덱스도 갱신해야 하므로 쓰기 성능이 느려진다
• 인덱스가 많을수록 옵티마이저가 어떤 인덱스를 쓸지 고민하는 시간이 늘어난다

그래서 인덱스는 실제로 자주 사용되는 쿼리 패턴을 분석한 뒤에 만들어야 한다. "혹시 모르니 일단 만들자"는 좋지 않은 접근이다.

기본 문법

MAKEDATE(year, dayofyear) : date타입 반환

핵심 개념: dayofyear

두 번째 인자가 월/일이 아니라 "연중 몇 번째 날" 이라는 점이 포인트예요.

MAKEDATE(2025, 1)    -- 2025-01-01  (1월 1일 = 연중 1번째 날)
MAKEDATE(2025, 31)   -- 2025-01-31  (1월 31일 = 연중 31번째 날)
MAKEDATE(2025, 32)   -- 2025-02-01  (2월 1일 = 연중 32번째 날)
MAKEDATE(2025, 365)  -- 2025-12-31
MAKEDATE(2024, 366)  -- 2024-12-31  (2024년은 윤년이라 366일)

특이 동작: 365 초과값

dayofyear가 365를 넘으면 다음 연도로 넘어가요.

MAKEDATE(2025, 366)  -- 2026-01-01  (2025년은 윤년 아님)
MAKEDATE(2025, 400)  -- 2026-02-04

NULL 반환 케이스

MAKEDATE(2025, 0)    -- NULL (0번째 날은 없음)
MAKEDATE(0, 1)       -- NULL (연도 0은 허용 안 함)
MAKEDATE(NULL, 1)    -- NULL
MAKEDATE(2025, NULL) -- NULL

실전 활용 예시

-- 해당 연도의 첫째날
MAKEDATE(YEAR(NOW()), 1)          -- 2025-01-01

-- 특정 날짜가 속한 연도의 첫째날
MAKEDATE(YEAR('2025-11-03'), 1)   -- 2025-01-01

-- DAYOFYEAR()와 조합 (날짜 → 연중 일수 → 다시 날짜)
MAKEDATE(2025, DAYOFYEAR('2025-03-15'))  -- 2025-03-15

DAYOFYEAR()와 세트로 기억하기

MAKEDATE()의 반대 함수가 DAYOFYEAR()예요.

DAYOFYEAR('2025-03-15')  -- 74  (3월 15일은 연중 74번째 날)
MAKEDATE(2025, 74)       -- 2025-03-15

주의사항 요약

• 두 번째 인자는 월/일이 아닌 연중 일수
• 0 입력 시 NULL 반환
• 365 초과 시 다음 해로 넘어감
• 반환 타입은 항상 DATE

1. TO_DATE → STR_TO_DATE

문자열을 날짜로 변환하는 함수예요.

-- Oracle
SELECT TO_DATE('2024-01-15', 'YYYY-MM-DD') FROM dual;

-- MySQL
SELECT STR_TO_DATE('2024-01-15', '%Y-%m-%d');

포맷 문자열이 다릅니다 — 이게 가장 헷갈리는 부분이에요.

-- Oracle
TO_DATE('2024-01-15 14:30:00', 'YYYY-MM-DD HH24:MI:SS')

-- MySQL
STR_TO_DATE('2024-01-15 14:30:00', '%Y-%m-%d %H:%i:%s')

2. TRUNC → DATE_FORMAT / DATE / FLOOR

Oracle의 TRUNC는 날짜/숫자 양쪽 다 쓰는 함수라 MySQL에선 목적에 따라 나뉘어요.

날짜 절삭 (시분초 제거)

-- Oracle: 시분초 날려서 날짜만
SELECT TRUNC(SYSDATE) FROM dual;
SELECT TRUNC(created_at) FROM orders;

-- MySQL: DATE()로 동일하게
SELECT DATE(NOW());
SELECT DATE(created_at) FROM orders;

특정 단위로 절삭

-- Oracle: 월의 첫날로
SELECT TRUNC(SYSDATE, 'MM') FROM dual;  -- 2024-01-01

-- MySQL: DATE_FORMAT으로 동일 효과
SELECT DATE_FORMAT(NOW(), '%Y-%m-01');  -- 2024-01-01

-- Oracle: 연도의 첫날로
SELECT TRUNC(SYSDATE, 'YYYY') FROM dual;  -- 2024-01-01

-- MySQL
SELECT DATE_FORMAT(NOW(), '%Y-01-01');

숫자 절삭 (소수점)

-- Oracle
SELECT TRUNC(3.14159, 2) FROM dual;  -- 3.14

-- MySQL: TRUNCATE (함수명 다름!)
SELECT TRUNCATE(3.14159, 2);  -- 3.14

Oracle은 TRUNC, MySQL은 숫자에 TRUNCATE를 써요. TRUNC라고 쓰면 MySQL에서 에러 납니다.

3. TO_CHAR → DATE_FORMAT / CAST

날짜나 숫자를 문자열로 변환하는 함수예요.

날짜 → 문자열

-- Oracle
SELECT TO_CHAR(SYSDATE, 'YYYY-MM-DD') FROM dual;
SELECT TO_CHAR(created_at, 'YYYY년 MM월 DD일') FROM orders;

-- MySQL: DATE_FORMAT
SELECT DATE_FORMAT(NOW(), '%Y-%m-%d');
SELECT DATE_FORMAT(created_at, '%Y년 %m월 %d일') FROM orders;

숫자 → 문자열

-- Oracle
SELECT TO_CHAR(12345.6, '999,999.9') FROM dual;  -- 12,345.6

-- MySQL: FORMAT 또는 CAST
SELECT FORMAT(12345.6, 1);   -- 12,345.6 (천단위 콤마 자동)
SELECT CAST(12345.6 AS CHAR);  -- 12345.6 (단순 변환)

한눈에 보는 요약표

추가로 자주 마주치는 차이점

Oracle에서 습관적으로 쓰던 것들이 MySQL에서 달라서 막히는 경우가 많아요.

-- Oracle의 dual 테이블 → MySQL은 그냥 생략
SELECT SYSDATE FROM dual;   -- Oracle
SELECT NOW();               -- MySQL (FROM 없어도 됨)

-- Oracle SYSDATE → MySQL NOW() 또는 CURDATE()
SYSDATE          → NOW()       -- 날짜+시간
SYSDATE (날짜만) → CURDATE()   -- 날짜만

-- NULL 처리
NVL(col, 0)      → IFNULL(col, 0)
NVL2(col, a, b)  → IF(col IS NOT NULL, a, b)

Context7란?

AI 코딩 어시스턴트에게 최신 공식 문서를 실시간으로 주입해주는 MCP 서버

Claude Code, Gemini CLI 같은 AI 코딩 어시스턴트는 학습 데이터가 과거 기준이라, 최신 라이브러리 API를 모르거나 이미 deprecated된 코드를 생성하는 문제가 있다.

Context7은 이 문제를 해결하기 위해 AI에게 버전별 최신 공식 문서와 코드 예제를 직접 제공하여 AI가 올바르게 동작하는 코드를 작성하도록 도와준다.

핵심 개념

왜 필요한가?

서버 구조

GitHub처럼 중앙화된 서버(mcp.context7.com)가 존재하며, 9,000개 이상의 라이브러리 문서가 인덱싱되어 있다.

사용 방식은 두 가지다.

• 리모트 MCP — 중앙 서버 URL에 직접 연결 (설치 불필요)
• 로컬 MCP — npx로 로컬 프로세스를 실행하되, 문서 데이터는 중앙 서버에서 가져옴 (오프라인 불가)

사용법

기본 원리

프롬프트 끝에 use context7을 붙이면, Context7이 자동으로:

1. 어떤 라이브러리를 묻는지 감지
2. 해당 라이브러리의 최신 공식 문서를 조회
3. 관련 문서를 AI 컨텍스트에 주입
4. AI가 최신 문서 기반으로 코드 생성

예제

✅ 기본 사용법

Next.js 미들웨어에서 JWT를 쿠키로 검증하고,
미인증 사용자는 /login으로 리다이렉트하는 코드 작성해줘. use context7

프롬프트 끝에 use context7만 추가하면 끝. Context7이 Next.js 최신 문서를 가져와 현재 버전에 맞는 미들웨어 코드를 생성해준다.

✅ 특정 라이브러리 명시

Supabase로 회원가입/로그인 기능 구현해줘. use context7 /supabase/supabase

라이브러리 ID(/supabase/supabase)를 직접 지정하면 Context7이 라이브러리 탐색 과정을 건너뛰고 바로 문서를 가져온다. 더 빠르고 정확하다.

✅ 특정 주제 조회

MongoDB Node.js 드라이버로 커넥션 풀링 설정하는 방법 알려줘. use context7

"커넥션 풀링"이라는 키워드를 기반으로 MongoDB 문서 중 관련 섹션만 골라서 주입한다.

✅ Claude Code에서 자동 적용 (rules 설정)

.claude/rules 파일에 아래 내용을 추가하면, 매번 use context7을 쓰지 않아도 자동으로 동작한다.

코드 생성, 라이브러리 설정, API 사용이 필요할 때는
항상 Context7 MCP 도구를 사용해서 최신 문서를 먼저 확인하고 답변해줘.

설치 방법 (Claude Desktop 기준)

claude_desktop_config.json에 아래 내용 추가:

{
  "mcpServers": {
    "context7": {
      "command": "npx",
      "args": ["-y", "@upstash/context7-mcp"]
    }
  }
}

또는 리모트 MCP 방식으로 URL만 등록:

https://mcp.context7.com/mcp

참고

• 공식 GitHub: github.com/upstash/context7
• 대시보드 (API 키 발급): context7.com/dashboard
• API 키 없이도 무료로 사용 가능 (요청 수 제한 있음)

Nginx는 고성능 웹 서버이자 리버스 프록시 서버로, 가볍고 빠른 처리 성능으로 널리 사용된다.
이 문서는 실무에서 자주 접하는 핵심 설정들을 정리한다.

목차

1. 기본 구조
2. worker 설정
3. http 블록 핵심 설정
4. server 블록
5. location 설정
6. proxy_pass 설정
7. HTTPS / SSL 설정
8. 로드 밸런싱
9. 정적 파일 서빙
10. 캐시 설정
11. 로그 설정
12. 보안 설정
13. gzip 압축
14. 타임아웃 설정

1. 기본 구조

Nginx 설정 파일(nginx.conf)은 블록(block) 단위로 구성된다.

main (전역)
├── events { }         # 연결 처리 방식
└── http { }           # HTTP 관련 설정
    ├── upstream { }   # 로드 밸런싱 대상 서버 그룹
    └── server { }     # 가상 호스트 설정
        └── location { } # 요청 경로별 처리

# nginx.conf 기본 구조

worker_processes auto;

events {
    worker_connections 1024;
}

http {
    include       mime.types;
    default_type  application/octet-stream;

    server {
        listen 80;
        server_name example.com;

        location / {
            root /var/www/html;
            index index.html;
        }
    }
}

2. worker 설정

Nginx는 멀티 프로세스 모델로 동작한다.
master process 1개가 worker process 여러 개를 관리한다.

# CPU 코어 수에 맞게 자동 설정 (권장)
worker_processes auto;

events {
    # worker 하나가 동시에 처리할 수 있는 최대 연결 수
    worker_connections 1024;

    # 여러 연결을 한 번에 수락 (성능 향상)
    multi_accept on;

    # Linux 에서 가장 효율적인 이벤트 처리 방식
    use epoll;
}

💡 최대 동시 처리 가능 연결 수 = worker_processes × worker_connections

3. http 블록 핵심 설정

http {
    # MIME 타입 정의 파일 포함
    include mime.types;
    default_type application/octet-stream;

    # sendfile: OS 커널이 직접 파일 전송 (성능 향상)
    sendfile on;

    # 패킷을 모아서 한 번에 전송 (sendfile on 일때 효과적)
    tcp_nopush on;

    # 작은 패킷도 즉시 전송 (지연 감소)
    tcp_nodelay on;

    # Keep-Alive 연결 유지 시간 (초)
    keepalive_timeout 65;
}

4. server 블록

하나의 Nginx에서 여러 도메인(가상 호스트) 을 운영할 수 있다.

# HTTP 서버
server {
    listen 80;
    server_name example.com www.example.com;

    # ...
}

# 다른 도메인
server {
    listen 80;
    server_name another.com;

    # ...
}

HTTP → HTTPS 리다이렉트

server {
    listen 80;
    server_name example.com;

    return 301 https://$host$request_uri;
}

5. location 설정

매칭 방식 및 우선순위

# ① 정확 일치 (최우선)
location = /health {
    return 200 'OK';
}

# ② prefix 우선 일치 (정규식보다 우선)
location ^~ /static/ {
    root /var/www;
}

# ③ 정규식 일치 (대소문자 구분)
location ~ ^/api/v\d+/ {
    proxy_pass http://localhost:8080;
}

# ③ 정규식 일치 (대소문자 무시)
location ~* \.(jpg|jpeg|png|gif)$ {
    expires 30d;
}

# ④ 일반 prefix 일치
location /app/ {
    proxy_pass http://localhost:3000/;
}

/path vs /path/ 주의사항

location /detector/ 는 /detector (trailing slash 없음) 요청을 매칭하지 않는다.
두 경우를 모두 처리하려면 아래처럼 설정한다.

location = /detector {
    return 301 /detector/;
}

location /detector/ {
    proxy_pass http://localhost:8080/;
}

6. proxy_pass 설정

trailing slash(/) 의 의미

proxy_pass 끝에 / 가 붙는지 여부에 따라, location prefix를 백엔드로 전달할지 말지가 결정된다.

# prefix 유지: /detector/api → localhost:8080/detector/api
location /detector/ {
    proxy_pass http://localhost:8080;
}

# prefix 제거: /detector/api → localhost:8080/api
location /detector/ {
    proxy_pass http://localhost:8080/;
}

정규식 location에서의 proxy_pass

정규식 location에서는 proxy_pass에 URI(trailing slash 포함)를 명시하면 nginx가 설정 로드 시 에러를 발생시킨다.

# ❌ 설정 에러 발생
location ~ ^/detector/\d+ {
    proxy_pass http://localhost:8080/;
}

# ✅ URI 없이만 사용 가능
location ~ ^/detector/\d+ {
    proxy_pass http://localhost:8080;
}

prefix를 제거하고 싶다면 rewrite 를 사용한다.

location ~ ^/detector/(.*)$ {
    rewrite ^/detector/(.*)$ /$1 break;
    proxy_pass http://localhost:8080;
    # /detector/api/test → localhost:8080/api/test
}

프록시 헤더 설정

리버스 프록시 시 클라이언트 정보를 백엔드로 전달하기 위해 헤더를 설정한다.

location /api/ {
    proxy_pass http://localhost:8080/;

    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
}

7. HTTPS / SSL 설정

server {
    listen 443 ssl;
    server_name example.com;

    # 인증서 경로
    ssl_certificate     /etc/nginx/ssl/example.com.crt;
    ssl_certificate_key /etc/nginx/ssl/example.com.key;

    # 권장 프로토콜 (구버전 TLS 제외)
    ssl_protocols TLSv1.2 TLSv1.3;

    # 권장 암호화 알고리즘
    ssl_ciphers HIGH:!aNULL:!MD5;

    # 서버 암호화 알고리즘 우선 사용
    ssl_prefer_server_ciphers on;

    # SSL 세션 캐시 (성능 향상)
    ssl_session_cache shared:SSL:10m;
    ssl_session_timeout 10m;

    location / {
        proxy_pass http://localhost:3000;
    }
}

💡 Let's Encrypt + Certbot 을 사용하면 무료 SSL 인증서를 자동으로 발급/갱신할 수 있다.

8. 로드 밸런싱

여러 백엔드 서버에 트래픽을 분산한다.

upstream backend {
    # 기본: Round Robin (순서대로 분산)
    server 127.0.0.1:8001;
    server 127.0.0.1:8002;
    server 127.0.0.1:8003;
}

server {
    location /api/ {
        proxy_pass http://backend/;
    }
}

로드 밸런싱 방식

upstream backend {
    # least_conn: 연결 수가 가장 적은 서버로 분산
    least_conn;

    server 127.0.0.1:8001;
    server 127.0.0.1:8002;
}

upstream backend {
    # ip_hash: 같은 클라이언트 IP는 항상 같은 서버로 (세션 유지)
    ip_hash;

    server 127.0.0.1:8001;
    server 127.0.0.1:8002;
}

upstream backend {
    # weight: 가중치 설정 (8001이 트래픽 3배 더 받음)
    server 127.0.0.1:8001 weight=3;
    server 127.0.0.1:8002 weight=1;
}

서버 상태 옵션

upstream backend {
    server 127.0.0.1:8001;
    server 127.0.0.1:8002 backup;   # 나머지 서버 장애시에만 사용
    server 127.0.0.1:8003 down;     # 사용 안 함 (점검용)
}

9. 정적 파일 서빙

server {
    listen 80;
    server_name example.com;

    # 루트 디렉토리 지정
    root /var/www/html;

    # 기본 인덱스 파일
    index index.html index.htm;

    location / {
        # 파일 → 디렉토리 → 404 순으로 시도
        try_files $uri $uri/ =404;
    }

    # SPA(React, Vue 등) 라우팅 처리
    location / {
        try_files $uri $uri/ /index.html;
    }
}

특정 확장자 캐싱

location ~* \.(jpg|jpeg|png|gif|ico|css|js|woff2)$ {
    expires 30d;
    add_header Cache-Control "public, no-transform";
}

10. 캐시 설정

프록시 캐시

백엔드 응답을 Nginx가 캐싱하여 백엔드 부하를 줄인다.

http {
    # 캐시 저장 경로 및 옵션 정의
    proxy_cache_path /var/cache/nginx
                     levels=1:2
                     keys_zone=my_cache:10m
                     max_size=1g
                     inactive=60m;

    server {
        location /api/ {
            proxy_pass http://localhost:8080/;
            proxy_cache my_cache;
            proxy_cache_valid 200 10m;   # 200 응답은 10분 캐시
            proxy_cache_valid 404 1m;    # 404 응답은 1분 캐시

            # 캐시 상태를 응답 헤더에 표시 (HIT/MISS/BYPASS)
            add_header X-Cache-Status $upstream_cache_status;
        }
    }
}

11. 로그 설정

http {
    # 로그 포맷 정의
    log_format main '$remote_addr - $remote_user [$time_local] "$request" '
                    '$status $body_bytes_sent "$http_referer" '
                    '"$http_user_agent"';

    # 접근 로그
    access_log /var/log/nginx/access.log main;

    # 에러 로그 (레벨: debug, info, notice, warn, error, crit)
    error_log /var/log/nginx/error.log warn;

    server {
        # 특정 서버만 로그 비활성화
        access_log off;
    }
}

12. 보안 설정

http {
    # Nginx 버전 정보 숨기기
    server_tokens off;

    server {
        # 클릭재킹 방지
        add_header X-Frame-Options "SAMEORIGIN";

        # XSS 필터 활성화
        add_header X-XSS-Protection "1; mode=block";

        # MIME 타입 스니핑 방지
        add_header X-Content-Type-Options "nosniff";

        # HTTPS 강제 (HSTS)
        add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;

        # 특정 HTTP 메서드만 허용
        if ($request_method !~ ^(GET|HEAD|POST|PUT|DELETE)$) {
            return 405;
        }
    }
}

요청 크기 제한

http {
    # 클라이언트 요청 body 최대 크기 (파일 업로드 등)
    client_max_body_size 10m;
}

IP 접근 제한

location /admin/ {
    allow 192.168.1.0/24;   # 특정 대역만 허용
    allow 127.0.0.1;
    deny all;               # 나머지 차단
}

13. gzip 압축

응답 데이터를 압축하여 전송 속도를 높인다.

http {
    gzip on;

    # 압축 레벨 (1~9, 높을수록 압축률 높고 CPU 사용량 증가)
    gzip_comp_level 6;

    # 최소 압축 대상 크기 (너무 작은 파일은 압축 불필요)
    gzip_min_length 1000;

    # 압축 대상 MIME 타입
    gzip_types
        text/plain
        text/css
        text/javascript
        application/json
        application/javascript
        application/xml
        image/svg+xml;

    # 프록시 캐시와 함께 사용 시 필요
    gzip_vary on;
}

14. 타임아웃 설정

http {
    # 클라이언트로부터 요청 헤더를 읽는 타임아웃
    client_header_timeout 10s;

    # 클라이언트로부터 요청 body를 읽는 타임아웃
    client_body_timeout 10s;

    # 클라이언트에게 응답을 전송하는 타임아웃
    send_timeout 10s;

    # 프록시 서버 연결 타임아웃
    proxy_connect_timeout 5s;

    # 프록시 서버로부터 응답을 받는 타임아웃
    proxy_read_timeout 60s;

    # 프록시 서버로 요청을 전송하는 타임아웃
    proxy_send_timeout 60s;
}

요약

1. proxy_pass 의 trailing slash(/) 의미

proxy_pass 끝에 / 가 붙는지 여부에 따라, location prefix를 백엔드로 전달할지 말지가 결정된다.

정리

• / 없음 → location prefix를 유지한 채로 전달
• / 있음 → location prefix를 제거하고 나머지 경로만 전달

예시

# prefix 유지: /detector/api → localhost:8080/detector/api
location /detector/ {
    proxy_pass http://localhost:8080;
}

# prefix 제거: /detector/api → localhost:8080/api
location /detector/ {
    proxy_pass http://localhost:8080/;
}

2. location 설정 3가지 방법

① Prefix Match (전방 일치)

입력한 prefix로 시작하는 모든 경로를 매칭한다.

location /detector/ {
    # /detector/, /detector/api/test 등 모두 매칭
}

⚠️ /detector/ 로 설정하면 /detector (trailing slash 없음) 는 매칭되지 않는다. 두 경우를 모두 처리하려면 아래처럼 리다이렉트를 추가한다.

location = /detector {
    return 301 /detector/;
}

② Exact Match (정확 일치)

입력한 경로와 정확히 일치하는 요청만 매칭한다.

location = /detector {
    # /detector 와 정확히 일치하는 요청만 매칭
}

③ Regex Match (정규식 일치)

정규식 패턴에 매칭되는 경로를 처리한다.

location ~ ^/detector/\d+ {
    # /detector/123, /detector/456 등 매칭
}

⚠️ 정규식 location에서는 proxy_pass에 URI(trailing slash)를 붙일 수 없다. nginx가 설정 로드 시점에 에러를 발생시키므로, 아예 허용되지 않는다.

# ❌ 설정 에러 발생
location ~ ^/detector/\d+ {
    proxy_pass http://localhost:8080/;
}

# ✅ URI 없이만 사용 가능
location ~ ^/detector/\d+ {
    proxy_pass http://localhost:8080;
}

따라서 정규식 location에서 prefix를 제거하고 싶을 때는 rewrite 를 사용한다.

3. rewrite 란?

요청 URI를 내부적으로 변경하는 기능이다.
정규식 location에서 prefix 제거가 필요할 때 주로 활용한다.

location ~ ^/detector/(.*)$ {
    rewrite ^/detector/(.*)$ /$1 break;
    proxy_pass http://localhost:8080;
    # /detector/api/test → localhost:8080/api/test
}