DatabaseDevGuide0007

실전 프로젝트 완전 정복 A-Z

블로그 · 쇼핑몰 DB 설계 · 구현 · 배포까지

📋 학습 목차 — 이 글 하나로 현업 DB 개발자가 됩니다

실전 프로젝트 개요 & 설계 원칙

요구사항 분석부터 ERD 작성까지 — 프로 개발자처럼 설계하는 법

💡 이 챕터에서 배우는 것

실무에서 DB 설계를 시작할 때 "어떻게 시작하지?"라는 막막함을 해결합니다. 요구사항 문서 분석 → 엔티티 도출 → 관계 정의 → ERD 작성 → DDL 생성의 체계적인 프로세스를 배웁니다.

프로젝트 1: 블로그 시스템 DB 설계

티스토리/Medium 같은 블로그 플랫폼의 DB를 처음부터 직접 설계합니다

📋 기능 요구사항 목록

블로그 DB 구현 — DDL + 샘플 데이터

설계도를 실제 SQL로 변환합니다. 현업에서 쓰는 패턴 그대로!

-- ============================================================
-- 블로그 시스템 DB DDL (현업 수준)
-- charset: utf8mb4 (이모지 포함 모든 문자 지원)
-- ============================================================

CREATE DATABASE blog_db
  CHARACTER SET utf8mb4
  COLLATE utf8mb4_unicode_ci;

USE blog_db;

-- 1. 사용자 테이블
CREATE TABLE users (
  id             BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
  username       VARCHAR(50)  NOT NULL,
  email          VARCHAR(255) NOT NULL,
  password_hash  VARCHAR(255) NOT NULL,
  role           ENUM('user','admin','editor') NOT NULL DEFAULT 'user',
  profile_image  VARCHAR(500),
  bio            TEXT,
  is_active      TINYINT(1) NOT NULL DEFAULT 1,
  last_login_at  DATETIME,
  created_at     TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
  updated_at     TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (id),
  UNIQUE KEY uk_email (email),
  UNIQUE KEY uk_username (username),
  INDEX idx_created_at (created_at)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

-- 2. 카테고리 테이블 (계층 구조)
CREATE TABLE categories (
  id          INT UNSIGNED NOT NULL AUTO_INCREMENT,
  parent_id   INT UNSIGNED,
  name        VARCHAR(100) NOT NULL,
  slug        VARCHAR(120) NOT NULL,
  sort_order  INT NOT NULL DEFAULT 0,
  created_at  TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
  PRIMARY KEY (id),
  UNIQUE KEY uk_slug (slug),
  FOREIGN KEY (parent_id) REFERENCES categories(id) ON DELETE SET NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- 3. 게시글 테이블
CREATE TABLE posts (
  id             BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
  user_id        BIGINT UNSIGNED NOT NULL,
  category_id    INT UNSIGNED,
  title          VARCHAR(300) NOT NULL,
  slug           VARCHAR(350) NOT NULL,
  content        LONGTEXT NOT NULL,
  summary        VARCHAR(500),
  thumbnail_url  VARCHAR(500),
  status         ENUM('draft','published','private','scheduled') NOT NULL DEFAULT 'draft',
  view_count     INT UNSIGNED NOT NULL DEFAULT 0,
  like_count     INT UNSIGNED NOT NULL DEFAULT 0,
  comment_count  INT UNSIGNED NOT NULL DEFAULT 0,
  is_featured    TINYINT(1) NOT NULL DEFAULT 0,
  published_at   DATETIME,
  deleted_at     DATETIME,
  created_at     TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
  updated_at     TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (id),
  UNIQUE KEY uk_slug (slug),
  INDEX idx_user_id (user_id),
  INDEX idx_category_id (category_id),
  INDEX idx_status_published (status, published_at),
  INDEX idx_deleted_at (deleted_at),
  FULLTEXT INDEX ft_title_content (title, content),
  FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
  FOREIGN KEY (category_id) REFERENCES categories(id) ON DELETE SET NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- 4. 댓글 테이블 (계층형 대댓글)
CREATE TABLE comments (
  id          BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
  post_id     BIGINT UNSIGNED NOT NULL,
  user_id     BIGINT UNSIGNED NOT NULL,
  parent_id   BIGINT UNSIGNED,  -- NULL이면 최상위 댓글
  content     TEXT NOT NULL,
  is_deleted  TINYINT(1) NOT NULL DEFAULT 0,
  created_at  TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
  updated_at  TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (id),
  INDEX idx_post_id (post_id),
  INDEX idx_user_id (user_id),
  INDEX idx_parent_id (parent_id),
  FOREIGN KEY (post_id) REFERENCES posts(id) ON DELETE CASCADE,
  FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- 5. 태그 테이블 (다대다)
CREATE TABLE tags (
  id    INT UNSIGNED NOT NULL AUTO_INCREMENT,
  name  VARCHAR(50) NOT NULL,
  slug  VARCHAR(60) NOT NULL,
  PRIMARY KEY (id),
  UNIQUE KEY uk_slug (slug)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

CREATE TABLE post_tags (
  post_id  BIGINT UNSIGNED NOT NULL,
  tag_id   INT UNSIGNED NOT NULL,
  PRIMARY KEY (post_id, tag_id),
  FOREIGN KEY (post_id) REFERENCES posts(id) ON DELETE CASCADE,
  FOREIGN KEY (tag_id) REFERENCES tags(id) ON DELETE CASCADE
) ENGINE=InnoDB;

-- 6. 좋아요 테이블
CREATE TABLE likes (
  post_id     BIGINT UNSIGNED NOT NULL,
  user_id     BIGINT UNSIGNED NOT NULL,
  created_at  TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
  PRIMARY KEY (post_id, user_id),
  INDEX idx_user_id (user_id),
  FOREIGN KEY (post_id) REFERENCES posts(id) ON DELETE CASCADE,
  FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
) ENGINE=InnoDB;

⚠️ 현업에서 자주 저지르는 DDL 실수 TOP 5

블로그 핵심 쿼리 실전 작성

실무에서 매일 쓰는 복잡한 쿼리들을 현업 수준으로 작성합니다

-- 메인 페이지 게시글 목록 (저자 정보, 카테고리, 태그 수, 커서 기반 페이지네이션)
SELECT
  p.id,
  p.title,
  p.slug,
  p.summary,
  p.thumbnail_url,
  p.view_count,
  p.like_count,
  p.comment_count,
  p.published_at,
  u.username    AS author_name,
  u.profile_image AS author_image,
  c.name        AS category_name,
  c.slug        AS category_slug,
  -- 태그 목록을 하나의 컬럼으로 집계
  GROUP_CONCAT(t.name ORDER BY t.name SEPARATOR ',') AS tag_names
FROM posts p
INNER JOIN users u      ON p.user_id = u.id
LEFT JOIN  categories c ON p.category_id = c.id
LEFT JOIN  post_tags pt ON p.id = pt.post_id
LEFT JOIN  tags t       ON pt.tag_id = t.id
WHERE
  p.status = 'published'
  AND p.deleted_at IS NULL
  AND p.published_at <= NOW()
  AND p.id < :last_id  -- 커서 기반 페이지네이션 (OFFSET보다 빠름!)
GROUP BY p.id
ORDER BY p.id DESC
LIMIT 10;

-- ✅ 왜 커서 기반 페이지네이션인가?
-- OFFSET 방식: SELECT ... LIMIT 20 OFFSET 10000 → 10020개 행 스캔 후 뒤 10개 반환 (느림!)
-- 커서 방식:  SELECT ... WHERE id < :last_id LIMIT 10 → 인덱스로 정확히 10개만 읽음 (빠름!)

-- FULLTEXT 검색 (제목 + 본문 통합 검색)
SELECT
  p.id,
  p.title,
  p.slug,
  p.summary,
  -- 검색어와의 관련성 점수
  MATCH(p.title, p.content) AGAINST(:keyword IN BOOLEAN MODE) AS relevance_score
FROM posts p
WHERE
  p.status = 'published'
  AND p.deleted_at IS NULL
  AND MATCH(p.title, p.content) AGAINST(:keyword IN BOOLEAN MODE)
ORDER BY relevance_score DESC
LIMIT 20;

-- BOOLEAN MODE 검색 예시
-- 'MySQL +인덱스'   → MySQL 포함, 인덱스 필수
-- 'MySQL -Django'  → MySQL 포함, Django 제외
-- '"트랜잭션 처리"' → 정확한 구문 검색

-- 댓글 + 대댓글 계층 조회 (2단계)
SELECT
  c.id,
  c.content,
  c.parent_id,
  c.created_at,
  c.is_deleted,
  u.id          AS user_id,
  u.username,
  u.profile_image,
  -- 대댓글 수
  (SELECT COUNT(*) FROM comments r WHERE r.parent_id = c.id AND r.is_deleted = 0) AS reply_count
FROM comments c
INNER JOIN users u ON c.user_id = u.id
WHERE
  c.post_id = :post_id
  AND c.parent_id IS NULL  -- 최상위 댓글만
ORDER BY c.created_at ASC;

-- 특정 댓글의 대댓글 로드
SELECT c.*, u.username, u.profile_image
FROM comments c
INNER JOIN users u ON c.user_id = u.id
WHERE c.parent_id = :parent_id AND c.is_deleted = 0
ORDER BY c.created_at ASC;

-- 좋아요 추가 시 posts.like_count 자동 증가
DELIMITER //
CREATE TRIGGER trg_likes_after_insert
  AFTER INSERT ON likes
  FOR EACH ROW
BEGIN
  UPDATE posts SET like_count = like_count + 1
  WHERE id = NEW.post_id;
END//

CREATE TRIGGER trg_likes_after_delete
  AFTER DELETE ON likes
  FOR EACH ROW
BEGIN
  UPDATE posts SET like_count = like_count - 1
  WHERE id = OLD.post_id;
END//
DELIMITER ;

-- 💡 트리거 대신 application 레벨에서 관리하는 방법도 있음
--    트리거: DB 자체에서 보장, 하지만 디버깅 어려움
--    애플리케이션: 명시적이지만 누락될 수 있음
--    현업에서는 Redis로 카운트 관리 후 주기적으로 DB 동기화하는 방식도 많이 씀

프로젝트 2: 쇼핑몰 DB 설계

쿠팡/11번가 같은 이커머스 플랫폼의 DB를 A-Z까지 직접 설계합니다

쇼핑몰 DB 구현 — DDL + 트랜잭션

주문 처리의 핵심: 재고 감소 + 주문 생성 + 결제 기록을 원자적으로 처리

CREATE DATABASE shop_db CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
USE shop_db;

-- 상품 카테고리 (계층 구조)
CREATE TABLE categories (
  id          INT UNSIGNED NOT NULL AUTO_INCREMENT,
  parent_id   INT UNSIGNED,
  name        VARCHAR(100) NOT NULL,
  depth       TINYINT NOT NULL DEFAULT 0, -- 0:대분류, 1:중분류, 2:소분류
  sort_order  INT NOT NULL DEFAULT 0,
  PRIMARY KEY (id),
  INDEX idx_parent (parent_id),
  FOREIGN KEY (parent_id) REFERENCES categories(id) ON DELETE SET NULL
) ENGINE=InnoDB;

-- 상품 테이블
CREATE TABLE products (
  id              BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
  category_id     INT UNSIGNED,
  name            VARCHAR(300) NOT NULL,
  description     LONGTEXT,
  price           DECIMAL(12, 2) NOT NULL, -- FLOAT 절대 쓰지 말 것!
  discount_rate   DECIMAL(5, 2) NOT NULL DEFAULT 0.00,
  stock_qty       INT UNSIGNED NOT NULL DEFAULT 0,
  status          ENUM('active','inactive','soldout') NOT NULL DEFAULT 'active',
  avg_rating      DECIMAL(3, 2) NOT NULL DEFAULT 0.00,
  review_count    INT UNSIGNED NOT NULL DEFAULT 0,
  sales_count     BIGINT UNSIGNED NOT NULL DEFAULT 0,
  thumbnail_url   VARCHAR(500),
  deleted_at      DATETIME,
  created_at      TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
  updated_at      TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (id),
  INDEX idx_category (category_id),
  INDEX idx_status_price (status, price),
  FULLTEXT INDEX ft_name (name)
) ENGINE=InnoDB;

-- 주문 테이블
CREATE TABLE orders (
  id               BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
  order_number     VARCHAR(30) NOT NULL,  -- ORD-20241015-000001
  user_id          BIGINT UNSIGNED NOT NULL,
  status           ENUM('pending','paid','shipping','delivered','cancelled','refunded') NOT NULL DEFAULT 'pending',
  total_amount     DECIMAL(14, 2) NOT NULL,
  discount_amount  DECIMAL(14, 2) NOT NULL DEFAULT 0.00,
  final_amount     DECIMAL(14, 2) NOT NULL,
  shipping_address TEXT NOT NULL,
  shipping_name    VARCHAR(100) NOT NULL,
  shipping_phone   VARCHAR(20) NOT NULL,
  memo             VARCHAR(500),
  paid_at          DATETIME,
  created_at       TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
  updated_at       TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (id),
  UNIQUE KEY uk_order_number (order_number),
  INDEX idx_user_id (user_id),
  INDEX idx_status_created (status, created_at)
) ENGINE=InnoDB;

-- 주문 상세 (스냅샷 패턴 - 중요!)
CREATE TABLE order_items (
  id              BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
  order_id        BIGINT UNSIGNED NOT NULL,
  product_id      BIGINT UNSIGNED NOT NULL,
  product_name    VARCHAR(300) NOT NULL,  -- 스냅샷! 상품명 변경돼도 주문 내역 보존
  unit_price      DECIMAL(12, 2) NOT NULL,  -- 스냅샷! 가격 변경돼도 보존
  quantity        INT UNSIGNED NOT NULL,
  subtotal        DECIMAL(14, 2) NOT NULL,
  PRIMARY KEY (id),
  INDEX idx_order_id (order_id),
  INDEX idx_product_id (product_id),
  FOREIGN KEY (order_id) REFERENCES orders(id) ON DELETE CASCADE
) ENGINE=InnoDB;

-- 주문 처리 완전 트랜잭션 (Node.js + mysql2 패턴)
-- 1) 재고 확인 & 감소 (FOR UPDATE로 락 획득)
-- 2) 주문 생성
-- 3) 주문 상세 생성  
-- 4) 결제 기록 생성
-- 5) 장바구니 비우기

START TRANSACTION;

-- Step 1: 재고 확인 및 비관적 락 획득
SELECT id, stock_qty, price, name
FROM products
WHERE id = :product_id
FOR UPDATE;  -- 다른 트랜잭션의 접근 차단!

-- (앱 코드에서) stock_qty < 주문수량이면 ROLLBACK

-- Step 2: 재고 감소
UPDATE products
SET stock_qty = stock_qty - :quantity,
    status = CASE WHEN stock_qty - :quantity = 0 THEN 'soldout' ELSE status END
WHERE id = :product_id AND stock_qty >= :quantity;

-- ROW_COUNT() = 0이면 재고 부족 → ROLLBACK

-- Step 3: 주문 생성
INSERT INTO orders (order_number, user_id, status, total_amount, final_amount, shipping_address, shipping_name, shipping_phone)
VALUES (:order_number, :user_id, 'pending', :total, :final, :address, :name, :phone);

-- Step 4: 주문 상세 (스냅샷 패턴)
INSERT INTO order_items (order_id, product_id, product_name, unit_price, quantity, subtotal)
VALUES (LAST_INSERT_ID(), :product_id, :product_name, :price, :qty, :price * :qty);

-- Step 5: 결제 기록
INSERT INTO payments (order_id, method, status, amount, pg_transaction_id)
VALUES (:order_id, :method, 'completed', :amount, :pg_tid);

COMMIT;  -- 모두 성공해야 확정!
-- 실패 시: ROLLBACK; (모든 변경사항 원복)

쇼핑몰 핵심 쿼리 실전 작성

매출 통계, 상품 추천, 재고 알림까지 — 실무에서 쓰는 쿼리 모음

-- 일별 매출 통계 (최근 30일)
SELECT
  DATE(o.created_at)          AS sale_date,
  COUNT(DISTINCT o.id)         AS order_count,
  COUNT(DISTINCT o.user_id)    AS unique_buyers,
  SUM(o.final_amount)          AS total_revenue,
  AVG(o.final_amount)          AS avg_order_value,
  SUM(oi.quantity)             AS total_items_sold
FROM orders o
INNER JOIN order_items oi ON o.id = oi.order_id
WHERE
  o.status IN ('paid', 'shipping', 'delivered')
  AND o.created_at >= DATE_SUB(NOW(), INTERVAL 30 DAY)
GROUP BY DATE(o.created_at)
ORDER BY sale_date DESC;

-- 카테고리별 매출 순위 (WITH ROLLUP)
SELECT
  IFNULL(c.name, '전체 합계')  AS category,
  COUNT(DISTINCT o.id)           AS order_count,
  SUM(oi.subtotal)               AS revenue,
  RANK() OVER (ORDER BY SUM(oi.subtotal) DESC) AS rank_no
FROM order_items oi
INNER JOIN products p  ON oi.product_id = p.id
INNER JOIN categories c ON p.category_id = c.id
INNER JOIN orders o    ON oi.order_id = o.id
WHERE o.status != 'cancelled'
GROUP BY c.id WITH ROLLUP
ORDER BY revenue DESC;

-- 재고 10개 미만 상품 목록 (긴급 발주 필요)
SELECT
  p.id,
  p.name,
  p.stock_qty,
  p.sales_count,
  c.name  AS category,
  -- 최근 7일 평균 판매량
  ROUND(
    (SELECT SUM(oi2.quantity)
     FROM order_items oi2
     INNER JOIN orders o2 ON oi2.order_id = o2.id
     WHERE oi2.product_id = p.id
       AND o2.created_at >= DATE_SUB(NOW(), INTERVAL 7 DAY)
    ) / 7, 1
  ) AS avg_daily_sales
FROM products p
LEFT JOIN categories c ON p.category_id = c.id
WHERE p.stock_qty < 10 AND p.status = 'active' AND p.deleted_at IS NULL
ORDER BY p.stock_qty ASC;

-- 상품 리뷰 평점 분포 (별점 분석)
SELECT
  p.id,
  p.name,
  COUNT(r.id)           AS total_reviews,
  AVG(r.rating)         AS avg_rating,
  SUM(CASE WHEN r.rating = 5 THEN 1 ELSE 0 END) AS five_star,
  SUM(CASE WHEN r.rating = 4 THEN 1 ELSE 0 END) AS four_star,
  SUM(CASE WHEN r.rating <= 2 THEN 1 ELSE 0 END) AS low_rating
FROM products p
LEFT JOIN reviews r ON p.id = r.product_id
GROUP BY p.id
HAVING total_reviews > 0
ORDER BY avg_rating DESC;

NoSQL 연동 전략 (MongoDB + Redis)

MySQL만으로는 한계가 있다! NoSQL을 올바르게 조합하는 법

// Node.js Redis 캐싱 패턴 (Cache-Aside / Lazy Loading)

async function getProduct(productId) {
  const cacheKey = `product:${productId}`;
  
  // 1. Redis 캐시 확인
  const cached = await redis.get(cacheKey);
  if (cached) {
    return JSON.parse(cached);  // 캐시 히트!
  }
  
  // 2. DB 조회 (캐시 미스)
  const product = await db.query(
    'SELECT * FROM products WHERE id = ?', [productId]
  );
  
  // 3. Redis에 저장 (TTL: 5분)
  await redis.setex(cacheKey, 300, JSON.stringify(product));
  
  return product;
}

// 실시간 인기 상품 랭킹 (Sorted Set)
// 상품 조회 시 점수 증가
await redis.zincrby('popular:products', 1, productId);

// 상위 10개 인기 상품 조회
const topProducts = await redis.zrevrange('popular:products', 0, 9, 'WITHSCORES');

// 조회수 원자적 증가 (Race Condition 없음!)
await redis.incr(`post:views:${postId}`);
// 주기적으로 DB에 동기화 (배치 작업)

성능 최적화 실전

슬로우 쿼리 발견부터 인덱스 튜닝까지 — 실무 트러블슈팅 완전 가이드

-- 슬로우 쿼리 로그 활성화 (MySQL)
SET GLOBAL slow_query_log = 'ON';
SET GLOBAL long_query_time = 1;  -- 1초 이상 걸리는 쿼리 기록
SET GLOBAL slow_query_log_file = '/var/log/mysql/slow.log';
SET GLOBAL log_queries_not_using_indexes = 'ON';

-- 현재 실행 중인 쿼리 목록
SHOW FULL PROCESSLIST;

-- 슬로우 쿼리 실행계획 분석
EXPLAIN FORMAT=JSON
SELECT * FROM orders o
INNER JOIN order_items oi ON o.id = oi.order_id
WHERE o.user_id = 12345 AND o.status = 'paid';

-- EXPLAIN 결과에서 확인할 핵심 컬럼:
-- type: ALL(풀스캔🔴) | ref(인덱스🟡) | const(최적🟢)
-- rows: 스캔 행 수 (작을수록 좋음)
-- Extra: Using filesort(정렬 느림🔴), Using index(커버링 인덱스🟢)

⚠️ 인덱스 사용을 방해하는 패턴 (무조건 피해야 함!)

배포 & 운영 자동화

Docker로 DB 환경 구성, 마이그레이션 자동화, CI/CD 파이프라인 구축

# docker-compose.yml (블로그/쇼핑몰 개발 환경)
version: '3.8'

services:
  mysql:
    image: mysql:8.0
    container_name: project_mysql
    ports:
      - "3306:3306"
    environment:
      MYSQL_ROOT_PASSWORD: rootpassword
      MYSQL_DATABASE: blog_db
      MYSQL_USER: developer
      MYSQL_PASSWORD: devpassword
    volumes:
      - mysql_data:/var/lib/mysql
      - ./init-scripts:/docker-entrypoint-initdb.d  # 초기 DDL 자동 실행
    command: --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
      interval: 30s
      timeout: 10s
      retries: 5

  redis:
    image: redis:7-alpine
    container_name: project_redis
    ports:
      - "6379:6379"
    command: redis-server --appendonly yes --maxmemory 256mb --maxmemory-policy allkeys-lru
    volumes:
      - redis_data:/data

  phpmyadmin:  # DB 관리 GUI (개발용)
    image: phpmyadmin/phpmyadmin
    ports:
      - "8080:80"
    environment:
      PMA_HOST: mysql
      PMA_USER: developer
      PMA_PASSWORD: devpassword

volumes:
  mysql_data:
  redis_data:

// Prisma 마이그레이션 워크플로우

// 1. schema.prisma 수정 (새 컬럼 추가)
model Post {
  id          Int      @id @default(autoincrement())
  title       String
  // 새로 추가!
  readingTime Int?     // 예상 읽기 시간 (분)
  updatedAt   DateTime @updatedAt
}

// 2. 마이그레이션 생성
$ npx prisma migrate dev --name add_reading_time_to_posts

// 3. 프로덕션 배포 시
$ npx prisma migrate deploy  # 미실행 마이그레이션만 자동 적용

// Sequelize 마이그레이션
module.exports = {
  async up(queryInterface, Sequelize) {
    await queryInterface.addColumn('posts', 'reading_time', {
      type: Sequelize.INTEGER,
      allowNull: true
    });
  },
  async down(queryInterface) {
    await queryInterface.removeColumn('posts', 'reading_time');
  }
};

$ npx sequelize-cli db:migrate        # 마이그레이션 실행
$ npx sequelize-cli db:migrate:undo   # 롤백

포트폴리오 작성 & 코드리뷰 포인트

프로젝트를 취업/이직에 활용하는 방법 — DB 개발자로 어필하는 전략

현업 면접 Q&A 파이널 TOP 20

실제 면접에서 나온 질문들 + 면접관을 감동시키는 답변 전략

📋 DatabaseDevGuide0007 최종 학습 체크리스트

DatabaseDevGuide 완주!

DB개념 · SQL기초 · SQL심화 · DB설계 · NoSQL · 실전활용 · 실전프로젝트
현업 DB 개발자가 되기 위한 모든 내용을 마스터했습니다!