01 데이터베이스란 무엇인가?

🏪 마트 비유로 이해하기

📊 데이터베이스 종류 한눈에 보기

02 SQL vs NoSQL 완전 비교

03 PostgreSQL 완전 정복

🔧 설치 및 초기 설정

# macOS (Homebrew)
brew install postgresql@16
brew services start postgresql@16

# Ubuntu/Debian
sudo apt install postgresql postgresql-contrib
sudo systemctl start postgresql

# 접속 (psql CLI)
psql -U postgres

# 데이터베이스 생성 및 사용자 생성
CREATE DATABASE myapp_db;
CREATE USER myapp_user WITH PASSWORD 'strongpassword123';
GRANT ALL PRIVILEGES ON DATABASE myapp_db TO myapp_user;

# Node.js에서 연결 (.env)
DATABASE_URL="postgresql://myapp_user:strongpassword123@localhost:5432/myapp_db"

📊 PostgreSQL 주요 데이터 타입

04 SQL 문법 완전 마스터

📝 DDL — 테이블 생성/수정/삭제

-- 테이블 생성
CREATE TABLE users (
  id         SERIAL PRIMARY KEY,          -- 자동 증가 기본키
  name       VARCHAR(50) NOT NULL,
  email      VARCHAR(100) UNIQUE NOT NULL,
  password   VARCHAR(255) NOT NULL,
  role       VARCHAR(20) DEFAULT 'USER',
  is_active  BOOLEAN DEFAULT TRUE,
  created_at TIMESTAMP DEFAULT NOW(),
  updated_at TIMESTAMP DEFAULT NOW()
);

-- 외래키 연결 (다른 테이블 참조)
CREATE TABLE posts (
  id         SERIAL PRIMARY KEY,
  title      VARCHAR(200) NOT NULL,
  content    TEXT,
  user_id    INTEGER REFERENCES users(id) ON DELETE CASCADE,
  view_count INTEGER DEFAULT 0,
  created_at TIMESTAMP DEFAULT NOW()
);

-- 컬럼 추가
ALTER TABLE users ADD COLUMN phone VARCHAR(20);

-- 테이블 삭제
DROP TABLE posts;  -- ⚠️ 되돌릴 수 없음! 신중하게!

🔍 DML — 데이터 조회/삽입/수정/삭제 (CRUD)

-- ====== INSERT (생성) ======
INSERT INTO users (name, email, password, role)
VALUES ('홍길동', 'hong@example.com', 'hashed_password', 'USER')
RETURNING id, name, email;  -- 삽입된 데이터 즉시 반환

-- ====== SELECT (조회) ======
-- 기본 조회
SELECT id, name, email FROM users WHERE is_active = TRUE;

-- 페이지네이션 (현업에서 가장 많이 쓰는 패턴)
SELECT id, name, email, created_at
FROM users
WHERE is_active = TRUE
  AND name ILIKE '%홍%'   -- 대소문자 무시 검색
ORDER BY created_at DESC
LIMIT 10 OFFSET 20;         -- 3페이지 (21~30번째)

-- 집계 함수
SELECT
  COUNT(*) AS total_users,
  COUNT(CASE WHEN role = 'ADMIN' THEN 1 END) AS admin_count,
  AVG(age) AS avg_age,
  MAX(created_at) AS last_joined
FROM users;

-- ====== UPDATE (수정) ======
UPDATE users
SET name = '김길동', updated_at = NOW()
WHERE id = 1
RETURNING *;

-- ====== DELETE (삭제) ======
DELETE FROM users WHERE id = 1;
-- ⚠️ WHERE 절 없으면 전체 삭제! 반드시 확인!

🔗 JOIN — 테이블 연결하기 (현업 핵심!)

-- INNER JOIN: 양쪽 테이블 모두 데이터 있을 때만 반환
SELECT
  p.id, p.title, p.created_at,
  u.name AS author_name,
  u.email AS author_email
FROM posts p
INNER JOIN users u ON p.user_id = u.id
WHERE p.created_at > '2026-01-01'
ORDER BY p.created_at DESC;

-- LEFT JOIN: 왼쪽 테이블은 모두 반환 (오른쪽은 없으면 NULL)
SELECT
  u.name,
  COUNT(p.id) AS post_count
FROM users u
LEFT JOIN posts p ON u.id = p.user_id
GROUP BY u.id, u.name
ORDER BY post_count DESC;

-- 3개 테이블 JOIN (게시글 + 작성자 + 댓글 수)
SELECT
  p.id, p.title,
  u.name AS author,
  COUNT(c.id) AS comment_count,
  COUNT(l.user_id) AS like_count
FROM posts p
INNER JOIN users u ON p.user_id = u.id
LEFT JOIN comments c ON p.id = c.post_id
LEFT JOIN likes l ON p.id = l.post_id
GROUP BY p.id, u.name
ORDER BY like_count DESC
LIMIT 10;

📊 JOIN 종류 시각적 이해

05 데이터 모델링 & 정규화

🔗 테이블 관계 3가지

users (id)
  ↕
profiles (user_id UNIQUE)

users (id)
  ↕
posts (user_id FK)

posts ↔ post_tags ↔ tags

📐 정규화 — 데이터 중복 제거

🏗️ 실전 블로그 DB 설계

-- 사용자 테이블
CREATE TABLE users (
  id         SERIAL PRIMARY KEY,
  name       VARCHAR(50) NOT NULL,
  email      VARCHAR(100) UNIQUE NOT NULL,
  password   VARCHAR(255) NOT NULL,
  role       VARCHAR(20) DEFAULT 'USER' CHECK (role IN ('USER', 'ADMIN')),
  created_at TIMESTAMP DEFAULT NOW()
);

-- 게시글 테이블
CREATE TABLE posts (
  id         SERIAL PRIMARY KEY,
  title      VARCHAR(200) NOT NULL,
  content    TEXT NOT NULL,
  published  BOOLEAN DEFAULT FALSE,
  view_count INTEGER DEFAULT 0,
  user_id    INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
  created_at TIMESTAMP DEFAULT NOW(),
  updated_at TIMESTAMP DEFAULT NOW()
);

-- 댓글 테이블
CREATE TABLE comments (
  id         SERIAL PRIMARY KEY,
  content    TEXT NOT NULL,
  post_id    INTEGER NOT NULL REFERENCES posts(id) ON DELETE CASCADE,
  user_id    INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
  created_at TIMESTAMP DEFAULT NOW()
);

-- 좋아요 테이블 (N:M 복합키)
CREATE TABLE likes (
  user_id INTEGER REFERENCES users(id) ON DELETE CASCADE,
  post_id INTEGER REFERENCES posts(id) ON DELETE CASCADE,
  PRIMARY KEY (user_id, post_id)  -- 중복 좋아요 방지!
);

-- 태그 (N:M 관계)
CREATE TABLE tags (
  id   SERIAL PRIMARY KEY,
  name VARCHAR(50) UNIQUE NOT NULL
);

CREATE TABLE post_tags (
  post_id INTEGER REFERENCES posts(id) ON DELETE CASCADE,
  tag_id  INTEGER REFERENCES tags(id) ON DELETE CASCADE,
  PRIMARY KEY (post_id, tag_id)
);

06 Prisma ORM 완전 정복

🔧 Prisma 설치 및 초기 설정

# 1. Prisma 설치
npm install prisma @prisma/client
npx prisma init   # prisma/ 폴더 + .env 생성

# 2. .env 설정
DATABASE_URL="postgresql://myapp_user:password@localhost:5432/myapp_db"

# 3. 스키마 작성 후 마이그레이션
npx prisma migrate dev --name init    # 개발 환경
npx prisma migrate deploy             # 프로덕션 환경

# 4. Prisma Studio (GUI DB 탐색기)
npx prisma studio   # localhost:5555 에서 DB 조회 가능!

# 5. Prisma Client 재생성 (스키마 변경 후)
npx prisma generate

📝 Prisma 스키마 완전 예시

// prisma/schema.prisma
generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "postgresql"  // "mysql" | "sqlite" | "mongodb"
  url      = env("DATABASE_URL")
}

model User {
  id        Int       @id @default(autoincrement())
  name      String    @db.VarChar(50)
  email     String    @unique @db.VarChar(100)
  password  String
  role      Role      @default(USER)
  isActive  Boolean   @default(true) @map("is_active")
  posts     Post[]
  comments  Comment[]
  likes     Like[]
  createdAt DateTime  @default(now()) @map("created_at")
  updatedAt DateTime  @updatedAt @map("updated_at")

  @@map("users")   // DB 테이블명 매핑
}

model Post {
  id         Int       @id @default(autoincrement())
  title      String    @db.VarChar(200)
  content    String    @db.Text
  published  Boolean   @default(false)
  viewCount  Int       @default(0) @map("view_count")
  author     User      @relation(fields: [userId], references: [id], onDelete: Cascade)
  userId     Int       @map("user_id")
  comments   Comment[]
  likes      Like[]
  tags       PostTag[]
  createdAt  DateTime  @default(now()) @map("created_at")
  updatedAt  DateTime  @updatedAt @map("updated_at")

  @@map("posts")
}

model Comment {
  id        Int      @id @default(autoincrement())
  content   String
  post      Post     @relation(fields: [postId], references: [id], onDelete: Cascade)
  postId    Int      @map("post_id")
  author    User     @relation(fields: [userId], references: [id], onDelete: Cascade)
  userId    Int      @map("user_id")
  createdAt DateTime @default(now()) @map("created_at")

  @@map("comments")
}

model Like {
  user   User @relation(fields: [userId], references: [id], onDelete: Cascade)
  userId Int  @map("user_id")
  post   Post @relation(fields: [postId], references: [id], onDelete: Cascade)
  postId Int  @map("post_id")

  @@id([userId, postId])   // 복합 기본키 (중복 좋아요 방지)
  @@map("likes")
}

enum Role {
  USER
  ADMIN
}

💻 Prisma CRUD 실전 코드

// db/prisma.js — 싱글톤 클라이언트 (중요!)
const { PrismaClient } = require('@prisma/client');

const globalForPrisma = global;
const prisma = globalForPrisma.prisma ??
  new PrismaClient({ log: ['query', 'error'] });

if (process.env.NODE_ENV !== 'production') {
  globalForPrisma.prisma = prisma;  // 개발 시 핫리로드로 연결 폭발 방지
}

module.exports = prisma;

// ====== 실전 CRUD 패턴 ======

// 1. 생성 (Create)
const user = await prisma.user.create({
  data: { name: '홍길동', email: 'hong@e.com', password: hashedPw },
  select: { id: true, name: true, email: true },  // 비밀번호 제외!
});

// 2. 조회 (Read) — 페이지네이션 + 검색
const [posts, total] = await Promise.all([
  prisma.post.findMany({
    where: {
      published: true,
      title: { contains: search, mode: 'insensitive' },  // 대소문자 무시
    },
    include: {
      author: { select: { name: true, email: true } },
      _count: { select: { comments: true, likes: true } },  // 댓글·좋아요 수
    },
    orderBy: { createdAt: 'desc' },
    skip: (page - 1) * limit,
    take: limit,
  }),
  prisma.post.count({ where: { published: true } }),
]);

// 3. 수정 (Update)
const updated = await prisma.post.update({
  where: { id: postId },
  data: { title, content, updatedAt: new Date() },
});

// 4. 삭제 (Delete)
await prisma.post.delete({ where: { id: postId } });

// 5. upsert (있으면 수정, 없으면 생성)
const like = await prisma.like.upsert({
  where: { userId_postId: { userId, postId } },
  create: { userId, postId },
  update: {},  // 이미 있으면 아무 것도 안 함
});

07 MongoDB & Mongoose

📊 PostgreSQL vs MongoDB 언어 비교

🔧 Mongoose 설치 및 연결

npm install mongoose

// db/mongoose.js — MongoDB 연결
const mongoose = require('mongoose');

const connectDB = async () => {
  try {
    await mongoose.connect(process.env.MONGODB_URI, {
      dbName: 'myapp',
    });
    console.log('✅ MongoDB 연결 성공!');
  } catch (err) {
    console.error('❌ MongoDB 연결 실패:', err);
    process.exit(1);
  }
};

module.exports = connectDB;

// .env
MONGODB_URI="mongodb://localhost:27017"
# 또는 MongoDB Atlas (클라우드)
MONGODB_URI="mongodb+srv://user:pass@cluster.mongodb.net/myapp"

📝 Mongoose 스키마 & 모델

// models/User.js
const mongoose = require('mongoose');

const userSchema = new mongoose.Schema({
  name: {
    type: String,
    required: [true, '이름은 필수입니다'],
    trim: true,
    maxlength: 50,
  },
  email: {
    type: String,
    required: [true, '이메일은 필수입니다'],
    unique: true,
    lowercase: true,    // 자동으로 소문자 변환
  },
  password: { type: String, required: true, select: false },  // 기본 조회 제외!
  role: {
    type: String,
    enum: ['USER', 'ADMIN'],
    default: 'USER',
  },
  isActive: { type: Boolean, default: true },
}, {
  timestamps: true,         // createdAt, updatedAt 자동 생성
  toJSON: { virtuals: true },
});

// 가상 필드 (DB에 저장 안 됨)
userSchema.virtual('postCount', {
  ref: 'Post',
  localField: '_id',
  foreignField: 'author',
  count: true,
});

module.exports = mongoose.model('User', userSchema);

// models/Post.js
const postSchema = new mongoose.Schema({
  title:     { type: String, required: true, maxlength: 200 },
  content:   { type: String, required: true },
  published: { type: Boolean, default: false },
  viewCount: { type: Number, default: 0 },
  author:    { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
  tags:      [{ type: String, trim: true }],  // 배열로 태그 저장
  likes:     [{ type: mongoose.Schema.Types.ObjectId, ref: 'User' }],
}, { timestamps: true });

module.exports = mongoose.model('Post', postSchema);

// ====== Mongoose CRUD ======
const Post = require('./models/Post');

// 생성
const post = await Post.create({ title, content, author: userId });

// 조회 (작성자 정보 포함)
const posts = await Post.find({ published: true })
  .populate('author', 'name email')  // JOIN처럼 author 정보 채우기
  .sort({ createdAt: -1 })
  .limit(10)
  .skip((page - 1) * 10);

// 수정
await Post.findByIdAndUpdate(postId, { title, content }, { new: true });

// 삭제
await Post.findByIdAndDelete(postId);

08 인덱스 & 쿼리 최적화

🚀 인덱스 생성 및 관리

-- 단일 컬럼 인덱스 (WHERE email = ? 같은 조건에 사용)
CREATE INDEX idx_users_email ON users(email);

-- 복합 인덱스 (자주 함께 검색하는 컬럼)
-- 예: WHERE user_id = ? AND published = TRUE
CREATE INDEX idx_posts_user_published ON posts(user_id, published);

-- 유니크 인덱스 (중복 방지 + 빠른 검색)
CREATE UNIQUE INDEX idx_users_email_unique ON users(email);

-- 부분 인덱스 (특정 조건의 데이터만 인덱싱)
CREATE INDEX idx_posts_published ON posts(created_at)
  WHERE published = TRUE;  -- 공개 게시글만 인덱싱

-- 인덱스 목록 확인
SELECT * FROM pg_indexes WHERE tablename = 'posts';

-- 쿼리 실행 계획 확인 (느린 쿼리 분석 필수!)
EXPLAIN ANALYZE
SELECT * FROM users WHERE email = 'hong@example.com';
-- "Index Scan" → 인덱스 사용 중 (빠름!)
-- "Seq Scan" → 전체 테이블 스캔 (느림, 인덱스 추가 필요!)

📊 인덱스 사용 가이드라인

⚡ 쿼리 최적화 핵심 팁

-- ❌ 나쁜 예: SELECT * (필요 없는 컬럼까지 모두 가져옴)
SELECT * FROM users;

-- ✅ 좋은 예: 필요한 컬럼만 명시
SELECT id, name, email FROM users;

-- ❌ 나쁜 예: 인덱스 컬럼에 함수 사용 (인덱스 무력화!)
SELECT * FROM users WHERE LOWER(email) = 'hong@e.com';

-- ✅ 좋은 예: 저장 시 소문자로 저장하거나 citext 타입 사용
SELECT * FROM users WHERE email = 'hong@e.com';

-- ❌ 나쁜 예: LIKE %검색어% (앞에 %가 있으면 인덱스 무력화)
SELECT * FROM posts WHERE title LIKE '%Node%';

-- ✅ 좋은 예: 전문 검색 인덱스 사용 (PostgreSQL)
CREATE INDEX idx_posts_title_fts ON posts USING gin(to_tsvector('english', title));
SELECT * FROM posts WHERE to_tsvector('english', title) @@ to_tsquery('Node');

-- Prisma에서 N+1 방지 (가장 흔한 실수!)
// ❌ N+1 문제
const posts = await prisma.post.findMany();
for (const post of posts) {
  post.author = await prisma.user.findUnique({ where: { id: post.userId } });
  // 게시글 100개 → DB 쿼리 101번!
}

// ✅ include로 한 번에
const posts = await prisma.post.findMany({
  include: { author: { select: { name: true } } }
  // DB 쿼리 1번으로 완료!
});

09 트랜잭션 & ACID

🏦 ACID 4가지 특성

💻 트랜잭션 실전 코드

// SQL 직접 트랜잭션
BEGIN;
  UPDATE accounts SET balance = balance - 100000 WHERE id = 1;
  UPDATE accounts SET balance = balance + 100000 WHERE id = 2;
COMMIT;  -- 성공 시 반영
-- ROLLBACK;  -- 실패 시 취소

// Prisma 트랜잭션 — 방법 1: $transaction 배열
const [debit, credit] = await prisma.$transaction([
  prisma.account.update({
    where: { id: fromAccountId },
    data: { balance: { decrement: amount } },
  }),
  prisma.account.update({
    where: { id: toAccountId },
    data: { balance: { increment: amount } },
  }),
]);
// 둘 중 하나라도 실패하면 둘 다 롤백!

// Prisma 트랜잭션 — 방법 2: interactive (복잡한 로직에 사용)
const result = await prisma.$transaction(async (tx) => {
  // tx는 트랜잭션 범위 내의 Prisma 클라이언트
  const sender = await tx.account.findUnique({ where: { id: fromAccountId } });
  
  if (sender.balance < amount) {
    throw new Error('잔액 부족');  // 에러 발생 시 자동 롤백!
  }

  await tx.account.update({
    where: { id: fromAccountId },
    data: { balance: { decrement: amount } },
  });

  await tx.account.update({
    where: { id: toAccountId },
    data: { balance: { increment: amount } },
  });

  await tx.transferLog.create({
    data: { fromAccountId, toAccountId, amount },
  });

  return { success: true, message: '송금 완료' };
});

10 Redis 캐싱 전략

📦 Redis 주요 사용 사례

🔧 Redis 설치 및 Node.js 연결

# Redis 설치
brew install redis           # macOS
brew services start redis    # 서비스 시작

# 또는 Docker
docker run -d -p 6379:6379 redis:alpine

# Node.js 패키지 설치
npm install ioredis

// db/redis.js — Redis 클라이언트 설정
const Redis = require('ioredis');

const redis = new Redis({
  host: process.env.REDIS_HOST || 'localhost',
  port: process.env.REDIS_PORT || 6379,
  password: process.env.REDIS_PASSWORD,
  lazyConnect: true,
  retryStrategy: (times) => Math.min(times * 50, 2000),  // 재연결 전략
});

redis.on('connect', () => console.log('✅ Redis 연결 성공!'));
redis.on('error', (err) => console.error('❌ Redis 오류:', err));

module.exports = redis;

💻 캐싱 패턴 실전 코드

// utils/cache.js — 캐싱 유틸리티
const redis = require('../db/redis');

/**
 * Cache-Aside 패턴 (가장 흔히 사용)
 * 캐시에 있으면 캐시에서, 없으면 DB에서 가져와 캐시에 저장
 */
const cacheGet = async (key, fetchFn, ttl = 3600) => {
  // 1. 캐시 조회
  const cached = await redis.get(key);
  if (cached) {
    return JSON.parse(cached);  // 캐시 히트!
  }
  // 2. DB 조회
  const data = await fetchFn();
  // 3. 캐시 저장 (TTL: 초 단위)
  await redis.setex(key, ttl, JSON.stringify(data));
  return data;
};

const cacheDelete = async (key) => redis.del(key);
const cacheDeletePattern = async (pattern) => {
  const keys = await redis.keys(pattern);
  if (keys.length) await redis.del(...keys);
};

module.exports = { cacheGet, cacheDelete, cacheDeletePattern };

// services/post.service.js — 캐시 적용 예시
const { cacheGet, cacheDelete } = require('../utils/cache');

const getPostById = async (id) => {
  return cacheGet(
    `post:${id}`,  // 캐시 키
    () => prisma.post.findUnique({ where: { id }, include: { author: true } }),
    1800  // 30분 TTL
  );
};

const updatePost = async (id, data) => {
  const post = await prisma.post.update({ where: { id }, data });
  await cacheDelete(`post:${id}`);  // 수정 시 캐시 삭제 (Cache Invalidation)
  return post;
};

// 이메일 인증 코드 저장 (5분 후 자동 만료)
const saveVerifyCode = async (email, code) => {
  await redis.setex(`verify:${email}`, 300, code);
};

const checkVerifyCode = async (email, code) => {
  const stored = await redis.get(`verify:${email}`);
  return stored === code;
};

11 데이터베이스 보안

🔒 보안 필수 체크리스트

// ❌ SQL Injection 취약 코드 (절대 이렇게 하지 마세요!)
const query = `SELECT * FROM users WHERE email = '${email}'`;
// 해커가 email에 "' OR '1'='1" 입력하면 모든 사용자 조회됨!

// ✅ 안전한 방법 1: Prisma ORM (자동으로 안전하게 처리)
const user = await prisma.user.findUnique({ where: { email } });

// ✅ 안전한 방법 2: Prepared Statement (pg 라이브러리)
const result = await pool.query(
  'SELECT * FROM users WHERE email = $1',
  [email]  // 파라미터 바인딩
);

12 현업/면접 단골 Q&A