// 获取执行统计信息（推荐）
 db.t_orders.find({
     status: "paid",
     createTime: { $gte: ISODate("2024-01-01") }
 }).explain("executionStats")

 // 错误：返回完整文档（包含不需要的大字段）
 db.t_products.find({ productId: "P001" })
 
 // 正确：仅返回需要的字段
 db.t_products.find(
     { productId: "P001" },
     { _id: 1, name: 1, price: 1, stock: 1 }
 )
 
 // 正确：排除大字段
 db.t_products.find(
     { productId: "P001" },
     { description: 0, htmlContent: 0 }
 )

 // 错误：skip 分页，深度分页时性能急剧下降
 db.t_orders.find().sort({ createTime: -1 }).skip(100000).limit(20)
 
 // 正确：游标分页，性能稳定
 // 第一页
 db.t_orders.find().sort({ createTime: -1, _id: -1 }).limit(20)
 
 // 后续页（使用上一页最后一条的 createTime 和 _id）
 db.t_orders.find({
     $or: [
         { createTime: { $lt: lastTime } },
         { createTime: lastTime, _id: { $lt: lastId } }
     ]
 }).sort({ createTime: -1, _id: -1 }).limit(20)

 // 高并发场景需谨慎：大列表 $in
 db.t_orders.find({ productId: { $in: [/* 100 个 ID */] } })
 
 // 正确：分批查询
 async function batchQuery(productIds, batchSize = 50) {
     const results = [];
     for (let i = 0; i < productIds.length; i += batchSize) {
         const batch = productIds.slice(i, i + batchSize);
         const docs = await db.t_orders.find({
             productId: { $in: batch }
         }).toArray();
         results.push(...docs);
     }
     return results;
 }

 // 错误：全文档替换（会丢失未指定的字段，且有并发问题）
 const user = await db.t_users.findOne({ _id: userId });
 user.nickName = "新昵称";
 await db.t_users.replaceOne({ _id: userId }, user);  // 危险！
 
 // 正确：$set 局部更新
 await db.t_users.updateOne(
     { _id: userId },
     { $set: { nickName: "新昵称" } }
 );
 
 // 正确：组合多个更新操作符
 await db.t_users.updateOne(
     { _id: userId },
     {
         $set: { nickName: "新昵称" },
         $inc: { loginCount: 1 },
         $currentDate: { lastLoginTime: true }
     }
 );

// 危险：空条件会匹配所有文档，极易误更新非目标数据
db.t_users.updateOne({}, { $set: { status: "inactive" } })

// 正确：带明确查询条件，精准定位目标文档
db.t_users.updateOne(
    { userId: "U001" },
    { $set: { status: "inactive" } }
)

// 正确：批量更新必须带明确条件，且更新前应评估影响范围
db.t_users.updateMany(
    { status: "pending", createTime: { $lt: ISODate("2024-01-01") } },
    { $set: { status: "expired" } }
)

 # Python 示例：防止空条件更新
 def safe_update(collection, filter_query, update_doc, **kwargs):
     if not filter_query or filter_query == {}:
         raise ValueError("Update filter cannot be empty!")
     return collection.update_one(filter_query, update_doc, **kwargs)

 // 错误：全量替换数组
 const order = await db.t_orders.findOne({ orderId: "ORD001" });
 order.items[0].quantity = 5;
 await db.t_orders.updateOne(
     { orderId: "ORD001" },
     { $set: { items: order.items } }  // 全量写入
 );
 
 // 正确：使用 $ 位置操作符更新匹配的元素
 await db.t_orders.updateOne(
     { orderId: "ORD001", "items.productId": "P001" },
     { $set: { "items.$.quantity": 5 } }  // 精准更新
 );
 
 // 正确：使用 arrayFilters 更新多个元素（MongoDB 3.6+）
 await db.t_orders.updateOne(
     { orderId: "ORD001" },
     { $set: { "items.$[elem].quantity": 5 } },
     { arrayFilters: [{ "elem.productId": { $in: ["P001", "P002"] } }] }
 );
 
 // 正确：向数组追加元素
 await db.t_orders.updateOne(
     { orderId: "ORD001" },
     { $push: { items: { productId: "P003", quantity: 1 } } }
 );
 
 // 正确：从数组删除元素
 await db.t_orders.updateOne(
     { orderId: "ORD001" },
     { $pull: { items: { productId: "P003" } } }
 );

 # Python 示例：分批插入
 import time
 
 def batch_insert(collection, documents, batch_size=1000, interval=0.1):
     for i in range(0, len(documents), batch_size):
         batch = documents[i:i + batch_size]
         collection.insert_many(batch, ordered=False)
 
         # 批次间休眠，降低数据库压力
         if i + batch_size < len(documents):
             time.sleep(interval)

 // 分批删除，每批 1000 条，间隔 100ms
 async function batchDelete(collection, filter, batchSize = 1000) {
     let totalDeleted = 0;
 
     while (true) {
         // 先查询要删除的文档 ID
         const docs = await collection.find(filter, { _id: 1 })
             .limit(batchSize)
             .toArray();
 
         if (docs.length === 0) break;
 
         const ids = docs.map(d => d._id);
         const result = await collection.deleteMany({ _id: { $in: ids } });
         totalDeleted += result.deletedCount;
 
         console.log(`已删除 ${totalDeleted} 条...`);
 
         // 间隔休眠
         await new Promise(resolve => setTimeout(resolve, 100));
     }
 
     return totalDeleted;
 }

  // 写入时按月路由到对应集合
const collName = "t_events_" + new Date().toISOString().slice(0, 7).replace("-", "")
db.getCollection(collName).insertOne({
    userId: "U001",
    action: "click_buy",
    createTime: new Date()
})

// 清理过期数据：直接 drop 两个月前的集合，瞬间完成
db.t_events_202601.drop()


 // 禁止：j:false 可能导致数据丢失
 db.t_orders.insertOne(
     { orderId: "ORD001" },
     { writeConcern: { w: 1, j: false } }  // 危险！
 )
 
 // 正确：核心业务使用 majority
 db.t_orders.insertOne(
     { orderId: "ORD001", amount: 199.00 },
     { writeConcern: { w: "majority", j: true, wtimeout: 5000 } }
 )
 
 // 连接串配置方式（全局生效）
 // mongodb://user:pwd@host1,host2,host3/db?w=majority&j=true&wtimeout=5000

 // 错误：先展开再过滤，中间数据量膨胀
 db.t_orders.aggregate([
     { $unwind: "$items" },           // 先展开，数据量膨胀
     { $match: { status: "paid" } },  // 再过滤
     { $group: { _id: "$items.category", total: { $sum: "$items.amount" } } }
 ])
 
 // 正确：先过滤再展开，源头缩减数据量
 db.t_orders.aggregate([
     { $match: { status: "paid" } },  // 先过滤，减少数据量
     { $project: { items: 1 } },      // 只保留需要的字段
     { $unwind: "$items" },           // 再展开
     { $group: { _id: "$items.category", total: { $sum: "$items.amount" } } }
 ])