// 冗余索引對
{ userId: 1, status: 1 } 
{ userId: 1, status: 1 }  // 完全重復(fù)

// 冗余索引對
{ userId: 1 }                 // 索引A
{ userId: 1, createdAt: -1 }  // 索引B → 包含A，可替代A

// 冗余索引對
{ createdAt: 1 }   // 升序
{ createdAt: -1 }  // 降序 → 若查詢僅需范圍過濾（非排序），兩者可合并

// 獲取所有索引的訪問統(tǒng)計（MongoDB 4.2+）
db.orders.aggregate([
  { $indexStats: {} },
  { $group: {
      _id: "$name",
      totalOps: { $sum: "$accesses.ops" },
      lastUsed: { $max: "$accesses.since" }
    }
  },
  { $sort: { totalOps: 1 } } // 按使用頻率升序
]);

[
  { "_id": "userId_1", "totalOps": 120000, "lastUsed": "2023-10-05T12:00:00Z" },
  { "_id": "userId_1_status_1", "totalOps": 0, "lastUsed": null }, // 僵尸索引！
  { "_id": "createdAt_-1", "totalOps": 8000, "lastUsed": "2023-10-05T11:30:00Z" }
]

// 步驟1：獲取索引大小
const collStats = db.orders.stats({ scale: 1048576, indexDetails: true });

// 步驟2：獲取查詢次數(shù)
const indexUsage = db.orders.aggregate([{$indexStats:{}}]).toArray();

// 步驟3：計算效率
indexUsage.forEach(index => {
  const sizeMB = collStats.indexSizes[index.name] || 0;
  const efficiency = index.accesses.ops / (sizeMB || 1); // 避免除零
  print(`${index.name} 效率: ${efficiency.toFixed(2)}`);
});

// 檢測索引A是否是索引B的子集
function isSubsetIndex(indexA, indexB) {
  const aFields = Object.keys(indexA);
  const bFields = Object.keys(indexB);
  
  // 檢查A是否為B的前綴子集
  for (let i = 0; i < aFields.length; i++) {
    if (aFields[i] !== bFields[i]) return false;
    if (indexA[aFields[i]] !== indexB[bFields[i]]) return false;
  }
  return true;
}

// 示例：檢查兩個索引
const idxA = { userId: 1 };
const idxB = { userId: 1, status: 1 };
print(isSubsetIndex(idxA, idxB)); // true → idxA冗余

// 識別所有冗余子集索引
const indexes = db.orders.getIndexes();
const redundant = [];

for (let i = 0; i < indexes.length; i++) {
  for (let j = 0; j < indexes.length; j++) {
    if (i === j) continue;
    if (isSubsetIndex(indexes[i].key, indexes[j].key)) {
      redundant.push({ 
        redundantIndex: indexes[i].name, 
        canBeReplacedBy: indexes[j].name 
      });
    }
  }
}

printjson(redundant);

[
  { "redundantIndex": "userId_1", "canBeReplacedBy": "userId_1_status_1" },
  { "redundantIndex": "status_1", "canBeReplacedBy": "userId_1_status_1" }
]

// 分析查詢使用的索引
db.orders.find({ userId: 123, status: "shipped" }).explain("executionStats");

// 關(guān)鍵輸出
{
  "queryPlanner": {
    "winningPlan": {
      "stage": "FETCH",
      "inputStage": {
        "stage": "IXSCAN",
        "indexName": "userId_1_status_1" // 實際使用的索引
      }
    }
  }
}

// 步驟1：標(biāo)記為hidden（繼續(xù)維護(hù)但不用于查詢）
db.orders.hideIndex("redundant_idx");

// 步驟2：監(jiān)控7天，確認(rèn)無查詢報錯

// 步驟3：正式刪除
db.orders.dropIndex("redundant_idx");

// 僅保留 { createdAt: 1 }
db.orders.find({ createdAt: { $gt: ... } })
          .sort({ createdAt: -1 }); // 用$sort替代降序索引

// 原始冗余索引
{ userId: 1, status: 1 }
{ userId: 1, createdAt: 1 }

// 優(yōu)化：合并為覆蓋索引
{ userId: 1, status: 1, createdAt: 1 }

db.orders.find(
  { userId: 123, status: "shipped" },
  { createdAt: 1, _id: 0 }
).explain("executionStats");

// 關(guān)鍵輸出：stage: "PROJECTION_COVERED" → 確認(rèn)覆蓋

// 刪除唯一索引（如郵箱唯一性約束）
db.users.dropIndex("email_1");

// 分片集群專用命令
sh.stopBalancer();
db.adminCommand({
  removeShardIndex: "mydb.orders",
  index: "redundant_idx"
});
sh.startBalancer();

// 手動觸發(fā)空間回收
db.runCommand({ compact: "orders" });

// 檢查索引是否支持查詢
db.orders.getIndexes().forEach(idx => {
  if (Object.keys(idx.key).includes("status")) {
    print(`Index ${idx.name} supports status query`);
  }
});

// 發(fā)現(xiàn)3組完全重復(fù)索引
// 5個字段子集索引（如{userId}和{userId, status}）
// 2個僵尸索引（`lastUsed=null`）

// 將3個單字段索引合并為覆蓋索引
db.orders.createIndex({ userId: 1, status: 1, createdAt: -1 });