데이터베이스가 필요한 이유

처음에는 JSON이나 CSV 파일로도 충분해 보이지만, 데이터와 사용자가 늘면 파일은 조용히 데이터를 잃어요. 두 프로그램이 동시에 쓰면 한쪽이 사라지고, 쓰는 도중에 멈추면 파일이 망가지고, 잘못된 값이 막힘없이 들어가고, 찾는 데 점점 오래 걸리는 모습을 직접 재현해요. 같은 일을 파이썬에 들어 있는 SQLite로 해서 데이터베이스가 무엇을 지켜 주는지 확인하고, 데이터베이스의 종류와 파일로 충분한 때를 가르는 기준까지 다뤄요.

초급강의 1 / 6약 14분

웹 개발 트랙의 할 일 앱은 데이터를 브라우저의 localStorage에 넣었어요. 그 브라우저에서만 보이고, 사이트 데이터를 지우면 사라졌죠. 여러 사람이 쓰는 서비스라면 데이터는 서버에 모아야 해요. 서버에 모으는 가장 쉬운 방법은 파일이에요. 실제로 처음에는 JSON 파일 하나로 시작하는 프로그램이 많아요. 그런데 그 파일이 어떤 순간에 데이터를 잃는지 알고 나면, 데이터베이스가 왜 있는지 저절로 이해돼요.

파일이 데이터를 잃는 순간 1: 동시에 쓸 때

할 일을 JSON 파일에 저장하는 프로그램 두 개가 거의 동시에 일한다고 해 볼게요. 웹 서버라면 두 사람이 동시에 "저장"을 누른 상황이에요.

import json
import pathlib
import tempfile

folder = pathlib.Path(tempfile.mkdtemp())
path = folder / "todos.json"
path.write_text("[]", encoding="utf-8")

def load():
    return json.loads(path.read_text(encoding="utf-8"))

def save(data):
    path.write_text(json.dumps(data, ensure_ascii=False), encoding="utf-8")

a = load()                       # 프로그램 A가 파일을 읽고
b = load()                       # 거의 동시에 프로그램 B도 읽어요
a.append("우유 사기")
save(a)
b.append("강의 읽기")
save(b)                          # B는 A가 쓴 줄 모르고 자기 것으로 덮어써요
print("남은 할 일:", load())
남은 할 일: ['강의 읽기']

둘 다 "저장 성공"이었는데 "우유 사기"가 사라졌어요. 둘 다 빈 목록을 읽고, 각자 하나씩 더해서, 나중에 쓴 쪽이 먼저 쓴 쪽을 덮어썼기 때문이에요. 이걸 갱신 분실(lost update)이라고 해요. 오류도 경고도 없이 일어나서, 사용자가 "분명히 저장했는데요"라고 말하기 전까지는 아무도 몰라요. 사용자가 적을 때는 드물게 일어나다가, 늘어날수록 자주 일어나요.

파일이 데이터를 잃는 순간 2: 쓰다가 멈출 때

파일을 쓰는 도중에 전원이 나가거나 프로그램이 죽으면 어떻게 될까요?

data = [{"id": i, "text": f"할 일 {i}"} for i in range(1000)]
full = json.dumps(data, ensure_ascii=False)
path.write_text(full[: len(full) // 2], encoding="utf-8")   # 쓰는 도중에 전원이 나갔다면
try:
    load()
except json.JSONDecodeError as e:
    print("파일이 망가졌어요:", e.msg, f"({e.pos}번째 글자)")
파일이 망가졌어요: Unterminated string starting at (15889번째 글자)

절반만 쓰인 파일은 JSON으로 읽을 수조차 없어요. 새로 더한 할 일 하나가 아니라 1,000개 전부를 잃은 거예요. 파일을 통째로 다시 쓰는 방식은 이렇게 약해요. 그래서 파일로 저장할 때는 임시 파일에 다 쓴 다음 한 번에 바꿔치기하는 요령을 써요.

import os

def save_safely(data):
    tmp = path.with_suffix(".tmp")
    tmp.write_text(json.dumps(data, ensure_ascii=False), encoding="utf-8")
    os.replace(tmp, path)        # 바꿔치기는 한 번에 일어나서, 예전 파일이나 새 파일 둘 중 하나만 남아요

이 요령으로 망가지는 건 막을 수 있지만, 앞의 갱신 분실은 여전히 못 막아요. 이런 문제를 하나하나 직접 해결하다 보면 결국 데이터베이스를 새로 만드는 셈이 돼요.

파일이 막지 못하는 것: 잘못된 값

JSON 파일에는 무엇이든 들어가요. 이메일이 같은 회원이 둘이어도, 이름이 비어 있어도, 날짜 자리에 "어제쯤"이라고 적혀 있어도 파일은 막지 않아요. 이런 데이터는 나중에 엉뚱한 곳에서 문제를 일으켜요. 데이터베이스는 규칙을 미리 정해 두고, 어긋나는 값을 들어오는 순간 거절해요. 파이썬에 들어 있는 SQLite로 해 볼게요. 따로 설치할 것이 없어요.

import sqlite3

db = sqlite3.connect(":memory:")
db.execute("""
CREATE TABLE users (
    id     INTEGER PRIMARY KEY,
    email  TEXT NOT NULL UNIQUE,
    name   TEXT NOT NULL,
    joined TEXT NOT NULL
)""")
db.executemany("INSERT INTO users (email, name, joined) VALUES (?, ?, ?)",
               [("[email protected]", "민지", "2026-01-03"), ("[email protected]", "준호", "2026-02-11")])
for row in db.execute("SELECT id, name, joined FROM users ORDER BY id"):
    print(row)
for bad in [("[email protected]", "가짜 민지", "2026-03-01"), ("[email protected]", None, "2026-03-01")]:
    try:
        db.execute("INSERT INTO users (email, name, joined) VALUES (?, ?, ?)", bad)
    except sqlite3.IntegrityError as e:
        print("거절:", e)
(1, '민지', '2026-01-03')
(2, '준호', '2026-02-11')
거절: UNIQUE constraint failed: users.email
거절: NOT NULL constraint failed: users.name
  • CREATE TABLE로 표(테이블)의 모양을 정해요. 칸(열)마다 이름과 종류와 규칙이 있어요.
  • UNIQUE는 "같은 값이 두 번 들어올 수 없다", NOT NULL은 "비워 둘 수 없다"는 규칙이에요. 이미 있는 이메일과 이름 없는 회원은 들어오는 순간 거절됐어요.
  • INTEGER PRIMARY KEY인 id는 행마다 붙는 고유 번호예요. 값을 주지 않으면 데이터베이스가 1, 2처럼 알아서 매겨요.
  • 값은 SQL 문장에 직접 붙이지 않고 ? 자리에 따로 넘겼어요. 이 습관이 중요한 이유는 다음 강의와 보안 트랙에서 다뤄요.

데이터베이스는 어떻게 지켜 주나

이번에는 처음의 두 사고를 데이터베이스로 다시 해 볼게요. 파일에 저장되는 SQLite 데이터베이스를 두 프로그램이 동시에 열어요.

file_db = folder / "todos.db"
setup = sqlite3.connect(file_db)
setup.execute("CREATE TABLE todos (id INTEGER PRIMARY KEY, text TEXT NOT NULL)")
setup.commit()
setup.close()

conn_a = sqlite3.connect(file_db)          # 프로그램 A
conn_b = sqlite3.connect(file_db)          # 프로그램 B
conn_a.execute("INSERT INTO todos (text) VALUES (?)", ("우유 사기",))
seen_by_b = conn_b.execute("SELECT COUNT(*) FROM todos").fetchone()[0]
conn_a.commit()
conn_b.execute("INSERT INTO todos (text) VALUES (?)", ("강의 읽기",))
conn_b.commit()
print("A가 저장을 마치기 전에 B가 본 개수:", seen_by_b)
print("남은 할 일:", [t for (t,) in conn_a.execute("SELECT text FROM todos ORDER BY id")])

conn_a.execute("CREATE TABLE accounts (name TEXT PRIMARY KEY, balance INTEGER NOT NULL)")
conn_a.executemany("INSERT INTO accounts VALUES (?, ?)", [("민지", 50000), ("준호", 10000)])
conn_a.commit()

def transfer(conn, sender, receiver, amount, fail_midway=False):
    with conn:                              # 이 안의 일은 모두 되거나, 하나도 안 되거나
        conn.execute("UPDATE accounts SET balance = balance - ? WHERE name = ?", (amount, sender))
        if fail_midway:
            raise RuntimeError("보내는 도중에 오류가 났어요")
        conn.execute("UPDATE accounts SET balance = balance + ? WHERE name = ?", (amount, receiver))

try:
    transfer(conn_a, "민지", "준호", 30000, fail_midway=True)
except RuntimeError as e:
    print(e)
print("잔액:", dict(conn_a.execute("SELECT name, balance FROM accounts")))
transfer(conn_a, "민지", "준호", 30000)
print("잔액:", dict(conn_a.execute("SELECT name, balance FROM accounts")))
conn_a.close()
conn_b.close()
A가 저장을 마치기 전에 B가 본 개수: 0
남은 할 일: ['우유 사기', '강의 읽기']
보내는 도중에 오류가 났어요
잔액: {'민지': 50000, '준호': 10000}
잔액: {'민지': 20000, '준호': 40000}
  • 둘 다 살아남았어요. 데이터베이스는 파일 전체를 덮어쓰지 않고 바뀐 행만 고치고, 동시에 고치려는 쪽을 차례로 줄 세워요.
  • 확정 전의 일은 남에게 보이지 않아요. A가 저장(commit)을 마치기 전에 B가 셌을 때는 0개였어요. 반쯤 된 일을 남이 보고 잘못 판단하는 걸 막아 줘요.
  • 모두 되거나, 하나도 안 되거나. 송금은 "민지에게서 빼기"와 "준호에게 더하기" 두 단계예요. 첫 단계만 하고 오류가 나면 돈이 증발하는데, 데이터베이스는 이 묶음을 트랜잭션으로 다뤄서 중간에 실패하면 처음 상태로 되돌려요. 성공하면 두 단계가 함께 확정돼요. 전원이 나가도 확정된 것은 남고, 확정되지 않은 것은 흔적 없이 사라져요.

이렇게 데이터베이스가 지키는 약속을 흔히 ACID라고 불러요. 모두 되거나 하나도 안 되거나(원자성), 규칙을 어기지 않음(일관성), 동시에 일해도 서로 꼬이지 않음(격리성), 확정된 것은 사라지지 않음(지속성)이에요. 트랜잭션 강의에서 자세히 다뤄요.

데이터가 많아져도 빠르게

파일에서 회원 한 명을 찾으려면 처음부터 끝까지 읽어야 해요. 20만 명이면 20만 줄을 읽어요. 데이터베이스는 책 뒤의 찾아보기처럼 인덱스를 만들어 둘 수 있어요.

import time

big = sqlite3.connect(":memory:")
big.execute("CREATE TABLE users (id INTEGER PRIMARY KEY, email TEXT, name TEXT)")
big.executemany("INSERT INTO users (email, name) VALUES (?, ?)",
                ((f"user{i}@example.com", f"사용자{i}") for i in range(200_000)))
query = "SELECT name FROM users WHERE email = ?"

def lookups():
    start = time.perf_counter()
    for i in range(0, 200_000, 2_000):                # 100번 찾기
        big.execute(query, (f"user{i}@example.com",)).fetchone()
    return time.perf_counter() - start

print(big.execute("EXPLAIN QUERY PLAN " + query, ("x",)).fetchone()[3])
slow = lookups()
big.execute("CREATE INDEX idx_users_email ON users(email)")
print(big.execute("EXPLAIN QUERY PLAN " + query, ("x",)).fetchone()[3])
fast = lookups()
print("인덱스로 100배 넘게 빨라졌나요?", slow / fast > 100)
SCAN users
SEARCH users USING INDEX idx_users_email (email=?)
인덱스로 100배 넘게 빨라졌나요? True

EXPLAIN QUERY PLAN은 데이터베이스가 질문에 어떻게 답할 계획인지 보여 줘요. 처음에는 SCAN, 즉 20만 행을 처음부터 훑었어요. 인덱스를 만든 뒤에는 SEARCH ... USING INDEX, 찾아보기에서 바로 찾아갔어요. 이 컴퓨터에서는 4천 배 넘게 빨라졌는데, 정확한 배수는 컴퓨터마다 달라서 예제에서는 100배를 넘는지만 확인했어요. 중요한 건 같은 질문을 고치지 않고 인덱스만 더했는데 빨라졌다는 점이에요. 어떻게 찾을지는 데이터베이스가 정해요. 인덱스 강의에서 원리와 대가를 자세히 봐요.

데이터베이스가 해 주는 일

정리하면, 데이터베이스 관리 시스템(DBMS)은 이런 일을 대신 해 줘요.

하는 일파일로 직접 하면
여럿이 동시에 읽고 써도 데이터를 지켜요갱신 분실이 조용히 일어나요
중간에 멈춰도 확정된 것만 남겨요(트랜잭션)파일이 망가지거나 반쯤 된 상태가 남아요
규칙에 어긋난 값을 거절해요(제약 조건)잘못된 값이 나중에 문제를 일으켜요
많은 데이터에서도 빨리 찾아요(인덱스)매번 처음부터 끝까지 읽어요
질문하는 말(SQL)로 원하는 데이터를 꺼내요반복문을 직접 짜야 해요
사용자별 권한과 백업을 관리해요파일 권한과 복사에 기대야 해요

데이터베이스의 종류

종류데이터를 담는 모양대표
관계형표(행과 열), 표끼리 관계로 연결PostgreSQL, MySQL, SQLite
키 값이름표와 값 한 쌍Redis
문서형JSON 같은 문서MongoDB
검색 엔진글을 낱말 단위로 쪼갠 찾아보기Elasticsearch, OpenSearch
분석용열 단위로 모아 큰 계산에 강함BigQuery, DuckDB
벡터임베딩 벡터, 비슷한 것 찾기pgvector, Qdrant

이 트랙에서는 가장 널리 쓰이는 관계형 데이터베이스와 그 언어인 SQL을 중심으로 배우고, 나머지는 NoSQL 강의에서 언제 무엇을 고를지 비교해요. 벡터 데이터베이스는 LLM 트랙의 RAG 강의에서 만난 그것이에요.

예제에 쓴 SQLite는 서버 없이 파일 하나로 동작하는 관계형 데이터베이스예요. 파이썬에 들어 있고, 휴대폰 앱과 브라우저 안에서도 쓰일 만큼 흔하고 튼튼해요. 배우기에도, 작은 서비스에도 좋아요. 여러 서버가 동시에 많은 사용자를 받는 웹 서비스라면 PostgreSQL이나 MySQL 같은 서버형 데이터베이스를 써요. SQL은 대부분 같아서, 여기서 배운 것을 그대로 쓸 수 있어요.

그래도 파일로 충분한 때

모든 데이터에 데이터베이스가 필요한 건 아니에요.

  • 한 프로그램만 쓰고, 통째로 읽고 쓰는 작은 데이터: 설정 파일, 개인용 메모 정도는 JSON이면 충분해요. 바꿔치기 저장 요령만 지키면 돼요.
  • 덧붙이기만 하는 기록: 로그처럼 끝에 줄을 더하기만 하고 고치지 않는 데이터는 파일이 잘 맞아요.
  • 주고받기용: 다른 프로그램에 넘기거나 사람이 열어 볼 데이터는 CSV나 JSON이 편해요.

반대로 여럿이 동시에 쓰거나, 일부만 자주 고치거나, 조건으로 찾거나, 잃으면 안 되는 데이터라면 처음부터 데이터베이스를 쓰는 게 나중의 고생을 크게 줄여요. 고민된다면 SQLite부터 시작해 보세요. 파일 하나만큼 가볍게 시작할 수 있어요.

실습

  1. 갱신 분실 예제를 threading으로 바꿔, 스레드 10개가 각자 할 일 100개를 JSON 파일에 더하게 해 보세요. 마지막에 몇 개가 남나요?
  2. 같은 실험을 SQLite로 해 보세요. 스레드마다 sqlite3.connect를 따로 하고, 하나씩 넣고 commit해요. 몇 개가 남나요?
  3. 회원 표에 age INTEGER CHECK (age >= 0) 칸을 더하고, 나이에 -5를 넣어 보세요. 어떤 오류가 나나요?
  4. 송금 함수에 "잔액이 모자라면 오류"를 더해 보세요. 민지가 10만 원을 보내려 하면 두 사람의 잔액은 어떻게 되나요?
  5. 인덱스 예제에서 WHERE name = ?으로 찾으면 계획이 SCAN인지 SEARCH인지 확인해 보세요. 왜 그럴까요?

자주 하는 실수

  • "사용자가 적으니 괜찮다"며 JSON 파일을 여럿이 쓰게 한다. 갱신 분실은 드물게라도 반드시 일어나고, 일어나도 티가 나지 않아요.
  • 파일을 제자리에서 통째로 다시 쓴다. 쓰다 멈추면 전부 잃어요. 임시 파일에 쓰고 바꿔치기해요.
  • 규칙을 프로그램 코드에만 둔다. 다른 프로그램이나 사람이 데이터를 넣으면 규칙이 지켜지지 않아요. 데이터베이스의 제약 조건에도 적어요.
  • commit을 잊는다. 확정하지 않은 변경은 연결을 닫는 순간 사라져요. with conn:으로 묶으면 성공할 때 알아서 확정돼요.
  • 데이터베이스를 쓰면서도 인덱스를 생각하지 않는다. 데이터가 적을 때는 빠르다가, 늘어나면 갑자기 느려져요.

점검 문제

  1. 두 프로그램이 같은 JSON 파일을 읽고 각자 고쳐 저장할 때 데이터가 사라지는 이유는?
  2. 파일을 쓰는 도중에 멈추면 새로 더한 항목만이 아니라 전부를 잃을 수 있는 이유는?
  3. UNIQUE와 NOT NULL은 각각 무엇을 막나요?
  4. 트랜잭션의 "모두 되거나 하나도 안 되거나"가 송금에서 중요한 이유는?
  5. A가 commit하기 전에 B가 할 일 개수를 0개로 본 것은 어떤 약속 때문인가요?
  6. EXPLAIN QUERY PLAN에서 SCAN과 SEARCH USING INDEX의 차이는?
  7. 데이터베이스 대신 파일로 충분한 경우 두 가지는?

정답

  1. 둘 다 같은 예전 내용을 읽고 각자 고친 뒤 파일 전체를 다시 쓰기 때문에, 나중에 쓴 쪽이 먼저 쓴 쪽의 변경을 덮어써 버려요(갱신 분실).
  2. 파일 전체를 처음부터 다시 쓰는 중이라 멈춘 순간 파일이 반쪽짜리가 되고, 반쪽짜리 JSON은 아예 읽을 수 없기 때문이에요.
  3. UNIQUE는 같은 값이 두 번 들어오는 것을, NOT NULL은 값을 비워 두는 것을 막아요.
  4. 빼기만 되고 더하기가 안 되면 돈이 사라지기 때문이에요. 트랜잭션은 중간에 실패하면 처음 상태로 되돌리고, 성공하면 두 단계를 함께 확정해요.
  5. 확정하지 않은 변경은 다른 연결에 보이지 않는다는 격리성 때문이에요.
  6. SCAN은 표의 모든 행을 처음부터 훑는 것이고, SEARCH USING INDEX는 인덱스로 해당하는 행을 바로 찾아가는 거예요.
  7. 한 프로그램만 쓰는 작은 설정이나 메모처럼 통째로 읽고 쓰는 데이터, 로그처럼 덧붙이기만 하는 기록, 다른 프로그램과 주고받거나 사람이 열어 볼 데이터예요.

다음 강의

데이터베이스가 무엇을 지켜 주는지 봤으니, 이제 데이터베이스와 대화하는 말을 배울 차례예요. 다음 강의에서는 SQL로 원하는 행을 고르고(SELECT, WHERE), 정렬하고, 묶어 세고, 여러 표를 이어 붙이는(JOIN) 법을 실습해요.