Devin.KR

AI 개발 · 실무

AI와 함께 만드는 웹 서비스 - 설계도에서 배포·운영까지

데이터부터 설계하기 - 테이블·관계·제약 조건

화면에서 명사 뽑기, 테이블·기본 키·외래 키, NOT NULL·UNIQUE·CHECK 로 규칙을 DB 에 맡기기, AI 가 만든 스키마에서 흔히 빠지는 것(삭제 정책·시간대·중복), sqlite3 메모리 DB 로 스키마 만들고 잘못된 데이터가 거절되는지 확인

개발자KR · 원고 갱신

이 장에서 배우는 것

동네 소모임 사이트에는 모임 공지 화면과 참가 신청 화면이 있다. 공지 화면에는 제목과 시작 시각이 표시되고, 신청 화면에서는 어느 회원이 어느 모임에 참가하는지 기록한다. 앞 장에서 작업 단위와 검증 기록을 정했으므로, 이번에는 이 두 화면에 필요한 데이터를 한 작업 단위로 설계한다. SQLite 메모리 데이터베이스에 설계한 구조를 만들고, 올바른 행은 저장되는지, 규칙을 어긴 행은 해당 제약 조건에서 거절되는지 확인한다.

  • 화면에 나오는 명사를 찾아 테이블과 열의 후보로 나눈다.
  • 기본 키와 외래 키로 모임, 회원, 참가 신청을 연결한다.
  • NOT NULL, UNIQUE, CHECK를 사용해 저장 규칙을 표현한다.
  • AI가 제안한 스키마의 변경분에서 삭제 정책, 시각 표현, 중복 신청 규칙을 검토한다.
  • 같은 메모리 데이터베이스에서 성공 사례와 실패 사례를 실행하고 저장 상태를 확인한다.

문제 상황

토요일 아침에 열리는 골목 산책 모임이 있다. 운영자가 공지에 붙인 제목은 ‘골목 산책’이다. 지난주에도 같은 제목을 썼고, 다음 주에도 같은 제목을 쓸 수 있다. 회원 민서는 이번 주 산책에도, 다음 주 산책에도 신청할 수 있다. 그런데 신청 버튼을 연달아 눌러 이번 주 산책 신청이 두 줄 생기면 운영자는 참가자 수를 잘못 센다. 제목을 기준으로 신청을 묶으면 지난주와 이번 주 참가자가 한 목록에 섞인다.

신청을 받은 뒤 운영자가 공지를 지우는 경우도 생각해 보자. 참가 신청이 남아 있는데 연결할 모임이 사라지면 운영자는 어느 모임의 신청인지 확인할 수 없다. 공지 입력란에 ‘오전 10시’라고만 적혀 있어도 문제가 생긴다. 날짜와 시간대를 함께 정해야 화면을 만드는 사람과 데이터를 저장하는 사람이 같은 시작 시각을 가리킬 수 있다.

이번 장에서는 모임별로 회원 한 명의 신청을 한 건만 허용하고, 신청이 남아 있는 동안에는 연결된 모임과 회원을 삭제하지 않기로 한다. 모임에는 1명 이상의 정원을 기록한다. 정원 숫자를 올바르게 저장하는 규칙과 실제 신청 수를 정원 이하로 유지하는 규칙에는 필요한 정보가 다르다. 전자는 모임 한 행의 값으로 판단할 수 있고, 후자는 그 모임에 연결된 신청 행까지 세어야 한다. 완성 코드에서는 정원 값의 범위를 검사한다.

화면의 명사에서 테이블과 관계 찾기

화면 문구를 소리 내어 읽으면 데이터 후보를 찾기 쉽다. ‘모임 제목’, ‘시작 시각’, ‘정원’, ‘회원 이름’, ‘참가 신청’에 밑줄을 그어 보자. 같은 제목의 모임이 여러 번 열리고, 같은 이름을 쓰는 회원도 있을 수 있다. 그래서 모임과 회원은 각각 고유한 식별자를 가진 테이블로 표현한다. 제목과 시작 시각, 정원은 특정 모임에 딸린 값이므로 모임 테이블의 열로 둔다. 이름은 회원 테이블의 열로 둔다.

‘공지’라는 명사도 후보지만, 지금 화면의 공지는 모임의 제목과 시작 시각, 정원을 보여 준다. 화면에 필요한 값이 이미 모임 한 행에 모여 있으므로 이 설계에서는 공지를 그 행에서 읽는다. 반면 참가 신청은 별도의 행으로 기록할 이유가 있다. 모임 하나에는 여러 회원의 신청이 들어오고, 회원 한 명은 여러 모임에 신청할 수 있다. 참가 신청 한 행이 이 관계에서 모임 하나와 회원 한 명을 연결한다.

화면에서 찾은 명사를 테이블과 열로 옮긴다
화면의 명사저장 위치판단 근거
모임과 공지meetups공지에 표시하는 값은 모임 한 건에서 읽을 수 있다.
제목과 시작 시각과 정원meetups의 열각 값은 특정 모임에 속한다.
회원과 이름members와 그 안의 name 열한 회원의 이름을 그 회원의 여러 신청에서 함께 사용한다.
참가 신청signups모임과 회원의 조합마다 신청을 기록한다.

기본 키(primary key)는 테이블 안에서 행 하나를 지정한다. 완성 코드에서는 세 테이블 모두 id INTEGER PRIMARY KEY를 쓴다. meetups.id가 1인 행과 members.id가 1인 행은 각자의 테이블 안에서 식별된다. 참가 신청에도 자체 식별자를 부여해 저장된 신청 한 건을 가리킬 수 있게 한다. 이 식별자와 회원의 중복 신청을 판정하는 기준은 각각 따로 선언한다.

외래 키(foreign key)는 한 테이블의 값이 다른 테이블의 어느 행을 참조하는지 지정한다. signups.meetup_id는 meetups.id를 참조하고, signups.member_id는 members.id를 참조한다. 모임 제목을 바꾸면 모임 행의 제목만 바뀐다. 신청은 같은 식별자를 계속 가리킨다. 신청 행에 제목과 회원 이름을 다시 저장하는 방식이라면 제목이나 이름을 바꿀 때 여러 행을 함께 고쳐야 한다.

참가 신청 한 행은 두 외래 키로 모임 한 건과 회원 한 명을 가리킨다.

저장 규칙을 제약 조건으로 옮기기

제약 조건은 데이터베이스가 저장되는 값을 검사하는 규칙이다. 예를 들어 신청 화면에서 모임 선택란을 필수로 지정해도, 다른 경로에서 데이터베이스에 직접 행을 추가할 수 있다. 테이블에 조건을 선언하면 입력 경로가 달라져도 같은 규칙으로 검사할 수 있다. 이 장에서는 다음 조건을 사용한다.

  • NOT NULL은 값이 비어 있음을 뜻하는 NULL의 저장을 막는다. 제목과 이름을 필수로 두고, 신청의 모임 번호와 회원 번호에도 이 조건을 건다. SQLite에서 외래 키 열에 NULL을 허용하면 참조할 행을 지정하지 않은 신청이 들어갈 수 있다. 빈 문자열은 별개의 값이므로 제목과 이름에는 앞뒤의 일반 공백을 제거한 뒤 길이가 양수인지도 검사한다.
  • UNIQUE (meetup_id, member_id)는 두 열의 조합이 중복되는 것을 막는다. 민서가 서로 다른 모임에 신청할 수 있고, 같은 모임에 다른 회원도 신청할 수 있다. 이미 신청한 모임에 민서가 다시 신청하면 두 번호가 모두 같으므로 거절된다.
  • CHECK는 행의 값이 조건을 만족하는지 검사한다. 정원은 저장된 값의 자료형이 정수이고 1 이상이어야 한다. SQLite에서 CHECK의 계산 결과가 NULL이면 그 조건만으로는 행이 거절되지 않으므로 필수인 정원에는 NOT NULL도 둔다.

두 외래 키에는 ON DELETE NO ACTION을 명시한다. 이 예제의 외래 키는 문장이 끝날 때 검사된다. 신청이 남아 있는 모임이나 회원을 삭제하려 하면 그 문장이 실패한다. 운영자가 관련 신청을 어떻게 처리할지 결정한 뒤 다시 삭제할 수 있다. SQLite에서 이 삭제 규칙은 절을 생략했을 때의 기본 동작과 같다. 절을 직접 적으면 스키마에서 이 서비스가 선택한 정책을 읽을 수 있다. 또 연결을 연 직후 PRAGMA foreign_keys = ON을 실행한다. SQLite의 외래 키 검사 설정은 연결마다 적용된다.

시작 시각은 협정 세계시(UTC)를 기준으로 1970년 1월 1일 자정부터 센 정수 초로 저장한다. 열 이름 starts_at_utc_s에 기준과 단위를 함께 표시한다. 예제는 초 단위 일정과 0 이상의 값을 사용한다. 테이블은 저장된 값이 정수인지, 범위의 하한을 지키는지 검사한다. 초와 밀리초를 혼동하면 둘 다 양의 정수가 될 수 있으므로, 단위는 값을 만드는 코드에서도 맞춰야 한다. 완성 코드에서는 시간대 정보가 들어 있는 고정 시각으로부터 정수 초를 만들고, 저장한 값을 다시 시간대 표기가 있는 문자열로 바꿔 출력한다.

서울 시각으로 오전 10시인 산책은 같은 날 UTC 오전 1시다. 두 표기는 하나의 순간을 가리킨다. 이번 장의 예제는 한국 시각에 해당하는 고정 오프셋을 넣어 이 변환을 확인한다. 시작 시각을 표시하는 방식은 화면의 용도에 맞춰 정할 수 있으며, 데이터베이스에는 변환의 기준이 되는 값을 남긴다.

한국 시각 오전 10시를 같은 순간의 UTC 오전 1시로 변환해 정수 초로 저장한다.

완성 코드

다음 코드를 main.py에 저장한다. 예제 데이터에는 제목이 같은 모임 두 건과 회원 두 명이 있다. 성공 사례로 서로 다른 모임에 같은 회원의 신청을 넣고, 같은 모임에 다른 회원의 신청도 넣는다. 그다음에는 실패 사례마다 입력값 하나 또는 관련 규칙 하나를 바꾼다. 정원이 0인 모임의 나머지 값은 유효하다. 그래야 정원 조건이 그 행을 거절했는지 판단할 수 있다.

import sqlite3
from contextlib import closing
from datetime import datetime, timedelta, timezone


SCHEMA = """
CREATE TABLE meetups (
    id INTEGER PRIMARY KEY,
    title TEXT NOT NULL CHECK (length(trim(title)) > 0),
    starts_at_utc_s INTEGER NOT NULL
        CHECK (typeof(starts_at_utc_s) = 'integer' AND starts_at_utc_s >= 0),
    capacity INTEGER NOT NULL
        CHECK (typeof(capacity) = 'integer' AND capacity >= 1)
);

CREATE TABLE members (
    id INTEGER PRIMARY KEY,
    name TEXT NOT NULL CHECK (length(trim(name)) > 0)
);

CREATE TABLE signups (
    id INTEGER PRIMARY KEY,
    meetup_id INTEGER NOT NULL
        REFERENCES meetups(id) ON DELETE NO ACTION,
    member_id INTEGER NOT NULL
        REFERENCES members(id) ON DELETE NO ACTION,
    UNIQUE (meetup_id, member_id)
);
"""

INSERT_MEETUP = """
INSERT INTO meetups (id, title, starts_at_utc_s, capacity)
VALUES (?, ?, ?, ?)
"""

INSERT_SIGNUP = """
INSERT INTO signups (meetup_id, member_id) VALUES (?, ?)
"""


def expect_rejection(db, label, sql, values, expected_error):
    try:
        with db:
            db.execute(sql, values)
            raise AssertionError(f"저장 규칙 위반을 허용함 — {label}")
    except sqlite3.IntegrityError as error:
        if error.sqlite_errorname != expected_error:
            raise AssertionError(
                f"{label} — 예상 {expected_error}, 실제 {error.sqlite_errorname}"
            ) from error

    print(f"거절 — {label}")


def main():
    korea_offset = timezone(timedelta(hours=9))
    local_start = datetime(2026, 10, 17, 10, 0, tzinfo=korea_offset)
    first_start = int(local_start.timestamp())
    second_start = int((local_start + timedelta(days=7)).timestamp())

    with closing(sqlite3.connect(":memory:")) as db:
        db.execute("PRAGMA foreign_keys = ON")
        if db.execute("PRAGMA foreign_keys").fetchone() != (1,):
            raise RuntimeError("외래 키 검사를 켜지 못함")
        db.executescript(SCHEMA)

        with db:
            db.executemany(
                INSERT_MEETUP,
                [
                    (1, "골목 산책", first_start, 8),
                    (2, "골목 산책", second_start, 8),
                ],
            )
            db.executemany(
                "INSERT INTO members (id, name) VALUES (?, ?)",
                [(1, "민서"), (2, "하람")],
            )
            db.executemany(INSERT_SIGNUP, [(1, 1), (2, 1), (1, 2)])

        saved_start = db.execute(
            "SELECT starts_at_utc_s FROM meetups WHERE id = ?", (1,)
        ).fetchone()[0]
        utc_start = datetime.fromtimestamp(saved_start, tz=timezone.utc)
        print(f"첫 모임 시작 — {utc_start.isoformat()}")
        print("정상 신청 저장 — 3건")

        expect_rejection(
            db, "제목 누락", INSERT_MEETUP,
            (3, None, first_start, 8), "SQLITE_CONSTRAINT_NOTNULL",
        )
        expect_rejection(
            db, "정원 0명", INSERT_MEETUP,
            (3, "공원 산책", first_start, 0), "SQLITE_CONSTRAINT_CHECK",
        )
        expect_rejection(
            db, "정원 1.5명", INSERT_MEETUP,
            (3, "공원 산책", first_start, 1.5), "SQLITE_CONSTRAINT_CHECK",
        )
        expect_rejection(
            db, "중복 신청", INSERT_SIGNUP,
            (1, 1), "SQLITE_CONSTRAINT_UNIQUE",
        )
        expect_rejection(
            db, "없는 모임에 신청", INSERT_SIGNUP,
            (99, 1), "SQLITE_CONSTRAINT_FOREIGNKEY",
        )
        expect_rejection(
            db, "회원 번호 누락", INSERT_SIGNUP,
            (1, None), "SQLITE_CONSTRAINT_NOTNULL",
        )
        expect_rejection(
            db, "신청이 남은 모임 삭제", "DELETE FROM meetups WHERE id = ?",
            (1,), "SQLITE_CONSTRAINT_FOREIGNKEY",
        )
        expect_rejection(
            db, "신청이 남은 회원 삭제", "DELETE FROM members WHERE id = ?",
            (1,), "SQLITE_CONSTRAINT_FOREIGNKEY",
        )

        meetups = db.execute("SELECT id FROM meetups ORDER BY id").fetchall()
        members = db.execute("SELECT id FROM members ORDER BY id").fetchall()
        signups = db.execute(
            "SELECT meetup_id, member_id FROM signups ORDER BY meetup_id, member_id"
        ).fetchall()
        if (
            meetups != [(1,), (2,)]
            or members != [(1,), (2,)]
            or signups != [(1, 1), (1, 2), (2, 1)]
        ):
            raise AssertionError("실패 사례를 실행한 뒤 저장된 행이 달라짐")

        with db:
            db.execute("INSERT INTO members (id, name) VALUES (?, ?)", (3, "유진"))
            deleted = db.execute("DELETE FROM members WHERE id = ?", (3,)).rowcount
            if deleted != 1:
                raise AssertionError("신청이 없는 회원 한 명을 삭제하지 못함")

        print("저장 확인 — 모임 2건, 회원 2명, 신청 3건")
        print("삭제 확인 — 신청이 없는 회원 1명")


if __name__ == "__main__":
    main()

줄별 해설

  1. SCHEMA의 CREATE TABLE 세 문장이 저장할 행의 형태를 정한다. signups의 두 외래 키는 앞의 두 테이블을 참조한다. 바로 아래의 UNIQUE는 열 하나가 아니라 괄호 안 두 열의 조합을 검사한다. 신청마다 다른 id가 부여돼도 모임 번호와 회원 번호의 조합은 한 번만 저장할 수 있다.

  2. typeof(capacity)는 데이터베이스가 실제로 저장하려는 값의 자료형을 읽는다. SQLite의 INTEGER 열은 값이 정수로 변환될 수 있으면 변환한다. 예를 들어 정수 모양의 문자열도 변환될 수 있다. 1.5는 정수로 온전히 변환할 수 없어 CHECK에서 거절된다. 파이썬에 들어온 값이 어떤 자료형이었는지와 SQLite에 어떤 자료형으로 저장되는지는 서로 다른 검사 지점이다.

  3. INSERT_MEETUP과 INSERT_SIGNUP의 물음표 자리는 실행할 때 넘긴 값으로 채워진다. executemany는 같은 문장을 값 묶음마다 실행한다. 신청 데이터의 (1, 1)과 (2, 1)은 민서가 모임 두 곳에 신청한 사례다. (1, 2)는 하람이 민서와 같은 모임에 신청한 사례다. 이 세 행이 모두 저장되어야 중복 조건의 범위가 맞다.

  4. local_start에는 날짜와 시각, UTC에서 아홉 시간 앞선다는 정보가 함께 들어 있다. timestamp()는 그 순간을 기준 시점부터의 초로 돌려준다. 입력 시각에 초 미만의 값이 없으므로 여기서는 int()로 정수 초를 만든다. 조회한 값을 datetime.fromtimestamp()에 전달할 때 tz=timezone.utc를 지정해 실행 환경의 기본 시간대와 관계없이 같은 출력이 나오게 한다.

  5. sqlite3.connect(":memory:")는 현재 연결에서 사용하는 메모리 데이터베이스를 만든다. 같은 문자열로 연결을 다시 열면 별도의 데이터베이스가 생긴다. 그래서 테이블 생성부터 마지막 조회까지 한 연결을 쓴다. closing은 바깥 블록이 끝날 때 연결을 닫고, 안쪽의 with db는 쓰기 작업을 묶어 성공하면 확정하고 예외가 나면 되돌린다.

  6. expect_rejection()은 쓰기 문장 하나를 실행한 뒤 제약 조건 오류의 종류를 비교한다. 예를 들어 중복 신청 검사가 외래 키 오류로 실패하면 예상한 검사가 일어난 것이 아니므로 실행을 멈춘다. 문장이 뜻밖에 성공해도 같은 블록 안에서 오류를 일으켜 그 변경을 되돌린다. SQL 문법 오류처럼 이 함수가 기대한 종류가 아닌 예외는 그대로 드러난다.

  7. 마지막 조회는 개수와 함께 살아남은 행의 식별자와 신청 조합을 비교한다. 개수만 같으면 신청 한 건이 다른 신청으로 바뀐 경우를 놓칠 수 있다. 이어서 신청이 없는 회원을 한 명 넣고 삭제한다. 신청이 있는 회원의 삭제는 거절되고, 참조하는 신청이 없는 회원의 삭제는 허용되는지 두 방향을 확인한다.

실행 결과

main.py를 저장한 디렉터리에서 다음 명령을 실행한다. 첫 명령은 경고를 오류로 취급해 컴파일을 확인하며, 성공하면 화면에 아무것도 출력하지 않는다. 둘째 명령은 예제 데이터를 저장한 뒤 검사 결과를 출력하고 종료한다.

python3 -W error -m py_compile main.py
python3 main.py

예상 출력은 다음과 같다.

첫 모임 시작 — 2026-10-17T01:00:00+00:00
정상 신청 저장 — 3건
거절 — 제목 누락
거절 — 정원 0명
거절 — 정원 1.5명
거절 — 중복 신청
거절 — 없는 모임에 신청
거절 — 회원 번호 누락
거절 — 신청이 남은 모임 삭제
거절 — 신청이 남은 회원 삭제
저장 확인 — 모임 2건, 회원 2명, 신청 3건
삭제 확인 — 신청이 없는 회원 1명

실무에서 자주 틀리는 것

AI에 보낼 요청문에는 테이블 이름과 함께 허용해야 할 동작과 거절해야 할 동작을 적는다. 삭제나 시간 단위처럼 답을 여러 방식으로 낼 수 있는 항목에는 서비스가 정한 정책도 넣는다.

모임, 회원, 참가 신청을 SQLite로 설계하라. 제목이 같은 모임 두 건을 저장할 수 있어야 한다. 회원은 여러 모임에 신청할 수 있고 같은 모임에는 한 번만 신청할 수 있다. 신청이 남은 모임과 회원의 삭제는 거절하라. 시작 시각은 UTC 기준 정수 초로 저장하고, 예제에는 시간대가 명시된 고정값을 사용하라. 파이썬 표준 라이브러리와 메모리 데이터베이스로 정상 저장, 제약 조건 위반, 실패 뒤 남은 행을 확인하라.

아래 표는 AI 응답을 검토하는 예시 기록이다. 스키마의 변경분(diff)을 읽을 때에는 신청 테이블의 조합 조건, 연결 직후의 설정, 시각을 만드는 줄을 각각 찾는다. 바뀐 줄을 확인한 뒤 완성 코드에서 그 변경과 대응하는 성공 또는 실패 사례를 실행한다.

요청에서 정한 규칙을 스키마 변경과 실행으로 확인한다
AI에 보낸 요청 요지초안 응답 예시사람이 고친 부분확인 방법
같은 모임에는 한 번만 신청한다.신청 번호를 기본 키로 둔다.기본 키를 유지하고 모임과 회원의 조합에 UNIQUE를 추가했다.같은 회원의 다른 모임 신청을 저장하고, 같은 조합은 중복 오류인지 확인한다.
신청이 남은 모임과 회원은 삭제할 수 없다.외래 키 선언을 추가한다.두 삭제 정책을 명시하고 연결 직후 외래 키 검사를 켰다.두 삭제가 외래 키 오류인지 확인하고, 신청이 없는 회원의 삭제를 실행한다.
시작 시각을 UTC 기준 정수 초로 저장한다.시간대 없는 날짜와 시각을 시각 열에 저장한다.고정 오프셋을 지정한 시각에서 정수 초를 만들고 열 이름에 단위를 적었다.저장값을 읽어 UTC 오전 1시가 출력되는지 확인한다.

신청 번호만 고유하게 만든다

다음 코드는 같은 신청을 두 번 저장한다. 신청 번호는 두 행에서 다르므로 기본 키 조건을 만족한다.

import sqlite3
from contextlib import closing

with closing(sqlite3.connect(":memory:")) as db:
    db.execute("""
        CREATE TABLE signups (
            id INTEGER PRIMARY KEY,
            meetup_id INTEGER NOT NULL,
            member_id INTEGER NOT NULL
        )
    """)
    sql = "INSERT INTO signups (meetup_id, member_id) VALUES (?, ?)"
    db.executemany(sql, [(1, 1), (1, 1)])
    print(db.execute("SELECT count(*) FROM signups").fetchone()[0])

고친 코드에는 두 번호의 조합을 검사하는 조건이 있다. 같은 모임에 들어온 서로 다른 회원의 신청을 저장한 뒤 첫 번째 조합을 다시 넣으면 SQLITE_CONSTRAINT_UNIQUE가 출력된다. 이 짧은 예제는 조합 조건을 따로 확인한다. 모임과 회원의 존재 여부까지 확인하는 외래 키는 완성 코드에 들어 있다.

import sqlite3
from contextlib import closing

with closing(sqlite3.connect(":memory:")) as db:
    db.execute("""
        CREATE TABLE signups (
            id INTEGER PRIMARY KEY,
            meetup_id INTEGER NOT NULL,
            member_id INTEGER NOT NULL,
            UNIQUE (meetup_id, member_id)
        )
    """)
    sql = "INSERT INTO signups (meetup_id, member_id) VALUES (?, ?)"
    with db:
        db.executemany(sql, [(1, 1), (1, 2)])
    try:
        with db:
            db.execute(sql, (1, 1))
    except sqlite3.IntegrityError as error:
        print(error.sqlite_errorname)

삭제 정책을 선언하고 연결에서 검사를 끈 채 쓴다

다음 코드는 외래 키 검사가 꺼진 상태를 명시적으로 만들어 실수를 재현한다. 신청이 연결된 모임을 지워도 신청 한 건이 남는다. 테이블에 삭제 정책을 적었는지, 실제 연결에서 그 정책을 검사하는지 둘 다 살펴야 한다.

import sqlite3
from contextlib import closing

with closing(sqlite3.connect(":memory:")) as db:
    db.execute("PRAGMA foreign_keys = OFF")
    db.executescript("""
        CREATE TABLE meetups (id INTEGER PRIMARY KEY);
        CREATE TABLE signups (
            meetup_id INTEGER NOT NULL
                REFERENCES meetups(id) ON DELETE NO ACTION
        );
        INSERT INTO meetups VALUES (1);
        INSERT INTO signups VALUES (1);
        DELETE FROM meetups WHERE id = 1;
    """)
    print(db.execute("SELECT meetup_id FROM signups").fetchall())

고친 코드에서는 연결을 열고 쓰기 작업을 시작하기 전에 검사를 켠다. 삭제 시 SQLITE_CONSTRAINT_FOREIGNKEY가 출력되고, 마지막 조회에서 모임 행 [(1,)]이 나온다. 외래 키 설정을 트랜잭션 안에서 바꾸려 하면 적용되지 않으므로 설정 줄의 위치도 변경분에서 확인한다.

import sqlite3
from contextlib import closing

with closing(sqlite3.connect(":memory:")) as db:
    db.execute("PRAGMA foreign_keys = ON")
    db.executescript("""
        CREATE TABLE meetups (id INTEGER PRIMARY KEY);
        CREATE TABLE signups (
            meetup_id INTEGER NOT NULL
                REFERENCES meetups(id) ON DELETE NO ACTION
        );
        INSERT INTO meetups VALUES (1);
        INSERT INTO signups VALUES (1);
    """)
    try:
        with db:
            db.execute("DELETE FROM meetups WHERE id = ?", (1,))
    except sqlite3.IntegrityError as error:
        print(error.sqlite_errorname)
    print(db.execute("SELECT id FROM meetups").fetchall())

시간대가 없는 값을 UTC라고 부른다

다음 코드는 출력에 UTC라는 글자를 덧붙인다. 원래 오전 10시가 한국 시각이었다면 출력에 적힌 순간은 실제 일정과 아홉 시간 차이가 난다. 시간대 정보 없이 만든 datetime에 곧바로 timestamp()를 호출하는 방식도 실행 환경의 현지 시간대에 의존한다.

from datetime import datetime

start = datetime(2026, 10, 17, 10, 0)
print(start.isoformat() + " UTC")

고친 코드에서는 처음부터 한국 시각의 오프셋을 포함해 순간을 지정하고, 저장 단위인 정수 초를 거쳐 UTC 표기로 되돌린다. 결과는 2026-10-17T01:00:00+00:00이다.

from datetime import datetime, timedelta, timezone

korea_offset = timezone(timedelta(hours=9))
start = datetime(2026, 10, 17, 10, 0, tzinfo=korea_offset)
stored_seconds = int(start.timestamp())
print(datetime.fromtimestamp(stored_seconds, tz=timezone.utc).isoformat())

한눈에 보기

서비스 규칙을 데이터베이스 선언과 검증 사례로 연결한다
규칙설계에 적는 곳검증 사례
같은 제목의 모임을 구분한다.meetups.id를 기본 키로 둔다.‘골목 산책’ 두 건을 서로 다른 번호로 저장한다.
모임과 회원이 있어야 신청할 수 있다.signups의 두 번호에 NOT NULL과 외래 키를 둔다.없는 모임 번호와 누락된 회원 번호를 각각 넣는다.
같은 모임에는 한 번 신청한다.신청의 두 번호에 조합 UNIQUE를 둔다.다른 조합은 저장하고 같은 조합은 거절한다.
정원은 1명 이상의 정수다.정원 열에 NOT NULL과 CHECK를 둔다.정원 0과 1.5를 각각 넣는다.
신청이 있으면 연결된 행을 삭제할 수 없다.외래 키 검사를 켜고 ON DELETE NO ACTION을 명시한다.신청이 남은 모임과 회원의 삭제를 각각 시도한다.
시작 시각의 기준과 단위가 일정하다.starts_at_utc_s에 UTC 기준 정수 초를 저장한다.고정 시각을 저장하고 다시 UTC 문자열로 읽는다.

다음 장에서는 이 테이블을 사용하는 요청과 응답을 설계한다. 같은 모임에 다시 신청한 경우와 존재하지 않는 모임에 신청한 경우를 데이터베이스에서 구분할 수 있으므로, 요청 처리 코드에서 각 상황에 맞는 응답을 정할 수 있다.

연습 문제

  1. 회원 번호에만 UNIQUE를 걸었다고 가정한다. 완성 코드의 정상 신청 세 건 중 어느 행에서 처음 실패하는지 찾고 그 이유를 설명하라.
  2. 완성 코드에 정원 1명이 허용되는지 확인하는 사례를 추가하라. 정원 0명을 거절하는 기존 사례와 함께 실행할 때 어떤 경계를 검사하는지 설명하라.
  3. 첫 번째 모임의 신청을 모두 지운 뒤 첫 번째 모임을 삭제한다. 두 작업이 성공하면 남아야 하는 모임 번호와 신청 조합을 적어라. 어떤 열을 기준으로 신청을 삭제해야 하는지도 설명하라.
  4. 시작 시각 검사에 음수 정수와 양의 밀리초 값을 각각 넣으면 어떻게 되는지 설명하라. 밀리초가 저장되는지 확인한 뒤 시간을 만드는 코드의 검증 방법을 한 가지 적어라.

정답과 해설

  1. 두 번째 신청 (2, 1)에서 실패한다. 첫 번째 신청 (1, 1)에 이미 회원 번호 1이 있어서다. 규칙에서 확인할 범위는 두 번호의 조합이다. 회원 번호만 검사하면 처음 신청한 모임 외에는 회원이 신청할 수 없다.

  2. 마지막 저장 확인 뒤에 새 모임 번호로 정원 1, 비어 있지 않은 제목, 기존의 시작 시각을 넣는다. 새 모임을 번호로 조회해 저장된 정원이 1인지 확인한다. 정원 0이 거절되고 그다음 정수인 1이 허용되면 하한을 포함하는 조건인지 확인할 수 있다. 새 행을 마지막 저장 확인 전에 넣으려면 그 검사에서 기대하는 모임 목록도 함께 바꿔야 한다.

  3. 신청은 meetup_id가 1인 행을 모두 삭제한다. 이어서 모임 테이블에서 id가 1인 행을 삭제하면 모임 번호 2와 신청 (2, 1)이 남는다. 신청 번호는 모임 번호와 독립적이므로 신청을 지울 때 signups.id를 기준으로 삼으면 해당 모임의 신청을 모두 찾지 못한다. 두 삭제를 하나의 with db에 두면 뒤의 삭제가 실패했을 때 앞의 삭제도 되돌릴 수 있다.

  4. 음수는 0 이상이라는 조건에서 거절된다. 양의 밀리초 값이 SQLite에 정수로 저장될 수 있는 범위에 있다면 현재 조건을 통과한다. first_start * 1000을 새 모임의 시각으로 넣어 확인할 수 있다. 변환 코드에서는 고정 입력 하나를 저장한 뒤 정수 값을 UTC 시각으로 되돌려 예상 날짜와 시각을 비교한다. 단위가 바뀌면 비교 결과가 달라지거나 시각 변환에서 오류가 난다.

오탈자·오류 제보 비공개로 접수되어 원고 수정에 반영됩니다

이메일 등 개인정보는 받지 않습니다. 답변이 필요한 질문은 아래 댓글을 이용해 주세요.

READER FEEDBACK

질문·의견

내용에 관한 질문이나 더 나은 설명을 위한 의견을 남겨 주세요. 오탈자는 위의 제보 양식이 더 빨리 반영됩니다. 이 댓글은 원래 게시글과 같은 자리에 쌓입니다.

댓글 0

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

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