// Obtain execution statistics (Recommended)
 db.t_orders.find({
     status: "paid",
     createTime: { $gte: ISODate("2024-01-01") }
 }).explain("executionStats")

 // Error: Returning the entire document (including unnecessary large fields)
 db.t_products.find({ productId: "P001" })
 
 // Correct: Returning only the required fields
 db.t_products.find(
     { productId: "P001" },
     { _id: 1, name: 1, price: 1, stock: 1 }
 )
 
 // Correct: Excluding large fields
 db.t_products.find(
     { productId: "P001" },
     { description: 0, htmlContent: 0 }
 )

 // Error: skip pagination, where performance degrades sharply during deep pagination.
 db.t_orders.find().sort({ createTime: -1 }).skip(100000).limit(20)
 
 // Correct: Cursor pagination, stable performance
 // Page 1
 db.t_orders.find().sort({ createTime: -1, _id: -1 }).limit(20)
 
 // Subsequent pages (using the createTime and _id of the last record from the previous page)
 db.t_orders.find({
     $or: [
         { createTime: { $lt: lastTime } },
         { createTime: lastTime, _id: { $lt: lastId } }
     ]
 }).sort({ createTime: -1, _id: -1 }).limit(20)

 // Exercise caution in high-concurrency scenarios: large list $in
 db.t_orders.find({ productId: { $in: [/* 100 IDs */] } })
 
 // Correct: Batch Querying
 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;
 }

 // Incorrect: Full document replacement (unspecified fields are lost, and concurrency issues may arise).
 const user = await db.t_users.findOne({ _id: userId });
 user.nickName = "new nickname";
 await db.t_users.replaceOne({ _id: userId }, user);  // Dangerous!
 
 // Correct: Partial update with $set
 await db.t_users.updateOne(
     { _id: userId },
     { $set: { nickName: "new nickname" } }
 );
 
 // Correct: Combine multiple update operators
 await db.t_users.updateOne(
     { _id: userId },
     {
         $set: { nickName: "new nickname" },
         $inc: { loginCount: 1 },
         $currentDate: { lastLoginTime: true }
     }
 );

// Danger: An empty condition matches all documents, making it highly prone to erroneously updating non-target data.
db.t_users.updateOne({}, { $set: { status: "inactive" } })

// Correct: With explicit query conditions, precisely targeting the intended documents.
db.t_users.updateOne(
    { userId: "U001" },
    { $set: { status: "inactive" } }
)

// Correct: Batch updates must include explicit conditions, and the impact scope should be assessed before updating.
db.t_users.updateMany(
    { status: "pending", createTime: { $lt: ISODate("2024-01-01") } },
    { $set: { status: "expired" } }
)

 # Python Example: Preventing Empty Condition Updates
 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)

 // Incorrect: Full array replacement.
 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 } }  // Full write
 );
 
 // Correct: Update matched elements using the $ positional operator.
 await db.t_orders.updateOne(
     { orderId: "ORD001", "items.productId": "P001" },
     { $set: { "items.$.quantity": 5 } }  // Precise update
 );
 
 // Correct: Use arrayFilters to update multiple elements (MongoDB 3.6+)
 await db.t_orders.updateOne(
     { orderId: "ORD001" },
     { $set: { "items.$[elem].quantity": 5 } },
     { arrayFilters: [{ "elem.productId": { $in: ["P001", "P002"] } }] }
 );
 
 // Correct: Append elements to an array.
 await db.t_orders.updateOne(
     { orderId: "ORD001" },
     { $push: { items: { productId: "P003", quantity: 1 } } }
 );
 
 // Correct: Remove elements from an array.
 await db.t_orders.updateOne(
     { orderId: "ORD001" },
     { $pull: { items: { productId: "P003" } } }
 );

 # Python Example: Batch Insertion
 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)
 
         # Pause between batches to reduce database pressure.
         if i + batch_size < len(documents):
             time.sleep(interval)

 // Batch deletion, 1000 records per batch, with a 100ms interval between batches.
 async function batchDelete(collection, filter, batchSize = 1000) {
     let totalDeleted = 0;
 
     while (true) {
         // First, query the document IDs to be deleted.
         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} records deleted...`);
 
         // Pause between intervals.
         await new Promise(resolve => setTimeout(resolve, 100));
     }
 
     return totalDeleted;
 }

  // Route writes to the corresponding collection based on month.
const collName = "t_events_" + new Date().toISOString().slice(0, 7).replace("-", "")
db.getCollection(collName).insertOne({
    userId: "U001",
    action: "click_buy",
    createTime: new Date()
})

// Clean up expired data: Directly drop collections older than two months. This operation completes instantly.
db.t_events_202601.drop()


 // Prohibited: j:false may cause data loss.
 db.t_orders.insertOne(
     { orderId: "ORD001" },
     { writeConcern: { w: 1, j: false } }  // Dangerous!
 )
 
 // Correct: Use majority for core services.
 db.t_orders.insertOne(
     { orderId: "ORD001", amount: 199.00 },
     { writeConcern: { w: "majority", j: true, wtimeout: 5000 } }
 )
 
 // Connection String Configuration Method (Globally Effective)
 // mongodb://user:pwd@host1,host2,host3/db?w=majority&j=true&wtimeout=5000

 // Error: Expanding before filtering causes intermediate data volume to expand.
 db.t_orders.aggregate([
     { $unwind: "$items" },           // Unwinding first causes data volume to expand.
     { $match: { status: "paid" } },  // Then filter
     { $group: { _id: "$items.category", total: { $sum: "$items.amount" } } }
 ])
 
 // Correct: Filtering before expanding reduces data volume at the source.
 db.t_orders.aggregate([
     { $match: { status: "paid" } },  // Filter first to reduce data volume.
     { $project: { items: 1 } },      // Keep only the required fields.
     { $unwind: "$items" },           // Then unwind.
     { $group: { _id: "$items.category", total: { $sum: "$items.amount" } } }
 ])