MongoDB聚合操作

Firechou2024-01-07 17:53

聚合操作概述

聚合操作允许用户处理多个文档并返回计算结果。聚合操作组值来自多个文档，可以对分组数据执行各种操作以返回单个结果。

聚合操作包含三类：单一作用聚合、聚合管道、MapReduce。

  • 单一作用聚合

提供了对常见聚合过程的简单访问，操作都从单个集合聚合文档。MongoDB 提供 db.collection.estimatedDocumentCount()、db.collection.countDocument()、db.collection.distinct()这类单一作用的聚合函数。 所有这些操作都聚合来自单个集合的文档。虽然这些操作提供了对公共聚合过程的简单访问，但它们缺乏聚合管道和 map-Reduce 的灵活性和功能。

  • 聚合管道

是一个数据聚合的框架，模型基于数据处理流水线的概念。文档进入多级管道，将文档转换为聚合结果。

  • MapReduce

操作具有两个阶段：处理每个文档并向每个输入文档发射一个或多个对象的 map 阶段，以及 reduce 组合 map 操作的输出阶段。从 MongoDB 5.0 开始，map-reduce 操作已被弃用。聚合管道比 map-reduce 操作提供更好的性能和可用性。

MongoDB 6.0 在原有聚合功能的基础上，推出了如下新特性以及优化项：

  • 分片集群实例支持 $lookup 和 $graphLookup。
  • 改进 $lookup 对 JOINS 的支持。
  • 改进 $graphLookup 对图遍历的支持。
  • 提升 $lookup 性能，部分场景中性能提升可达百倍。

聚合管道

MongoDB 聚合框架（Aggregation Framework）是一个计算框架，它可以：

  • 作用在一个或几个集合上；
  • 对集合中的数据进行的一系列运算；
  • 将这些数据转化为期望的形式；

从效果而言，聚合框架相当于 SQL 查询中的 GROUP BY、 LEFT OUTER JOIN 、 AS 等。

管道（Pipeline）和阶段（Stage）

整个聚合运算过程称为管道（Pipeline），它是由多个阶段（Stage）组成的， 每个管道：

  • 接受一系列文档（原始数据）；
  • 每个阶段对这些文档进行一系列运算；
  • 结果文档输出给下一个阶段；

通过将多个操作符组合到聚合管道中，用户可以构建出足够复杂的数据处理管道以提取数据并进行分析。

聚合管道操作语法：

bash 复制代码 
pipeline = [$stage1, $stage2, ...$stageN];
db.collection.aggregate(pipeline, {options})
  • pipelines

组数聚合阶段。除 o u t 、 out、 out、Merge 和 $geonear 阶段之外，每个阶段都可以在管道中出现多次。

  • options

可选，聚合操作的其他参数。包含：查询计划、是否使用临时文件、 游标、最大操作时间、读写策略、强制索引等等。

图示说明：

常用的聚合阶段运算符

聚合管道包含非常丰富的聚合阶段，下面是最常用的聚合阶段。

阶段运算符 描述 SQL等价运算符
$match 筛选条件 WHERE
$project 投影 AS
$lookup 左外连接 LEFT OUTER JOIN
$sort 排序 ORDER BY
$group 分组 GROUP BY
s k i p / skip/ skip/limit 分页
$unwind 展开数组
$graphLookup 图搜索
f a c e t / facet/ facet/bucket 分面搜索

参考文档：https://www.mongodb.com/docs/manual/reference/operator/aggregation-pipeline/

聚合表达式：

bash 复制代码 
# 获取字段信息
$<field> ：用 $ 指示字段路径
$<field>.<sub field> ：使用 $ 和 . 来指示内嵌文档的路径

常量表达式：

bash 复制代码 
$literal :<value> ：指示常量 <value>

系统变量表达式：

bash 复制代码 
$$<variable>  使用 $$ 指示系统变量
$$CURRENT 指示管道中当前操作的文档

测试数据脚本：

bash 复制代码 
var tags = ["nosql","mongodb","document","developer","popular"];
var types = ["technology","sociality","travel","novel","literature"];
var books=[];
for(var i=0;i<50;i++){
    var typeIdx = Math.floor(Math.random()*types.length);
    var tagIdx = Math.floor(Math.random()*tags.length);
    var tagIdx2 = Math.floor(Math.random()*tags.length);
    var favCount = Math.floor(Math.random()*100);
    var username = "xx00"+Math.floor(Math.random()*10);
    var age = 20 + Math.floor(Math.random()*15);
    var book = {
        title: "book-"+i,
        type: types[typeIdx],
        tag: [tags[tagIdx],tags[tagIdx2]],
        favCount: favCount,
        author: {name:username,age:age}
    };
    books.push(book)
}
db.books.insertMany(books);

SQL to Aggregation Mapping Chart：https://www.mongodb.com/docs/manual/reference/sql-aggregation-comparison/

下面详细说明。

$project

投影操作， 将原始字段投影成指定名称， 如将集合中的 title 投影成 name：

bash 复制代码 
db.books.aggregate([{$project:{name:"$title"}}])

$project 可以灵活控制输出文档的格式，也可以剔除不需要的字段：

bash 复制代码 
db.books.aggregate([{$project:{name:"$title",_id:0,type:1,author:1}}])

从嵌套文档中排除字段：

bash 复制代码 
db.books.aggregate([
    {$project:{name:"$title",_id:0,type:1,"author.name":1}}
])

或者

bash 复制代码 
db.books.aggregate([
    {$project:{name:"$title",_id:0,type:1,author:{name:1}}}
])

$match

m a t c h 用于对文档进行筛选，之后可以在得到的文档子集上做聚合， match 用于对文档进行筛选，之后可以在得到的文档子集上做聚合， match用于对文档进行筛选，之后可以在得到的文档子集上做聚合，match 可以使用除了地理空间之外的所有常规查询操作符，在实际应用中尽可能将 $match 放在管道的前面位置。这样有两个好处：一是可以快速将不需要的文档过滤掉，以减少管道的工作量；二是如果在投射和分组之前执行 $match，查询可以使用索引。

bash 复制代码 
db.books.aggregate([{$match:{type:"technology"}}])

筛选管道操作和其他管道操作配合时候时，尽量放到开始阶段，这样可以减少后续管道操作符要操作的文档数，提升效率。

bash 复制代码 
db.books.aggregate([
    {$match:{type:"technology"}},
    {$project:{name:"$title",_id:0,type:1,author:{name:1}}}
])

$count

计数并返回与查询匹配的结果数。

bash 复制代码 
db.books.aggregate([
    {$match:{type:"technology"}},
    {$count: "type_count"}
])

说明：
m a t c h 阶段筛选出 t y p e 匹配 t e c h n o l o g y 的文档，并传到下一阶段； < b r / > match 阶段筛选出 type 匹配 technology 的文档，并传到下一阶段；<br /> match阶段筛选出type匹配technology的文档，并传到下一阶段；<br/>count 阶段返回聚合管道中剩余文档的计数，并将该值分配给 type_count；

$group

按指定的表达式对文档进行分组，并将每个不同分组的文档输出到下一个阶段。输出文档包含一个 _id 字段，该字段按键包含不同的组。

输出文档还可以包含计算字段，该字段保存由 $group 的 _id 字段分组的一些 accumulator 表达式的值。 $group不会输出具体的文档而只是统计信息。

bash 复制代码 
{ $group: { _id: <expression>, <field1>: { <accumulator1> : <expression1> }, ... } }

_id 字段是必填的。但是，可以指定 _id 值为 null 来为整个输入文档计算累计值。

剩余的计算字段是可选的，并使用 运算符进行计算。

_id 和 表达式可以接受任何有效的表达式。

accumulator 操作符：

名称 描述 类比sql
$avg 计算均值。 avg
$first 返回每组第一个文档，如果有排序，按照排序，如果没有按照默认的存储的顺序的第一个文档。 limit 0,1
$last 返回每组最后一个文档，如果有排序，按照排序，如果没有按照默认的存储的顺序的最后个文档。 -
$max 根据分组，获取集合中所有文档对应值得最大值。 max
$min 根据分组，获取集合中所有文档对应值得最小值。 min
$push 将指定的表达式的值添加到一个数组中。 -
$addToSet 将表达式的值添加到一个集合中（无重复值，无序）。 -
$sum 计算总和。 sum
$stdDevPop 返回输入值的总体标准偏差（population standard deviation）。 -
$stdDevSamp 返回输入值的样本标准偏差（the sample standard deviation）。 -

g r o u p 阶段的内存限制为 100 M 。默认情况下，如果 s t a g e 超过此限制， group 阶段的内存限制为 100M。默认情况下，如果 stage 超过此限制， group阶段的内存限制为100M。默认情况下，如果stage超过此限制，group 将产生错误。但是，要允许处理大型数据集，请将 allowDiskUse 选项设置为 true 以启用 $group 操作以写入临时文件。

book 的数量，收藏总数和平均值：

bash 复制代码 
db.books.aggregate([
    {$group:{_id:null,count:{$sum:1},pop:{$sum:"$favCount"},avg:{$avg:"$favCount"}}}
])

统计每个作者的 book 收藏总数：

bash 复制代码 
db.books.aggregate([
    {$group:{_id:"$author.name",pop:{$sum:"$favCount"}}}
])

统计每个作者的每本 book 的收藏数：

bash 复制代码 
db.books.aggregate([
    {$group:{_id:{name:"$author.name",title:"$title"},pop:{$sum:"$favCount"}}}
])

每个作者的 book 的 type 合集：

bash 复制代码 
db.books.aggregate([
    {$group:{_id:"$author.name",types:{$addToSet:"$type"}}}
])

$unwind

可以将数组拆分为单独的文档。

v3.2+ 支持如下语法：

bash 复制代码 
{
  $unwind:
    {
      # 要指定字段路径，在字段名称前加上$符并用引号括起来。
      path: <field path>,
      # 可选，一个新字段的名称用于存放元素的数组索引。该名称不能以$开头。
      includeArrayIndex: <string>,  
      # 可选，default: false，若为true，如果路径为空，缺少或为空数组，则$unwind输出文档
      preserveNullAndEmptyArrays: <boolean> 
 } }

姓名为 xx006 的作者的 book 的 tag 数组拆分为多个文档：

bash 复制代码 
db.books.aggregate([
    {$match:{"author.name":"xx006"}},
    {$unwind:"$tag"}
])

db.books.aggregate([
    {$match:{"author.name":"xx006"}}
])

每个作者的 book 的 tag 合集：

bash 复制代码 
db.books.aggregate([
    {$unwind:"$tag"},
    {$group:{_id:"$author.name",types:{$addToSet:"$tag"}}}
])

案例

示例数据：

bash 复制代码 
db.books.insert([
{
    "title" : "book-51",
    "type" : "technology",
    "favCount" : 11,
     "tag":[],
    "author" : {
        "name" : "firechou",
        "age" : 28
    }
},{
    "title" : "book-52",
    "type" : "technology",
    "favCount" : 15,
    "author" : {
        "name" : "firechou",
        "age" : 28
    }
},{
    "title" : "book-53",
    "type" : "technology",
    "tag" : [
        "nosql",
        "document"
    ],
    "favCount" : 20,
    "author" : {
        "name" : "firechou",
        "age" : 28
    }
}])

测试：

bash 复制代码 
# 使用includeArrayIndex选项来输出数组元素的数组索引
db.books.aggregate([
    {$match:{"author.name":"firechou"}},
    {$unwind:{path:"$tag", includeArrayIndex: "arrayIndex"}}
])
# 使用preserveNullAndEmptyArrays选项在输出中包含缺少size字段，null或空数组的文档
db.books.aggregate([
    {$match:{"author.name":"firechou"}},
    {$unwind:{path:"$tag", preserveNullAndEmptyArrays: true}}
])

$limit

限制传递到管道中下一阶段的文档数。

bash 复制代码 
db.books.aggregate([
    {$limit : 5 }
])

此操作仅返回管道传递给它的前 5 个文档。 $limit 对其传递的文档内容没有影响。

注意：当 $sort 在管道中的 l i m i t 之前立即出现时， limit 之前立即出现时， limit之前立即出现时，sort 操作只会在过程中维持前 n 个结果，其中 n 是指定的限制，而 MongoDB 只需要将 n 个项存储在内存中。

$skip

跳过进入 stage 的指定数量的文档，并将其余文档传递到管道中的下一个阶段。

bash 复制代码 
db.books.aggregate([
    {$skip : 5 }
])

此操作将跳过管道传递给它的前 5 个文档。 $skip 对沿着管道传递的文档的内容没有影响。

$sort

对所有输入文档进行排序，并按排序顺序将它们返回到管道。

bash 复制代码 
{ $sort: { <field1>: <sort order>, <field2>: <sort order> ... } }

要对字段进行排序，请将排序顺序设置为 1 或 -1，以分别指定升序或降序排序，如下例所示：

bash 复制代码 
db.books.aggregate([
    {$sort : {favCount:-1,"author.age":1}}
])

$lookup

MongoDB 3.2 版本新增，主要用来实现多表关联查询，相当关系型数据库中多表关联查询。每个输入待处理的文档，经过 $lookup 阶段的处理，输出的新文档中会包含一个新生成的数组（可根据需要命名新 key ）。数组列存放的数据是来自被 Join 集合的适配文档，如果没有，集合为空（即 为[ ]）。

语法：

bash 复制代码 
db.collection.aggregate([{
      $lookup: {
             from: "<collection to join>",
             localField: "<field from the input documents>",
             foreignField: "<field from the documents of the from collection>",
             as: "<output array field>"
           }
  })

参数说明：

from 同一个数据库下等待被 Join 的集合。
localField 源集合中的 match 值，如果输入的集合中，某文档没有 localField 这个Key（Field），在处理的过程中，会默认为此文档含有 localField：null 的键值对。
foreignField 待 Join 的集合的 match 值，如果待 Join 的集合中，文档没有 foreignField 值，在处理的过程中，会默认为此文档含有 foreignField：null 的键值对。
as 为输出文档的新增值命名。如果输入的集合中已存在该值，则会覆盖掉。

注意：null = null 此为真。

其语法功能类似于下面的伪 SQL 语句：

plsql 复制代码 
SELECT *, <output array field>
FROM collection
WHERE <output array field> IN (SELECT *
                               FROM <collection to join>
                               WHERE <foreignField>= <collection.localField>);

案例

数据准备：

bash 复制代码 
db.customer.insert({customerCode:1,name:"customer1",phone:"13112345678",address:"test1"})
db.customer.insert({customerCode:2,name:"customer2",phone:"13112345679",address:"test2"})

db.order.insert({orderId:1,orderCode:"order001",customerCode:1,price:200})
db.order.insert({orderId:2,orderCode:"order002",customerCode:2,price:400})

db.orderItem.insert({itemId:1,productName:"apples",qutity:2,orderId:1})
db.orderItem.insert({itemId:2,productName:"oranges",qutity:2,orderId:1})
db.orderItem.insert({itemId:3,productName:"mangoes",qutity:2,orderId:1})
db.orderItem.insert({itemId:4,productName:"apples",qutity:2,orderId:2})
db.orderItem.insert({itemId:5,productName:"oranges",qutity:2,orderId:2})
db.orderItem.insert({itemId:6,productName:"mangoes",qutity:2,orderId:2})

关联查询：

bash 复制代码 
db.customer.aggregate([        
    {$lookup: {
       from: "order",
       localField: "customerCode",
       foreignField: "customerCode",
       as: "customerOrder"
     }
    } 
])

db.order.aggregate([
    {$lookup: {
               from: "customer",
               localField: "customerCode",
               foreignField: "customerCode",
               as: "curstomer"
             }
        
    },
    {$lookup: {
               from: "orderItem",
               localField: "orderId",
               foreignField: "orderId",
               as: "orderItem"
             }
    }
])

聚合操作案例 1

统计每个分类的 book 文档数量：

bash 复制代码 
db.books.aggregate([
    {$group:{_id:"$type",total:{$sum:1}}},
    {$sort:{total:-1}}
])

标签的热度排行，标签的热度则按其关联 book 文档的收藏数（favCount）来计算：

bash 复制代码 
db.books.aggregate([
    {$match:{favCount:{$gt:0}}},
    {$unwind:"$tag"},
    {$group:{_id:"$tag",total:{$sum:"$favCount"}}},
    {$sort:{total:-1}}
])

说明：

$match 阶段：用于过滤 favCount=0 的文档。

unwind 阶段：用于将标签数组进行展开，这样一个包含 3 个标签的文档会被拆解为 3 个条目。 g r o u p 阶段：对拆解后的文档进行分组计算， ' group 阶段：对拆解后的文档进行分组计算，\` group阶段：对拆解后的文档进行分组计算，'sum："favCount"`表示按 favCount 字段进行累加。

$sort 阶段：接收分组计算的输出，按 total 得分进行排序。

统计 book 文档收藏数 [0,10),[10,60),[60,80),[80,100),[100,+∞)：

bash 复制代码 
db.books.aggregate([{
    $bucket:{
        groupBy:"$favCount",
        boundaries:[0,10,60,80,100],
        default:"other",
        output:{"count":{$sum:1}}
    }
}])

聚合操作案例 2

导入邮政编码数据集

数据地址：https://media.mongodb.org/zips.json

下载完成后，使用 mongoimport 工具导入数据：

bash 复制代码 
mongoimport -h 192.168.65.174 -d test -u firechou -p firechou --authenticationDatabase=admin -c zips --file /user/local/mongodb/import/zips.json

h,--host：代表远程连接的数据库地址，默认连接本地 Mongo 数据库；

--port：代表远程连接的数据库的端口，默认连接的远程端口 27017；

-u,--username：代表连接远程数据库的账号，如果设置数据库的认证，需要指定用户账号；

-p,--password：代表连接数据库的账号对应的密码；

-d,--db：代表连接的数据库；

-c,--collection：代表连接数据库中的集合；

-f, --fields：代表导入集合中的字段；

--type：代表导入的文件类型，包括 csv 和 json, tsv 文件，默认 json 格式；

--file：导入的文件名称；

--headerline：导入 csv 文件时，指明第一行是列名，不需要导入；

返回人口超过 1000 万的州：

bash 复制代码 
db.zips.aggregate( [
   { $group: { _id: "$state", totalPop: { $sum: "$pop" } } },
   { $match: { totalPop: { $gte: 10*1000*1000 } } }
] )

这个聚合操作的等价 SQL 是：

plsql 复制代码 
SELECT state, SUM(pop) AS totalPop
FROM zips
GROUP BY state
HAVING totalPop >= (10*1000*1000)

返回各州平均城市人口：

bash 复制代码 
db.zips.aggregate( [
   { $group: { _id: { state: "$state", city: "$city" }, cityPop: { $sum: "$pop" } } },
   { $group: { _id: "$_id.state", avgCityPop: { $avg: "$cityPop" } } }
] )

按州返回最大和最小的城市：

bash 复制代码 
db.zips.aggregate( [
   { $group:
      {
        _id: { state: "$state", city: "$city" },
        pop: { $sum: "$pop" }
      }
   },
   { $sort: { pop: 1 } },
   { $group:
      {
        _id : "$_id.state",
        biggestCity:  { $last: "$_id.city" },
        biggestPop:   { $last: "$pop" },
        smallestCity: { $first: "$_id.city" },
        smallestPop:  { $first: "$pop" }
      }
   },
  { $project:
    { _id: 0,
      state: "$_id",
      biggestCity:  { name: "$biggestCity",  pop: "$biggestPop" },
      smallestCity: { name: "$smallestCity", pop: "$smallestPop" }
    }
  }
] )

聚合优化

https://www.mongodb.com/docs/manual/core/aggregation-pipeline-optimization/

聚合优化的三大目标：

  • 尽可能利用索引完成搜索和排序
  • 尽早尽多减少数据量
  • 尽可能减少执行步骤

执行顺序

m a t c h / match/ match/sort vs p r o j e c t / project/ project/addFields：

为了使查询能够命中索引， m a t c h / match/ match/sort 步骤需要在最前面，该原则适用于 MongoDB <= 3.4。MongoDB 3.6 开始具备一定的自动优化能力。

$project + s k i p / skip/ skip/limit：
s k i p / skip/ skip/limit 应该尽可能放在 $project 之前，减少 $project 的工作量。3.6 开始自动完成这个优化。

内存排序

在没有索引支持的情况下，MongoDB 最多只支持使用 100MB 内存进行排序。假设总共可用内存为 16GB，一个请求最多可以使用 100MB 内存排序，总共可以有 16000 / 100 = 160 个请求同时执行。

内存排序消耗的不仅是内存，还有大量CPU。

方案一：$sort + $limit

只排Top N ，只要 N 条记录总和不超过 100MB 即可。

方案二：{allowDiskUse: true}

使用磁盘作为交换空间完成全量，超出 100MB 部分与磁盘交换排序。

方案三：索引排序

使用索引完成排序，没有内存限制。

相关推荐
十叶知秋9 分钟前
【jmeter】jmeter的线程组功能的详细介绍
数据库·jmeter·性能测试
瓜牛_gn2 小时前
mysql特性
数据库·mysql
奶糖趣多多3 小时前
Redis知识点
数据库·redis·缓存
CoderIsArt4 小时前
Redis的三种模式：主从模式，哨兵与集群模式
数据库·redis·缓存
师太，答应老衲吧6 小时前
SQL实战训练之，力扣：2020. 无流量的帐户数（递归）
数据库·sql·leetcode
Channing Lewis7 小时前
salesforce case可以新建一个roll up 字段，统计出这个case下的email数量吗
数据库·salesforce
毕业设计制作和分享8 小时前
ssm《数据库系统原理》课程平台的设计与实现+vue
前端·数据库·vue.js·oracle·mybatis
ketil278 小时前
Redis - String 字符串
数据库·redis·缓存
Hsu_kk9 小时前
MySQL 批量删除海量数据的几种方法
数据库·mysql
编程学无止境9 小时前
第02章 MySQL环境搭建
数据库·mysql
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10红米手机使用google play