Devin.KR

데이터베이스 - 인덱스·트랜잭션·마이그레이션

개발자KR 조회 4

이 장에서 배우는 것

앞 장에서 서점의 요청 처리 코드를 컨트롤러, 서비스, 저장소로 나눴다. 이번에는 저장소가 책과 재고를 읽고 쓰는 곳을 살펴본다. 데이터베이스는 상품 목록을 일정한 순서로 돌려주고, 주문 기록과 재고가 함께 바뀌도록 보장하며, 프로그램 버전이 바뀌어도 이미 저장된 데이터를 이어서 쓸 수 있게 한다. 이 장에서는 파이썬 표준 라이브러리의 sqlite3로 이 세 가지 일을 확인한다.

  • 서점에서 반복해서 실행하는 질의를 고르고, 인덱스(index)를 만들기 전과 후의 실행 계획을 비교한다.
  • 트랜잭션(transaction)으로 재고 감소와 주문 기록의 범위를 묶고, 두 연결이 동시에 쓰려고 할 때의 결과를 확인한다.
  • 스키마(schema) 변경을 번호 붙은 마이그레이션(migration)으로 적용하고, 적용 기록과 변경 내용을 함께 관리한다.
  • 백업을 새 데이터베이스에 복구하고, 데이터와 스키마를 검사한 뒤 복구본으로 주문을 연습한다.

문제 상황

작은 온라인 서점은 분류 페이지에 가격이 낮은 책 여섯 권을 먼저 보여 준다. 가격이 같으면 책 번호가 작은 책이 앞에 온다. 책이 몇 권일 때는 목록이 빠르게 표시된다. 상품을 대량으로 등록한 뒤에도 목록은 여섯 권이지만, 데이터베이스가 그 여섯 권을 찾으려고 훑는 행의 수는 늘어날 수 있다. 화면에서 보이는 목록의 길이만으로 데이터베이스가 한 일을 판단하기 어렵다.

같은 날, 재고가 한 권 남은 책을 두 고객이 주문한다. 두 요청이 각각 재고를 읽으면 둘 다 한 권이 있다고 볼 수 있다. 그 값을 가지고 나중에 주문을 확정하면 책 한 권에 주문 두 건이 생길 수 있다. 주문을 저장하는 도중 오류가 났을 때는 재고만 줄어드는 경우도 막아야 한다.

목록 질의를 개선하려면 기존 데이터베이스에 인덱스를 추가해야 한다. 새 데이터베이스를 만들 때 실행하는 SQL만 고치면, 이미 운영 중인 서점에는 인덱스가 생기지 않는다. 변경 SQL을 순서대로 적용하는 절차와 함께, 변경 전에 확보한 백업으로 실제 주문 흐름을 다시 실행할 수 있는지도 확인해야 한다.

목록 질의와 인덱스

인덱스를 검토할 때는 화면 이름보다 저장소가 실행하는 SQL을 먼저 찾는다. 이 예제의 목록 질의에는 분류를 고르는 WHERE category = ?, 가격과 책 번호로 결과를 정렬하는 ORDER BY price, id, 여섯 권으로 제한하는 LIMIT 6이 있다. 가격만 정렬하면 가격이 같은 책끼리의 순서를 질의가 지정하지 않는다. 책 번호까지 적으면 인덱스를 적용하기 전과 후에 같은 순서의 결과가 나오는지 검사할 수 있다.

인덱스 열은 category, price, id 순서로 둔다. 같은 분류의 항목을 모아 두고, 그 안에서는 가격과 책 번호 순서로 읽을 수 있다. LIMIT 6은 돌려줄 행의 수를 제한한다. 조건에 맞는 책을 입력 순서대로 읽어야 한다면, 뒤쪽에 더 싼 책이 있을 수 있어 여섯 권을 찾은 시점에도 읽기를 끝낼 수 없다. 복합 인덱스의 순서가 질의와 맞으면 분류의 시작 위치를 찾은 뒤 앞쪽 항목부터 읽을 수 있다.

분류와 가격 순서가 맞는 인덱스에서 목록의 앞부분을 바로 읽을 수 있다.

EXPLAIN QUERY PLAN은 질의 실행 방법을 요약한다. 이 예제에서 적용 전에는 SCAN으로 책 테이블을 훑고, ORDER BY를 처리하기 위해 임시 정렬 구조를 사용한다. 적용 후에는 지정한 인덱스가 포함된 SEARCH가 나타난다. SCAN은 전체 인덱스를 훑을 때도 나올 수 있으므로 무엇을 훑는지 함께 읽는다. 실행 계획은 걸린 시간을 알려 주지 않는다. 실제 서비스에서 효과를 판단할 때는 대표 데이터와 바인딩 값으로 측정하고, 책을 등록하거나 가격을 바꿀 때 인덱스도 갱신된다는 점을 고려한다.

재고 변경의 경계

트랜잭션은 여러 SQL 문을 하나의 변경으로 다룬다. 이 예제에서는 주문을 시작하면 먼저 UPDATE의 조건에 stock > 0을 넣고 재고를 한 권 줄인다. 변경된 행이 한 개일 때만 주문을 삽입한다. 변경된 행이 없으면 이 예제에서는 판매할 수 없는 책으로 처리한다. 재고를 먼저 읽어 애플리케이션에 보관해 두는 방식과 달리, 조건 검사와 차감이 한 SQL 문 안에서 이뤄진다.

주문 기록까지 성공하면 COMMIT으로 두 변경을 확정한다. 주문 번호 중복으로 삽입에 실패하면 ROLLBACK으로 재고 감소도 되돌린다. 이 경계는 저장소의 재고 함수와 주문 함수가 각자 확정하는 구조로는 만들기 어렵다. 서비스를 나눠 작성하더라도 주문 한 건의 성공 여부를 판단하는 곳에서 두 작업의 경계를 관리한다.

재고를 줄인 뒤 주문 기록에 실패하면 롤백으로 재고 감소도 되돌린다.

SQLite는 같은 데이터베이스에 대한 쓰기를 한 번에 연결 하나에 허용한다. BEGIN IMMEDIATE는 시작할 때 쓰기 권한을 얻으려 한다. 예제는 두 번째 연결의 timeout을 0으로 두어, 첫 번째 연결이 권한을 잡고 있는 동안 두 번째 연결이 즉시 SQLITE_BUSY를 받게 한다. 두 연결의 호출 순서는 프로그램이 직접 제어한다. 첫 주문이 확정된 다음 다시 요청하면 두 번째 연결은 쓰기를 시작할 수 있고, 이미 재고가 0이라 주문을 거절한다. 쓰기 경합과 재고 부족은 결과가 다르다. 경합을 재시도할 때는 쓰기 권한을 기다리는 동안의 정책을 정하고, 재시도한 트랜잭션에서 재고를 다시 판정한다.

스키마 변경과 복구

스키마는 데이터에 이름과 구조를 부여한다. 이 장의 첫 마이그레이션은 책과 주문 테이블을 만들고, 두 번째 마이그레이션은 분류별 목록에 쓰는 인덱스를 만든다. schema_migrations에는 적용한 번호와 이름을 넣는다. 이미 배포한 마이그레이션을 고치면 같은 번호를 가진 데이터베이스가 서로 다른 구조를 가질 수 있다. 후속 변경에는 새 번호를 부여한다.

완성 코드에서는 마이그레이션마다 쓰기 트랜잭션을 열고 그 안에서 적용 이력을 조회한다. 아직 적용하지 않은 번호라면 SQL 문을 순서대로 실행하고 이력을 삽입한 뒤 한 번에 확정한다. 중간에 실패하면 이 트랜잭션에 들어 있던 스키마 변경과 기록을 함께 되돌린다. 같은 파일에 두 연결이 적용을 시도해도, 먼저 쓰기 권한을 얻어 적용을 끝낸 뒤 다음 연결이 조회하면 그 기록을 볼 수 있다. 다음 연결이 쓰기 권한을 얻지 못한 경우에는 적용 작업 자체가 오류로 끝난다.

복구 연습은 백업에 들어 있을 내용을 정하는 것부터 시작한다. 예제는 두 마이그레이션을 적용한 뒤, 주문을 받기 전에 Connection.backup()으로 별도 파일에 스냅샷을 만든다. 이 메서드는 연결을 통해 일관된 복사본을 만든다. 이어서 주문이 생긴 원본을 그대로 두고, 백업을 새 메모리 데이터베이스에 복구한다. 구조 검사 결과, 적용 이력, 목록 실행 계획, 대표 질의 결과, 재고와 주문 건수를 본다. 마지막으로 복구본에서 새 주문을 한 건 처리한다. 이때 복구본은 백업 시점의 재고로 되돌아가므로 백업 이후에 들어온 주문은 복구본에 없다. 실제 복구 연습에서도 어떤 시점까지의 주문을 돌려받았는지 기록해야 한다.

배포 전 연습에서 확인할 세 지점
지점확인할 값예제에서의 판정
스키마 변경 전후목록의 행과 순서, 실행 계획목록은 같고 계획에는 새 인덱스가 쓰인다.
쓰기 충돌과 삽입 실패 후예외 종류, 재고, 주문 건수경합한 연결은 대기 없이 오류를 받고, 중복 주문으로 줄어든 재고는 되돌아온다.
별도 위치에 복구한 직후무결성, 외래 키, 이력, 재고와 주문백업 시점의 구조와 데이터가 돌아오고 주문을 새로 받을 수 있다.

완성 코드

아래 코드를 main.py에 저장한다. Python 3.12 이상에서 실행한다. 두 연결이 같은 데이터베이스를 열어 쓰기를 시험해야 하므로 임시 파일을 사용한다. 연결을 모두 닫고 나면 임시 디렉터리와 그 안의 파일이 정리된다. 목록 계획의 세부 문구는 SQLite 버전에 따라 달라질 수 있으므로, 프로그램은 이 장에서 확인할 특징을 추려 고정된 문구로 출력한다.

main.py

import sqlite3
from contextlib import closing, contextmanager
from pathlib import Path
from tempfile import TemporaryDirectory


FIRST_MIGRATION = (
    1,
    "책과 주문 테이블",
    (
        """
        CREATE TABLE books (
            id INTEGER PRIMARY KEY,
            title TEXT NOT NULL,
            category TEXT NOT NULL,
            price INTEGER NOT NULL CHECK (price >= 0),
            stock INTEGER NOT NULL CHECK (stock >= 0)
        )
        """,
        """
        CREATE TABLE orders (
            id INTEGER PRIMARY KEY,
            book_id INTEGER NOT NULL REFERENCES books(id)
        )
        """,
    ),
)

INDEX_NAME = "idx_books_category_price_id"
SECOND_MIGRATION = (
    2,
    "분류별 목록 인덱스",
    (
        f"CREATE INDEX {INDEX_NAME} ON books(category, price, id)",
    ),
)

LIST_SQL = """
    SELECT id, title, price
    FROM books
    WHERE category = ?
    ORDER BY price, id
    LIMIT 6
"""


def connect(database):
    db = sqlite3.connect(database, timeout=0, autocommit=True)
    db.execute("PRAGMA foreign_keys = ON")
    return db


@contextmanager
def write_transaction(db):
    db.execute("BEGIN IMMEDIATE")
    try:
        yield
        db.execute("COMMIT")
    except BaseException:
        if db.in_transaction:
            db.execute("ROLLBACK")
        raise


def apply_migrations(db, migrations):
    for number, name, statements in migrations:
        with write_transaction(db):
            db.execute("""
                CREATE TABLE IF NOT EXISTS schema_migrations (
                    number INTEGER PRIMARY KEY,
                    name TEXT NOT NULL
                )
            """)
            recorded = db.execute(
                "SELECT name FROM schema_migrations WHERE number = ?",
                (number,),
            ).fetchone()
            if recorded is not None:
                if recorded != (name,):
                    raise ValueError(f"마이그레이션 이름 불일치: {number}")
                continue
            for statement in statements:
                db.execute(statement)
            db.execute(
                "INSERT INTO schema_migrations VALUES (?, ?)",
                (number, name),
            )
        print(f"적용 {number:03d}  {name}")


def seed_books(db):
    with write_transaction(db):
        db.executemany(
            "INSERT INTO books VALUES (?, ?, ?, ?, ?)",
            (
                (
                    number,
                    f"서점 책 {number}",
                    "소설" if number % 4 == 1 else "에세이",
                    8000 + (number % 7) * 500,
                    1 if number == 1 else 5,
                )
                for number in range(1, 401)
            ),
        )


def plan_details(db, category):
    return [
        row[3].upper()
        for row in db.execute("EXPLAIN QUERY PLAN " + LIST_SQL, (category,))
    ]


def uses_list_index(details):
    return any(
        detail.startswith("SEARCH ") and INDEX_NAME.upper() in detail
        for detail in details
    )


def has_temporary_sort(details):
    return any(
        "TEMP B-TREE" in detail and "ORDER BY" in detail
        for detail in details
    )


def migration_history(db):
    return db.execute(
        "SELECT number, name FROM schema_migrations ORDER BY number"
    ).fetchall()


def add_order(db, book_id, order_id):
    changed = db.execute(
        "UPDATE books SET stock = stock - 1 WHERE id = ? AND stock > 0",
        (book_id,),
    ).rowcount
    if changed == 0:
        return False
    db.execute(
        "INSERT INTO orders (id, book_id) VALUES (?, ?)",
        (order_id, book_id),
    )
    return True


def place_order(db, book_id, order_id):
    with write_transaction(db):
        return add_order(db, book_id, order_id)


def book_state(db, book_id):
    stock = db.execute(
        "SELECT stock FROM books WHERE id = ?", (book_id,)
    ).fetchone()[0]
    count = db.execute(
        "SELECT COUNT(*) FROM orders WHERE book_id = ?", (book_id,)
    ).fetchone()[0]
    return stock, count


def check_orders(first, second):
    with write_transaction(first):
        assert add_order(first, book_id=1, order_id=101)
        try:
            place_order(second, book_id=1, order_id=102)
        except sqlite3.OperationalError as error:
            if error.sqlite_errorcode != sqlite3.SQLITE_BUSY:
                raise
            print("동시 쓰기: SQLITE_BUSY")
        else:
            raise AssertionError("쓰기 경합이 관찰되지 않음")

    assert not place_order(second, book_id=1, order_id=102)
    print("재시도: 재고 부족")

    state_before = book_state(first, book_id=2)
    try:
        place_order(first, book_id=2, order_id=101)
    except sqlite3.IntegrityError as error:
        if error.sqlite_errorcode != sqlite3.SQLITE_CONSTRAINT_PRIMARYKEY:
            raise
        assert book_state(first, book_id=2) == state_before == (5, 0)
        print("중복 주문 번호: 재고 감소 되돌림")
    else:
        raise AssertionError("중복 주문 번호가 저장됨")

    assert book_state(first, book_id=1) == (0, 1)
    print("원본 책 1: 재고 0, 주문 1")


def check_restore(backup_path, expected_history, expected_books):
    with closing(connect(backup_path)) as backup:
        with closing(connect(":memory:")) as restored:
            backup.backup(restored)
            assert restored.execute("PRAGMA integrity_check").fetchall() == [
                ("ok",)
            ]
            assert restored.execute("PRAGMA foreign_key_check").fetchall() == []
            assert migration_history(restored) == expected_history
            assert uses_list_index(plan_details(restored, "소설"))
            assert restored.execute(LIST_SQL, ("소설",)).fetchall() == expected_books
            assert book_state(restored, book_id=1) == (1, 0)
            print("복구 책 1: 재고 1, 주문 0")
            assert place_order(restored, book_id=1, order_id=201)
            assert book_state(restored, book_id=1) == (0, 1)
            print("복구본 주문 후 책 1: 재고 0, 주문 1")


def main():
    with TemporaryDirectory() as directory:
        database_path = Path(directory) / "bookshop.db"
        backup_path = Path(directory) / "backup.db"
        with closing(connect(database_path)) as first:
            apply_migrations(first, (FIRST_MIGRATION,))
            seed_books(first)
            before_rows = first.execute(LIST_SQL, ("소설",)).fetchall()
            before_plan = plan_details(first, "소설")
            assert any(detail.startswith("SCAN BOOKS") for detail in before_plan)
            assert has_temporary_sort(before_plan)
            print("인덱스 전: SCAN, 임시 정렬 있음")

            apply_migrations(first, (SECOND_MIGRATION,))
            after_plan = plan_details(first, "소설")
            assert uses_list_index(after_plan)
            assert not has_temporary_sort(after_plan)
            print("인덱스 후: SEARCH, 목록 인덱스 사용, 임시 정렬 없음")
            after_rows = first.execute(LIST_SQL, ("소설",)).fetchall()
            assert before_rows == after_rows and len(after_rows) == 6
            print("비교: 목록 6건의 값과 순서 일치")

            history = migration_history(first)
            apply_migrations(first, (FIRST_MIGRATION, SECOND_MIGRATION))
            assert migration_history(first) == history
            print("적용 기록:")
            for number, name in history:
                print(f"  {number:03d}  {name}")

            with closing(connect(backup_path)) as backup:
                first.backup(backup)
            with closing(connect(database_path)) as second:
                check_orders(first, second)
            check_restore(backup_path, history, after_rows)
            assert book_state(first, book_id=1) == (0, 1)


if __name__ == "__main__":
    main()

줄별 해설

FIRST_MIGRATION부터 LIST_SQL까지. 책 번호와 주문 번호에는 기본 키를 지정하고, 주문의 책 번호에는 외래 키를 둔다. CHECK 제약은 재고의 음수 값을 거부한다. 목록 인덱스는 별도 번호에 두므로 같은 데이터로 적용 전후를 비교할 수 있다. 이 예제에서 책 번호가 가리키는 id는 행 식별자의 별칭이다. 인덱스 정의에도 id를 명시해 목록에 필요한 정렬 순서를 함께 읽을 수 있게 했다.

connect()와 write_transaction(). 연결마다 외래 키 검사를 켠다. autocommit=True에서는 명시적인 제어에 SQL의 BEGIN IMMEDIATE, COMMIT, ROLLBACK을 사용한다. 첫 줄의 BEGIN IMMEDIATE가 실패하면 이 함수는 호출자에게 예외를 전달한다. 시작에 성공한 뒤 작업이나 확정에서 예외가 나면 열린 트랜잭션을 되돌린다. closing()은 사용이 끝난 연결을 닫는다.

apply_migrations(). 이력 테이블을 확보한 뒤 현재 번호를 조회한다. 같은 번호와 이름의 기록이 있으면 변경을 건너뛴다. 이름 비교는 기록과 코드가 어긋난 경우를 잡는 한 가지 검사다. 배포된 SQL 본문의 변경 여부는 버전 관리에서 확인해야 한다. 새 변경은 execute()로 한 문장씩 실행한다. 이력 삽입이 끝나고 확정에 성공한 뒤에 적용 메시지를 출력하므로, 메시지만 먼저 남고 SQL이 되돌아가는 상황을 피한다.

seed_books()부터 실행 계획 검사까지. 책 번호에서 분류와 가격을 계산해 실행할 때마다 같은 책 400권을 만든다. 분류 조건에는 물음표 자리를 두고 ("소설",)을 넘긴다. plan_details()의 row[3]은 실행 계획 행의 설명 열이다. main()은 같은 질의와 같은 분류 값으로 계획과 결과를 각각 비교한다. 실행 계획을 정규화해 출력하는 부분은 이 예제의 검사에 맞춰져 있다. 실제 진단에서 새로운 계획이 나오면 설명 열 전체를 보고 판정한다.

add_order()부터 check_orders()까지. rowcount는 조건부 수정이 바꾼 행 수다. 책 번호가 기본 키여서 변경 가능한 행은 최대 하나다. check_orders()는 첫 연결의 트랜잭션 안에서 두 번째 연결을 호출해 쓰기가 겹치는 순간을 만든다. 첫 연결을 확정한 뒤 두 번째 연결이 다시 실행되면 재고가 0이어서 주문을 삽입하지 않는다. 이어서 재고가 충분한 책 2에 기존 주문 번호를 다시 사용한다. 이때 재고 감소는 실행되고, 주문 삽입이 실패하며, 트랜잭션을 되돌린 뒤 책 2의 상태가 원래 값과 같은지 검사한다.

check_restore()와 main()의 마지막 부분. 원본에서 백업 파일로, 백업 파일에서 빈 복구본으로 순서대로 복사한다. integrity_check는 데이터베이스 구조를 검사하고, foreign_key_check는 참조 관계 위반을 찾는다. 장부의 의미는 별도로 검증해야 하므로 목록과 주문 상태도 직접 조회한다. 복구본에 주문을 넣은 뒤 원본을 다시 조회해 두 연결이 서로 다른 데이터베이스를 가리키는지 확인한다. 예제는 검사용 assert를 실행하는 기본 모드인 python3 main.py를 기준으로 한다.

실행 결과

python3 main.py
적용 001  책과 주문 테이블
인덱스 전: SCAN, 임시 정렬 있음
적용 002  분류별 목록 인덱스
인덱스 후: SEARCH, 목록 인덱스 사용, 임시 정렬 없음
비교: 목록 6건의 값과 순서 일치
적용 기록:
  001  책과 주문 테이블
  002  분류별 목록 인덱스
동시 쓰기: SQLITE_BUSY
재시도: 재고 부족
중복 주문 번호: 재고 감소 되돌림
원본 책 1: 재고 0, 주문 1
복구 책 1: 재고 1, 주문 0
복구본 주문 후 책 1: 재고 0, 주문 1

실무에서 자주 틀리는 것

다음 코드는 각 실수를 비교하기 위한 조각이다. db는 완성 코드의 connect()로 연 연결이라고 가정한다. 변경을 실험할 때는 장에서 만든 임시 데이터베이스를 사용한다.

조건 열만 보고 인덱스를 만든다

다음 코드는 분류 조건에만 맞춘 변경이다. 해당 분류의 행을 좁힐 수 있지만, 그 인덱스에는 가격 순서가 없어 이 목록의 정렬이 남을 수 있다.

db.execute("CREATE INDEX idx_category_only ON books(category)")

고친 코드는 정렬 열까지 포함한 두 번째 마이그레이션을 적용한다. 첫 번째 마이그레이션과 책 입력을 마친 상태에서 실행 계획을 보며 두 번째 변경의 효과를 확인한다.

apply_migrations(db, (SECOND_MIGRATION,))
for detail in plan_details(db, "소설"):
    print(detail)

재고 조회값을 나중에 그대로 쓴다

이 코드는 트랜잭션 밖에서 읽은 값을 기억한다. 조회와 수정 사이에 다른 요청이 재고를 줄이면 이전 재고를 기준으로 덮어쓸 수 있다. 주문 삽입이 실패해도 앞의 재고 수정은 이미 확정된다.

stock = db.execute(
    "SELECT stock FROM books WHERE id = ?", (1,)
).fetchone()[0]
if stock > 0:
    db.execute("UPDATE books SET stock = ? WHERE id = ?", (stock - 1, 1))
    db.execute("INSERT INTO orders VALUES (?, ?)", (101, 1))

고친 코드는 조건부 감소와 주문 삽입을 한 트랜잭션에 넣는다. 반환값은 주문이 저장됐는지 알려 주며, 쓰기 경합이나 제약 조건 위반은 예외로 전달된다.

placed = place_order(db, book_id=1, order_id=101)
print("주문 저장" if placed else "재고 부족")

스키마 변경을 확정한 뒤 이력에 적는다

이력 테이블에 첫 번째 번호만 있는 상태라고 하자. 아래 코드는 인덱스 생성과 이력 삽입을 따로 확정한다. 두 실행 사이에 프로그램이 멈추면 인덱스는 있는데 이력이 비어 있어 다음 배포에서 같은 이름의 인덱스를 다시 만들려고 한다.

db.execute(SECOND_MIGRATION[2][0])
db.execute(
    "INSERT INTO schema_migrations VALUES (?, ?)",
    SECOND_MIGRATION[:2],
)

고친 코드는 적용 여부를 확인하는 시점부터 스키마와 이력을 같은 경계에 둔다. 번호를 적용한 뒤 같은 호출을 한 번 더 해도 이력에는 번호가 한 번만 남는다.

apply_migrations(db, (SECOND_MIGRATION,))
apply_migrations(db, (SECOND_MIGRATION,))
assert migration_history(db)[-1] == SECOND_MIGRATION[:2]

한눈에 보기

AI가 서점 데이터베이스 변경을 작성했을 때 확인할 항목
맡길 작업AI에게 줄 요청문검토하고 실행할 것
목록 질의와 인덱스분류별로 가격과 책 번호 순서의 앞 여섯 권을 읽는 인덱스를 제안하라.변경 전후 코드를 비교해 정렬 조건과 인자가 유지됐는지 보고, 두 계획과 목록 값을 대조한다.
주문 트랜잭션조건부 재고 감소와 주문 삽입을 묶고 두 연결에서 확인하는 코드를 작성하라.확정 위치를 검토하고, 재고 한 권의 경합과 주문 번호 중복을 실행해 최종 재고와 주문을 센다.
번호 붙은 스키마 변경기존 번호를 유지하고 다음 번호에 목록 인덱스를 추가하라.변경 전후 코드의 차이(diff)에서 기존 번호의 SQL이 그대로인지 확인하고, 이전 스키마에 변경을 두 번 적용한다.
백업과 복구임시 파일의 백업을 새 연결에 복구하고 장부를 조회하라.원본과 복구 대상 경로를 검토하고, 복구 시점의 적용 기록과 재고를 확인한 뒤 복구본에서 주문을 넣어 본다.

연습 문제

  1. 목록 질의에서 WHERE category = ?를 없애고 전체 책을 가격과 책 번호 순으로 읽으려 한다. 기존 인덱스의 행 순서로 정렬을 마칠 수 있는지 설명하고, 적합한 인덱스 열을 제안한다.
  2. 책 1을 주문 번호 101로 판매해 재고가 0이 됐다. 같은 책을 이미 사용한 번호 101로 다시 주문하면 중복 번호 예외가 발생하는지, 실행할 SQL의 순서로 설명한다.
  3. 세 번째 마이그레이션에 정상적인 인덱스 생성문 하나와 존재하지 않는 테이블에 대한 인덱스 생성문 하나를 순서대로 넣는다. 오류를 잡은 다음 새 인덱스와 적용 기록이 남았는지 검사할 질의를 생각해 본다.
  4. 원본의 첫 주문까지 백업에 담도록 백업 시점을 옮긴다. 복구 직후 책 1의 상태와 복구본에서 새 주문을 시도한 결과를 예상하고, 복구 검사에서 바꿔야 할 부분을 찾는다.

정답과 해설

  1. 기존 인덱스에서는 분류마다 가격 순서가 다시 시작한다. 그 순서대로 읽으면 모든 분류를 합친 가격 순서는 보장되지 않는다. (price, id) 인덱스가 새 정렬 순서와 맞는다. 기존 검사용 설명 함수는 분류 인자를 넘기므로 이 실험에서는 바인딩 인자도 제거한다. 실제로 어느 계획을 골랐는지 EXPLAIN QUERY PLAN으로 확인한다.
  2. 재고 조건이 붙은 UPDATE가 먼저 실행된다. 변경 행이 0이라 add_order()에서 False를 돌려주고 주문 삽입에 도달하지 않는다. 번호 중복으로 인한 롤백을 시험하려면 완성 코드처럼 재고가 있는 책 2에 이미 사용한 번호 101을 넘긴다.
  3. 첫 생성문이 성공해도 다음 문장에서 예외가 나면 트랜잭션이 되돌아간다. sqlite_schema에서 type = 'index'와 새 인덱스 이름을 조건으로 조회하면 행이 없어야 한다. schema_migrations에서 번호 3을 조회해도 행이 없어야 한다. 두 질의로 스키마와 이력을 각각 확인한다.
  4. main()에서 check_orders()를 호출한 뒤 백업을 만들면, 복구 직후 책 1은 재고 0과 주문 1건을 가진다. 복구본에서 번호 201을 넣으려 하면 place_order()는 False를 반환하고 책 1의 상태는 (0, 1)이다. check_restore()의 복구 직후 상태 검사와 주문 반환값 검사, 상태를 출력하는 문구를 이 결과에 맞춰 고친다.

다음 장에서는 이 책 목록을 매번 데이터베이스에서 읽는 비용과, 주문 후 달라진 값을 언제 다시 읽어야 하는지를 캐시와 비동기 작업의 관점에서 살펴본다.

댓글 0

아직 댓글이 없습니다. 첫 댓글을 남겨 보세요.

댓글을 남기려면 로그인이 필요합니다.