聚合框架中常用的几个操作:

  • $project:修改输入文档的结构。可以用来重命名、增加或删除域,也可以用于创建计算结果以及嵌套文档。(显示的列,相当遇sql 的)
  • $match:用于过滤数据,只输出符合条件的文档。$match使用MongoDB的标准查询操作。  (相当sql的 where)
  • $limit:用来限制MongoDB聚合管道返回的文档数。
  • $skip:在聚合管道中跳过指定数量的文档,并返回余下的文档。
  • $unwind:将文档中的某一个数组类型字段拆分成多条,每条包含数组中的一个值。
  • $group:将集合中的文档分组,可用于统计结果,( 其中_id 相当于sql 的 group by ,   其它的写函数语法 )。
  • $sort:将输入文档排序后输出。
  • $geoNear:输出接近某一地理位置的有序文档。
  1.        DBCollection collection = baseMongoDAO.getCollection("seoProduce"); // 查询的表
           // $group
  2. DBObject group = new BasicDBObject();
  3. DBObject q = new BasicDBObject();
  4. DBObject l = new BasicDBObject();
  5. DBObject c = new BasicDBObject();
  6. l.put("site" , "$site");
  7. l.put("status" , "$status");
  8. c.put("$sum" ,1);
  9. q.put("_id" ,l);
  10. q.put("count",c );
  11. group.put("$group", q);
  12.  
  13. // $project
  14. DBObject project = new BasicDBObject();
  15. DBObject p = new BasicDBObject();
  16. p.put( "_id" , 0);
  17. p.put("site", "$_id.site");
  18. p.put("status", "$_id.status");
  19. p.put("count" ,"$count");
  20. project.put("$project", p);
  21.  
  22. // $match
  23. DBObject match = new BasicDBObject();
  24. match.put("$match", new BasicDBObject());
  25. AggregationOutput output = collection.aggregate(project match group); // 顺序必须是 顺序必须是 project match group 【非常重要】

下面的是复制的贴:

mongodb高级聚合查询

 

  在工作中会经常遇到一些mongodb的聚合操作,特此总结下。mongo存储的可以是复杂类型,比如数组、对象等mysql不善于处理的文档型结构,并且聚合的操作也比mysql复杂很多。

注:本文基于 mongodb v3.6

目录

  • mongo与mysql聚合类比
  • aggregate简介
  • aggregate语法
  • aggregate常用pipeline stage介绍(本文核心)
  • node操作mongo聚合查询(本文核心)

mongo与mysql聚合类比

为了便于理解,先将常见的mongo的聚合操作和mysql的查询做下类比:

SQL 操作/函数    mongodb聚合操作
where $match
group by $group
having $match
select $project
order by $sort
limit  $limit
sum() $sum
count() $sum
join

$lookup

(v3.2 新增)

下面举了一些常用的mongo聚合例子和mysql对比,假设有一条如下的数据库记录(表名:orders)作为例子:

  1. {
  2. cust_id: "abc123",
  3. ord_date: ISODate("2012-11-02T17:04:11.102Z"),
  4. status: 'A',
  5. price: 50,
  6. items: [ { sku: "xxx", qty: 25, price: 1 },
  7. { sku: "yyy", qty: 25, price: 1 } ]
  8. }

1. 统计orders表所有记录

  1. db.orders.aggregate( [
  2. {
  3. $group: {
  4. _id: null,
  5. count: { $sum: 1 }
  6. }
  7. }
  8. ] )
  9.  
  10. 类似mysql:
  11. SELECT COUNT(*) AS count FROM orders

2.对orders表计算所有price求和

  1. db.orders.aggregate( [
  2. {
  3. $group: {
  4. _id: null,
  5. total: { $sum: "$price" }
  6. }
  7. }
  8. ] )
  9.  
  10. 类似mysql;
  11. SELECT SUM(price) AS total FROM orders

3.对每一个唯一的cust_id, 计算price总和

  1. db.orders.aggregate( [
  2. {
  3. $group: {
  4. _id: "$cust_id",
  5. total: { $sum: "$price" }
  6. }
  7. }
  8. ] )
  9.  
  10. 类似mysql:
  11. SELECT cust_id,
  12. SUM(price) AS total
  13. FROM orders
  14. GROUP BY cust_id

4.对每一个唯一对cust_id和ord_date分组,计算price总和,不包括日期的时间部分

  1. db.orders.aggregate( [
  2. {
  3. $group: {
  4. _id: {
  5. cust_id: "$cust_id",
  6. ord_date: {
  7. month: { $month: "$ord_date" },
  8. day: { $dayOfMonth: "$ord_date" },
  9. year: { $year: "$ord_date"}
  10. }
  11. },
  12. total: { $sum: "$price" }
  13. }
  14. }
  15. ] )
  16.  
  17. 类似mysql
  18. SELECT cust_id,
  19. ord_date,
  20. SUM(price) AS total
  21. FROM orders
  22. GROUP BY cust_id,
  23. ord_date

5.对于有多个记录的cust_id,返回cust_id和对应的数量

  1. db.orders.aggregate( [
  2. {
  3. $group: {
  4. _id: "$cust_id",
  5. count: { $sum: 1 }
  6. }
  7. },
  8. { $match: { count: { $gt: 1 } } }
  9. ] )
  10.  
  11. 类似mysql:
  12. SELECT cust_id,
  13. count(*)
  14. FROM orders
  15. GROUP BY cust_id
  16. HAVING count(*) > 1

6.对每个唯一的cust_id和ord_date分组,计算价格总和,并只返回price总和大于250的记录,且排除日期的时间部分

  1. db.orders.aggregate( [
  2. {
  3. $group: {
  4. _id: {
  5. cust_id: "$cust_id",
  6. ord_date: {
  7. month: { $month: "$ord_date" },
  8. day: { $dayOfMonth: "$ord_date" },
  9. year: { $year: "$ord_date"}
  10. }
  11. },
  12. total: { $sum: "$price" }
  13. }
  14. },
  15. { $match: { total: { $gt: 250 } } }
  16. ] )
  17.  
  18. 类似mysql:
  19. SELECT cust_id,
  20. ord_date,
  21. SUM(price) AS total
  22. FROM orders
  23. GROUP BY cust_id,
  24. ord_date
  25. HAVING total > 250

7.对每个唯一的cust_id且status=A,计算price总和

  1. db.orders.aggregate( [
  2. { $match: { status: 'A' } },
  3. {
  4. $group: {
  5. _id: "$cust_id",
  6. total: { $sum: "$price" }
  7. }
  8. }
  9. ] )
  10.  
  11. 类似mysql:
  12. SELECT cust_id,
  13. SUM(price) as total
  14. FROM orders
  15. WHERE status = 'A'
  16. GROUP BY cust_id

8.对每个唯一的cust_id且status=A,计算price总和并且只返回price总和大于250的记录

  1. db.orders.aggregate( [
  2. { $match: { status: 'A' } },
  3. {
  4. $group: {
  5. _id: "$cust_id",
  6. total: { $sum: "$price" }
  7. }
  8. },
  9. { $match: { total: { $gt: 250 } } }
  10. ] )
  11.  
  12. 类似mysql:
  13. SELECT cust_id,
  14. SUM(price) as total
  15. FROM orders
  16. WHERE status = 'A'
  17. GROUP BY cust_id
  18. HAVING total > 250

9.对于每个唯一的cust_id,将与orders相关联的相应订单项order_lineitem的qty字段进行总计

  1. db.orders.aggregate( [
  2. { $unwind: "$items" },
  3. {
  4. $group: {
  5. _id: "$cust_id",
  6. qty: { $sum: "$items.qty" }
  7. }
  8. }
  9. ] )
  10.  
  11. 类似mysql:
  12. SELECT cust_id,
  13. SUM(li.qty) as qty
  14. FROM orders o,
  15. order_lineitem li
  16. WHERE li.order_id = o.id
  17. GROUP BY cust_id

10.统计不同cust_id和ord_date分组的数量,排除日期的时间部分

  1. db.orders.aggregate( [
  2. {
  3. $group: {
  4. _id: {
  5. cust_id: "$cust_id",
  6. ord_date: {
  7. month: { $month: "$ord_date" },
  8. day: { $dayOfMonth: "$ord_date" },
  9. year: { $year: "$ord_date"}
  10. }
  11. }
  12. }
  13. },
  14. {
  15. $group: {
  16. _id: null,
  17. count: { $sum: 1 }
  18. }
  19. }
  20. ] )
  21.  
  22. 类似mysql:
  23. SELECT COUNT(*)
  24. FROM (SELECT cust_id, ord_date
  25. FROM orders
  26. GROUP BY cust_id, ord_date)
  27. as DerivedTable

Aggregate简介

  db.collection.aggregate()是基于数据处理的聚合管道,每个文档通过一个由多个阶段(stage)组成的管道,可以对每个阶段的管道进行分组、过滤等功能,然后经过一系列的处理,输出相应的结果。

通过这张图,可以了解Aggregate处理的过程。

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()方法返回一个指针,可以返回任何结果集的大小。

Aggregate语法

基本格式:

  1. db.collection.aggregate(pipeline, options)

参数说明:

参数          类型            描述
pipeline array

一系列数据聚合操作或阶段。详见聚合管道操作符
在版本2.6中更改:该方法仍然可以将流水线阶段作为单独的参数接受,而不是作为数组中的元素;但是,如果不将管道指定为数组,则不能指定options参数

options document  

可选。 aggregate()传递给聚合命令的其他选项。
2.6版中的新增功能:仅当将管道指定为数组时才可用。

注意:

使用db.collection.aggregate()直接查询会提示错误,但是传一个空数组如db.collection.aggregate([])则不会报错,且会和find一样返回所有文档。

pipeline有很多stage,但这里我只记录我经常用到的几个,如果后续用到再补充。stage详见官网

接下来介绍这几个常用的stage:

$count , $group,  $match, $project,  $unwind, $limit, $skip,  $sort, $sortByCount,  $lookup, $out, $addFields

aggregate常用pipeline stage介绍

$count

释义:

返回包含输入到stage的文档的计数,理解为返回与表或视图的find()查询匹配的文档的计数。

db.collection.count()方法不执行find()操作,而是计数并返回与查询匹配的结果数。

语法:

  1. { $count: <string> }

$count阶段相当于下面$group+$project的序列:

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

举例:

示例数据:

  1. { "_id" : 1, "subject" : "History", "score" : 88 }
  2. { "_id" : 2, "subject" : "History", "score" : 92 }
  3. { "_id" : 3, "subject" : "History", "score" : 97 }
  4. { "_id" : 4, "subject" : "History", "score" : 71 }
  5. { "_id" : 5, "subject" : "History", "score" : 79 }
  6. { "_id" : 6, "subject" : "History", "score" : 83 }

执行:

1)$match 阶段排除score小于等于80的文档,将大于80的文档传到下个阶段

2)$count阶段返回聚合管道中剩余文档的计数,并将该值分配给名为passing_scores的字段。

执行结果:

$group

释义:

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

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

语法:

  1. { $group: { _id: <expression>, <field1>: { <accumulator1> : <expression1> }, ... } }
  • _id字段是必填的;但是,可以指定_id值为null来为整个输入文档计算累计值。
  • 剩余的计算字段是可选的,并使用<accumulator>运算符进行计算。
  • _id和<accumulator>表达式可以接受任何有效的表达式

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) -

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

友情备注:

  • "$addToSet":expr,如果当前数组中不包含expr,那就将它添加到数组中。
  • "$push":expr,不管expr是什么只,都将它添加到数组中。返回包含所有值的数组。

在版本2.6中进行了更改:对于$group阶段,MongoDB引入了100M内存的限制以及allowDiskUse选项来处理大数据集的操作。

举例:

示例数据:

  1. { "_id" : 1, "item" : "abc", "price" : 10, "quantity" : 2, "date" : ISODate("2014-03-01T08:00:00Z") }
  2. { "_id" : 2, "item" : "jkl", "price" : 20, "quantity" : 1, "date" : ISODate("2014-03-01T09:00:00Z") }
  3. { "_id" : 3, "item" : "xyz", "price" : 5, "quantity" : 10, "date" : ISODate("2014-03-15T09:00:00Z") }
  4. { "_id" : 4, "item" : "xyz", "price" : 5, "quantity" : 20, "date" : ISODate("2014-04-04T11:21:39.736Z") }
  5. { "_id" : 5, "item" : "abc", "price" : 10, "quantity" : 10, "date" : ISODate("2014-04-04T21:23:13.331Z") }

1. 以下汇总操作使用$group阶段按月份,日期和年份对文档进行分组,并计算total price和average quantity,并计算每个组的文档数量:

返回:

  1. /* 1 */
  2. {
  3. "_id" : {
  4. "month" : 4,
  5. "day" : 4,
  6. "year" : 2014
  7. },
  8. "totalPrice" : 200,
  9. "averageQuantity" : 15.0,
  10. "count" : 2.0
  11. }
  12.  
  13. /* 2 */
  14. {
  15. "_id" : {
  16. "month" : 3,
  17. "day" : 15,
  18. "year" : 2014
  19. },
  20. "totalPrice" : 50,
  21. "averageQuantity" : 10.0,
  22. "count" : 1.0
  23. }
  24.  
  25. /* 3 */
  26. {
  27. "_id" : {
  28. "month" : 3,
  29. "day" : 1,
  30. "year" : 2014
  31. },
  32. "totalPrice" : 40,
  33. "averageQuantity" : 1.5,
  34. "count" : 2.0
  35. }

2. group null  , 以下聚合操作将指定组_id为null,计算集合中所有文档的总价格和平均数量以及计数:

3. 查询distinct values

以下汇总操作使用$group阶段按item对文档进行分组以检索不同的项目值:

4. 数据转换

1)将集合中的数据按price分组转换成item数组

返回的数据id值是group中指定的字段,items可以自定义,是分组后的列表

2)下面聚合操作实用系统变量$$ROOT按item对文档进行分组,生成的文档不得超过BSON文档大小限制。

返回:

  1. /* 1 */
  2. {
  3. "_id" : "xyz",
  4. "books" : [
  5. {
  6. "_id" : 3,
  7. "item" : "xyz",
  8. "price" : 5,
  9. "quantity" : 10,
  10. "date" : ISODate("2014-03-15T09:00:00.000Z")
  11. },
  12. {
  13. "_id" : 4,
  14. "item" : "xyz",
  15. "price" : 5,
  16. "quantity" : 20,
  17. "date" : ISODate("2014-04-04T11:21:39.736Z")
  18. }
  19. ]
  20. }
  21.  
  22. /* 2 */
  23. {
  24. "_id" : "jkl",
  25. "books" : [
  26. {
  27. "_id" : 2,
  28. "item" : "jkl",
  29. "price" : 20,
  30. "quantity" : 1,
  31. "date" : ISODate("2014-03-01T09:00:00.000Z")
  32. }
  33. ]
  34. }
  35.  
  36. /* 3 */
  37. {
  38. "_id" : "abc",
  39. "books" : [
  40. {
  41. "_id" : 1,
  42. "item" : "abc",
  43. "price" : 10,
  44. "quantity" : 2,
  45. "date" : ISODate("2014-03-01T08:00:00.000Z")
  46. },
  47. {
  48. "_id" : 5,
  49. "item" : "abc",
  50. "price" : 10,
  51. "quantity" : 10,
  52. "date" : ISODate("2014-04-04T21:23:13.331Z")
  53. }
  54. ]
  55. }

$match

释义:

过滤文档,仅将符合指定条件的文档传递到下一个管道阶段。
$match接受一个指定查询条件的文档。查询语法与读操作查询语法相同。

语法:

  1. { $match: { <query> } }

管道优化:

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

限制:

  • 不能在$ match查询中使用$作为聚合管道的一部分。
  • 要在$match阶段使用$text,$match阶段必须是管道的第一阶段。
  • 视图不支持文本搜索。

举例:

示例数据:

  1. { "_id" : ObjectId("512bc95fe835e68f199c8686"), "author" : "dave", "score" : 80, "views" : 100 }
  2. { "_id" : ObjectId("512bc962e835e68f199c8687"), "author" : "dave", "score" : 85, "views" : 521 }
  3. { "_id" : ObjectId("55f5a192d4bede9ac365b257"), "author" : "ahn", "score" : 60, "views" : 1000 }
  4. { "_id" : ObjectId("55f5a192d4bede9ac365b258"), "author" : "li", "score" : 55, "views" : 5000 }
  5. { "_id" : ObjectId("55f5a1d3d4bede9ac365b259"), "author" : "annT", "score" : 60, "views" : 50 }
  6. { "_id" : ObjectId("55f5a1d3d4bede9ac365b25a"), "author" : "li", "score" : 94, "views" : 999 }
  7. { "_id" : ObjectId("55f5a1d3d4bede9ac365b25b"), "author" : "ty", "score" : 95, "views" : 1000 }

1.使用 $match做简单的匹配查询

返回:

  1. /* 1 */
  2. {
  3. "_id" : ObjectId("512bc95fe835e68f199c8686"),
  4. "author" : "dave",
  5. "score" : 80,
  6. "views" : 100
  7. }
  8.  
  9. /* 2 */
  10. {
  11. "_id" : ObjectId("512bc962e835e68f199c8687"),
  12. "author" : "dave",
  13. "score" : 85,
  14. "views" : 521
  15. }

2. 使用$match管道选择要处理的文档,然后将结果输出到$group管道以计算文档的计数:

返回:

  1. /* 1 */
  2. {
  3. "_id" : null,
  4. "count" : 5.0
  5. }

$unwind

释义:

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

语法:

  1. { $unwind: <field path> }

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

v3.2+支持如下语法:

  1. {
  2. $unwind:
  3. {
  4. path: <field path>,
  5. includeArrayIndex: <string>, #可选,一个新字段的名称用于存放元素的数组索引。该名称不能以$开头。
  1. preserveNullAndEmptyArrays: <boolean> #可选,default :false,若为true,如果路径为空,缺少或为空数组,则$unwind输出文档
  1. }
    }

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

版本3.2中的新功能:要输出数组字段丢失的文档,null或空数组,请使用选项preserveNullAndEmptyArrays。

举例:

1. 示例数据1:

  1. { "_id" : 1, "item" : "ABC1", sizes: [ "S", "M", "L"] }

以下聚合使用$unwind为sizes数组中的每个元素输出一个文档:

  1. db.getCollection('test').aggregate(
  2. [ { $unwind : "$sizes" } ]
  3. )
  4.  
  5. 返回:

{ "_id" : 1, "item" : "ABC1", "sizes" : "S" }
{ "_id" : 1, "item" : "ABC1", "sizes" : "M" }
{ "_id" : 1, "item" : "ABC1", "sizes" : "L" }

每个文档与输入文档相同,除了sizes字段的值是原始sizes数组的值。

2. 再如下示例数据:

  1. { "_id" : 1, "item" : "ABC", "sizes": [ "S", "M", "L"] }
  2. { "_id" : 2, "item" : "EFG", "sizes" : [ ] }
  3. { "_id" : 3, "item" : "IJK", "sizes": "M" }
  4. { "_id" : 4, "item" : "LMN" }
  5. { "_id" : 5, "item" : "XYZ", "sizes" : null }

1)以下$unwind操作使用includeArrayIndex选项来输出数组元素的数组索引。

  1. db.getCollection('test').aggregate( [ { $unwind: { path: "$sizes", includeArrayIndex: "arrayIndex" } } ] )
  2.  
  3. 返回:

{ "_id" : 1, "item" : "ABC", "sizes" : "S", "arrayIndex" : NumberLong(0) }
{ "_id" : 1, "item" : "ABC", "sizes" : "M", "arrayIndex" : NumberLong(1) }
{ "_id" : 1, "item" : "ABC", "sizes" : "L", "arrayIndex" : NumberLong(2) }
{ "_id" : 3, "item" : "IJK", "sizes" : "M", "arrayIndex" : null }

2)以下$unwind操作使用preserveNullAndEmptyArrays选项在输出中包含缺少size字段,null或空数组的文档。

  1. db.inventory.aggregate( [
  2. { $unwind: { path: "$sizes", preserveNullAndEmptyArrays: true } }
  3. ] )
  4.  
  5. 返回:
  6. { "_id" : 1, "item" : "ABC", "sizes" : "S" }
  7. { "_id" : 1, "item" : "ABC", "sizes" : "M" }
  8. { "_id" : 1, "item" : "ABC", "sizes" : "L" }
  9. { "_id" : 2, "item" : "EFG" }
  10. { "_id" : 3, "item" : "IJK", "sizes" : "M" }
  11. { "_id" : 4, "item" : "LMN" }
  12. { "_id" : 5, "item" : "XYZ", "sizes" : null }

$project

释义:

$project可以从文档中选择想要的字段,和不想要的字段(指定的字段可以是来自输入文档或新计算字段的现有字段

),也可以通过管道表达式进行一些复杂的操作,例如数学操作,日期操作,字符串操作,逻辑操作。

语法:

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

$project 管道符的作用是选择字段(指定字段,添加字段,不显示字段,_id:0,排除字段等),重命名字段,派生字段。

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和更高版本会产生一个错误。
  • 投影或添加/重置嵌入文档中的字段时,可以使用点符号。如:
  1. "contact.address.country": <1 or 0 or expression>

  2. contact: { address: { country: <1 or 0 or expression> } }

举例:

示例数据:

  1. {
  2. "_id" : 1,
  3. title: "abc123",
  4. isbn: "0001122223334",
  5. author: { last: "zzz", first: "aaa" },
  6. copies: 5,
  7. lastModified: "2016-07-28"
  8. }

1. 以下$project阶段的输出文档中只包含_id,title和author字段:

  1. db.getCollection('test').aggregate( [ { $project : { title : 1 , author : 1 } } ] )

返回:

  1. { "_id" : 1, "title" : "abc123", "author" : { "last" : "zzz", "first" : "aaa" } }

2. _id字段默认包含在内。要从$ project阶段的输出文档中排除_id字段,请在project文档中将_id字段设置为0来指定排除_id字段。

  1. db.getCollection('test').aggregate( [ { $project : { _id: 0, title : 1 , author : 1 } } ] )

返回:

  1. { "title" : "abc123", "author" : { "last" : "zzz", "first" : "aaa" } }

3.以下$ project阶段从输出中排除lastModified字段:

  1. db.getCollection('test').aggregate( [ { $project : { "lastModified": 0 } } ] )

4.从嵌套文档中排除字段, 在$ project阶段从输出中排除了author.first和lastModified字段:

  1. db.test.aggregate( [ { $project : { "author.first" : 0, "lastModified" : 0 } } ] )

或者可以将排除规范嵌套在文档中:

  1. db.test.aggregate( [ { $project: { "author": { "first": 0}, "lastModified" : 0 } } ] )

返回:

  1. {
  2. "_id" : 1,
  3. "title" : "abc123",
  4. "isbn" : "0001122223334",
  5. "author" : {
  6. "last" : "zzz"
  7. },
  8. "copies" : 5,
  9. }

3.6版本中的新功能。从MongoDB 3.6开始,可以在聚合表达式中使用变量REMOVE来有条件地禁止一个字段。

示例数据:

  1. {
  2. "_id" : 1,
  3. title: "abc123",
  4. isbn: "0001122223334",
  5. author: { last: "zzz", first: "aaa" },
  6. copies: 5,
  7. lastModified: "2016-07-28"
  8. }
  9. {
  10. "_id" : 2,
  11. title: "Baked Goods",
  12. isbn: "9999999999999",
  13. author: { last: "xyz", first: "abc", middle: "" },
  14. copies: 2,
  15. lastModified: "2017-07-21"
  16. }
  17. {
  18. "_id" : 3,
  19. title: "Ice Cream Cakes",
  20. isbn: "8888888888888",
  21. author: { last: "xyz", first: "abc", middle: "mmm" },
  22. copies: 5,
  23. lastModified: "2017-07-22"
  24. }

5. 下面的$project阶段使用REMOVE变量来排除author.middle字段,前提是它等于"":

  1. db.books.aggregate( [
  2. {
  3. $project: {
  4. title: 1,
  5. "author.first": 1,
  6. "author.last" : 1,
  7. "author.middle": {
  8. $cond: {
  9. if: { $eq: [ "", "$author.middle" ] },
  10. then: "$$REMOVE",
  11. else: "$author.middle"
  12. }
  13. }
  14. }
  15. }
  16. ] )

返回:

  1. { "_id" : 1, "title" : "abc123", "author" : { "last" : "zzz", "first" : "aaa" } }
  2. { "_id" : 2, "title" : "Baked Goods", "author" : { "last" : "xyz", "first" : "abc" } }
  3. { "_id" : 3, "title" : "Ice Cream Cakes", "author" : { "last" : "xyz", "first" : "abc", "middle" : "mmm" } }

包含来自嵌入文档的指定字段(结果只返回包含嵌套文档的字段,当然也包括_id)

示例文档:

  1. { _id: 1, user: "1234", stop: { title: "book1", author: "xyz", page: 32 } }
  2. { _id: 2, user: "7890", stop: [ { title: "book2", author: "abc", page: 5 }, { title: "book3", author: "ijk", page: 100 } ] }

只返回stop字段中的title字段:

  1. db.bookmarks.aggregate( [ { $project: { "stop.title": 1 } } ] )
  2.  

  3. db.bookmarks.aggregate( [ { $project: { stop: { title: 1 } } } ] )

返回:

  1. { "_id" : 1, "stop" : { "title" : "book1" } }
  2. { "_id" : 2, "stop" : [ { "title" : "book2" }, { "title" : "book3" } ] }

包含计算字段

示例数据:

  1. {
  2. "_id" : 1,
  3. title: "abc123",
  4. isbn: "0001122223334",
  5. author: { last: "zzz", first: "aaa" },
  6. copies: 5
  7. }

返回字段新增了isbn, lastname和copiesold

  1. db.books.aggregate(
  2. [
  3. {
  4. $project: {
  5. title: 1,
  6. isbn: {
  7. prefix: { $substr: [ "$isbn", 0, 3 ] },
  8. group: { $substr: [ "$isbn", 3, 2 ] },
  9. publisher: { $substr: [ "$isbn", 5, 4 ] },
  10. title: { $substr: [ "$isbn", 9, 3 ] },
  11. checkDigit: { $substr: [ "$isbn", 12, 1] }
  12. },
  13. lastName: "$author.last",
  14. copiesSold: "$copies"
  15. }
  16. }
  17. ]
  18. )

上面执行的返回结果:

  1. {
  2. "_id" : 1,
  3. "title" : "abc123",
  4. "isbn" : {
  5. "prefix" : "000",
  6. "group" : "11",
  7. "publisher" : "2222",
  8. "title" : "333",
  9. "checkDigit" : "4"
  10. },
  11. "lastName" : "zzz",
  12. "copiesSold" : 5
  13. }

投影出新数组字段

示例数据:

  1. { "_id" : ObjectId("55ad167f320c6be244eb3b95"), "x" : 1, "y" : 1 }

下面的聚合操作将返回新的数组字段myArray:

  1. db.collection.aggregate( [ { $project: { myArray: [ "$x", "$y" ] } } ] )

返回:

  1. { "_id" : ObjectId("55ad167f320c6be244eb3b95"), "myArray" : [ 1, 1 ] }

如果返回的数组包含了不存在的字段,则会返回null:

  1. db.collection.aggregate( [ { $project: { myArray: [ "$x", "$y", "$someField" ] } } ] )

返回:

  1. { "_id" : ObjectId("55ad167f320c6be244eb3b95"), "myArray" : [ 1, 1, null ] }

MongoDB的aggregate聚合的更多相关文章

  1. Mongodb - 解决 ( aggregate聚合管道 ) $match 根据 id 匹配 返回 [ ] 的问题

    需要对 id 进行转换 const mongoose = require('mongoose') var ObjectId = mongoose.Types.ObjectId;   await Use ...

  2. MongoDB学习day06--高级查询aggregate聚合管道和nodejs操作aggregate

    一.MongoDB聚合管道(Aggregation Pilpeline) 使用聚合管道可以对集合中的文档进行变换和组合. 主要功能:表的关联查询.数据统计 二.aggregate 管道操作符与表达式 ...

  3. MongoDB(七):聚合aggregate

    1. 聚合aggregate 聚合主要用于计算数据,类似sql中的sum().avg() 语法: db.集合名称.aggregate([{管道:{表达式}}]) stu准备的数据: db.stu.in ...

  4. Python全栈 MongoDB 数据库(聚合、二进制、GridFS、pymongo模块)

    断网了2天  今天补上     聚合操作: 对文档的信息进行整理统计的操作 返回:统计后的文档集合 db.collection.aggregate() 功能:聚合函数,完成聚合操作 参数:聚合条件,配 ...

  5. mongodb与sql聚合对应图 M

    mongodb与sql聚合对应图 M - CSDN博客 http://blog.csdn.net/u011930016/article/details/49422425 SQL Terms, Func ...

  6. Mongoose: aggregate聚合 $group使用说明

    aggregate聚合是通过管道操作实现的.聚合管道里的每一步输出,都会作为下一步的输入,每一步在输入文档执行完操作后生成输出文档. 聚合管道:  $project 修改输入文档的结构.可以用来重命名 ...

  7. 在MongoDB中实现聚合函数

    在MongoDB中实现聚合函数 随着组织产生的数据爆炸性增长,从GB到TB,从TB到PB,传统的数据库已经无法通过垂直扩展来管理如此之大数据.传统方法存储和处理数据的成本将会随着数据量增长而显著增加. ...

  8. mongodb aggregate 聚合 操作(扁平化flatten)

    mongodb自带的函数非常多,最近用mongo做持久化数据库,遇到一个需求:子文档是个数组,把数组里的各个字段扁平化合到根文档中,查过资料后(主要是mongodb的文档和stackoverflow) ...

  9. MongoDB的学习--聚合

    最近要去的新项目使用mysql,趁着还没忘记,总结记录以下MongoDB的聚合. 聚合是泛指各种可以处理批量记录并返回计算结果的操作.MongoDB提供了丰富的聚合操作,用于对数据集执行计算操作.在  ...

随机推荐

  1. 新建一个项目,如何使用abp用户登录系统

    1.首先参考Framework.Web里的packages.config,把相关的包都安装好. 2.App_Start文件夹下的xxxModule.cs和Startup.cs拷过来,修改下命名空间. ...

  2. 快速创建IIS站点并设置权限

     net user WebSiteUser WebSiteUserWebSiteUser /add /yWMIC Path Win32_UserAccount Where Name="Web ...

  3. CentOS_mini下安装docker 之 安装docker CE

    警告:切勿在没有配置 Docker YUM 源的情况下直接使用 yum 命令安装 Docker. 原文地址:https://yeasy.gitbooks.io/docker_practice/inst ...

  4. 【Spark2.0源码学习】-7.Driver与DriverRunner

         承接上一节内容,Client向Master发起RequestSubmitDriver请求,Master将DriverInfo添加待调度列表中(waitingDrivers),下面针对于Dri ...

  5. trinitycore 魔兽服务器源码分析(二) 网络

    书接上文 继续分析Socket.h SocketMgr.h template<class T>class Socket : public std::enable_shared_from_t ...

  6. js判断手机系统(Android或IOS),跳转相应下载地址

    <script type="text/javascript"> $(document).ready(function(e) { var u = navigator.us ...

  7. Mysql知识点个人整理

    1.概念 数据库:保存有组织的数据的容器. 表: 某种特定类型数据的结构化清单 模式:关于数据库和表的布局和特性的信息?(有时指数据库) 主键: primary key 一个列或一组列,其值能唯一区分 ...

  8. Mac下Tomcat安装与Intellij IDEA配置Tomcat

    Mac下Tomcat安装与Intellij IDEA配置Tomcat 一 安装 1 下载地址:https://tomcat.apache.org/download-90.cgi 2 将压缩包解压后移至 ...

  9. 2019.02.12 bzoj3944: Sum(杜教筛)

    传送门 题意: 思路:直接上杜教筛. 知道怎么推导就很简单了,注意预处理的范围. 然后我因为预处理范围不对被zxyoi教育了(ldx你这个傻×两倍常数活该被卡TLE) 喜闻乐见 代码: #includ ...

  10. ABP框架系列之四十六:(Setting-Management-设置管理)

    Introduction Every application need to store some settings and use these settings in somewhere in th ...