MongoDB 완전 가이드 - NoSQL 실전

services:
  mongodb:
    image: mongo:7.0
    container_name: my-mongodb
    environment:
      MONGO_INITDB_ROOT_USERNAME: admin
      MONGO_INITDB_ROOT_PASSWORD: password
      MONGO_INITDB_DATABASE: mydb
    ports:
      - "27017:27017"
    volumes:
      - mongodb_data:/data/db

volumes:
  mongodb_data:

docker-compose up -d

# mongosh 접속
docker exec -it my-mongodb mongosh -u admin -p password

show dbs           // DB 목록
use mydb           // DB 선택/생성
show collections   // 컬렉션 목록
db.stats()         // DB 통계

{
  "_id": "ObjectId('..')",
  "title": "MongoDB 가이드",
  "author": {
    "id": "user_123",
    "name": "junetapa"
  },
  "tags": ["MongoDB", "NoSQL", "DB"],
  "meta": {
    "views": 1500,
    "likes": 42
  },
  "comments": [],
  "published": true,
  "createdAt": "ISODate('2026-02-19')"
}

// Create
db.posts.insertOne({
  title: "MongoDB 완전 가이드",
  author: { id: "user_1", name: "junetapa" },
  tags: ["MongoDB", "NoSQL"],
  views: 0,
  published: true,
  createdAt: new Date()
});

db.posts.insertMany([
  { title: "첫 번째 포스트", tags: ["intro"], published: true },
  { title: "두 번째 포스트", tags: ["advanced"], published: false }
]);

// Read
db.posts.find({ published: true })
  .sort({ createdAt: -1 })
  .limit(20)
  .skip(0);

// 특정 필드만 반환 (projection)
db.posts.find(
  { published: true },
  { title: 1, tags: 1, createdAt: 1, _id: 0 }
);

// Update
db.posts.updateOne(
  { _id: ObjectId("..") },
  {
    $set: { title: "수정된 제목", updatedAt: new Date() },
    $inc: { "meta.views": 1 }
  }
);

// 배열에 항목 추가
db.posts.updateOne(
  { _id: ObjectId("..") },
  { $push: { tags: "newTag" } }
);

// Upsert
db.users.updateOne(
  { email: "hong@example.com" },
  { $set: { name: "홍길동", updatedAt: new Date() } },
  { upsert: true }
);

// Delete
db.posts.deleteOne({ _id: ObjectId("..") });
db.posts.deleteMany({ published: false, createdAt: { $lt: new Date("2025-01-01") } });

// 비교 연산자
db.posts.find({ views: { $gte: 100, $lt: 1000 } });
db.posts.find({ title: { $ne: "삭제됨" } });
db.posts.find({ status: { $in: ["draft", "published"] } });

// 논리 연산자
db.posts.find({
  $and: [
    { published: true },
    { views: { $gte: 50 } }
  ]
});

// 배열 연산자
db.posts.find({ tags: "MongoDB" });           // 배열에 포함
db.posts.find({ tags: { $all: ["DB", "NoSQL"] } }); // 모두 포함
db.posts.find({ "tags.0": "MongoDB" });       // 첫 번째 원소

// 정규식 (대소문자 무관 검색)
db.posts.find({ title: { $regex: /mongodb/i } });

// null/존재 확인
db.posts.find({ deletedAt: null });
db.posts.find({ bio: { $exists: true } });

// 단일 인덱스
db.posts.createIndex({ createdAt: -1 });

// 복합 인덱스 (자주 함께 쓰는 필드)
db.posts.createIndex({ published: 1, createdAt: -1 });

// 고유 인덱스
db.users.createIndex({ email: 1 }, { unique: true });

// 텍스트 인덱스 (전문 검색)
db.posts.createIndex({ title: "text", content: "text" });
db.posts.find({ $text: { $search: "MongoDB 가이드" } });

// TTL 인덱스 (자동 만료)
// 생성 후 7일 뒤 자동 삭제
db.sessions.createIndex({ createdAt: 1 }, { expireAfterSeconds: 604800 });

// 인덱스 목록
db.posts.getIndexes();

// 실행 계획 확인 (SQL의 EXPLAIN ANALYZE)
db.posts.find({ published: true }).sort({ createdAt: -1 }).explain("executionStats");

db.posts.aggregate([
  { $match: { published: true } },             // 필터
  { $group: {
      _id: { $arrayElemAt: ["$tags", 0] },     // 첫 번째 태그로 그룹
      postCount: { $sum: 1 },
      totalViews: { $sum: "$meta.views" },
      avgViews: { $avg: "$meta.views" }
  }},
  { $sort: { totalViews: -1 } },
  { $limit: 10 }
]);

db.posts.aggregate([
  { $match: { published: true } },
  { $lookup: {
      from: "users",
      localField: "author.id",
      foreignField: "_id",
      as: "authorInfo"
  }},
  { $unwind: "$authorInfo" },
  { $project: {
      title: 1,
      "authorInfo.name": 1,
      "authorInfo.email": 1,
      views: "$meta.views",
      createdAt: 1
  }},
  { $sort: { createdAt: -1 } },
  { $limit: 20 }
]);

db.posts.aggregate([
  { $match: { published: true } },
  { $facet: {
    "byMonth": [
      { $group: { _id: { $month: "$createdAt" }, count: { $sum: 1 } } },
      { $sort: { "_id": 1 } }
    ],
    "topPosts": [
      { $sort: { "meta.views": -1 } },
      { $limit: 5 },
      { $project: { title: 1, views: "$meta.views" } }
    ]
  }}
]);

npm install mongoose

import mongoose from 'mongoose';

export async function connectDB() {
  await mongoose.connect(process.env.MONGODB_URI || 'mongodb://localhost:27017/mydb');
  console.log('MongoDB 연결 성공');
}

// models/Post.js
const postSchema = new mongoose.Schema({
  title: { type: String, required: true, maxlength: 500 },
  content: { type: String, required: true },
  author: {
    id: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
    name: { type: String, required: true }
  },
  tags: [{ type: String }],
  meta: {
    views: { type: Number, default: 0 },
    likes: { type: Number, default: 0 }
  },
  published: { type: Boolean, default: false },
  deletedAt: Date
}, {
  timestamps: true  // createdAt, updatedAt 자동 생성
});

// 인덱스 정의
postSchema.index({ published: 1, createdAt: -1 });
postSchema.index({ tags: 1 });
postSchema.index({ title: 'text', content: 'text' });

// 미들웨어 (소프트 삭제)
postSchema.pre('find', function() {
  this.where({ deletedAt: null });
});

export const Post = mongoose.model('Post', postSchema);

// 생성
const post = await Post.create({ title: '제목', content: '내용', author: { id, name } });

// 조회 (페이징)
const posts = await Post.find({ published: true })
  .sort({ createdAt: -1 })
  .limit(20)
  .skip((page - 1) * 20)
  .lean();  // 일반 JS 객체로 반환 (성능 향상)

// populate — 참조 도큐먼트 조인
const post = await Post.findById(id).populate('author.id', 'name email avatar');

// 업데이트
await Post.findByIdAndUpdate(id,
  { $set: { title: '수정 제목' }, $inc: { 'meta.views': 1 } },
  { new: true }  // 업데이트된 도큐먼트 반환
);

pip install pymongo python-dotenv

from pymongo import MongoClient, DESCENDING
from bson import ObjectId
from datetime import datetime
import os

# 연결
client = MongoClient(os.getenv("MONGODB_URI", "mongodb://localhost:27017/"))
db = client["mydb"]
posts = db["posts"]

# 삽입
result = posts.insert_one({
    "title": "MongoDB Python 가이드",
    "tags": ["Python", "MongoDB"],
    "meta": {"views": 0},
    "published": True,
    "createdAt": datetime.utcnow()
})
print(f"삽입된 ID: {result.inserted_id}")

# 조회 (정렬 + 페이징)
cursor = posts.find(
    {"published": True},
    {"title": 1, "tags": 1, "createdAt": 1}
).sort("createdAt", DESCENDING).limit(20)

for post in cursor:
    print(post["title"])

# 업데이트
posts.update_one(
    {"_id": ObjectId("..")},
    {"$inc": {"meta.views": 1}, "$set": {"updatedAt": datetime.utcnow()}}
)

# Aggregation
pipeline = [
    {"$match": {"published": True}},
    {"$group": {"_id": None, "total": {"$sum": 1}, "avgViews": {"$avg": "$meta.views"}}}
]
result = list(posts.aggregate(pipeline))

# Atlas 연결 문자열 (환경변수로 관리)
MONGODB_URI=mongodb+srv://<username>:<password>@cluster0.xxxxx.mongodb.net/mydb?retryWrites=true&w=majority

# 백업 (전체 DB)
mongodump --uri="mongodb://localhost:27017" --out=./backup/

# 특정 컬렉션만 백업
mongodump --uri="mongodb://localhost:27017/mydb" --collection=posts --out=./backup/

# 복원
mongorestore --uri="mongodb://localhost:27017" ./backup/