개발자노트

[데이터베이스] 2. 관계형 데이터베이스

dev-K — Fri, 9 Jan 2026 05:11:50 +0900

관계형 데이터베이스란,
"관계있는" 여러 개의 테이블을 연결해놓은 것.

애초에 데이터베이스라는 것이 여러 개의 테이블이다.
이 테이블들간의 어떤 관계를 설정하여 연결하면
그게 관계형 데이터베이스다. (RDB, Relationship DataBase)

예시로, 어떤 가게에서 주문을 한다고 가정하자.
이 상황에서 생각할 수 있는 테이블들은 아래와 같다.

[사람]

MEMBER_ ID	이름
1	김철수
2	박짱구
3	최유리
...	...

[상품]

PRODUCT_ID	상품명	가격
1	볼펜	1,000원
2	연필	800원
3	지우개	500원
...	...	...

이 상황에서, 김철수가 볼펜 하나를 구매하는 상황을 생각해볼 수 있다.
이 문장과 동치는, 이 테이블에서 관계가 발생했다는 것,
그리고 관계형 데이터베이스를 생각해볼 수 있다는 것이다.

"사람" 테이블에서 "MEMBER_ID"가 "1"이고 "이름"이 "김철수"인 사람이, 
"상품" 테이블에서 "PRODUCT_ID"가 "1"이고 "상품명"이 "볼펜"이고, "가격"이 "1,000원"인 상품을 
"주문" 했다.

쓸데없이 말이 길게 느껴지는 이유는, 불필요한 정보가 포함되었기 때문이다.
저 표를 보면, MEMBER_ID가 1인 사람의 이름이 김철수 라는 사실을 누가 모르겠는가?
따라서 이렇게 바꿀 수 있다.

"사람" 테이블에서 "MEMBER_ID"가 "1"이고 "이름"이 "김철수"인 사람이, 
--> "사람" 테이블에서 "MEMBER_ID"가 "1"인 사람이

이름을 뺀 이유는, 동명이인을 고려한 것이고 학창시절 출석번호를 생각하면 된다.

같은 맥락으로 "상품"테이블도, "PRODUCT_ID"로만 부른다면
복잡한 문장은 아래와 같이 바뀐다.

"사람" 테이블에서 "MEMBER_ID"가 "1"인 사람이, 
"상품" 테이블에서 "PRODUCT_ID"가 "1"인 상품을 
"주문" 했다.

여기에서 MEMBER_ID와 PRODUCT_ID는 각각 사람, 상품 테이블의 기본키이다.

기본키는 다른 객체와 중복되지 않으면서

관계형 데이터베이스는, 두 테이블을 연결짓는 사건 또한 테이블로 정의한다.
따라서 앞서 텍스트로 표현했던 "주문" 이라는 사건 또한 아래 테이블로 정의할 수 있다.

[데이터베이스] 1. 데이터베이스 기본용어

dev-K — Wed, 7 Jan 2026 20:51:21 +0900

엑셀같은 프로그램을 자주 접하거나 공부해봤다면 입문하기 좋을 거야.

앞으로 만들 여러 프로그램들이 있다.

프로그램들은 기본적인 입출력, 처리/가공 동작 등을 할 것이지만

외부에서 정보를 읽어오기도 하고,

또한 외부로 정보를 내보내기도 할 것이며,

외부 시스템을 통해 다른 사용자와의 실시간 상호작용도 지원하겠지.

그런 동작들을 구현하기 위해

코딩 외적으로 알아야하는 개념이 네트워크와 데이터베이스다.

외부와 소통한다고 하는 관점에서 비유해볼 때,

데이터베이스는 출발지와 목적지의 좌표이고,

네트워크는 이동수단이다.

걸어가든 대중교통을 타고 가든, 비행기를 타고 가든간에

어디로 가야 하는지 모르면 어떤 이동수단을 써도 의미가 없다.
마찬가지로, 어떤 데이터를 읽고 쓰는지가 정해지지 않으면 네트워크 통신도 의미가 없다.
그래서 데이터베이스 개념을 먼저 이해하는 것이 중요하다.

✔ 단위 개념 (엑셀을 생각하면 쉽다.)

-. 데이터베이스 = 여러 테이블들의 집합이다.
-. 테이블 = 행(row)과 열(column)로 구성된 데이터의 집합이다.
-. 행(row) = 한 객체(사람, 주문, 상품 등)에 대한 하나의 기록이다.
-. 열(column) = 각 기록을 구성하는 속성(이름, 전화번호, 가격 등)이다.
-. 셀(cell) = 행과 열이 만나는 지점의 실제 값이다.

-. 스키마(schema) = 데이터베이스의 구조(테이블·열·관계 설계도)이다.
-. 기본키(Primary Key) = 각 행을 고유하게 식별하는 값이다.
-. 외래키(Foreign Key) = 다른 테이블의 기본키를 참조하는 열이다.
-. 인덱스(index) = 검색 속도를 높이기 위한 구조이다.

✔ 확장

-. 데이터베이스 관리 시스템(DBMS) = 데이터베이스를 생성·저장·수정·조회하도록 관리하는 소프트웨어 시스템이다.
(ex. Oracle, MySQL, PostgreSQL, MariaDB, SQL Server 등)

-. 데이터(data) = 의미를 해석하기 전의 사실이나 값이다.
-. 정보(information) = 데이터를 가공·분석하여 의미가 생긴 것이다.

-. 정형 데이터 = 행과 열 구조로 표현될 수 있는 데이터이다.
-. 비정형 데이터 = 문서, 이미지, 영상처럼 고정된 표 구조로 표현하기 어려운 데이터이다.

-. 파일(file) = 컴퓨터에 저장되는 데이터의 기본 단위이며, 데이터베이스에서는 파일 자체가 아니라 파일의 정보(경로, 이름, 크기 등 메타데이터)를 주로 관리한다.

업무 자동화 툴 킷(Automation toolkit, A.T) - 3일차

dev-K — Tue, 6 Jan 2026 20:04:46 +0900

1️⃣ writer.py 역할

-. writer.py는 가공된 DataFrame을 결과물로 변환한다.

-. 입력 : List[pd.DataFrame] / processor에서 받음.

-. 출력 : Excel 파일

2️⃣ 실제 코드

# app/pipeline/writer.py

from pathlib import Path
from typing import List

import pandas as pd

from app.utils.logger import get_logger

logger = get_logger(__name__)


def write_excel(
    dfs: List[pd.DataFrame],
    output_dir: str,
    prefix: str = "result"
) -> None:
    """
    DataFrame 리스트를 Excel 파일로 저장한다.
    """
    output_path = Path(output_dir)
    output_path.mkdir(parents=True, exist_ok=True)

    for idx, df in enumerate(dfs, start=1):
        file_name = f"{prefix}_{idx}.xlsx"
        file_path = output_path / file_name

        try:
            df.to_excel(file_path, index=False)
            logger.info(f"Excel 저장 완료: {file_path}")
        except Exception:
            logger.exception(f"Excel 저장 실패: {file_path}")

3️⃣ main.py 수정

from app.pipeline.writer import write_excel

@app.command()
def run(...):
    ...
    dfs = read_input(input_path)
    processed_dfs = process_dataframes(dfs)

    write_excel(processed_dfs, output_path)

    logger.info("전체 파이프라인 완료")

4️⃣ 실행코드 및 결과

python -m app.main --input-path ./examples --output-path ./output

업무 자동화 툴 킷(Automation toolkit, A.T) - 2일차

dev-K — Sun, 4 Jan 2026 19:04:25 +0900

1️⃣ 테스트용 파일 준비 (examples\sample.csv)

name,age,score
Alice,30,85
Bob,25,90

2️⃣ main.py 작성 및 연동

# app/main.py

import typer

from app.pipeline.reader import read_input
from app.utils.logger import get_logger

app = typer.Typer()
logger = get_logger(__name__)


@app.command()
def run(
    input_path: str = typer.Option(..., help="입력 파일 또는 폴더 경로"),
    output_path: str = typer.Option("./output", help="출력 경로"),
):
    logger.info("자동화 파이프라인 시작")

    dataframes = read_input(input_path)

    logger.info(f"총 DataFrame 개수: {len(dataframes)}")
    logger.info("작업 완료")


if __name__ == "__main__":
    app()

실행결과

3️⃣ processor.py

-. 이 파일은 입력(DataFrame)을 받아서, 규칙 기반으로 가공된 DataFrame을 반환한다.

-. 파일 입출력은 하지 않고, 순수 함수에 가깝게 작성하는 것이 원칙.

# app/pipeline/processor.py

from typing import List

import pandas as pd

from app.utils.logger import get_logger

logger = get_logger(__name__)


def process_dataframes(dfs: List[pd.DataFrame]) -> List[pd.DataFrame]:
    """
    여러 DataFrame을 받아 규칙 기반으로 가공한다.
    """
    processed: List[pd.DataFrame] = []

    for idx, df in enumerate(dfs):
        logger.info(f"DataFrame 처리 시작: index={idx}")
        try:
            processed_df = _process_single_dataframe(df)
            processed.append(processed_df)
        except Exception:
            logger.exception(f"DataFrame 처리 실패: index={idx}")

    logger.info(f"총 처리 완료 DataFrame 수: {len(processed)}")
    return processed


def _process_single_dataframe(df: pd.DataFrame) -> pd.DataFrame:
    """
    DataFrame 하나에 대한 가공 로직
    """
    df = df.copy()

    df = _normalize_columns(df)
    df = _apply_rules(df)

    return df


def _normalize_columns(df: pd.DataFrame) -> pd.DataFrame:
    """
    컬럼명 정규화
    """
    df.columns = (
        df.columns
        .str.strip()
        .str.lower()
        .str.replace(" ", "_")
    )
    logger.debug(f"정규화된 컬럼: {list(df.columns)}")
    return df


def _apply_rules(df: pd.DataFrame) -> pd.DataFrame:
    """
    예시 규칙:
    - score >= 90 : grade = 'A'
    - score >= 80 : grade = 'B'
    - 그 외 : 'C'
    """
    if "score" not in df.columns:
        logger.warning("score 컬럼이 없어 규칙 적용 스킵")
        return df

    def classify(score):
        if score >= 90:
            return "A"
        if score >= 80:
            return "B"
        return "C"

    df["grade"] = df["score"].apply(classify)
    logger.info("grade 컬럼 생성 완료")

    return df

scroe에 대한 grade 기준을 나누는 것으로 간단한 예시를 구현.

DataFrame -> DataFrame으로 가공한다는 큰 틀을 벗어나지 않는다면, 입력 데이터에 따른 구현방식은 수정 가능.

4️⃣ main 함수에 processor 연결

# app/main.py

import typer

from app.pipeline.reader import read_input
from app.utils.logger import get_logger
from app.pipeline.processor import process_dataframes

app = typer.Typer()
logger = get_logger(__name__)


@app.command()
def run(
    input_path: str = typer.Option(..., help="입력 파일 또는 폴더 경로"),
    output_path: str = typer.Option("./output", help="출력 경로"),
):
    logger.info("자동화 파이프라인 시작")

    dfs = read_input(input_path)
    processed_dfs = process_dataframes(dfs)
    logger.info(f"가공 완료 DataFrame 수: {len(processed_dfs)}")
    logger.info("작업 완료")


if __name__ == "__main__":
    app()

실행결과

업무 자동화 툴 킷(Automation toolkit, A.T) - 1일차

dev-K — Fri, 2 Jan 2026 20:23:39 +0900

1️⃣ 업무환경 및 필수 프로그램 설치

-. Windows 11 환경에서 CMD 창을 이용하여 가상환경을 조성.

-. 파이썬은 최신 버전이 설치되어있는 상태 (현재 기준 3.12)

-. 프로젝트 폴더 생성 및 이동 : 원하는 작업 경로에서

mkdir automation_toolkit
cd automation_toolkit

-. 가상환경 생성

python -m venv venv
venv\Scripts\activate

-. 기본 패키지 설치

pip install pandas openpyxl httpx typer fastapi uvicorn python-dotenv

-. 설치 시 모습 ( pip list 명령어 )

2️⃣ requirements.txt 생성

-. readme.md 파일과 함께 앞으로 모든 프로젝트의 기본이 되는 파일.

-. 전달/협업/배포 시 필수

pip freeze > requirements.txt

3️⃣ 폴더 구조 생성

mkdir app app\pipeline app\utils tests examples
type nul > app\main.py
type nul > app\config.py
type nul > app\pipeline\reader.py
type nul > app\pipeline\processor.py
type nul > app\pipeline\writer.py
type nul > app\utils\logger.py
type nul > app\utils\validator.py
type nul > README.md

-. 결과

4️⃣ 편집기 설치 및 실행

-. 추천 : VS Code / 이유 : 간편함. 가벼움. 가독성 Good.

-. 파일(File) - 폴더 열기(Open Folder) - 아까 만든 app 폴더를 한 번 클릭 후 [폴더 열기] 클릭.

5️⃣ 가장 먼저 만들 파일 : logger.py (app\utils)

-. 먼저 만드는 이유 : 유지보수용 핵심 파일이다.

-. 상세 이유 : 프로그램 돌아가는 이유, 안 돌아가는 이유, 까먹었을 때 어떻게 동작했더라? → 로그 확인 필수

# app/utils/logger.py
import logging
from pathlib import Path

LOG_DIR = Path("logs")
LOG_DIR.mkdir(exist_ok=True)

def get_logger(name: str) -> logging.Logger:
    logger = logging.getLogger(name)
    logger.setLevel(logging.INFO)

    if not logger.handlers:
        formatter = logging.Formatter(
            "[%(asctime)s] [%(levelname)s] %(name)s - %(message)s"
        )

        file_handler = logging.FileHandler(LOG_DIR / "app.log", encoding="utf-8")
        file_handler.setFormatter(formatter)

        console_handler = logging.StreamHandler()
        console_handler.setFormatter(formatter)

        logger.addHandler(file_handler)
        logger.addHandler(console_handler)

    return logger

-. 코드 설명 : [2026-01-02 14:30:01] [INFO] reader - file loaded 이런 식으로 출력됨. 시간,레벨,이름,메시지

6️⃣ 두 번째로 만들 파일 : reader.py (app\pipeline)

-. 실제 구현에 있어 순차적으로 (reader, processor, writer)

-. reader.py의 역할

1) 입력 경로가 파일인지 폴더인지 판별

2) 데이터를 pandas.DataFrame으로 변환(정규화)

3) 과정 기록 (logger)

# app/pipeline/reader.py

from pathlib import Path
from typing import List

import pandas as pd

from app.utils.logger import get_logger

logger = get_logger(__name__)

SUPPORTED_EXTENSIONS = {".csv", ".xlsx", ".xls"}


def read_input(path: str) -> List[pd.DataFrame]:
    """
    입력 경로를 받아 CSV / Excel 파일들을 읽어 DataFrame 리스트로 반환한다.
    """
    input_path = Path(path)

    if not input_path.exists():
        logger.error(f"입력 경로가 존재하지 않음: {input_path}")
        raise FileNotFoundError(f"{input_path} not found")

    if input_path.is_file():
        logger.info(f"파일 입력 감지: {input_path}")
        return [_read_file(input_path)]

    if input_path.is_dir():
        logger.info(f"폴더 입력 감지: {input_path}")
        return _read_directory(input_path)

    logger.error(f"지원하지 않는 입력 타입: {input_path}")
    raise ValueError("Unsupported input type")


def _read_directory(dir_path: Path) -> List[pd.DataFrame]:
    dataframes: List[pd.DataFrame] = []

    for file_path in dir_path.iterdir():
        if file_path.suffix.lower() in SUPPORTED_EXTENSIONS:
            try:
                logger.info(f"파일 로드 중: {file_path.name}")
                df = _read_file(file_path)
                dataframes.append(df)
            except Exception as e:
                logger.exception(f"파일 로드 실패: {file_path.name}")

    logger.info(f"총 로드된 파일 수: {len(dataframes)}")
    return dataframes


def _read_file(file_path: Path) -> pd.DataFrame:
    ext = file_path.suffix.lower()

    if ext == ".csv":
        df = pd.read_csv(file_path)
    elif ext in {".xlsx", ".xls"}:
        df = pd.read_excel(file_path)
    else:
        logger.error(f"지원하지 않는 파일 형식: {file_path}")
        raise ValueError(f"Unsupported file extension: {ext}")

    logger.info(
        f"데이터 로드 완료: {file_path.name} "
        f"(rows={len(df)}, cols={len(df.columns)})"
    )
    return df

파이썬 실습 프로젝트 : 업무 자동화 툴 킷(Automation toolkit, A.T)

dev-K — Fri, 2 Jan 2026 19:41:52 +0900

1️⃣ 시나리오

-. 엑셀로 매일 정리하는 데이터가 있다.

-. 이 데이터를 자동으로 가공(첨삭, 필터 등) → API 전송 (암호화) → 리포트 생성 (출력) 하는 프로그램을 만들고자 함.

2️⃣ 핵심 기능 구성

-. 모든 프로그래밍 언어가 그렇듯, 입력 → 처리 → 출력 의 과정을 거친다.

✅ 입력

-. Excel / CSV 파일 (테이블로 정리된 데이터베이스)

-. REST API 응답 (프로토콜, JSON)

-. 폴더 단위 파일

✅ 처리

-. 데이터 정제(가공)

-. 규칙 기반 분류

-. 병렬 처리(multiprocessing, asyncio)

-. 예외 자동 기록 (유지보수)

✅ 출력

-. Excel / PDF 리포트 파일

-. DB 저장

-. 메일 발송 or 파일 저장

3️⃣ 기술스택

-. Python 3.11

-. pandas

-. openpyxl

-. requests / httpx

-. Typer

-. logging

-. FastAPI

4️⃣ 폴더 구조

automation_toolkit/
├── app/
│   ├── main.py          # CLI 진입점
│   ├── config.py        # 설정
│   ├── pipeline/
│   │   ├── reader.py    # 입력
│   │   ├── processor.py # 처리
│   │   ├── writer.py    # 출력
│   ├── utils/
│   │   ├── logger.py
│   │   └── validator.py
├── tests/
├── examples/
├── README.md
└── requirements.txt

5️⃣ 구현 순서(3~4주 기준)

-. Typer 기반 CLI

-. 파일 입력 → 처리 → 출력 구조

-. 로그 / 예외처리

-. API 연동

-. 병렬처리

-. 리포트 생성 (예외 기록 등)

-. README 정리