MongoDB完整学习指南 - 从入门到精通

关系型数据库    MongoDB
数据库         数据库(Database)
表(Table)      集合(Collection)
行(Row)        文档(Document)
列(Column)     字段(Field)
索引           索引
表连接         嵌入文档或引用
主键           主键（MongoDB提供了默认的_id字段）

// 基本数据类型示例
{
  "name": "张三",                    // String
  "age": 25,                        // Number (Int32)
  "salary": 8500.50,               // Number (Double)
  "isActive": true,                // Boolean
  "birthDate": new Date(),         // Date
  "address": {                     // Object (嵌套文档)
    "city": "北京",
    "district": "朝阳区"
  },
  "skills": ["Java", "Python", "MongoDB"],  // Array
  "avatar": null,                  // Null
  "userId": ObjectId("..."),       // ObjectId
  "metadata": {                    // Mixed
    "created": new Date(),
    "tags": ["developer", "backend"]
  }
}

# 方法一：使用rs.stepDown()命令（推荐）
# 连接到当前的主节点（mongodb-0），执行：
# 让主节点主动退位，60秒内不参与选举
rs.stepDown(60)

# 这个命令会：
1. 让mongodb-1. 0主动放弃主节点身份
2. 在60秒内不参与新的选举
3. 触发其他节点进行选举

# 方法二：临时降低优先级
# 获取当前配置
cfg = rs.conf()

# 将mongodb-0的优先级设为0（不能成为主节点）
cfg.members[0].priority = 0

# 重新配置副本集
rs.reconfig(cfg)

# 观察选举过程

# 检查副本集状态
rs.status()

# 查看选举统计
rs.printReplicationInfo()


# 先切换到admin数据库
use admin

# 实时监控状态变化
while(true) {
  try {
    var status = rs.isMaster()
    var replStatus = rs.status()
    var myState = replStatus.myState
    print(new Date() + ": isMaster=" + status.ismaster + 
          " | primary=" + (status.primary || "NONE") + 
          " | myState=" + myState)
  } catch(e) {
    print(new Date() + ": Error - " + e.message)
  }
  sleep(1000)
}

# 立即检查状态
rs.status()

# 再次检查谁是新主节点
rs.isMaster()

Client --> mongod

        +-------------------+
        |    Client         |
        +-------------------+
             |  |
             |  |
       +-----+  +------+
       |              |
   Primary       Secondary(s)
       |              |
   Oplog同步         读操作（可选）

            +-------------+
            |   Client    |
            +-------------+
                   |
                 mongos（路由）
                   |
       +-----------+-----------+
       |                       |
Config Server           Config Server
       |                       |
  +---------+           +----------+
  | Shard 1 |           | Shard 2  |
  |(Replica)|           |(Replica) |
  +---------+           +----------+

# 1. 下载MongoDB Community Server
# 访问：https://www.mongodb.com/try/download/community

# 2. 安装后设置环境变量
# 将 C:\Program Files\MongoDB\Server\7.0\bin 添加到PATH

# 3. 创建数据目录
mkdir C:\data\db

# 4. 启动MongoDB服务
mongod --dbpath C:\data\db

# 1. 导入公钥
wget -qO - https://www.mongodb.org/static/pgp/server-7.0.asc | sudo apt-key add -

# 2. 创建源列表文件
echo "deb [ arch=amd64,arm64 ] https://repo.mongodb.org/apt/ubuntu focal/mongodb-org/7.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-7.0.list

# 3. 更新包数据库
sudo apt-get update

# 4. 安装MongoDB
sudo apt-get install -y mongodb-org

# 5. 启动MongoDB服务
sudo systemctl start mongod
sudo systemctl enable mongod

# 拉取MongoDB镜像
docker pull mongo:latest

# 运行MongoDB容器
docker run --name mongodb -p 27017:27017 -d mongo:latest

# 连接到MongoDB
docker exec -it mongodb mongosh

# architecture 可选择：standalone, replicaset
    # standalone：单例模式
    # replicaset：副本集模式
# arbiter.enabled：是否启用仲裁节点、当节点数为偶数时，需要启用仲裁节点，仲裁节点不存储数据，只参与选举
# replicaCount：副本集数量
# auth.enabled：是否启用认证
# auth.rootPassword：root密码
# backup.enabled：是否启用备份
# metrics.enabled：是否启用监控
# serviceMonitor.enabled：是否启用ServiceMonitor

# 单例模式
helm upgrade --install mongodb oci://registry-1.docker.io/bitnamicharts/mongodb \
  -n mongodb \
  --create-namespace \
  --set global.storageClass="nfs" \
  --set architecture="standalone" \
  --set auth.enabled=true \
  --set auth.rootPassword="your-password" \
  --set replicaCount=1 \
  --set backup.enabled=true \
  --set metrics.enabled=true \
  --set serviceMonitor.enabled=false

# 副本集模式
helm upgrade --install mongodb oci://registry-1.docker.io/bitnamicharts/mongodb \
  -n mongodb \
  --create-namespace \
  --set global.storageClass="nfs" \
  --set architecture="replicaset" \
  --set auth.enabled=true \
  --set auth.rootPassword="your-password" \
  --set replicaCount=2 \
  --set arbiter.enabled=true \
  --set backup.enabled=true \
  --set metrics.enabled=true \
  --set serviceMonitor.enabled=false

# 高性能部署
# MongoDB 的 wiredTigerCacheSizeGB 参数用于配置 WiredTiger 存储引擎的内存缓存大小，直接影响数据库性能
# 专用 MongoDB 服务器：分配 ‌60%-80%‌ 物理内存
# 云服务器：分配 50%-60% 物理内存
helm upgrade --install mongodb oci://registry-1.docker.io/bitnamicharts/mongodb \
  -n mongodb \
  --create-namespace \
  --set global.storageClass="nfs" \
  --set architecture="replicaset" \
  --set auth.enabled=true \
  --set auth.rootPassword="your-password" \
  --set replicaCount=2 \
  --set arbiter.enabled=true \
  --set backup.enabled=true \
  --set metrics.enabled=true \
  --set serviceMonitor.enabled=false \
  --set resources.requests.cpu=4 \  
  --set resources.requests.memory="16Gi" \
  --set resources.limits.cpu=4 \
  --set resources.limits.memory="16Gi" \
  --set-string extraFlags[0]="--wiredTigerCacheSizeGB=8"

// 使用mongosh连接
mongosh "mongodb://localhost:27017"

// 或指定数据库
mongosh "mongodb://localhost:27017/myapp"

// 查看所有数据库
show dbs

// 创建/切换数据库
use myapp

// 查看当前数据库
db

// 删除数据库
db.dropDatabase()

// 查看数据库状态
db.stats()

// 创建集合
db.createCollection("users")

// 查看所有集合
show collections

// 删除集合
db.users.drop()

// 重命名集合
db.users.renameCollection("members")

// 插入单个文档
db.users.insertOne({
  name: "张三",
  age: 25,
  email: "zhangsan@example.com",
  skills: ["JavaScript", "Python"],
  address: {
    city: "北京",
    district: "朝阳区"
  },
  createdAt: new Date()
})

// 插入多个文档
db.users.insertMany([
  {
    name: "李四",
    age: 28,
    email: "lisi@example.com",
    skills: ["Java", "Spring"],
    department: "后端开发"
  },
  {
    name: "王五",
    age: 30,
    email: "wangwu@example.com",
    skills: ["React", "Vue"],
    department: "前端开发"
  }
])

// 批量插入的返回结果
{
  "acknowledged": true,
  "insertedIds": [
    ObjectId("..."),
    ObjectId("...")
  ]
}

// 查询所有文档
db.users.find()

// 格式化输出
db.users.find().pretty()

// 查询指定条件
db.users.findOne({name: "张三"})

// 条件查询
db.users.find({age: {$gte: 25}})  // 年龄大于等于25

// 多条件查询
db.users.find({
  age: {$gte: 25, $lt: 30},
  department: "后端开发"
})

// 正则表达式查询
db.users.find({name: /^张/})  // 姓张的用户

// 数组字段查询
db.users.find({skills: "JavaScript"})  // 技能包含JavaScript

// 嵌套文档查询
db.users.find({"address.city": "北京"})

// 更新单个文档
db.users.updateOne(
  {name: "张三"},  // 查询条件
  {
    $set: {
      age: 26,
      email: "zhangsan_new@example.com"
    },
    $push: {
      skills: "MongoDB"
    }
  }
)

// 更新多个文档
db.users.updateMany(
  {department: "前端开发"},
  {
    $set: {
      level: "高级"
    }
  }
)

// 替换文档
db.users.replaceOne(
  {name: "李四"},
  {
    name: "李四",
    age: 29,
    email: "lisi_updated@example.com",
    skills: ["Java", "Spring", "MongoDB"],
    department: "全栈开发",
    updatedAt: new Date()
  }
)

// 更新操作符
db.users.updateOne(
  {name: "王五"},
  {
    $inc: {age: 1},           // 递增
    $unset: {department: ""},  // 删除字段
    $addToSet: {skills: "Node.js"},  // 向数组添加唯一值
    $currentDate: {lastModified: true}  // 设置当前日期
  }
)

// 删除单个文档
db.users.deleteOne({name: "张三"})

// 删除多个文档
db.users.deleteMany({age: {$lt: 25}})

// 删除所有文档
db.users.deleteMany({})

// 等于
db.products.find({price: 100})

// 不等于
db.products.find({price: {$ne: 100}})

// 大于
db.products.find({price: {$gt: 100}})

// 大于等于
db.products.find({price: {$gte: 100}})

// 小于
db.products.find({price: {$lt: 200}})

// 小于等于
db.products.find({price: {$lte: 200}})

// 在指定值内
db.products.find({category: {$in: ["电子", "图书"]}})

// 不在指定值内
db.products.find({category: {$nin: ["电子", "图书"]}})

// AND 查询（默认）
db.products.find({
  price: {$gte: 100, $lte: 500},
  category: "电子"
})

// 显式 AND
db.products.find({
  $and: [
    {price: {$gte: 100}},
    {category: "电子"}
  ]
})

// OR 查询
db.products.find({
  $or: [
    {price: {$lt: 50}},
    {category: "图书"}
  ]
})

// NOT 查询
db.products.find({
  price: {$not: {$gt: 100}}
})

// NOR 查询（都不满足）
db.products.find({
  $nor: [
    {price: {$lt: 50}},
    {category: "电子"}
  ]
})

// 准备数据
db.students.insertMany([
  {
    name: "张三",
    grades: [85, 90, 78],
    subjects: ["数学", "物理", "化学"]
  },
  {
    name: "李四",
    grades: [92, 88, 95],
    subjects: ["数学", "英语", "历史"]
  }
])

// 查询数组包含特定值
db.students.find({subjects: "数学"})

// 查询数组包含所有指定值
db.students.find({subjects: {$all: ["数学", "物理"]}})

// 查询数组大小
db.students.find({grades: {$size: 3}})

// 查询数组元素范围
db.students.find({grades: {$elemMatch: {$gte: 85, $lte: 95}}})

// 数组索引查询
db.students.find({"grades.0": {$gte: 90}})  // 第一个成绩大于等于90

// 只返回指定字段
db.users.find({}, {name: 1, age: 1})

// 排除指定字段
db.users.find({}, {_id: 0, password: 0})

// 数组切片
db.students.find({}, {
  name: 1,
  grades: {$slice: 2}  // 只返回前2个成绩
})

// 数组元素匹配位置
db.students.find(
  {grades: {$gte: 90}},
  {name: 1, "grades.$": 1}  // 只返回匹配的数组元素
)

// 排序
db.products.find().sort({price: 1})    // 升序
db.products.find().sort({price: -1})   // 降序

// 多字段排序
db.products.find().sort({category: 1, price: -1})

// 分页
db.products.find()
  .sort({_id: 1})
  .limit(10)     // 限制返回10条
  .skip(20)      // 跳过前20条

// 计算总数
db.products.countDocuments({price: {$gte: 100}})

// 查看集合的索引
db.users.getIndexes()

// 创建单字段索引
db.users.createIndex({name: 1})    // 升序索引
db.users.createIndex({age: -1})    // 降序索引

// 创建复合索引
db.users.createIndex({age: 1, name: 1})

// 创建唯一索引
db.users.createIndex({email: 1}, {unique: true})

// 创建稀疏索引（跳过没有该字段的文档）
db.users.createIndex({phone: 1}, {sparse: true})

// 创建TTL索引（生存时间索引）
db.sessions.createIndex(
  {createdAt: 1},
  {expireAfterSeconds: 3600}  // 1小时后过期
)

// 1. 文本索引
db.articles.createIndex({
  title: "text",
  content: "text"
})

// 文本搜索
db.articles.find({$text: {$search: "MongoDB 教程"}})

// 2. 地理空间索引
db.locations.createIndex({location: "2dsphere"})

// 地理查询
db.locations.find({
  location: {
    $near: {
      $geometry: {type: "Point", coordinates: [116.4074, 39.9042]},
      $maxDistance: 1000  // 1000米内
    }
  }
})

// 3. 哈希索引（分片键常用）
db.users.createIndex({userId: "hashed"})

// 查看查询执行计划
db.users.find({age: 25}).explain("executionStats")

// 强制使用指定索引
db.users.find({age: 25}).hint({age: 1})

// 查看索引使用统计
db.users.aggregate([{$indexStats: {}}])

// 删除索引
db.users.dropIndex({age: 1})

// 删除所有索引（除了_id）
db.users.dropIndexes()

// 复合索引的字段顺序很重要
// 好的顺序：相等查询 -> 范围查询 -> 排序
db.orders.createIndex({
  status: 1,        // 相等查询
  createdAt: 1,     // 范围查询
  amount: -1        // 排序
})

// 查询示例
db.orders.find({
  status: "completed",
  createdAt: {$gte: new Date("2024-01-01")}
}).sort({amount: -1})

// 基本聚合管道结构
db.orders.aggregate([
  {$match: {status: "completed"}},    // 筛选阶段
  {$group: {                          // 分组阶段
    _id: "$customerId",
    totalAmount: {$sum: "$amount"},
    orderCount: {$sum: 1}
  }},
  {$sort: {totalAmount: -1}},         // 排序阶段
  {$limit: 10}                        // 限制阶段
])

// 准备测试数据
db.sales.insertMany([
  {
    _id: 1,
    product: "iPhone",
    category: "electronics",
    price: 999,
    quantity: 2,
    date: new Date("2024-01-15"),
    salesperson: "张三"
  },
  {
    _id: 2,
    product: "MacBook",
    category: "electronics", 
    price: 1999,
    quantity: 1,
    date: new Date("2024-01-20"),
    salesperson: "李四"
  },
  {
    _id: 3,
    product: "Java编程思想",
    category: "books",
    price: 89,
    quantity: 5,
    date: new Date("2024-02-01"),
    salesperson: "张三"
  }
])

// $match - 筛选文档
db.sales.aggregate([
  {$match: {category: "electronics"}}
])

// $group - 分组聚合
db.sales.aggregate([
  {$group: {
    _id: "$category",
    totalRevenue: {$sum: {$multiply: ["$price", "$quantity"]}},
    avgPrice: {$avg: "$price"},
    maxPrice: {$max: "$price"},
    minPrice: {$min: "$price"},
    count: {$sum: 1}
  }}
])

// $project - 字段投影和计算
db.sales.aggregate([
  {$project: {
    product: 1,
    price: 1,
    quantity: 1,
    revenue: {$multiply: ["$price", "$quantity"]},
    discountPrice: {$multiply: ["$price", 0.9]},
    year: {$year: "$date"},
    month: {$month: "$date"}
  }}
])

// $sort - 排序
db.sales.aggregate([
  {$project: {
    product: 1,
    revenue: {$multiply: ["$price", "$quantity"]}
  }},
  {$sort: {revenue: -1}}
])

// $limit 和 $skip - 分页
db.sales.aggregate([
  {$sort: {date: -1}},
  {$skip: 1},
  {$limit: 2}
])

// $unwind - 展开数组
db.articles.insertOne({
  title: "MongoDB教程",
  tags: ["数据库", "NoSQL", "MongoDB"],
  author: "技术专家"
})

db.articles.aggregate([
  {$unwind: "$tags"},
  {$group: {
    _id: "$tags",
    count: {$sum: 1}
  }}
])

// $lookup - 关联查询（类似SQL的JOIN）
// 假设有用户和订单两个集合
db.users.insertMany([
  {_id: 1, name: "张三", email: "zhang@example.com"},
  {_id: 2, name: "李四", email: "li@example.com"}
])

db.orders.insertMany([
  {_id: 1, userId: 1, product: "iPhone", amount: 999},
  {_id: 2, userId: 1, product: "iPad", amount: 699},
  {_id: 3, userId: 2, product: "MacBook", amount: 1999}
])

db.users.aggregate([
  {$lookup: {
    from: "orders",           // 关联的集合
    localField: "_id",        // 本集合的字段
    foreignField: "userId",   // 关联集合的字段
    as: "userOrders"          // 结果字段名
  }},
  {$project: {
    name: 1,
    email: 1,
    totalOrders: {$size: "$userOrders"},
    totalSpent: {$sum: "$userOrders.amount"}
  }}
])

// $facet - 多维度聚合
db.sales.aggregate([
  {$facet: {
    "byCategory": [
      {$group: {
        _id: "$category",
        total: {$sum: {$multiply: ["$price", "$quantity"]}}
      }}
    ],
    "bySalesperson": [
      {$group: {
        _id: "$salesperson", 
        total: {$sum: {$multiply: ["$price", "$quantity"]}}
      }}
    ],
    "priceRange": [
      {$bucket: {
        groupBy: "$price",
        boundaries: [0, 100, 500, 1000, 2000],
        default: "other",
        output: {count: {$sum: 1}}
      }}
    ]
  }}
])

// $addFields - 添加计算字段
db.sales.aggregate([
  {$addFields: {
    revenue: {$multiply: ["$price", "$quantity"]},
    season: {
      $switch: {
        branches: [
          {case: {$in: [{$month: "$date"}, [3, 4, 5]]}, then: "春季"},
          {case: {$in: [{$month: "$date"}, [6, 7, 8]]}, then: "夏季"},
          {case: {$in: [{$month: "$date"}, [9, 10, 11]]}, then: "秋季"}
        ],
        default: "冬季"
      }
    }
  }}
])

// 条件表达式
db.students.aggregate([
  {$project: {
    name: 1,
    score: 1,
    grade: {
      $switch: {
        branches: [
          {case: {$gte: ["$score", 90]}, then: "A"},
          {case: {$gte: ["$score", 80]}, then: "B"},
          {case: {$gte: ["$score", 70]}, then: "C"}
        ],
        default: "D"
      }
    },
    pass: {$cond: {if: {$gte: ["$score", 60]}, then: "通过", else: "不通过"}}
  }}
])

// 数组表达式
db.surveys.aggregate([
  {$project: {
    answers: 1,
    answerCount: {$size: "$answers"},
    firstAnswer: {$arrayElemAt: ["$answers", 0]},
    hasAnswers: {$gt: [{$size: "$answers"}, 0]},
    avgRating: {$avg: "$answers.rating"}
  }}
])

// 字符串表达式  
db.users.aggregate([
  {$project: {
    fullName: {$concat: ["$firstName", " ", "$lastName"]},
    nameLength: {$strLenCP: "$name"},
    upperName: {$toUpper: "$name"},
    emailDomain: {
      $arrayElemAt: [
        {$split: ["$email", "@"]}, 1
      ]
    }
  }}
])

// 复制集配置示例
rs.initiate({
  _id: "myReplicaSet",
  members: [
    {_id: 0, host: "mongodb1.example.com:27017"},
    {_id: 1, host: "mongodb2.example.com:27017"},  
    {_id: 2, host: "mongodb3.example.com:27017"}
  ]
})

// 查看复制集状态
rs.status()

// 添加成员
rs.add("mongodb4.example.com:27017")

// 移除成员
rs.remove("mongodb4.example.com:27017")

// 设置读偏好
db.users.find().readPref("secondary")

// 连接复制集
mongosh "mongodb://mongodb1.example.com:27017,mongodb2.example.com:27017,mongodb3.example.com:27017/myapp?replicaSet=myReplicaSet"

// 启动配置服务器
mongod --configsvr --replSet configReplSet --port 27019 --dbpath /data/configdb

// 启动分片服务器
mongod --shardsvr --replSet shard1 --port 27018 --dbpath /data/shard1

// 启动mongos路由器
mongos --configdb configReplSet/mongodb1:27019,mongodb2:27019,mongodb3:27019 --port 27017

// 连接到mongos并添加分片
sh.addShard("shard1/mongodb1:27018,mongodb2:27018,mongodb3:27018")

// 启用数据库分片
sh.enableSharding("myapp")

// 创建分片键
sh.shardCollection("myapp.users", {"userId": "hashed"})

// 查看分片状态
sh.status()

// 1. 使用索引
db.users.createIndex({age: 1, name: 1})

// 2. 限制返回字段
db.users.find({age: {$gte: 25}}, {name: 1, email: 1})

// 3. 使用limit限制结果
db.users.find({status: "active"}).limit(100)

// 4. 避免全表扫描
db.users.find({name: /^张/})  // 好：前缀匹配
db.users.find({name: /张/})   // 差：包含匹配

// 5. 使用聚合管道优化
// 差的做法：先查询再在应用层处理
const users = db.users.find({age: {$gte: 25}}).toArray()
// 在JavaScript中处理统计

// 好的做法：使用聚合管道
db.users.aggregate([
  {$match: {age: {$gte: 25}}},
  {$group: {
    _id: "$department",
    count: {$sum: 1},
    avgAge: {$avg: "$age"}
  }}
])

// 1. 批量写入
const bulk = db.users.initializeOrderedBulkOp()
for(let i = 0; i < 1000; i++) {
  bulk.insert({
    name: `User${i}`,
    age: Math.floor(Math.random() * 50) + 20,
    createdAt: new Date()
  })
}
bulk.execute()

// 2. 使用upsert减少查询
db.users.updateOne(
  {email: "user@example.com"},
  {
    $set: {
      name: "Updated Name",
      lastLogin: new Date()
    }
  },
  {upsert: true}  // 如果不存在则插入
)

// 3. 写入关注点设置
db.users.insertOne(
  {name: "张三", age: 25},
  {writeConcern: {w: "majority", j: true, wtimeout: 5000}}
)

// 1. 查看当前操作
db.currentOp()

// 2. 终止长时间运行的操作
db.killOp(opId)

// 3. 数据库统计信息
db.stats()

// 4. 集合统计信息
db.users.stats()

// 5. 分析慢查询
db.setProfilingLevel(2, {slowms: 100})  // 记录超过100ms的操作
db.system.profile.find().limit(5).sort({ts: -1})

// 6. 索引使用统计
db.users.aggregate([{$indexStats: {}}])

// 1. 用户集合设计
db.users.insertOne({
  _id: ObjectId(),
  username: "techblogger",
  email: "blogger@example.com",
  password: "hashed_password",
  profile: {
    firstName: "Tech",
    lastName: "Blogger",
    avatar: "https://example.com/avatar.jpg",
    bio: "热爱技术分享的程序员"
  },
  social: {
    github: "techblogger",
    twitter: "@techblogger",
    website: "https://techblog.example.com"
  },
  settings: {
    emailNotifications: true,
    privacy: "public"
  },
  stats: {
    postsCount: 0,
    followersCount: 0,
    followingCount: 0
  },
  createdAt: new Date(),
  updatedAt: new Date()
})

// 2. 文章集合设计
db.posts.insertOne({
  _id: ObjectId(),
  title: "MongoDB聚合框架深入解析",
  slug: "mongodb-aggregation-framework-deep-dive",
  content: "文章内容...",
  excerpt: "本文深入探讨MongoDB聚合框架的高级用法...",
  author: {
    userId: ObjectId("用户ID"),
    username: "techblogger",
    avatar: "https://example.com/avatar.jpg"
  },
  tags: ["MongoDB", "数据库", "聚合", "NoSQL"],
  categories: ["数据库", "后端开发"],
  status: "published", // draft, published, archived
  publishedAt: new Date(),
  stats: {
    views: 1250,
    likes: 89,
    comments: 23,
    shares: 15
  },
  seo: {
    metaTitle: "MongoDB聚合框架完整指南",
    metaDescription: "学习MongoDB聚合框架...",
    keywords: ["MongoDB", "聚合", "数据库"]
  },
  createdAt: new Date(),
  updatedAt: new Date()
})

// 3. 评论集合设计
db.comments.insertOne({
  _id: ObjectId(),
  postId: ObjectId("文章ID"),
  author: {
    userId: ObjectId("用户ID"),
    username: "reader001",
    avatar: "https://example.com/user_avatar.jpg"
  },
  content: "这篇文章写得很详细，对我很有帮助！",
  parentId: null, // 父评论ID，用于嵌套回复
  level: 0, // 嵌套层级
  likes: 5,
  dislikes: 0,
  status: "approved", // pending, approved, spam, deleted
  createdAt: new Date(),
  updatedAt: new Date()
})

// 4. 标签集合设计
db.tags.insertOne({
  _id: ObjectId(),
  name: "MongoDB",
  slug: "mongodb",
  description: "MongoDB数据库相关文章",
  color: "#13aa52",
  postsCount: 45,
  followersCount: 128,
  createdAt: new Date()
})

// 1. 发布文章
function publishPost(postData) {
  const session = db.getMongo().startSession()
  
  try {
    session.startTransaction()
    
    // 插入文章
    const postResult = db.posts.insertOne({
      ...postData,
      publishedAt: new Date(),
      status: "published",
      stats: {
        views: 0,
        likes: 0,
        comments: 0,
        shares: 0
      }
    }, {session})
    
    // 更新用户文章数
    db.users.updateOne(
      {_id: postData.author.userId},
      {$inc: {"stats.postsCount": 1}},
      {session}
    )
    
    // 更新标签文章数
    if (postData.tags && postData.tags.length > 0) {
      db.tags.updateMany(
        {name: {$in: postData.tags}},
        {$inc: {postsCount: 1}},
        {session}
      )
    }
    
    session.commitTransaction()
    return postResult.insertedId
    
  } catch (error) {
    session.abortTransaction()
    throw error
  } finally {
    session.endSession()
  }
}

// 2. 文章列表查询（支持分页、排序、筛选）
function getPostsList(options = {}) {
  const {
    page = 1,
    limit = 10,
    author,
    tags,
    category,
    search,
    sortBy = "publishedAt",
    sortOrder = -1
  } = options
  
  let matchStage = {status: "published"}
  
  // 添加筛选条件
  if (author) matchStage["author.username"] = author
  if (tags) matchStage.tags = {$in: Array.isArray(tags) ? tags : [tags]}
  if (category) matchStage.categories = category
  if (search) {
    matchStage.$text = {$search: search}
  }
  
  return db.posts.aggregate([
    {$match: matchStage},
    {$sort: {[sortBy]: sortOrder}},
    {$skip: (page - 1) * limit},
    {$limit: limit},
    {$project: {
      title: 1,
      slug: 1,
      excerpt: 1,
      author: 1,
      tags: 1,
      categories: 1,
      publishedAt: 1,
      stats: 1,
      readTime: {
        $round: [{$divide: [{$strLenCP: "$content"}, 200]}] // 估算阅读时间
      }
    }}
  ])
}

// 3. 热门文章统计
function getPopularPosts(timeRange = 7) {
  const startDate = new Date()
  startDate.setDate(startDate.getDate() - timeRange)
  
  return db.posts.aggregate([
    {$match: {
      status: "published",
      publishedAt: {$gte: startDate}
    }},
    {$addFields: {
      popularityScore: {
        $add: [
          {$multiply: ["$stats.views", 1]},
          {$multiply: ["$stats.likes", 5]},
          {$multiply: ["$stats.comments", 10]},
          {$multiply: ["$stats.shares", 15]}
        ]
      }
    }},
    {$sort: {popularityScore: -1}},
    {$limit: 10},
    {$project: {
      title: 1,
      slug: 1,
      author: 1,
      publishedAt: 1,
      stats: 1,
      popularityScore: 1
    }}
  ])
}

// 4. 用户关注系统
db.follows.insertOne({
  _id: ObjectId(),
  follower: ObjectId("关注者ID"),
  following: ObjectId("被关注者ID"),
  createdAt: new Date()
})

// 获取用户关注的人的文章
function getFollowingPosts(userId, page = 1, limit = 10) {
  return db.follows.aggregate([
    {$match: {follower: ObjectId(userId)}},
    {$lookup: {
      from: "posts",
      localField: "following",
      foreignField: "author.userId",
      as: "posts"
    }},
    {$unwind: "$posts"},
    {$match: {"posts.status": "published"}},
    {$sort: {"posts.publishedAt": -1}},
    {$skip: (page - 1) * limit},
    {$limit: limit},
    {$replaceRoot: {newRoot: "$posts"}}
  ])
}

// 5. 搜索功能
db.posts.createIndex({
  title: "text",
  content: "text",
  tags: "text"
}, {
  weights: {
    title: 10,
    tags: 5,
    content: 1
  },
  name: "posts_text_index"
})

function searchPosts(query, page = 1, limit = 10) {
  return db.posts.aggregate([
    {$match: {
      $text: {$search: query},
      status: "published"
    }},
    {$addFields: {
      score: {$meta: "textScore"}
    }},
    {$sort: {score: {$meta: "textScore"}}},
    {$skip: (page - 1) * limit},
    {$limit: limit}
  ])
}

// 1. 商品集合设计
db.products.insertOne({
  _id: ObjectId(),
  name: "iPhone 15 Pro",
  slug: "iphone-15-pro",
  description: "最新款iPhone，搭载A17 Pro芯片",
  category: {
    main: "电子产品",
    sub: "智能手机",
    path: ["电子产品", "智能手机", "苹果"]
  },
  brand: "Apple",
  sku: "IPH15P-256-BLU",
  variants: [
    {
      sku: "IPH15P-128-BLU",
      attributes: {
        storage: "128GB",
        color: "深空蓝色"
      },
      price: 8999,
      stock: 50,
      images: ["url1.jpg", "url2.jpg"]
    },
    {
      sku: "IPH15P-256-BLU", 
      attributes: {
        storage: "256GB",
        color: "深空蓝色"
      },
      price: 9999,
      stock: 30,
      images: ["url3.jpg", "url4.jpg"]
    }
  ],
  specifications: {
    "屏幕尺寸": "6.1英寸",
    "处理器": "A17 Pro",
    "摄像头": "4800万像素主摄",
    "电池": "3274mAh"
  },
  tags: ["5G", "Face ID", "无线充电"],
  seo: {
    title: "iPhone 15 Pro - Apple官方授权",
    description: "购买iPhone 15 Pro...",
    keywords: ["iPhone", "苹果手机", "5G手机"]
  },
  pricing: {
    basePrice: 8999,
    salePrice: null,
    wholesalePrice: 8500,
    currency: "CNY"
  },
  inventory: {
    totalStock: 80,
    reserved: 5,
    available: 75,
    lowStockThreshold: 10
  },
  ratings: {
    average: 4.8,
    count: 1250,
    distribution: {
      "5": 980,
      "4": 200,
      "3": 50,
      "2": 15,
      "1": 5
    }
  },
  status: "active", // active, inactive, discontinued
  isDigital: false,
  shippingInfo: {
    weight: 0.187, // kg
    dimensions: {
      length: 14.76,
      width: 7.15,
      height: 0.83
    },
    freeShipping: true,
    shippingMethods: ["standard", "express", "same-day"]
  },
  createdAt: new Date(),
  updatedAt: new Date()
})

// 2. 订单集合设计
db.orders.insertOne({
  _id: ObjectId(),
  orderNumber: "ORD20240807001",
  customer: {
    userId: ObjectId("用户ID"),
    email: "customer@example.com",
    name: "张三",
    phone: "13800138000"
  },
  items: [
    {
      productId: ObjectId("商品ID"),
      sku: "IPH15P-256-BLU",
      name: "iPhone 15 Pro 256GB 深空蓝色",
      price: 9999,
      quantity: 1,
      subtotal: 9999,
      attributes: {
        storage: "256GB",
        color: "深空蓝色"
      }
    }
  ],
  pricing: {
    subtotal: 9999,
    shipping: 0,
    tax: 899.91,
    discount: 0,
    total: 10898.91,
    currency: "CNY"
  },
  shipping: {
    method: "express",
    address: {
      recipient: "张三",
      phone: "13800138000",
      province: "北京市",
      city: "北京市", 
      district: "朝阳区",
      street: "XXX街道XXX号",
      postalCode: "100000"
    },
    estimatedDelivery: new Date("2024-08-09")
  },
  payment: {
    method: "alipay",
    status: "paid",
    transactionId: "ALI20240807001",
    paidAt: new Date()
  },
  status: "processing", // pending, paid, processing, shipped, delivered, cancelled, refunded
  timeline: [
    {
      status: "pending",
      timestamp: new Date("2024-08-07T10:00:00Z"),
      note: "订单已创建"
    },
    {
      status: "paid", 
      timestamp: new Date("2024-08-07T10:05:00Z"),
      note: "支付成功"
    }
  ],
  createdAt: new Date(),
  updatedAt: new Date()
})

// 3. 购物车集合设计
db.carts.insertOne({
  _id: ObjectId(),
  userId: ObjectId("用户ID"),
  items: [
    {
      productId: ObjectId("商品ID"),
      sku: "IPH15P-256-BLU",
      quantity: 1,
      addedAt: new Date(),
      price: 9999 // 添加时的价格
    }
  ],
  totals: {
    itemCount: 1,
    subtotal: 9999
  },
  createdAt: new Date(),
  updatedAt: new Date(),
  expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000) // 7天后过期
})

// 4. 库存管理
function updateInventory(sku, quantityChange, operation = "reserve") {
  const session = db.getMongo().startSession()
  
  try {
    session.startTransaction()
    
    const product = db.products.findOne(
      {"variants.sku": sku},
      {session}
    )
    
    if (!product) {
      throw new Error("商品不存在")
    }
    
    const variant = product.variants.find(v => v.sku === sku)
    if (operation === "reserve" && variant.stock < quantityChange) {
      throw new Error("库存不足")
    }
    
    // 更新库存
    const updateDoc = {}
    updateDoc[`variants.$.stock`] = variant.stock - quantityChange
    
    db.products.updateOne(
      {"variants.sku": sku},
      {$inc: updateDoc},
      {session}
    )
    
    // 记录库存变动
    db.inventoryLogs.insertOne({
      sku: sku,
      operation: operation,
      quantity: quantityChange,
      previousStock: variant.stock,
      newStock: variant.stock - quantityChange,
      reason: "订单处理",
      timestamp: new Date()
    }, {session})
    
    session.commitTransaction()
    
  } catch (error) {
    session.abortTransaction()
    throw error
  } finally {
    session.endSession()
  }
}

// 5. 商品推荐系统
function getRecommendations(userId, limit = 10) {
  return db.orders.aggregate([
    // 找出用户购买过的商品类别
    {$match: {"customer.userId": ObjectId(userId)}},
    {$unwind: "$items"},
    {$lookup: {
      from: "products",
      localField: "items.productId",
      foreignField: "_id",
      as: "product"
    }},
    {$unwind: "$product"},
    
    // 统计用户偏好的类别
    {$group: {
      _id: "$product.category.main",
      purchaseCount: {$sum: 1}
    }},
    {$sort: {purchaseCount: -1}},
    {$limit: 3},
    
    // 查找相似类别的热门商品
    {$lookup: {
      from: "products",
      let: {category: "$_id"},
      pipeline: [
        {$match: {
          $expr: {$eq: ["$category.main", "$category"]},
          status: "active"
        }},
        {$sort: {"ratings.average": -1, "ratings.count": -1}},
        {$limit: limit}
      ],
      as: "recommendations"
    }},
    
    {$unwind: "$recommendations"},
    {$replaceRoot: {newRoot: "$recommendations"}},
    {$limit: limit}
  ])
}

ObjectId = 4字节时间戳 + 5字节随机值 + 3字节递增计数器
- 前4字节：Unix时间戳，确保时间排序
- 接下来5字节：机器和进程的随机值
- 最后3字节：自增计数器，确保同一秒内的唯一性

// 1. 单字段索引
db.collection.createIndex({field: 1})

// 2. 复合索引  
db.collection.createIndex({field1: 1, field2: -1})

// 3. 多键索引（数组字段自动创建）
db.collection.createIndex({arrayField: 1})

// 4. 文本索引
db.collection.createIndex({title: "text", content: "text"})

// 5. 地理空间索引
db.collection.createIndex({location: "2dsphere"})

// 6. 哈希索引
db.collection.createIndex({field: "hashed"})

// 7. 稀疏索引
db.collection.createIndex({field: 1}, {sparse: true})

// 8. 唯一索引
db.collection.createIndex({email: 1}, {unique: true})

// 9. TTL索引
db.collection.createIndex({createdAt: 1}, {expireAfterSeconds: 3600})

// 1. 使用explain()分析查询
db.collection.find({field: value}).explain("executionStats")

// 2. 创建合适的索引
db.collection.createIndex({queryField: 1})

// 3. 复合索引的字段顺序：等值查询 -> 范围查询 -> 排序
db.collection.createIndex({status: 1, createdAt: 1, priority: -1})

// 4. 使用投影限制返回字段
db.collection.find({}, {name: 1, email: 1})

// 5. 使用limit限制结果集
db.collection.find().limit(100)

// 6. 避免否定查询
db.collection.find({status: {$ne: "inactive"}}) // 避免
db.collection.find({status: "active"}) // 推荐

// 7. 使用聚合管道优化复杂查询
db.collection.aggregate([
  {$match: {status: "active"}}, // 先过滤
  {$sort: {createdAt: -1}},     // 再排序
  {$limit: 100}                 // 最后限制
])

// 聚合管道示例
db.orders.aggregate([
  // 第1阶段：匹配条件
  {$match: {
    status: "completed",
    orderDate: {$gte: new Date("2024-01-01")}
  }},
  
  // 第2阶段：展开数组字段
  {$unwind: "$items"},
  
  // 第3阶段：分组聚合
  {$group: {
    _id: "$items.category",
    totalRevenue: {$sum: {$multiply: ["$items.price", "$items.quantity"]}},
    orderCount: {$sum: 1},
    avgOrderValue: {$avg: "$totalAmount"}
  }},
  
  // 第4阶段：排序
  {$sort: {totalRevenue: -1}},
  
  // 第5阶段：限制结果
  {$limit: 10}
])

// 基本用法
db.orders.aggregate([
  {$lookup: {
    from: "users",              // 关联集合
    localField: "userId",       // 本集合字段
    foreignField: "_id",        // 关联集合字段  
    as: "userInfo"             // 输出字段名
  }}
])

// 高级用法：带条件的lookup
db.orders.aggregate([
  {$lookup: {
    from: "products",
    let: {orderItems: "$items"},
    pipeline: [
      {$match: {
        $expr: {$in: ["$_id", "$orderItems.productId"]},
        status: "active"
      }},
      {$project: {name: 1, price: 1}}
    ],
    as: "productDetails"
  }}
])

// 使用场景：
// 1. 需要展示关联数据（如订单显示用户信息）
// 2. 数据统计分析（如用户订单汇总）
// 3. 替代应用层的多次查询

// 初始化复制集
rs.initiate({
  _id: "myReplicaSet",
  members: [
    {_id: 0, host: "mongo1:27017", priority: 2}, // Primary优先级高
    {_id: 1, host: "mongo2:27017", priority: 1}, // Secondary
    {_id: 2, host: "mongo3:27017", priority: 0, arbiterOnly: true} // Arbiter
  ]
})

// 特点：
// 1. 自动故障转移
// 2. 数据冗余备份  
// 3. 读写分离（可配置读偏好）
// 4. 最少需要3个节点（或2个数据节点+1个仲裁节点）

// 使用分片的场景：
// 1. 数据量超过单机存储能力（TB级别）
// 2. 读写QPS超过单机处理能力
// 3. 需要水平扩展存储和计算能力

// 分片键设计原则：
// 1. 高基数（Cardinality）- 取值范围要广
// 2. 低频率（Frequency）- 避免数据倾斜
// 3. 单调变化避免（Non-monotonically changing）

// 好的分片键示例：
sh.shardCollection("app.users", {userId: "hashed"}) // 哈希分片
sh.shardCollection("app.logs", {timestamp: 1, userId: 1}) // 复合分片键
sh.shardCollection("app.products", {category: 1, productId: 1})

// 避免的分片键：
// {_id: 1} - ObjectId是单调递增的
// {timestamp: 1} - 时间戳单调递增
// {status: 1} - 基数太低

// 1. 数据库性能分析
db.enableFreeMonitoring() // 启用免费监控

// 2. 慢查询分析
db.setProfilingLevel(2, {slowms: 100}) // 记录>100ms的操作
db.system.profile.find().limit(5).sort({ts: -1}).pretty()

// 3. 实时监控
db.serverStatus() // 服务器状态
db.stats() // 数据库统计
db.collection.stats() // 集合统计

// 4. 当前操作监控
db.currentOp({
  "active": true,
  "secs_running": {"$gte": 5}
}) // 查看运行超过5秒的操作

// 5. 索引使用分析
db.collection.aggregate([{$indexStats: {}}])

// 6. 连接池监控
db.serverStatus().connections

// 7. 锁信息
db.serverStatus().globalLock

// 写关注级别
db.collection.insertOne(
  {name: "test"},
  {
    writeConcern: {
      w: "majority",        // 等待大多数节点确认
      j: true,              // 等待写入journal
      wtimeout: 5000        // 5秒超时
    }
  }
)

// 写关注选项：
// w: 1 - 只等待primary确认（默认）
// w: "majority" - 等待大多数节点确认
// w: 0 - 不等待确认（最快但不安全）

// 读偏好设置
db.collection.find().readPref("secondary") // 从secondary读取
db.collection.find().readPref("primaryPreferred") // 优先primary

// 读偏好选项：
// primary - 只从primary读（默认）
// primaryPreferred - 优先primary，不可用时从secondary
// secondary - 只从secondary读
// secondaryPreferred - 优先secondary，不可用时从primary
// nearest - 从网络延迟最小的节点读

// 单文档事务（自动支持）
db.accounts.updateOne(
  {_id: "account1"},
  {$inc: {balance: -100}}
)

// 多文档事务
const session = db.getMongo().startSession()

try {
  session.startTransaction({
    readConcern: {level: "snapshot"},
    writeConcern: {w: "majority"}
  })
  
  // 转账操作
  db.accounts.updateOne(
    {_id: "account1"},
    {$inc: {balance: -100}},
    {session}
  )
  
  db.accounts.updateOne(
    {_id: "account2"}, 
    {$inc: {balance: 100}},
    {session}
  )
  
  // 记录转账日志
  db.transactions.insertOne({
    from: "account1",
    to: "account2",
    amount: 100,
    timestamp: new Date()
  }, {session})
  
  session.commitTransaction()
  
} catch (error) {
  session.abortTransaction()
  throw error
} finally {
  session.endSession()
}

// 事务使用场景：
// 1. 金融转账操作
// 2. 订单处理（扣库存、创建订单、更新用户积分）
// 3. 多集合数据一致性要求的操作

// 1. 文档级原子性（单文档操作天然原子）
db.users.updateOne(
  {_id: userId},
  {
    $inc: {balance: -100, orderCount: 1},
    $push: {orders: orderId},
    $set: {lastOrderDate: new Date()}
  }
)

// 2. 使用事务保证多文档一致性
function transferMoney(fromId, toId, amount) {
  const session = db.getMongo().startSession()
  
  try {
    session.startTransaction()
    
    const fromAccount = db.accounts.findOne({_id: fromId}, {session})
    if (fromAccount.balance < amount) {
      throw new Error("余额不足")
    }
    
    db.accounts.updateOne(
      {_id: fromId},
      {$inc: {balance: -amount}},
      {session}
    )
    
    db.accounts.updateOne(
      {_id: toId},
      {$inc: {balance: amount}},
      {session}
    )
    
    session.commitTransaction()
  } catch (error) {
    session.abortTransaction()
    throw error
  } finally {
    session.endSession()
  }
}

// 3. 最终一致性模式（适用于不需要强一致性的场景）
// 订单创建 -> 异步更新库存 -> 异步更新用户统计
function createOrderEventually(orderData) {
  // 1. 先创建订单
  const orderId = db.orders.insertOne(orderData).insertedId
  
  // 2. 发布事件到消息队列
  publishEvent('order.created', {
    orderId: orderId,
    items: orderData.items,
    userId: orderData.userId
  })
  
  return orderId
}

// 4. 使用唯一索引防止重复
db.orders.createIndex({orderNumber: 1}, {unique: true})
db.users.createIndex({email: 1}, {unique: true})