// Query plan
db.t_orders.find({ status: "paid" }).explain()

// Execute statistics
db.t_orders.find({ status: "paid" }).explain("executionStats")

// All plan execution information
db.t_orders.find({ status: "paid" }).explain("allPlansExecution")

{
    "queryPlanner": {
        "winningPlan": {
            "stage": "FETCH",              // Execution stage
            "inputStage": {
                "stage": "IXSCAN",         // Uses index scan
                "keyPattern": { "status": 1 },
                "indexName": "idx_status",
                "direction": "forward"
            }
        },
        "rejectedPlans": [...]             // Rejected plans
    },
    "executionStats": {
        "executionSuccess": true,
        "nReturned": 1000,                 // Number of documents returned
        "executionTimeMillis": 15,         // Execution time (milliseconds)
        "totalKeysExamined": 1000,         // Number of index entries scanned
        "totalDocsExamined": 1000,         // Number of documents scanned
        "executionStages": {
            "stage": "FETCH",
            "nReturned": 1000,
            "docsExamined": 1000,
            "inputStage": {
                "stage": "IXSCAN",
                "nReturned": 1000,
                "keysExamined": 1000
            }
        }
    }
}

// View the current slow log query threshold
db.getProfilingStatus()
// { "was": 1, "slowms": 100 }

// Set the slow log query threshold to 200 ms
db.setProfilingLevel(1, { slowms: 200 })

// level 0: Disable
// level 1: Log only slow log queries
// level 2: Log all operations (Use with caution, as it has a significant performance impact)

// View all current operations
db.currentOp()

// View operations whose execution time exceeds 5 seconds
db.currentOp({
    "active": true,
    "secs_running": { "$gt": 5 }
})

// View operations that are waiting for locks
db.currentOp({
    "waitingForLock": true
})

// View operations for a specific collection
db.currentOp({
    "ns": "mydb.t_orders"
})


// Terminate operations whose execution time exceeds 10 seconds
db.currentOp().inprog.forEach(function(item){if(item.secs_running > 10 )db.killOp(item.opid)})

db.serverStatus()

// Key metrics to focus on
{
    "connections": {
        "current": 50,      // current number of connections
        "available": 950,   // number of available connections
        "totalCreated": 1000
    },
    "opcounters": {
        "insert": 10000,
        "query": 50000,
        "update": 5000,
        "delete": 1000
    },
    "mem": {
        "resident": 4096,   // resident memory (MB)
        "virtual": 8192     // virtual memory (MB)
    },
    "wiredTiger": {
        "cache": {
            "bytes currently in the cache": ...,
            "maximum bytes configured": ...
        }
    }
}

// 1. Confirm whether a full table scan is performed
db.t_orders.find({ status: "paid" }).explain("executionStats")
// Check whether winningPlan.stage is COLLSCAN

// 2. Check existing indexes
db.t_orders.getIndexes()

// 3. Create appropriate indexes
db.t_orders.createIndex({ status: 1 }, { background: true })

// 4. Verify that the index takes effect
db.t_orders.find({ status: "paid" }).explain("executionStats")
// Confirm that the stage has changed to IXSCAN

// 1. Confirm whether an in-memory sort is performed
db.t_orders.find({ status: "paid" }).sort({ createTime: -1 }).explain("executionStats")
// Check whether a SORT stage exists

// 2. Create an index that supports sorting
db.t_orders.createIndex({ status: 1, createTime: -1 }, { background: true })

// 3. Verify index sorting
db.t_orders.find({ status: "paid" }).sort({ createTime: -1 }).explain("executionStats")
// Confirm that no SORT stage exists

// 1. View the shard data distribution
db.t_orders.getShardDistribution()

// 2. View the chunk distribution
db.getSiblingDB("config").chunks.aggregate([
    { $match: { ns: "mydb.t_orders" } },
    { $group: { _id: "$shard", count: { $sum: 1 } } }
])

// 3. Check the shard key selection
db.getSiblingDB("config").collections.findOne({ _id: "mydb.t_orders" })

// 1. View the current number of connections
db.serverStatus().connections
// { "current": 950, "available": 50, "totalCreated": 10000 }

// 2. View the connection sources
db.currentOp(true).inprog.forEach(function(op) {
    if (op.client) print(op.client);
})

// 3. Check the application connection pool configuration
// Confirm whether the maxPoolSize setting is appropriate

// 1. View operations in lock waiting
db.currentOp({ "waitingForLock": true })

// 2. View operations that hold locks for a long time
db.currentOp({
    "active": true,
    "secs_running": { "$gt": 10 }
})

// 3. View the lock status
db.serverStatus().locks

// List all indexes
db.t_orders.getIndexes()

// Check index usage statistics
db.t_orders.aggregate([{ $indexStats: {} }])

// Verify index coverage for the primary queries
const mainQueries = [
    { status: "paid" },
    { customerId: "C001", createTime: { $gte: ISODate("2024-01-01") } },
    { orderId: "ORD001" }
];

mainQueries.forEach(query => {
    const plan = db.t_orders.find(query).explain("executionStats");
    print("Query:", JSON.stringify(query));
    print("Stage:", plan.queryPlanner.winningPlan.stage);
    print("DocsExamined:", plan.executionStats.totalDocsExamined);
    print("---");
});