关于java:详细教程一文参透MongoDB聚合查询

MongoDB 聚合查问

什么是聚合查问

聚合操作次要用于解决数据并返回计算结果。聚合操作将来自多个文档的值组合在一起，按条件分组后，再进行一系列操作（如求和、平均值、最大值、最小值）以返回单个后果。

MongoDB 的聚合查问

​ 聚合是 MongoDB 的高级查询语言，它容许咱们通过转化合并由多个文档的数据来生成新的在单个文档里不存在的文档信息。MongoDB 中聚合 (aggregate) 次要用于解决数据（例如分组统计平均值、求和、最大值等），并返回计算后的数据后果，有点相似 sql 语句中的 count(*)、group by。

​ 在 MongoDB 中，有两种形式计算聚合：Pipeline 和 MapReduce。Pipeline 查问速度快于 MapReduce，然而 MapReduce 的弱小之处在于可能在多台 Server 上并行执行简单的聚合逻辑。MongoDB 不容许 Pipeline 的单个聚合操作占用过多的零碎内存。

聚合管道办法

MongoDB 的聚合框架就是将文档输出解决管道，在管道内实现对文档的操作，最终将文档转换为聚合后果，MongoDB 的聚合管道将 MongoDB 文档在一个管道处理完毕后将后果传递给下一个管道解决，管道操作是能够反复的。

​ 最根本的管道阶段提供过滤器，其操作相似查问和文档转换，能够批改输入文档的模式。其余管道操作提供了按特定字段对文档进行分组和排序的工具，以及用于聚合数组内容（包含文档数组）的工具。

​ 此外，在管道阶段还能够应用运算符来执行诸如计算平均值或连贯字符串之类的工作。聚合管道能够在分片汇合上运行。

聚合流程

db.collection.aggregate()是基于数据处理的聚合管道，每个文档通过一个由多个阶段（stage）组成的管道，能够对每个阶段的管道进行分组、过滤等性能，而后通过一系列的解决，输入相应的后果。

聚合管道办法的流程参见下图

上图的聚合操作相当于 MySQL 中的以下语句：

select cust_id as _id, sum(amount) as total from orders where status like "%A%" group by cust_id;

具体流程

1. db.collection.aggregate() 能够用多个构件创立一个管道，对于一连串的文档进行解决。这些构件包含：筛选操作的match、映射操作的project、分组操作的group、排序操作的sort、限度操作的limit、和跳过操作的skip。
2. db.collection.aggregate()应用了 MongoDB 内置的原生操作，聚合效率十分高, 反对相似于 SQL Group By 操作的性能，而不再须要用户编写自定义的 JavaScript 例程。
3. 每个阶段管道限度为 100MB 的内存。如果一个节点管道超过这个极限,MongoDB 将产生一个谬误。为了可能在解决大型数据集, 能够设置 allowDiskUse 为true来在聚合管道节点把数据写入临时文件。这样就能够解决 100MB 的内存的限度。
4. db.collection.aggregate()能够作用在分片汇合，但后果不能输在分片汇合，MapReduce能够 作用在分片汇合，后果也能够输在分片汇合。
5. db.collection.aggregate()办法能够返回一个指针（cursor），数据放在内存中，间接操作。跟 Mongo shell 一样指针操作。
6. db.collection.aggregate()输入的后果只能保留在一个文档中，BSON Document大小限度为 16M。能够通过返回指针解决，版本 2.6 中：DB.collect.aggregate()办法返回一个指针，能够返回任何后果集的大小。

聚合语法

db.collection.aggregate(pipeline, options)

参数阐明

注意事项

​ 应用 db.collection.aggregate()间接查问会提醒谬误，然而传一个空数组如 db.collection.aggregate([])则不会报错，且会和 find 一样返回所有文档。

罕用聚合管道

与 mysql 聚合类比

为了便于了解，先将常见的 mongo 的聚合操作和 mysql 的查问做下类比

$count

返回蕴含输出到 stage 的文档的计数，了解为返回与表或视图的 find()查问匹配的文档的计数。db.collection.count()办法不执行 find()操作，而是计数并返回与查问匹配的后果数。

语法

{$count: <string>}

$count 阶段相当于上面 $group+$project 的序列：

db.collection.aggregate([
    {
        "$group": {
            "_id": null,
            "count": {// 这里 count 自定义，相当于 mysql 的 select count(*) as tables
                "$sum": 1
            }
        }
    },
    {
        "$project": {// 返回不显示_id 字段
            "_id": 0
        }
    }
])

示例

查问人数是 100000 以上的城市的数量

• $match：阶段排除 pop 小于等于 100000 的文档，将大于 100000 的文档传到下个阶段
• $count：阶段返回聚合管道中残余文档的计数，并将该值调配给名为 count 的字段。

db.zips.aggregate([
    {
        "$match": {
            "pop": {"$gt": 100000}
        }
    },
    {"$count": "count"}
])

$group

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

​ 输入文档还能够蕴含计算字段，该字段保留由 $group 的_id 字段分组的一些 accumulator 表达式的值。$group 不会输入具体的文档而只是统计信息。

语法

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

• _id字段是必填的; 然而，能够指定_id 值为 null 来为整个输出文档计算累计值。
• 残余的计算字段是可选的，并应用 <accumulator> 运算符进行计算。
• _id和 <accumulator> 表达式能够承受任何无效的表达式。

accumulator 操作符

$group 阶段的内存限度为 100M，默认状况下，如果 stage 超过此限度，$group 将产生谬误，然而，要容许解决大型数据集，请将 allowDiskUse 选项设置为 true 以启用 $group 操作以写入临时文件。

留神：

• “$addToSet”:expr，如果以后数组中不蕴含 expr，那就将它增加到数组中。
• “$push”:expr，不论 expr 是什么值，都将它增加到数组中，返回蕴含所有值的数组。

示例

依照 state 分组，并计算每一个 state 分组的总人数，均匀人数以及每个分组的数量

db.zips.aggregate([
    {
        "$group": {
            "_id": "$state",
            "totalPop": {"$sum": "$pop"},
            "avglPop": {"$avg": "$pop"},
            "count": {"$sum": 1}
        }
    }
])

查找不反复的所有的 state 的值

db.zips.aggregate([
    {
        "$group": {"_id": "$state"}
    }
])

依照 city 分组，并且分组内的 state 字段列表退出到 stateItem 并显示

db.zips.aggregate([
    {
        "$group": {
            "_id": "$city",
            "stateItem": {"$push": "$state"}
        }
    }
])

上面聚合操作应用零碎变量 $$ROOT 按 item 对文档进行分组，生成的文档不得超过 BSON 文档大小限度

db.zips.aggregate([
    {
        "$group": {
            "_id": "$city",
            "item": {"$push": "$$ROOT"}
        }
    }
]).pretty();

$match

过滤文档，仅将合乎指定条件的文档传递到下一个管道阶段。

$match 承受一个指定查问条件的文档，查问语法与读操作查问语法雷同。

语法

{$match: { <query>} }

管道优化

​ $match 用于对文档进行筛选，之后能够在失去的文档子集上做聚合，$match 能够应用除了天文空间之外的所有惯例查问操作符，在理论利用中尽可能将 $match 放在管道的后面地位。这样有两个益处：

• 一是能够疾速将不须要的文档过滤掉，以 缩小管道的工作量；
• 二是如果再投射和分组之前执行 $match，查问能够应用索引。

应用限度

• 不能在 $match 查问中应用 $ 作为聚合管道的一部分。
• 要在 $match 阶段应用 $text，$match 阶段必须是管道的第一阶段。
• 视图不反对文本搜寻。

示例

应用 $match 做简略的匹配查问，查问缩写是 NY 的城市数据

db.zips.aggregate([
    {
        "$match": {"state": "NY"}
    }
]).pretty();

应用 $match 管道抉择要解决的文档，而后将后果输入到 $group 管道以计算文档的计数

db.zips.aggregate([
    {
        "$match": {"state": "NY"}
    },
    {
        "$group": {
            "_id": null,
            "sum": {"$sum": "$pop"},
            "avg": {"$avg": "$pop"},
            "count": {"$sum": 1}
        }
    }
]).pretty();

$unwind

从输出文档解构数组字段以输入每个元素的文档，简略说就是 能够将数组拆分为独自的文档。

语法

要指定字段门路，在字段名称前加上 $ 符并用引号括起来。

{$unwind: <field path>}

v3.2+ 反对如下语法

{
  $unwind:
    {
      path: <field path>,
      #可选, 一个新字段的名称用于寄存元素的数组索引。该名称不能以 $ 结尾。includeArrayIndex: <string>, 
      #可选，default :false，若为 true, 如果门路为空，短少或为空数组，则 $unwind 输入文档
      preserveNullAndEmptyArrays: <boolean> 
     } 
 }

​ 如果为输出文档中不存在的字段指定门路，或者该字段为空数组，则 $unwind 默认会疏忽输出文档，并且不会输入该输出文档的文档。

版本 3.2 中的新性能：要输入数组字段失落的文档，null 或空数组，请应用选项 preserveNullAndEmptyArrays。

示例

以下聚合应用 $unwind 为 loc 数组中的每个元素输入一个文档：

db.zips.aggregate([
    {
        "$match": {"_id": "01002"}
    },
    {"$unwind": "$loc"}
]).pretty();

$project

$project 能够从文档中抉择想要的字段，和不想要的字段（指定的字段能够是来自输出文档或新计算字段的现有字段），也能够通过管道表达式进行一些简单的操作，例如数学操作，日期操作，字符串操作，逻辑操作。

语法

$project 管道符的作用是抉择字段（指定字段，增加字段，不显示字段,_id：0，排除字段等），重命名字段，派生字段。

{$project: { <specification(s)> } }

specifications 有以下模式：

<field>: <1 or true> 是否蕴含该字段，field:1/0，示意抉择 / 不抉择 field

_id: <0 or false> 是否指定_id 字段

<field>: <expression> 增加新字段或重置现有字段的值。在版本 3.6 中更改：MongoDB 3.6 增加变量 REMOVE。如果表达式的计算结果为 $$REMOVE，则该字段将排除在输入中。

<field>:<0 or false> v3.4 新增性能，指定排除字段

• 默认状况下，_id 字段蕴含在输入文档中。要在输入文档中蕴含输出文档中的任何其余字段，必须明确指定 $project 中的蕴含。如果指定蕴含文档中不存在的字段，$project 将疏忽该字段蕴含，并且不会将该字段增加到文档中。
• 默认状况下，_id 字段蕴含在输入文档中。要从输入文档中排除_id 字段，必须明确指定 $project 中的_id 字段为 0。
• v3.4 版新增性能 - 如果指定排除一个或多个字段，则所有其余字段将在输入文档中返回。如果指定排除_id 以外的字段，则不能应用任何其余 $project 标准表单：即，如果排除字段，则不能指定蕴含字段，重置现有字段的值或增加新字段。此限度不适用于应用 REMOVE 变量条件排除字段。
• v3.6 版本中的新性能 - 从 MongoDB 3.6 开始，能够在聚合表达式中应用变量 REMOVE 来有条件地禁止一个字段。
• 要增加新字段或重置现有字段的值，请指定字段名称并将其值设置为某个表达式。
• 要将字段值间接设置为数字或布尔文本，而不是将字段设置为解析为文字的表达式，请应用 $literal 操作符。否则，$project 会将数字或布尔文字视为蕴含或排除该字段的标记。
• 通过指定新字段并将其值设置为现有字段的字段门路，能够无效地重命名字段。
• 从 MongoDB 3.2 开始，$project 阶段反对应用方括号 [] 间接创立新的数组字段。如果数组标准蕴含文档中不存在的字段，则该操作会将空值替换为该字段的值。
• 在版本 3.4 中更改 - 如果 $project 是一个空文档，MongoDB 3.4 和更高版本会产生一个谬误。
• 投影或增加 / 重置嵌入文档中的字段时，能够应用点符号

示例

以下 $project 阶段的输入文档中只蕴含_id，city 和 state 字段

db.zips.aggregate([
    {
        "$project": {
            "_id": 1,
            "city": 1,
            "state": 1
        }
    }
]).pretty();

_id字段默认蕴含在内。要从 $ project 阶段的输入文档中排除 _id 字段，请在 project 文档中将 _id 字段设置为 0 来指定排除_id 字段。

db.zips.aggregate([
    {
        "$project": {
            "_id": 0,
            "city": 1,
            "state": 1
        }
    }
]).pretty();

以下 $ project 阶段从输入中排除 loc 字段

db.zips.aggregate([
    {
        "$project": {"loc": 0}
    }
]).pretty();

能够在聚合表达式中应用变量 REMOVE 来有条件地禁止一个字段，

db.zips.aggregate([
    {
        "$project": {
            "_id": 1,
            "city": 1,
            "state": 1,
            "pop": 1,
            "loc": {
                "$cond": {
                    "if": {
                        "$gt": [
                            "$pop",
                            1000
                        ]
                    },
                    "then": "$$REMOVE",
                    "else": "$loc"
                }
            }
        }
    }
]).pretty();

咱们还能够扭转数据，将人数大于 1000 的城市坐标重置为 0

db.zips.aggregate([
    {
        "$project": {
            "_id": 1,
            "city": 1,
            "state": 1,
            "pop": 1,
            "loc": {
                "$cond": {
                    "if": {
                        "$gt": [
                            "$pop",
                            1000
                        ]
                    },
                    "then": [
                        0,
                        0
                    ],
                    "else": "$loc"
                }
            }
        }
    }
]).pretty();

新增字段列

db.zips.aggregate([
    {
        "$project": {
            "_id": 1,
            "city": 1,
            "state": 1,
            "pop": 1,
            "desc": {
                "$cond": {
                    "if": {
                        "$gt": [
                            "$pop",
                            1000
                        ]
                    },
                    "then": "人数过多",
                    "else": "人数过少"
                }
            },
            "loc": {
                "$cond": {
                    "if": {
                        "$gt": [
                            "$pop",
                            1000
                        ]
                    },
                    "then": [
                        0,
                        0
                    ],
                    "else": "$loc"
                }
            }
        }
    }
]).pretty();

$limit

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

语法

{$limit: <positive integer>}

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

db.zips.aggregate({"$limit": 5});

留神

​ 当 $sort 在管道中的 $limit 之前立刻呈现时，$sort 操作只会在过程中维持前 n 个后果，其中 n 是指定的限度，而 MongoDB 只须要将 n 个项存储在内存中。当 allowDiskUse 为 true 并且 n 个我的项目超过聚合内存限度时，此优化依然实用。

$skip

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

语法

{$skip: <positive integer>}

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

db.zips.aggregate({"$skip": 5});

$sort

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

语法

{$sort: { <field1>: <sort order>, <field2>: <sort order> ...} }

$sort 指定要排序的字段和相应的排序程序的文档。<sort order>能够具备以下值之一：

• 1 指定升序。
• - 1 指定降序。
• {$meta：“textScore”}依照降序排列计算出的 textScore 元数据。

示例

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

db.zips.aggregate([
    {
        "$sort": {
            "pop": -1,
            "city": 1
        }
    }
])

$sortByCount

依据指定表达式的值对传入文档分组，而后计算每个不同组中文档的数量。每个输入文档都蕴含两个字段：蕴含不同分组值的_id 字段和蕴含属于该分组或类别的文档数的计数字段，文件按降序排列。

语法

{$sortByCount:  <expression>}

应用示例

上面举了一些罕用的 mongo 聚合例子和 mysql 比照，假如有一条如下的数据库记录（表名：zips）作为例子：

统计所有数据

SQL 的语法格局如下

select count(1) from zips;

mongoDB 的语法格局

db.zips.aggregate([
    {
        "$group": {
            "_id": null,
            "count": {"$sum": 1}
        }
    }
])

对所有城市人数求合

SQL 的语法格局如下

select sum(pop) AS tota from zips;

mongoDB 的语法格局

db.zips.aggregate([
    {
        "$group": {
            "_id": null,
            "total": {"$sum": "$pop"}
        }
    }
])

对城市缩写雷同的城市人数求合

SQL 的语法格局如下

select state,sum(pop) AS tota from zips group by state;

mongoDB 的语法格局

db.zips.aggregate([
    {
        "$group": {
            "_id": "$state",
            "total": {"$sum": "$pop"}
        }
    }
])

state 反复的城市个数

SQL 的语法格局如下

select state,count(1) AS total from zips group by state;

mongoDB 的语法格局

db.zips.aggregate([
    {
        "$group": {
            "_id": "$state",
            "total": {"$sum": 1}
        }
    }
])

state 反复个数大于 100 的城市

SQL 的语法格局如下

select state,count(1) AS total from zips group by state having count(1)>100;

mongoDB 的语法格局

db.zips.aggregate([
    {
        "$group": {
            "_id": "$state",
            "total": {"$sum": 1}
        }
    },
    {
        "$match": {
            "total": {"$gt": 100}
        }
    }
])

本文由传智教育博学谷 – 狂野架构师教研团队公布，转载请注明出处！

如果本文对您有帮忙，欢送关注和点赞；如果您有任何倡议也可留言评论或私信，您的反对是我保持创作的能源