MongoDB中从序列值提取连续范围（含自定义步长）的解决方案咨询

任务1：默认步长（步长=1）的连续范围提取 #

针对你1亿条文档的场景，直接全量扫描会很慢，所以第一步要给x字段建立单字段索引：

db.collection.createIndex({x: 1})

然后使用以下聚合查询来精准提取连续区间：

db.collection.aggregate([
  // 先按x排序（利用索引，避免内存排序）
  { $sort: { x: 1 } },
  // 用窗口函数获取前一个文档的x值
  {
    $setWindowFields: {
      partitionBy: { $strLenCP: { $toString: "$x" } }, // 按数字位数分区，减少窗口计算量
      sortBy: { x: 1 },
      output: {
        prevX: { $lag: "$x", offset: 1 }
      }
    }
  },
  // 判断当前x是否和前一个x连续，生成分组标识
  {
    $addFields: {
      isContinuous: { $eq: [{ $subtract: ["$x", "$prevX"] }, 1] },
      // 当prevX不存在（第一个文档）或者不连续时，生成新的分组key
      groupKey: {
        $cond: [
          { $or: [{ $eq: ["$prevX", null] }, { $ne: [{ $subtract: ["$x", "$prevX"] }, 1] }] },
          "$x",
          null
        ]
      }
    }
  },
  // 向前填充groupKey，把同一连续区间的文档打上相同的分组key
  {
    $setWindowFields: {
      partitionBy: { $strLenCP: { $toString: "$x" } },
      sortBy: { x: 1 },
      output: {
        groupKey: { $fill: { output: { groupKey: { method: "locf" } } } }
      }
    }
  },
  // 按groupKey分组统计连续区间的min、max、count
  {
    $group: {
      _id: "$groupKey",
      minX: { $min: "$x" },
      maxX: { $max: "$x" },
      count: { $sum: 1 }
    }
  },
  // 整理成你需要的输出格式
  {
    $project: {
      _id: 0,
      x: ["$minX", "$maxX"],
      count: "$count"
    }
  },
  // 可选：按区间起始值排序
  { $sort: { "x.0": 1 } }
])

关键优化点： #

• 按数字位数分区：你提到数据分为10位和15位数字，分区后每个窗口的计算范围缩小，大幅提升性能
• 利用索引排序：$sort阶段直接使用x的索引，避免内存中排序1亿条数据
• 窗口函数+向前填充：高效标记同一连续区间的文档，避免复杂的条件判断

任务2：自定义步长的连续范围提取 #

假设步长为step=3，核心思路和任务1一致，只是修改连续判断的条件。同样先确保y字段有索引：

db.collection.createIndex({y: 1})

聚合查询（可替换step变量为你需要的步长）：

const step = 3; // 自定义步长
db.collection.aggregate([
  { $sort: { y: 1 } },
  {
    $setWindowFields: {
      partitionBy: { $strLenCP: { $toString: "$y" } }, // 同样按数字位数分区优化
      sortBy: { y: 1 },
      output: {
        prevY: { $lag: "$y", offset: 1 }
      }
    }
  },
  {
    $addFields: {
      isContinuous: { $eq: [{ $subtract: ["$y", "$prevY"] }, step] },
      groupKey: {
        $cond: [
          { $or: [{ $eq: ["$prevY", null] }, { $ne: [{ $subtract: ["$y", "$prevY"] }, step] }] },
          "$y",
          null
        ]
      }
    }
  },
  {
    $setWindowFields: {
      partitionBy: { $strLenCP: { $toString: "$y" } },
      sortBy: { y: 1 },
      output: {
        groupKey: { $fill: { output: { groupKey: { method: "locf" } } } }
      }
    }
  },
  {
    $group: {
      _id: "$groupKey",
      minY: { $min: "$y" },
      maxY: { $max: "$y" },
      count: { $sum: 1 }
    }
  },
  {
    $project: {
      _id: 0,
      y: ["$minY", "$maxY"],
      count: "$count"
    }
  },
  { $sort: { "y.0": 1 } }
])

说明： #

• 只需修改step变量即可适配不同步长需求
• 同样继承了任务1的性能优化点，适合大集合场景

关于你现有初步实现的补充 #

你当前的查询是按数字位数分组，只能得到每个位数段的整体范围，无法拆分内部的连续子区间。上面的方案在你的基础上，通过窗口函数实现了精准的连续区间划分，同时保留了按位数分区的性能优势。

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