NoSQL과 저장소 고르는 기준

표에 담는 관계형 데이터베이스 말고도 키와 값, 문서, 와이드 컬럼, 그래프, 검색 엔진처럼 다른 모양으로 담는 저장소들이 있어요. 각각이 무엇을 잘하려고 생겼는지 파이썬과 SQLite로 작게 흉내 내 보며 이해해요. 캐시와 요청 횟수 제한, 문서에 끼워 넣은 정보가 갈라지는 문제, 질문에 맞춰 표를 여러 벌 만드는 설계, 친구의 친구 찾기, 한국어 검색이 어려운 이유, 복제가 늦어서 방금 바꾼 값이 옛날로 보이는 현상을 확인하고, 내 서비스에 맞는 저장소를 고르는 질문 목록을 만들어요.

중급강의 5 / 6약 18분

지금까지 다룬 관계형 데이터베이스는 데이터를 표에 담고, SQL로 묻고, 트랜잭션으로 지켜요. 대부분의 서비스에 잘 맞는 튼튼한 기본값이에요. 그런데 2000년대 후반부터 NoSQL이라고 불리는 저장소들이 널리 쓰이기 시작했어요. 이름은 "SQL이 아니다"처럼 들리지만, 실제 뜻은 "표와 SQL만이 답은 아니다"에 가까워요. 서비스가 커지면서 생긴 특정한 문제를 더 잘 풀려고 만든 저장소들이에요.

  • 한 대의 컴퓨터로는 감당이 안 될 만큼 데이터와 요청이 많아서, 여러 대에 나눠 담아야 할 때
  • 데이터의 모양이 제각각이라 표의 칸을 미리 정하기 어려울 때
  • 캐시, 메시지 목록, 친구 관계, 글 검색처럼 한 가지 질문을 아주 빠르게 해야 할 때

종류마다 잘하는 일을 직접 흉내 내 볼게요.

키-값 저장소: 이름표로 바로 꺼내기

가장 단순한 모양이에요. 이름표(키)를 주면 값을 돌려줘요. 대표인 Redis는 데이터를 메모리에 두어 아주 빠르고, 값마다 수명(TTL)을 정할 수 있어요. 그래서 캐시와 요청 횟수 제한에 많이 써요.

class KeyValue:                                       # Redis 같은 키-값 저장소를 아주 작게 흉내 내요
    def __init__(self):
        self.data = {}

    def set(self, key, value, ttl=None, now=0):
        self.data[key] = (value, None if ttl is None else now + ttl)

    def get(self, key, now=0):
        value, expires = self.data.get(key, (None, None))
        if expires is not None and now >= expires:    # 수명이 다하면 사라져요
            del self.data[key]
            return None
        return value

    def incr(self, key, ttl, now=0):
        count = (self.get(key, now) or 0) + 1
        expires = self.data.get(key, (None, now + ttl))[1]
        self.data[key] = (count, expires)
        return count

kv = KeyValue()
db_calls = 0

def popular_posts(now):
    global db_calls
    cached = kv.get("popular", now)
    if cached is not None:
        return cached, "캐시"
    db_calls += 1                                     # 느린 데이터베이스 질문이라고 생각해요
    result = ["키보드 고르는 법", "모니터 받침대 후기"]
    kv.set("popular", result, ttl=60, now=now)
    return result, "데이터베이스"

for t in (0, 30, 61):
    print(f"{t}초: {popular_posts(t)[1]}에서 가져옴")
print("데이터베이스에 물은 횟수:", db_calls)

def allowed(user, now, limit=3, window=10):           # 10초에 3번까지
    return kv.incr(f"rate:{user}:{now // window}", ttl=window, now=now) <= limit

print("요청 결과:", [(t, allowed("민지", t)) for t in (0, 1, 2, 3, 11)])
0초: 데이터베이스에서 가져옴
30초: 캐시에서 가져옴
61초: 데이터베이스에서 가져옴
데이터베이스에 물은 횟수: 2
요청 결과: [(0, True), (1, True), (2, True), (3, False), (11, True)]
  • 캐시: "인기 글" 질문의 결과를 60초 동안 저장해 두니, 세 번 중 두 번만 데이터베이스에 물었어요. 같은 질문이 1초에 수천 번 들어오는 페이지라면 차이가 엄청나요. 대신 최대 60초 동안은 조금 옛날 결과를 보여 준다는 점을 받아들여야 해요.
  • 요청 횟수 제한: 사용자와 10초 단위 시간 칸으로 이름표를 만들어 횟수를 셌어요. 네 번째 요청은 막히고, 다음 10초가 시작되면 다시 열려요. HTTP 강의의 429 응답을 이렇게 만들어요.
  • 로그인 정보(세션)처럼 "이름표로 바로 꺼내고, 일정 시간 뒤 사라지는" 데이터에도 잘 맞아요.

키-값 저장소는 이름표를 모르면 아무것도 찾지 못해요. "가격이 3만 원 이하인 상품"처럼 조건으로 찾는 질문은 못 해요. 원래 데이터는 관계형 데이터베이스에 두고, 키-값 저장소는 그 앞의 빠른 복사본으로 쓰는 경우가 많아요.

문서형 데이터베이스: 한 덩어리로 담기

MongoDB 같은 문서형 데이터베이스는 JSON 같은 문서를 통째로 담아요. 글 하나에 글쓴이, 태그, 댓글을 함께 끼워 넣을 수 있고, 문서마다 칸이 달라도 돼요. 관계형 데이터베이스도 이런 기능을 갖추고 있어서(PostgreSQL의 JSONB, SQLite의 JSON 함수), SQLite로 흉내 내 볼게요.

import json
import sqlite3

docs = sqlite3.connect(":memory:")
docs.execute("CREATE TABLE posts (id INTEGER PRIMARY KEY, doc TEXT NOT NULL)")
posts = [
    {"title": "키보드 고르는 법", "author": {"id": 1, "name": "민지"}, "tags": ["키보드", "입문"],
     "comments": [{"by": "준호", "text": "도움 됐어요"}]},
    {"title": "모니터 받침대 후기", "author": {"id": 1, "name": "민지"}, "tags": ["모니터"], "comments": []},
    {"title": "USB 허브 비교", "author": {"id": 2, "name": "준호"}, "tags": ["주변기기"],
     "video": "https://example.com/v/1"},
]
docs.executemany("INSERT INTO posts (doc) VALUES (?)", [(json.dumps(p, ensure_ascii=False),) for p in posts])

print(docs.execute("SELECT json_extract(doc, '$.title') FROM posts "
                   "WHERE json_extract(doc, '$.author.name') = '민지'").fetchall())
print(docs.execute("SELECT json_extract(doc, '$.title'), json_array_length(doc, '$.comments') FROM posts").fetchall())
docs.execute("UPDATE posts SET doc = json_set(doc, '$.author.name', '김민지') WHERE id = 1")   # 민지가 이름을 바꿨어요
print(docs.execute("SELECT DISTINCT json_extract(doc, '$.author.name') FROM posts "
                   "WHERE json_extract(doc, '$.author.id') = 1 ORDER BY 1").fetchall())
[('키보드 고르는 법',), ('모니터 받침대 후기',)]
[('키보드 고르는 법', 1), ('모니터 받침대 후기', 0), ('USB 허브 비교', None)]
[('김민지',), ('민지',)]
  • 한 번에 읽기: 글 화면에 필요한 글쓴이, 태그, 댓글이 문서 하나에 다 있어서 이어 붙일 필요가 없어요. 글 화면처럼 "한 덩어리로 읽는" 일이 대부분이라면 빠르고 편해요.
  • 칸이 자유로워요: 셋째 글에만 video가 있고 comments는 아예 없어요. 칸을 미리 정하지 않아도 돼요. 대신 comments가 없는 문서를 만나면 None이 나오듯, 어떤 칸이 있을지 프로그램이 늘 확인해야 해요. 규칙을 데이터베이스가 아니라 프로그램이 떠맡는 셈이에요.
  • 끼워 넣은 정보는 갈라져요: 민지가 이름을 바꾸자 첫 글만 고쳐져서, 같은 글쓴이의 이름이 둘이 됐어요. 테이블 설계 강의의 "고치기 이상"이 그대로 돌아왔어요. 그래서 문서형에서도 자주 바뀌는 정보는 끼워 넣지 않고 번호로 가리키게 하고, 끼워 넣을 정보는 "그 당시의 값"이어도 괜찮은 것(주문 당시의 배송 주소처럼)으로 골라요.

와이드 컬럼 저장소: 질문마다 표를 따로

Cassandra나 DynamoDB 같은 저장소는 데이터를 파티션 키로 여러 서버에 나눠 담고, 파티션 안에서는 정렬 키 순서로 줄 세워 둬요. 파티션 키를 알면 엄청난 양에서도 빠르지만, 모르면 모든 서버를 뒤져야 해요. 채팅 메시지로 흉내 내 볼게요.

import bisect
from collections import defaultdict

by_room = defaultdict(list)                           # 파티션 키: 방, 그 안의 정렬 키: 시각
by_user = defaultdict(list)                           # 같은 메시지를 '사용자별' 질문용으로 한 번 더

def send(room, at, user, text):
    bisect.insort(by_room[room], (at, user, text))
    bisect.insort(by_user[user], (at, room, text))

for i, (room, user) in enumerate([("공지", "운영자"), ("잡담", "민지"), ("잡담", "준호"), ("공지", "운영자"),
                                  ("질문", "민지"), ("잡담", "민지"), ("질문", "서연"), ("공지", "운영자")]):
    send(room, 1000 + i, user, f"메시지 {i}")

print("잡담방 최근 2개:", [text for _, _, text in by_room["잡담"][-2:]], "| 읽은 파티션 1개")
scanned = [m for msgs in by_room.values() for m in msgs if m[1] == "민지"]
print("방 기준 표로 민지의 메시지 찾기:", len(scanned), "개 | 읽은 파티션", len(by_room), "개 전부")
print("사용자 기준 표로:", len(by_user["민지"]), "개 | 읽은 파티션 1개")
잡담방 최근 2개: ['메시지 2', '메시지 5'] | 읽은 파티션 1개
방 기준 표로 민지의 메시지 찾기: 3 개 | 읽은 파티션 3 개 전부
사용자 기준 표로: 3 개 | 읽은 파티션 1개

"이 방의 최근 메시지"는 방 파티션 하나만 읽으면 돼요. 하지만 "민지가 쓴 메시지"는 방 기준으로 담겨 있어서 모든 파티션을 뒤졌어요. 실제로는 파티션이 수백만 개라 이런 질문은 사실상 못 해요. 그래서 이런 저장소에서는 질문마다 표를 따로 만들고, 쓸 때 여러 표에 함께 써요. 정규화와 정반대의 생각이에요. 질문이 미리 정해져 있고 양이 어마어마할 때(메시지, 로그, 사물 인터넷 센서 기록) 강하지만, 나중에 새로운 질문이 생기면 표를 새로 만들어 데이터를 다시 채워야 해요.

그래프 데이터베이스: 관계를 따라가기

Neo4j 같은 그래프 데이터베이스는 "누가 누구를 팔로우한다"처럼 관계 자체가 주인공인 데이터에 강해요. "친구의 친구의 친구"를 따라가는 질문이죠. 이 정도 깊이는 관계형 데이터베이스도 재귀 질문(WITH RECURSIVE)으로 할 수 있어요. SQL과 파이썬의 너비 우선 탐색으로 같은 답을 구해 볼게요.

graph = sqlite3.connect(":memory:")
graph.execute("CREATE TABLE follows (a TEXT, b TEXT)")
edges = [("민지", "준호"), ("준호", "서연"), ("서연", "도윤"), ("민지", "하준"), ("하준", "서연"), ("도윤", "지우")]
graph.executemany("INSERT INTO follows VALUES (?, ?)", edges)

print(graph.execute("""
WITH RECURSIVE reach(name, depth) AS (
    SELECT '민지', 0
    UNION
    SELECT f.b, r.depth + 1 FROM follows f JOIN reach r ON f.a = r.name WHERE r.depth < 3
)
SELECT name, MIN(depth) FROM reach GROUP BY name ORDER BY MIN(depth), name
""").fetchall())

from collections import deque
neighbors = defaultdict(list)
for a, b in edges:
    neighbors[a].append(b)
dist, queue = {"민지": 0}, deque(["민지"])
while queue:
    person = queue.popleft()
    for nxt in neighbors[person]:
        if nxt not in dist and dist[person] < 3:
            dist[nxt] = dist[person] + 1
            queue.append(nxt)
print(sorted(dist.items(), key=lambda kv: (kv[1], kv[0])))
[('민지', 0), ('준호', 1), ('하준', 1), ('서연', 2), ('도윤', 3)]
[('민지', 0), ('준호', 1), ('하준', 1), ('서연', 2), ('도윤', 3)]

민지에게서 세 단계 안에 닿는 사람과 거리예요. 서연은 준호를 거쳐도, 하준을 거쳐도 두 단계라 한 번만 나왔고, 네 단계 떨어진 지우는 빠졌어요. 관계형 데이터베이스는 단계마다 표를 다시 이어 붙여야 해서, 관계가 수억 개이고 깊이가 깊어지면 급격히 느려져요. 그래프 데이터베이스는 각 사람이 자기 이웃을 직접 가리키게 저장해서 따라가기가 빨라요. 추천("친구가 좋아한 상품"), 사기 탐지(돈이 도는 고리 찾기), 지식 그래프에 써요.

검색 엔진: 낱말로 찾기

인덱스 강의에서 LIKE '%키보드%'는 인덱스를 쓰지 못한다고 했어요. 글 속 낱말로 찾는 일은 Elasticsearch나 OpenSearch 같은 검색 엔진이 맡아요. 핵심은 역색인이에요. 책 뒤의 찾아보기처럼 "낱말 → 그 낱말이 든 글"을 미리 만들어 둬요.

articles = {1: "무선 키보드 고르는 법", 2: "무선 마우스와 키보드 비교", 3: "모니터 받침대 후기"}

words = defaultdict(set)                               # 역색인: 낱말 → 그 낱말이 든 글
for doc_id, text in articles.items():
    for word in text.split():
        words[word].add(doc_id)
print("'키보드':", sorted(words["키보드"]), "| '무선'과 '키보드' 모두:", sorted(words["무선"] & words["키보드"]))
print("'마우스':", sorted(words["마우스"]))

grams = defaultdict(set)                               # 두 글자씩 잘라 만든 색인
for doc_id, text in articles.items():
    for chunk in text.split():
        for i in range(len(chunk) - 1):
            grams[chunk[i:i + 2]].add(doc_id)
query = "마우스"
hits = set.intersection(*(grams[query[i:i + 2]] for i in range(len(query) - 1)))
print("두 글자 색인으로 '마우스':", sorted(hits))
'키보드': [1, 2] | '무선'과 '키보드' 모두: [1, 2]
'마우스': []
두 글자 색인으로 '마우스': [2]

역색인이 있으면 낱말마다 글 목록을 바로 꺼내고, 두 낱말이 모두 든 글은 목록의 교집합으로 구해요. 그런데 "마우스"를 찾으니 0건이에요. 2번 글에는 "마우스와"로 조사가 붙어 있어서, 띄어쓰기로 자른 색인에는 "마우스"라는 낱말이 없거든요. 한국어는 낱말에 조사와 어미가 붙어서, 띄어쓰기만으로 자르면 검색이 잘 안 돼요. 그래서 한국어 검색에는 두 방법을 써요.

  • 글자 조각(n-gram): 두세 글자씩 잘라 색인해요. 위처럼 "마우"와 "우스"가 모두 든 글로 찾았어요. 대신 색인이 커지고, 엉뚱한 글이 섞이기도 해요.
  • 형태소 분석: "마우스와"를 "마우스 + 와"로 나눠 주는 한국어 분석기를 써요. Elasticsearch의 nori 같은 분석기가 이 일을 해요.

검색 엔진은 정확한 일치뿐 아니라 "얼마나 관련 있는가"로 순서를 매기고(BM25 같은 점수), 오타와 비슷한 말도 다뤄요. LLM 트랙의 RAG 강의에서 본 벡터 검색은 낱말 대신 뜻이 가까운 글을 찾는, 또 다른 검색 방식이에요.

여러 대로 나누면 생기는 일: 복제와 일관성

데이터를 여러 서버에 복사해 두면(복제) 한 대가 고장 나도 버티고, 읽기를 나눠 받을 수 있어요. 그런데 복사가 즉시 일어나지 않으면 이상한 일이 생겨요. 원본 서버가 쓰기를 받고, 복제 서버가 0.5초 늦게 따라온다고 해 볼게요.

primary, replica = {}, {}
pending = []                                            # 복제를 기다리는 변경: (도착할 시각, 키, 값)
LAG = 0.5                                               # 복제가 0.5초 늦게 따라와요

def write(key, value, now):
    primary[key] = value
    pending.append((now + LAG, key, value))

def read_from_replica(key, now):
    while pending and pending[0][0] <= now:
        _, k, v = pending.pop(0)
        replica[k] = v
    return replica.get(key)

write("nickname", "민지", now=0.0)
print("0.1초:", read_from_replica("nickname", now=0.1))
print("0.6초:", read_from_replica("nickname", now=0.6))
write("nickname", "민지짱", now=1.0)
print("1.2초:", read_from_replica("nickname", now=1.2), "| 원본에는:", primary["nickname"])
print("1.6초:", read_from_replica("nickname", now=1.6))
0.1초: None
0.6초: 민지
1.2초: 민지 | 원본에는: 민지짱
1.6초: 민지짱

닉네임을 "민지짱"으로 바꾸고 바로 새로 고쳤더니 옛 닉네임이 보여요. 조금 기다리면 결국 같아지는데, 이걸 최종 일관성(eventual consistency)이라고 해요. 좋아요 수가 잠깐 덜 보이는 정도면 괜찮지만, 방금 결제한 내역이 안 보이면 사용자는 또 결제할지도 몰라요. 그래서 "자기가 방금 쓴 것은 원본에서 읽기", "중요한 읽기는 원본에서" 같은 규칙을 둬요.

여러 서버를 잇는 네트워크가 끊기면 더 어려운 선택이 기다려요. 끊긴 쪽이 계속 요청을 받으면 양쪽 데이터가 어긋나고(일관성 포기), 받지 않으면 그동안 서비스가 멈춰요(가용성 포기). 네트워크가 끊긴 동안에는 둘 다 가질 수 없다는 이 사실을 CAP 정리라고 불러요. 저장소마다 어느 쪽을 택하는지, 또는 고를 수 있게 해 주는지가 달라요.

저장소를 고르는 질문

질문기울어지는 쪽
데이터끼리 관계가 많고, 조건을 바꿔 가며 묻나요?관계형
돈, 재고처럼 틀리면 안 되는 데이터인가요?관계형(트랜잭션)
이름표로만 꺼내고, 빠르고, 사라져도 되나요?키-값(캐시, 세션)
한 덩어리로 읽고 쓰며 모양이 제각각인가요?문서형(또는 관계형의 JSON 칸)
질문이 정해져 있고 양이 어마어마한가요?와이드 컬럼
관계를 여러 단계 따라가는 질문이 핵심인가요?그래프
글 속 낱말로 찾고 관련도로 줄 세우나요?검색 엔진

그리고 몇 가지를 함께 따져요.

  • 정말 그만큼 큰가요? 잘 설계한 PostgreSQL 한 대는 생각보다 훨씬 많은 데이터와 요청을 감당해요. "언젠가 커질 테니까"로 고른 분산 저장소는 지금의 개발과 운영을 몇 배 어렵게 만들어요.
  • 누가 운영하나요? 저장소를 하나 더할 때마다 백업, 감시, 업그레이드할 대상이 늘어요. 클라우드의 관리형 서비스가 그 부담을 덜어 줘요.
  • 두 저장소를 어떻게 맞추나요? 관계형 데이터베이스와 검색 엔진을 함께 쓰면, 글을 고칠 때 둘 다 고쳐야 해요. 한쪽만 고쳐지는 순간이 반드시 생기니, 어느 쪽이 원본이고 다른 쪽은 언제 따라오는지 정해 둬요.

그래서 흔한 출발점은 이래요. 관계형 데이터베이스 하나로 시작하고, 캐시나 검색처럼 분명한 필요가 생길 때 그 일만 맡을 저장소를 더해요. 관계형 데이터베이스도 JSON 칸, 전문 검색, 벡터 확장(pgvector)을 갖추고 있어서 꽤 멀리까지 혼자 갈 수 있어요.

실습

  1. 키-값 예제의 캐시 수명을 10초로 줄이면 0, 30, 61초에 데이터베이스에 몇 번 묻나요? 인기 글이 바뀌었을 때 캐시를 바로 지우는 함수도 만들어 보세요.
  2. 요청 횟수 제한을 "10초 단위 칸" 대신 "마지막 10초 동안"으로 바꾸려면 무엇을 저장해야 할까요? 9초와 11초에 요청이 몰리는 경우를 생각해 보세요.
  3. 문서 예제에서 글쓴이 정보를 끼워 넣지 않고 author_id만 두게 바꾸고, 이름을 바꿀 때 몇 곳을 고치면 되는지 비교해 보세요.
  4. 그래프 예제에서 민지가 아직 팔로우하지 않았지만 두 단계 안에 있는 사람을 "추천 친구"로 뽑는 질문을 써 보세요.
  5. 검색 예제에 "키보드와 마우스 정리"라는 글을 더하고, 띄어쓰기 색인과 두 글자 색인으로 "키보드"를 각각 찾아보세요.
  6. 복제 예제에 "방금 쓴 키는 1초 동안 원본에서 읽기" 규칙을 더해서, 1.2초의 결과가 "민지짱"이 나오게 해 보세요.

자주 하는 실수

  • 유행이나 "언젠가의 규모" 때문에 저장소를 고른다. 지금의 데이터 모양과 질문을 먼저 봐요.
  • 캐시를 원본처럼 쓴다. 캐시는 사라질 수 있어요. 언제든 원본에서 다시 만들 수 있어야 해요.
  • 문서에 자주 바뀌는 정보를 끼워 넣는다. 바꿀 때마다 모든 문서를 고쳐야 하고, 놓치면 갈라져요.
  • 문서형이니 규칙이 필요 없다고 생각한다. 데이터베이스가 안 지키면 프로그램이 지켜야 해요. 검증 규칙을 꼭 둬요.
  • 질문을 정하지 않고 와이드 컬럼 저장소를 설계한다. 나중에 생긴 질문은 거의 답할 수 없어요.
  • 복제 서버에서 방금 쓴 값을 읽는다. 옛날 값이 보여요. 중요한 읽기는 원본에서 해요.
  • 한국어 검색을 띄어쓰기로만 자른다. 조사가 붙은 낱말을 못 찾아요. 형태소 분석이나 글자 조각을 써요.

점검 문제

  1. NoSQL 저장소들이 생겨난 세 가지 이유는?
  2. 키-값 저장소가 캐시와 요청 횟수 제한에 잘 맞는 이유와, 못 하는 질문은?
  3. 문서에 글쓴이 이름을 끼워 넣으면 생기는 문제는?
  4. 와이드 컬럼 저장소에서 질문마다 표를 따로 만드는 이유는?
  5. 관계형 데이터베이스로도 친구의 친구를 찾을 수 있는데, 그래프 데이터베이스를 쓰는 때는?
  6. 띄어쓰기로 만든 역색인이 "마우스"로 "마우스와"가 든 글을 찾지 못한 이유와 해결책 두 가지는?
  7. 최종 일관성이란 무엇이고, 사용자가 겪는 문제의 예는?
  8. 많은 경우 관계형 데이터베이스 하나로 시작하는 게 좋은 이유는?

정답

  1. 데이터와 요청이 너무 많아 여러 대에 나눠 담아야 할 때, 데이터 모양이 제각각이라 칸을 미리 정하기 어려울 때, 캐시나 검색처럼 한 가지 질문을 아주 빠르게 해야 할 때예요.
  2. 이름표로 바로 꺼내고 값마다 수명을 정할 수 있어서, 일정 시간 저장해 두거나 일정 시간 동안 횟수를 세는 일에 딱 맞아요. 대신 이름표를 모르는 조건 검색(가격이 3만 원 이하인 상품 등)은 못 해요.
  3. 같은 정보가 여러 문서에 복사되어서, 이름이 바뀌면 모든 문서를 고쳐야 하고 하나라도 놓치면 이름이 갈라져요.
  4. 파티션 키를 알아야 빠르게 찾을 수 있는데, 질문마다 필요한 파티션 키가 다르기 때문이에요. 그래서 같은 데이터를 질문별로 다른 키로 나눠 여러 표에 함께 써요.
  5. 관계가 아주 많고 여러 단계를 따라가는 질문이 서비스의 핵심일 때예요. 관계형은 단계마다 다시 이어 붙여야 해서 깊어질수록 느려지지만, 그래프 데이터베이스는 이웃을 직접 가리키게 저장해서 따라가기가 빨라요.
  6. 글에는 "마우스와"로 조사가 붙어 있어서 띄어쓰기로 자르면 "마우스"라는 낱말이 색인에 없기 때문이에요. 두세 글자씩 잘라 색인하거나, 형태소 분석기로 "마우스 + 와"처럼 나눠 색인해요.
  7. 복제가 늦게 따라와서 잠깐 동안은 서버마다 값이 다를 수 있지만, 기다리면 결국 같아지는 성질이에요. 닉네임을 바꾸고 새로 고쳤는데 옛 닉네임이 보이는 것이 그 예예요.
  8. 트랜잭션, 이어 붙이기, 규칙 검사를 모두 갖춘 튼튼한 기본값이고, JSON 칸과 전문 검색과 벡터 확장으로 꽤 많은 필요를 혼자 감당하기 때문이에요. 저장소를 더할수록 운영과 동기화 부담이 늘어나니, 분명한 필요가 생길 때 더해요.

다음 강의

데이터베이스 트랙의 마지막 강의에서는 첫 강의부터 계속 등장한 트랜잭션을 깊이 들여다봐요. 두 사람이 동시에 마지막 재고 하나를 사려 할 때, 동시에 같은 계좌에서 돈을 뺄 때 무슨 일이 생기는지 직접 재현하고, 격리 수준과 잠금이 데이터를 어떻게 지키는지 배워요.