精通MongoDB聚合操作API：深入探索高级技巧与实践

MongoDB 聚合操作API提供了强大的数据处理能力，能够对数据进行筛选、变换、分组、统计等复杂操作。本文介绍了MongoDB的基本用法和高级用法，高级用法涵盖了setWindowFields、merge、facet、expr、accumulator窗口函数、结果合并、多面聚合、查询表达式在聚合中的使用以及自定义聚合操作，基本用法涵盖了match、project、group、sort、limit、skip、unwind、lookup、graphLookup、sample、bucket等。

一、基本用法：

1. $match：筛选文档

作用：根据指定的查询条件过滤输入文档。

语法：

{ $match: { <query> } }

示例：筛选年龄大于等于30的用户文档：

db.users.aggregate([
  { $match: { age: { $gte: 30 } } }
]);

2. $project：重塑文档

作用：指定输出文档的字段及内容，可以包括添加新字段、重命名字段、删除字段、计算表达式等。

语法：

{ $project: { <field1>: <1 or 0>, <field2>: <1 or 0>, ... } }

示例：只输出用户姓名和年龄，不包含其他字段：

db.users.aggregate([
  { $project: { name: 1, age: 1, _id: 0 } } // _id: 0 表示不包含_id字段
]);

3. $group：分组并计算

作用：根据指定的键（通常是一个字段）对文档进行分组，并对每个组应用聚合函数（如计数、求和、平均值等）。

语法：

{ $group: { _id: <expression>, <field1>: { <accumulator1>: <expression1> }, ... } }

示例：按年龄分组，统计每个年龄段的用户数量：

db.users.aggregate([
  { $group: { _id: "$age", count: { $sum: 1 } } }
]);

4. $sort：排序文档

作用：对输入文档进行排序。

语法：

{ $sort: { <field1>: <1 or -1>, <field2>: <1 or -1>, ... } }

示例：按年龄降序排序用户：

db.users.aggregate([
  { $sort: { age: -1 } }
]);

5. $limit：限制输出文档数量

作用：限制输出结果集的最大文档数。

语法：

{ $limit: <number> }

示例：只返回前5个用户：

db.users.aggregate([
  { $limit: 5 }
]);

6. $skip：跳过指定数量的文档

作用：跳过指定数量的文档，返回剩余文档。

语法：

{ $skip: <number> }

示例：跳过前10个用户，返回剩下的用户：

db.users.aggregate([
  { $skip: 10 }
]);

7. $unwind：展开数组字段

作用：将文档中某个数组字段的每个元素拆分为独立文档。

语法：

{ $unwind: "<field>" }

示例：假设每个用户有多项技能，将技能数组拆分为独立文档：

db.users.aggregate([
  { $unwind: "$skills" }
]);

8. $lookup：联接其他集合

作用：执行类似于关系型数据库的左外部联接操作，将来自不同集合的数据合并到一个结果集中。

语法：

{ $lookup: {
  from: "<collection to join>",
  localField: "<field from the input documents>",
  foreignField: "<field from the documents of the 'from' collection>",
  as: "<output array field>"
} }

示例 ：假设有一个 orders 集合，联接用户和他们的订单：

db.users.aggregate([
  { $lookup: {
    from: "orders",
    localField: "_id",
    foreignField: "userId",
    as: "orders"
  } }
]);

9. $graphLookup：深度查询关联文档

作用：在集合中递归地查询与当前文档相关的文档，构建层次结构或图状结构。

语法：

{ $graphLookup: {
  from: "<collection to search>",
  startWith: "<expression>",
  connectFromField: "<field in the 'from' collection>",
  connectToField: "<field in the input documents>",
  as: "<output array field>",
  maxDepth: <number>,
  depthField: "<output field>",
  restrictSearchWithMatch: { <query> }
} }

示例 ：假设有一个 departments 集合，每个部门可能有上级部门，构建部门间的层级关系：

db.departments.aggregate([
  { $graphLookup: {
    from: "departments",
    startWith: "$parentDepartmentId",
    connectFromField: "parentDepartmentId",
    connectToField: "_id",
    as: "ancestors",
    maxDepth: 10,
    depthField: "level"
  } }
]);

10. $sample：随机采样文档

作用：从输入文档中随机选取指定数量的文档。

语法：

{ $sample: { size: <number> } }

示例：随机选取10个用户：

db.users.aggregate([
  { $sample: { size: 10 } }
]);

11. $bucket：桶式分组

作用：根据指定的范围边界将数据划分为桶（区间），并对每个桶进行统计或聚合操作。

语法：

{ $bucket: {
  groupBy: "<expression>",
  boundaries: [ <value1>, <value2>, ... ],
  default: <output document>,
  output: {
    <field1>: { <accumulator1>: <expression1> },
    <field2>: { <accumulator2>: <expression2> },
    ...
  }
} }

示例：将用户年龄分为几个区间，并统计每个区间的用户数量：

db.users.aggregate([
  { $bucket: {
    groupBy: "$age",
    boundaries: [ 18, 25, 30, 40, 50 ],
    default: "other",
    output: { count: { $sum: 1 } }
  } }
]);

12. $bucketAuto：自动桶式分组

作用：根据数据分布自动划分桶（区间），并进行统计或聚合操作。

语法：

{ $bucketAuto: {
  groupBy: "<expression>",
  buckets: <number>,
  granularity: "<string>",
  output: {
    <field1>: { <accumulator1>: <expression1> },
    <field2>: { <accumulator2>: <expression2> },
    ...
  }
} }

示例：自动将用户年龄分为若干区间，并统计每个区间的用户数量：

db.users.aggregate([
  { $bucketAuto: {
    groupBy: "$age",
    buckets: 5,
    output: { count: { $sum: 1 } }
  } }
]);

以上就是MongoDB聚合操作API的全面解析以及示例，涵盖了主要的聚合阶段。实际使用时，可以根据具体需求组合这些阶段，构建复杂的数据分析管道。注意，聚合管道的执行顺序是从左到右，先执行 $match 这样的筛选阶段通常可以提高性能。

MongoDB 聚合框架除了提供基本的聚合操作外，还支持一些高级操作，用于处理更复杂的数据分析场景。以下是对这些高级聚合操作API的全面解析以及示例：

二、高级用法：

1. $setWindowFields：窗口函数

作用：在一组相邻文档（称为窗口）上执行计算，每个文档的结果依赖于窗口内的其他文档。支持多种窗口函数，如排名、累加、移动平均、分组统计等。

语法：

{ $setWindowFields: {
  partitionBy: <expression>,
  sortBy: { <field1>: <1 or -1>, <field2>: <1 or -1>, ... },
  output: {
    <field1>: { <windowFunction1>: { ... } },
    <field2>: { <windowFunction2>: { ... } },
    ...
  }
} }

示例：计算每个用户的连续订单编号、订单总金额及订单数量：

db.orders.aggregate([
  { $setWindowFields: {
    partitionBy: "$userId",
    sortBy: { orderDate: 1 },
    output: {
      consecutiveOrderNumber: { $denseRank: {} },
      cumulativeTotalAmount: { $sum: "$amount", window: { documents: ["unbounded", "current"] } },
      orderCountInLast3Days: {
        $count: {},
        window: { range: [-3, "current"], unit: "day", timezone: "America/New_York" }
      }
    }
  } }
]);

2. $merge：合并结果到集合

作用：将聚合管道的结果合并到另一个集合中，支持插入、更新、替换等多种合并策略。

语法：

{ $merge: {
  into: "<collection>",
  on: <field or array of fields>,
  whenMatched: "<mergeMode>",
  whenNotMatched: "<mergeMode>",
  let: { <var1>: <expression1>, <var2>: <expression2>, ... },
  pipeline: [ <stage1>, <stage2>, ... ]
} }

示例 ：将按年龄分组统计的用户数量结果合并到 userCounts 集合中，存在则更新，不存在则插入：

db.users.aggregate([
  { $group: { _id: "$age", count: { $sum: 1 } } },
  { $merge: {
    into: "userCounts",
    on: "_id",
    whenMatched: "replace",
    whenNotMatched: "insert"
  } }
]);

3. $facet：多面聚合

作用：在一个阶段内执行多个聚合管道，每个管道可以有不同的阶段和输出字段，最终结果将所有子聚合的输出合并到一个文档中。

语法：

{ $facet: {
  <outputField1>: [ <stage1>, <stage2>, ... ],
  <outputField2>: [ <stage3>, <stage4>, ... ],
  ...
} }

示例：同时计算年龄大于等于30和小于30的用户数量：

db.users.aggregate([
  { $facet: {
    "over30": [
      { $match: { age: { $gte: 30 } } },
      { $count: "count" }
    ],
    "under30": [
      { $match: { age: { $lt: 30 } } },
      { $count: "count" }
    ]
  } }
]);

4. $expr：在聚合表达式中使用查询运算符

作用 ：在聚合操作（如 $match、$project、$redact 等）中使用查询表达式，允许在聚合管道中使用查询操作符。

语法：

{ $match: { $expr: { <query operator expression> } } }

示例：查找年龄比其所在部门平均年龄大的用户：

db.users.aggregate([
  {
    $lookup: {
      from: "departments",
      localField: "departmentId",
      foreignField: "_id",
      as: "department"
    }
  },
  {
    $unwind: "$department"
  },
  {
    $match: {
      $expr: {
        $gt: ["$age", { $avg: "$department.ages" }]
      }
    }
  }
]);

5. $accumulator：自定义聚合操作

作用 ：允许定义自己的聚合操作（自定义累加器），用于在 $group 阶段执行特定的计算。

语法：

db.createAggregateAccumulator(
  "<accumulatorName>",
  "<javascriptCode>",
  { finalize: "<javascriptCode>", lang: "<language>" }
)

// 在聚合管道中使用自定义累加器
{ $group: { _id: "$category", customValue: { $accumulator: "<accumulatorName>" } } }

示例：创建一个自定义累加器，计算文档数组中每个元素的平方和：

db.createAggregateAccumulator(
  "squareSum",
  "function(values) { return values.reduce((acc, val) => acc + Math.pow(val, 2), 0); }",
  { lang: "js" }
)

// 在聚合管道中使用自定义累加器
db.items.aggregate([
  { $group: { _id: "$category", squareSum: { $accumulator: "squareSum", initialValue: [], accumulateArgs: ["$itemValues"] } } }
]);

以上就是MongoDB聚合高级操作API的全面解析以及示例，涵盖了窗口函数、结果合并、多面聚合、查询表达式在聚合中的使用以及自定义聚合操作。这些高级操作极大地扩展了聚合框架的功能，使其能够应对更复杂的数据分析需求。在实际使用时，应根据具体业务场景灵活运用这些高级操作，构建高效、精确的聚合管道。