MongoDB批量更新Users文档：关联Countries集合替换字段为UUID

我明白你要处理数十万条Users文档的批量更新需求——把用户的国家、省份、城市、组织名称替换成Countries集合里对应的UUID，还要处理字段的层级依赖关系。你已经搭好了嵌套循环的架子，但缺了MongoDB实际的查询和更新逻辑，而且直接嵌套遍历集合效率会很低，我来帮你完善这个脚本。

首先，我们先把Countries集合的数据加载到内存，做成快速查找的映射结构（用Map对象），这样不用每次处理用户都去遍历整个Countries集合，能大幅提升效率，毕竟是数十万条数据，性能很重要。

第一步：构建Countries映射表 #

// 加载Countries数据并构建映射，方便快速查找UUID
const countryMap = {};
db.Countries.find().forEach(countryDoc => {
  const countryEntry = {
    uuid: countryDoc.uuid,
    provinces: new Map(), // 省份名称 -> {uuid: ..., cities: Map}
    organizations: new Map() // 组织名称 -> UUID
  };

  // 处理省份和下属城市的映射
  if (countryDoc.province?.length) {
    countryDoc.province.forEach(province => {
      const provinceInfo = {
        uuid: province.uuid,
        cities: new Map()
      };
      // 给当前省份添加城市映射
      if (province.city?.length) {
        province.city.forEach(city => provinceInfo.cities.set(city.key, city.uuid));
      }
      countryEntry.provinces.set(province.key, provinceInfo);
    });
  }

  // 处理组织的映射
  if (countryDoc.organization?.length) {
    countryDoc.organization.forEach(org => countryEntry.organizations.set(org.key, org.uuid));
  }

  countryMap[countryDoc.key] = countryEntry;
});

第二步：遍历Users集合执行批量更新 #

接下来我们遍历每个用户文档，根据映射表找到对应的UUID，然后执行MongoDB的更新操作。如果是超大规模数据，还可以用bulkWrite来优化性能：

基础版本（适合中等数据量）

// 遍历Users文档并更新
db.Users.find().forEach(userDoc => {
  const updateFields = {};

  // 先匹配国家UUID
  if (userDoc.country && countryMap[userDoc.country]) {
    updateFields.country = countryMap[userDoc.country].uuid;

    // 匹配省份UUID（依赖国家存在）
    if (userDoc.province) {
      const provinceInfo = countryMap[userDoc.country].provinces.get(userDoc.province);
      if (provinceInfo) {
        updateFields.province = provinceInfo.uuid;

        // 匹配城市UUID（依赖省份存在）
        if (userDoc.city) {
          const cityUuid = provinceInfo.cities.get(userDoc.city);
          if (cityUuid) updateFields.city = cityUuid;
        }
      }
    }

    // 匹配组织UUID（依赖国家存在）
    if (userDoc.organization) {
      const orgUuid = countryMap[userDoc.country].organizations.get(userDoc.organization);
      if (orgUuid) updateFields.organization = orgUuid;
    }
  }

  // 如果有需要更新的字段，执行更新
  if (Object.keys(updateFields).length) {
    db.Users.updateOne(
      { _id: userDoc._id },
      { $set: updateFields }
    );
    // 可选：打印更新日志，跟踪进度
    print(`Updated user ${userDoc.user} (ID: ${userDoc._id}): ${JSON.stringify(updateFields)}`);
  }
});

优化版本（适合数十万级大规模数据）

如果数据量特别大，用bulkWrite可以减少MongoDB的请求次数，避免频繁的网络开销：

const bulkOps = [];
const batchSize = 1000; // 每1000条执行一次批量操作

db.Users.find().forEach(userDoc => {
  const updateFields = {};
  // 这里的逻辑和上面基础版本完全一致
  if (userDoc.country && countryMap[userDoc.country]) {
    updateFields.country = countryMap[userDoc.country].uuid;

    if (userDoc.province) {
      const provinceInfo = countryMap[userDoc.country].provinces.get(userDoc.province);
      if (provinceInfo) {
        updateFields.province = provinceInfo.uuid;
        if (userDoc.city) {
          const cityUuid = provinceInfo.cities.get(userDoc.city);
          if (cityUuid) updateFields.city = cityUuid;
        }
      }
    }

    if (userDoc.organization) {
      const orgUuid = countryMap[userDoc.country].organizations.get(userDoc.organization);
      if (orgUuid) updateFields.organization = orgUuid;
    }
  }

  if (Object.keys(updateFields).length) {
    bulkOps.push({
      updateOne: {
        filter: { _id: userDoc._id },
        update: { $set: updateFields }
      }
    });

    // 达到批量阈值就执行更新
    if (bulkOps.length === batchSize) {
      db.Users.bulkWrite(bulkOps);
      bulkOps.length = 0; // 清空数组
      print(`Completed batch of ${batchSize} updates`);
    }
  }
});

// 执行剩余的未批量操作
if (bulkOps.length) {
  db.Users.bulkWrite(bulkOps);
  print(`Completed final batch of ${bulkOps.length} updates`);
}

关键说明 #

1. 空值/不存在字段处理：如果某个子字段（比如city）不存在或者找不到对应的UUID，脚本不会更新该字段，保持原文档的状态，符合你要求的"允许父字段存在但子字段为空或不存在"的规则。
2. 性能优化：用Map替代嵌套数组遍历，查找效率从O(n)变成O(1)，对于数十万数据来说，这个优化能节省大量时间。
3. 日志跟踪：脚本里的print语句可以帮你跟踪更新进度，避免不知道脚本运行到哪一步。

内容的提问来源于stack exchange，提问作者Bonnard