【翻译】MongoDB指南/聚合——聚合管道

发布时间:2018-11-15  栏目:NoSQL  评论:0 Comments

俺们先介绍一下 MongoDB
的集合功能,聚合操作主要用以对数据的批量拍卖,往往以记录按标准分组以后,然后又开展同样层层操作,例如,求最好可怜价值、最小值、平均值,求与相当操作。聚合操作还会对记录进行复杂的操作,主要用于数理统计和数码挖掘。在
MongoDB
中,聚合操作的输入是汇聚中的文档,输出可以是一个文档,也得是大半条文档。在管道查询过程遭到,上次询问的结果可以啊这次询问的法。

【原文地址】https://docs.mongodb.com/manual/

用阶段操作符之前,我们先押一下 article
集合中的文档列表,也即是范例中因故到的多寡。

聚合

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

>db.article.find().pretty()

{

   "_id": ObjectId("58e1d2f0bb1bbc3245fa7570")

   "title""MongoDB Aggregate",

   "author""liruihuan",

   "tags": ['Mongodb''Database''Query'],

   "pages": 5,

   "time" : ISODate("2017-04-09T11:42:39.736Z")

},

{

   "_id": ObjectId("58e1d2f0bb1bbc3245fa7571")

   "title""MongoDB Index",

   "author""liruihuan",

   "tags": ['Mongodb''Index''Query'],

   "pages": 3,

   "time" : ISODate("2017-04-09T11:43:39.236Z")

},

{

   "_id": ObjectId("58e1d2f0bb1bbc3245fa7572")

   "title""MongoDB Query",

   "author""eryueyang",

   "tags": ['Mongodb''Query'],

   "pages": 8,

   "time" : ISODate("2017-04-09T11:44:56.276Z")

}

聚集操作处理数量记录并回计算后的结果。聚合操作以大半个文档分组,并会对已经分组的数额实行同一雨后春笋操作而归单一结果。MongoDB提供了三栽实施聚合的点子:聚合管道,map-reduce方法和单纯目的聚合操作。

 

会师管道

1.1.1、$project 

MongoDB的集框架模型建立以数码处理管道这等同概念的底蕴之上。文档进入多等管道被,管道将文档转换为汇结果。最中心的管道等类似于查询过滤器和改动出口文档形式之文档转换器。

作用

旁的管道也分组和排序提供一些工具,可透过点名一个要么多个字段完成分组或排序;同时提供了聚合数组内容的家伙,操作的数组包括文档数组。另外,聚合阶段能够使有运算符,完成诸如计算均值或连字符串之类的职责。

改文档的构造,可以为此来更命名、增加还是去文档中之字段。

管道用MongoDB本机的操作方法提供了卓有成效的数目聚合操作,并且于数据聚合来说采用本机的操作方法是首选的。

范例1

集管道支持在分片集合上执行操作。

一味回去文档中 title 和 author 字段

集合管道在它的一点阶段会使用索引来提高性能。另外,聚合管道有一个之中优化等。

1

2

3

4

>db.article.aggregate([{$project:{_id:0, title:1, author:1 }}])

"title""MongoDB Aggregate",  "author""liruihuan" },

"title""MongoDB Index",  "author""liruihuan" },

"title""MongoDB Query",  "author""eryueyang" }

 图片 1

以许段 _id 是默认显示的,这里不可不用 _id:0 把字段_id过滤掉。

Map-Reduce

范例2

MongoDB也克提供map-reduce操作来好聚合。一般地,map-reduce操作发生星星点点单级次:map 阶段处理各一个文档并将诸一个输入文档映射成一个要么多单对象,reduce合成map等的出口。可挑选的,map-reduce操作可以发一个finalize路为对输出做最后之改。像其它的聚合操作一样,

拿文档中 pages 字段的价都增加10。并重命名成 newPages 字段。

 map-reduce操作会指定询问条件筛选输入文档和指向结果开展排序和界定。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

>db.article.aggregate(

   [

      {

          $project:{

               _id:0,

               title:1,

               author:1,

               newPages: {$add:["$Pages",10]}

         }

      }

   ]

)

"title""MongoDB Aggregate",  "author""liruihuan""newPages": 15 },

"title""MongoDB Index",  "author""liruihuan""newPages": 13  },

"title""MongoDB Query",  "author""eryueyang""newPages": 18  }

map-reduce使用自定义JavaScript方法来兑现map,reduce和finalize 操作。虽然和聚集管道相比,自定义JavaScript提供了极大的八面玲珑,

内部,$add 是 加
的意思,是算术类型表达式操作符,具体表达式操作符,下面会说到。

但是map-reduce比聚合管道效率低且比聚合管道还复杂。

1.1.2、$match

map-reduce可以在分片集合上实行操作。map-reduce操作也能用数据输出到分片集合上。

作用

注:

用于过滤文档。用法类似于 find() 方法被之参数。

自从2.4版开始,某些mongo shell 方法和特征不支持map-reduce操作。2.4本子为支持而运转多独JavaScript操作。2.4事先的版,

范例

JavaScript代码在单线程中施行,对map-reduce操作来说有并发问题。

询问有文档中 pages 字段的价值超过等于5之数额。

 图片 2

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

>db.article.aggregate(

    [

         {

              $match: {"pages": {$gte: 5}}

         }

    ]

   ).pretty()

{

   "_id": ObjectId("58e1d2f0bb1bbc3245fa7570")

   "title""MongoDB Aggregate",

   "author""liruihuan",

   "tags": ['Mongodb''Database''Query'],

   "pages": 5,

   "time" : ISODate("2017-04-09T11:42:39.736Z")

},

{

   "_id": ObjectId("58e1d2f0bb1bbc3245fa7572")

   "title""MongoDB Query",

   "author""eryueyang",

   "tags": ['Mongodb''Query'],

   "pages": 8,

   "time" : ISODate("2017-04-09T11:44:56.276Z")

}

单纯性目的聚合操作

注:

MongoDB还提供了db.collection.count(),
db.collection.group(), db.collection.distinct()专用数据库命令。

  • 以 $match 中无能够利用 $where 表达式操作符
  • 设 $match 位于管道的首先单等级,可以使用寻引来提高查询效率
  • $match 中使 $text 操作符的口舌,只能放在管道的率先等
  • $match
    尽量出现于管道的不过前边,过滤出待之数码,在延续的流受到可提高效率。

抱有这些操作自一个成团中集文档。虽然这些操作提供了简单的实现集操作的主意,但是她不够灵活性和和集管道和

1.1.3、$group

map-reduce相似的属性。

作用

 图片 3

以集结中之文档进行分组,可用以统计结果。

1 聚合管道

范例

汇聚管道是一个建立在数额处理管道模型概念基础及的框架。文档进入多阶段管道中,管道用文档转换为集聚结果。

起 article 中落每个 author 的篇章数,并输入 author 和呼应之稿子数。

 图片 4

1

2

3

4

5

6

7

8

9

>db.article.aggregate(

    [

         {

              $group: {_id: "$author", total: {$sum: 1}}

         }

    ]

   )

{"_id" "eryueyang""total" : 1}

{"_id" "liruihuan""total" : 2}

会合管道提供了map-reduce 的替代品,并且对 map-reduce的繁杂是多余的聚众任务的话,聚合管道可能是首选之解决方案。

1.1.4、$sort

聚拢管道对值的种以及归结果的分寸做了限制。

作用

1.1 管道

用集聚中之文档进行排序。

MongoDB 聚合管道由多只级次做。当文档经过逐一管道经常,每个管道对文档进行转移。对于每一个输入文档,管道各阶段不需有输出文档。例如,某些阶段或者会见变动新文档或过滤掉一部分文档。聚合管道的一些等级可以在管道遭冒出反复。

范例

MongoDB提供了而每当mongo shell中执行之db.collection.aggregate()方法和集合管道命令aggregate。

于集合 article 以 pages 升序排列

1.2 聚合管道表达式

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

>db.article.aggregate([{$sort: {"pages": 1}}]).pretty()

{

   "_id": ObjectId("58e1d2f0bb1bbc3245fa7571")

   "title""MongoDB Index",

   "author""liruihuan",

   "tags": ['Mongodb''Index''Query'],

   "pages": 3,

   "time" : ISODate("2017-04-09T11:43:39.236Z")

},

{

   "_id": ObjectId("58e1d2f0bb1bbc3245fa7570")

   "title""MongoDB Aggregate",

   "author""liruihuan",

   "tags": ['Mongodb''Database''Query'],

   "pages": 5,

   "time" : ISODate("2017-04-09T11:42:39.736Z")

},

{

   "_id": ObjectId("58e1d2f0bb1bbc3245fa7572")

   "title""MongoDB Query",

   "author""eryueyang",

   "tags": ['Mongodb''Query'],

   "pages": 8,

   "time" : ISODate("2017-04-09T11:44:56.276Z")

}

一些管道等采取聚合管道表达式作为它们的操作数。聚合管道表达式指定了采取为输入文档的转移。聚合管道表达式采用文档结构以可分包其他聚合管道表达式。

  如果以降序排列,则装成 “pages”: -1

聚集管道表达式能够单独作用被管道遭之眼前文档并且不见面提到其他文档数据:聚合管道表达式支持在内存中施行文档转换。

1.1.5、$limit

相似地,聚合管道表达式是任状态的还要只是于给集处理过程发现时才给求值,但累加器表达式除外。

作用

累加器用当$group阶段,当文档经过这个管道经常,它们的状态让封存下来(例如总数,最深价值,最小值,相关数据)。

克返回的文档数量

3.2本子中之扭转:某些累加器在$project阶段可以利用。然而,在$project阶段采取这些累加器时,这些累加器不见面保留其的状态及文档中。

范例

1.3 聚拢管道行为

归来集合 article 中前片长长的文档

以MongoDB中汇聚命令作用为一个聚众,在逻辑上将整个集合传入聚合管道。为了优化操作,尽可能地使下的政策以避免扫描整个集合。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

>db.article.aggregate([{$limit: 2}]).pretty()

{

   "_id": ObjectId("58e1d2f0bb1bbc3245fa7570")

   "title""MongoDB Aggregate",

   "author""liruihuan",

   "tags": ['Mongodb''Database''Query'],

   "pages": 5,

   "time" : ISODate("2017-04-09T11:42:39.736Z")

},

{

   "_id": ObjectId("58e1d2f0bb1bbc3245fa7571")

   "title""MongoDB Index",

   "author""liruihuan",

   "tags": ['Mongodb''Index''Query'],

   "pages": 3,

   "time" : ISODate("2017-04-09T11:43:39.236Z")

}

管道操作符合索引

1.1.6、$skip

$match 和$sort管道操作符能够以索引,当它在管道起处于起常常。

作用

2.4版的转:$geoNear管道操作符能够利用地理空间引得。当使用$geoNear时,$geoNear管道操作符必须出现在汇管道的第一路。

跳过指定数量的文档,并回到余下的文档。

3.2版中的更动:从3.2版本开始索引能够覆盖一个会师管道。在2.6
和3.0本被,索引不克掩盖聚合管道,因为就是管道用了目录,聚合还是得利用实际的文档。

范例

正如早地过滤

跳过集合 article 中一样长文档,输出剩下的文档

倘您的成团操作就需要汇聚中的一个数子集,那么下$match, $limit,和$skip阶段来限制最开头上管道的文档。当于放置管道的起来处于经常,$match操作使用相当的目,只扫描集合中匹配到的文档。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

>db.article.aggregate([{$skip: 1}]).pretty()

{

   "_id": ObjectId("58e1d2f0bb1bbc3245fa7571")

   "title""MongoDB Index",

   "author""liruihuan",

   "tags": ['Mongodb''Index''Query'],

   "pages": 3,

   "time" : ISODate("2017-04-09T11:43:39.236Z")

},

{

   "_id": ObjectId("58e1d2f0bb1bbc3245fa7572")

   "title""MongoDB Query",

   "author""eryueyang",

   "tags": ['Mongodb''Query'],

   "pages": 8,

   "time" : ISODate("2017-04-09T11:44:56.276Z")

}

每当管道的初步处于采用后紧跟了$sort阶段的$match管道阶段,这在逻辑上等价于使用了目录的隐含排序的询问操作。尽可能地拿$match阶段在管道的极致开头处于。

1.1.7、$unwind

其它的特性

作用

汇聚管道发生一个中尽优化等,这个路改进了几许操作的性。

以文档中数组类型的字段拆分成多长长的,每条文档包含数组中的一个值。

汇管道支持分片集合上的操作。

范例

1.4 聚合管道优化

管集合 article 中 title=”MongoDB Aggregate” 的 tags 字段拆分

汇聚管道操作发生一个优化等,此号试图重塑管道以改善性能。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

>db.article.aggregate(

    [

         {

              $match: {"title""MongoDB Aggregate"}

         },

         {

              $unwind: "$tags"

         }

    ]

   ).pretty()

{

   "_id": ObjectId("58e1d2f0bb1bbc3245fa7570")

   "title""MongoDB Aggregate",

   "author""liruihuan",

   "tags""Mongodb",

   "pages": 5,

   "time" : ISODate("2017-04-09T11:42:39.736Z")

},

{

   "_id": ObjectId("58e1d2f0bb1bbc3245fa7570")

   "title""MongoDB Aggregate",

   "author""liruihuan",

   "tags""Database",

   "pages": 5,

   "time" : ISODate("2017-04-09T11:42:39.736Z")

},

{

   "_id": ObjectId("58e1d2f0bb1bbc3245fa7570")

   "title""MongoDB Aggregate",

   "author""liruihuan",

   "tags""Query",

   "pages": 5,

   "time" : ISODate("2017-04-09T11:42:39.736Z")

}

啊翻动优化程序如何改进一个特定的集结管道,在db.collection.aggregate()方法中使用explain 选项。

注:

1.4.1 投影器优化

  • $unwind
    参数数组字段为空或非有时时,待处理的文档将会给忽视,该文档将未会见生出其它输出
  • $unwind 参数不是一个数组类型时,将会弃来特别
  • $unwind 所犯的修改,只用于出口,不克改原先文档

集合管道会判明是否采取集合中字段的一个子集来博结果。如果采取子集,那么聚集管道用只会利用那些急需之字段以压缩管道中传的数据量。

1.2、表达式操作符

1.4.2 管道顺序优化

 表达式操作符有许多操作类型,其中最常用的发布尔管道聚合操作、集合操作、比较聚合操作、算术聚合操作、字符串聚合操作、数组聚合操作、日期聚合操作、条件聚合操作、数据类型聚合操作等。每种型且起很多所以法,这里虽不一一举例了。

$sort + $match管道顺序优化

1.2.1、布尔管道聚合操作(Boolean Aggregation Operators)

名称 说明
$and Returns true only when all its expressions evaluate to true. Accepts any number of argument expressions.
$or Returns true when any of its expressions evaluates to true. Accepts any number of argument expressions.
$not Returns the boolean value that is the opposite of its argument expression. Accepts a single argument expression.

范例

如若发生一个聚众 mycol

1

2

3

4

5

"_id" : 1, "item" "abc1", description: "product 1", qty: 300 }

"_id" : 2, "item" "abc2", description: "product 2", qty: 200 }

"_id" : 3, "item" "xyz1", description: "product 3", qty: 250 }

"_id" : 4, "item" "VWZ1", description: "product 4", qty: 300 }

"_id" : 5, "item" "VWZ2", description: "product 5", qty: 180 }

规定 qty 是否超出250要小于200

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

db.mycol.aggregate(

   [

     {

       $project:

          {

            item: 1,

            result: { $or: [ { $gt: [ "$qty", 250 ] }, { $lt: [ "$qty", 200 ] } ] }

          }

     }

   ]

)

"_id" : 1, "item" "abc1""result" true }

"_id" : 2, "item" "abc2""result" false }

"_id" : 3, "item" "xyz1""result" false }

"_id" : 4, "item" "VWZ1""result" true }

"_id" : 5, "item" "VWZ2""result" true }

1.2.2、集合操作(Set Operators)

用于汇操作,求集合的并集、交集、差集运算。

名称 说明
$setEquals Returns true if the input sets have the same distinct elements. Accepts two or more argument expressions.
$setIntersection Returns a set with elements that appear in all of the input sets. Accepts any number of argument expressions.
$setUnion Returns a set with elements that appear in any of the input sets. Accepts any number of argument expressions.
$setDifference Returns a set with elements that appear in the first set but not in the second set; i.e. performs a relative complement of the second set relative to the first. Accepts exactly two argument expressions.
$setIsSubset Returns true if all elements of the first set appear in the second set, including when the first set equals the second set; i.e. not a strict subset. Accepts exactly two argument expressions.
$anyElementTrue Returns true if any elements of a set evaluate to true; otherwise, returns false. Accepts a single argument expression.
$allElementsTrue Returns true if no element of a set evaluates to false, otherwise, returns false. Accepts a single argument expression.

范例

假定有一个会师 mycol

1

2

3

4

5

6

7

8

9

"_id" : 1, "A" : [ "red""blue" ], "B" : [ "red""blue" ] }

"_id" : 2, "A" : [ "red""blue" ], "B" : [ "blue""red""blue" ] }

"_id" : 3, "A" : [ "red""blue" ], "B" : [ "red""blue""green" ] }

"_id" : 4, "A" : [ "red""blue" ], "B" : [ "green""red" ] }

"_id" : 5, "A" : [ "red""blue" ], "B" : [ ] }

"_id" : 6, "A" : [ "red""blue" ], "B" : [ [ "red" ], [ "blue" ] ] }

"_id" : 7, "A" : [ "red""blue" ], "B" : [ [ "red""blue" ] ] }

"_id" : 8, "A" : [ ], "B" : [ ] }

"_id" : 9, "A" : [ ], "B" : [ "red" ] }

求来集合 mycol 中 A 和 B 的杂

1

2

3

4

5

6

7

8

9

10

11

12

13

14

db.mycol.aggregate(

   [

     { $project: { A:1, B: 1, allValues: { $setUnion: [ "$A""$B" ] }, _id: 0 } }

   ]

)

"A": [ "red""blue" ], "B": [ "red""blue" ], "allValues": [ "blue""red" ] }

"A": [ "red""blue" ], "B": [ "blue""red""blue" ], "allValues": [ "blue""red" ] }

"A": [ "red""blue" ], "B": [ "red""blue""green" ], "allValues": [ "blue""red""green" ] }

"A": [ "red""blue" ], "B": [ "green""red" ], "allValues": [ "blue""red""green" ] }

"A": [ "red""blue" ], "B": [ ], "allValues": [ "blue""red" ] }

"A": [ "red""blue" ], "B": [ [ "red" ], [ "blue" ] ], "allValues": [ "blue""red", [ "red" ], [ "blue" ] ] }

"A": [ "red""blue" ], "B": [ [ "red""blue" ] ], "allValues": [ "blue""red", [ "red""blue" ] ] }

"A": [ ], "B": [ ], "allValues": [ ] }

"A": [ ], "B": [ "red" ], "allValues": [ "red" ] }

1.2.3、比较聚合操作(Comparison Aggregation Operators)

名称 说明
$cmp Returns: 0 if the two values are equivalent, 1 if the first value is greater than the second, and -1 if the first value is less than the second.
$eq Returns true if the values are equivalent.
$gt Returns true if the first value is greater than the second.
$gte Returns true if the first value is greater than or equal to the second.
$lt Returns true if the first value is less than the second.
$lte Returns true if the first value is less than or equal to the second.
$ne Returns true if the values are not equivalent.

此处就无举例了,之前的例证有因此到过。

1.2.4、算术聚合操作(Arithmetic Aggregation Operators)

名称 说明
$abs Returns the absolute value of a number.
$add Adds numbers to return the sum, or adds numbers and a date to return a new date. If adding numbers and a date, treats the numbers as milliseconds. Accepts any number of argument expressions, but at most, one expression can resolve to a date.
$ceil Returns the smallest integer greater than or equal to the specified number.
$divide Returns the result of dividing the first number by the second. Accepts two argument expressions.
$exp Raises e to the specified exponent.
$floor Returns the largest integer less than or equal to the specified number.
$ln Calculates the natural log of a number.
$log Calculates the log of a number in the specified base.
$log10 Calculates the log base 10 of a number.
$mod Returns the remainder of the first number divided by the second. Accepts two argument expressions.
$multiply Multiplies numbers to return the product. Accepts any number of argument expressions.
$pow Raises a number to the specified exponent.
$sqrt Calculates the square root.
$subtract Returns the result of subtracting the second value from the first. If the two values are numbers, return the difference. If the two values are dates, return the difference in milliseconds. If the two values are a date and a number in milliseconds, return the resulting date. Accepts two argument expressions. If the two values are a date and a number, specify the date argument first as it is not meaningful to subtract a date from a number.
$trunc Truncates a number to its integer.

范例

如发生一个聚众 mycol

1

2

3

4

{ _id: 1, start: 5, end: 8 }

{ _id: 2, start: 4, end: 4 }

{ _id: 3, start: 9, end: 7 }

{ _id: 4, start: 6, end: 7 }

求集合 mycol 中 start 减去 end 的绝对值

1

2

3

4

5

6

7

8

9

db.mycol.aggregate([

   {

     $project: { delta: { $abs: { $subtract: [ "$start""$end" ] } } }

   }

])

"_id" : 1, "delta" : 3 }

"_id" : 2, "delta" : 0 }

"_id" : 3, "delta" : 2 }

"_id" : 4, "delta" : 1 }

1.2.5、字符串聚合操作(String Aggregation Operators)

名称 说明
$concat Concatenates any number of strings.
$indexOfBytes Searches a string for an occurence of a substring and returns the UTF-8 byte index of the first occurence. If the substring is not found, returns -1.
$indexOfCP Searches a string for an occurence of a substring and returns the UTF-8 code point index of the first occurence. If the substring is not found, returns -1.
$split Splits a string into substrings based on a delimiter. Returns an array of substrings. If the delimiter is not found within the string, returns an array containing the original string.
$strLenBytes Returns the number of UTF-8 encoded bytes in a string.
$strLenCP Returns the number of UTF-8 code points in a string.
$strcasecmp Performs case-insensitive string comparison and returns: 0 if two strings are equivalent, 1 if the first string is greater than the second, and -1 if the first string is less than the second.
$substr Deprecated. Use $substrBytes or $substrCP.
$substrBytes Returns the substring of a string. Starts with the character at the specified UTF-8 byte index (zero-based) in the string and continues for the specified number of bytes.
$substrCP Returns the substring of a string. Starts with the character at the specified UTF-8 code point (CP) index (zero-based) in the string and continues for the number of code points specified.
$toLower Converts a string to lowercase. Accepts a single argument expression.
$toUpper Converts a string to uppercase. Accepts a single argument expression.

范例

苟发生一个会合 mycol

1

2

3

4

5

6

7

"_id" : 1, "city" "Berkeley, CA""qty" : 648 }

"_id" : 2, "city" "Bend, OR""qty" : 491 }

"_id" : 3, "city" "Kensington, CA""qty" : 233 }

"_id" : 4, "city" "Eugene, OR""qty" : 842 }

"_id" : 5, "city" "Reno, NV""qty" : 655 }

"_id" : 6, "city" "Portland, OR""qty" : 408 }

"_id" : 7, "city" "Sacramento, CA""qty" : 574 }

为 ‘,’ 分割集合 mycol 中字符串city的价值,用 $unwind
拆分成多独文档,匹配有市名只有一定量个假名之市,并求与顺序都中 qty
的价,最后因降序排序。

1

2

3

4

5

6

7

8

9

10

db.mycol.aggregate([

  { $project : { city_state : { $split: ["$city"", "] }, qty : 1 } },

  { $unwind : "$city_state" },

  { $match : { city_state : /[A-Z]{2}/ } },

  { $group : { _id: { "state" "$city_state" }, total_qty : { "$sum" "$qty" } } },

  { $sort : { total_qty : -1 } }

])

"_id" : { "state" "OR" }, "total_qty" : 1741 }

"_id" : { "state" "CA" }, "total_qty" : 1455 }

"_id" : { "state" "NV" }, "total_qty" : 655 }

1.2.6、数组聚合操作(Array Aggregation Operators)

 

名称 说明
$arrayElemAt Returns the element at the specified array index.
$concatArrays Concatenates arrays to return the concatenated array.
$filter Selects a subset of the array to return an array with only the elements that match the filter condition.
$indexOfArray Searches an array for an occurence of a specified value and returns the array index of the first occurence. If the substring is not found, returns -1.
$isArray Determines if the operand is an array. Returns a boolean.
$range Outputs an array containing a sequence of integers according to user-defined inputs.
$reverseArray Returns an array with the elements in reverse order.
$reduce Applies an expression to each element in an array and combines them into a single value.
$size Returns the number of elements in the array. Accepts a single expression as argument.
$slice Returns a subset of an array.
$zip Merge two lists together.
$in Returns a boolean indicating whether a specified value is in an array.

范例

设若发生一个聚众 mycol

1

2

3

4

"_id" : 1, "name" "dave123", favorites: [ "chocolate""cake""butter""apples" ] }

"_id" : 2, "name" "li", favorites: [ "apples""pudding""pie" ] }

"_id" : 3, "name" "ahn", favorites: [ "pears""pecans""chocolate""cherries" ] }

"_id" : 4, "name" "ty", favorites: [ "ice cream" ] }

告出集合 mycol 中 favorites 的首先件和结尾一件

1

2

3

4

5

6

7

8

9

10

11

12

13

14

db.mycol.aggregate([

   {

     $project:

      {

         name: 1,

         first: { $arrayElemAt: [ "$favorites", 0 ] },

         last: { $arrayElemAt: [ "$favorites", -1 ] }

      }

   }

])

"_id" : 1, "name" "dave123""first" "chocolate""last" "apples" }

"_id" : 2, "name" "li""first" "apples""last" "pie" }

"_id" : 3, "name" "ahn""first" "pears""last" "cherries" }

"_id" : 4, "name" "ty""first" "ice cream""last" "ice cream" }

1.2.7、日期聚合操作(Date Aggregation Operators)

名称 说明
$dayOfYear Returns the day of the year for a date as a number between 1 and 366 (leap year).
$dayOfMonth Returns the day of the month for a date as a number between 1 and 31.
$dayOfWeek Returns the day of the week for a date as a number between 1 (Sunday) and 7 (Saturday).
$year Returns the year for a date as a number (e.g. 2014).
$month Returns the month for a date as a number between 1 (January) and 12 (December).
$week Returns the week number for a date as a number between 0 (the partial week that precedes the first Sunday of the year) and 53 (leap year).
$hour Returns the hour for a date as a number between 0 and 23.
$minute Returns the minute for a date as a number between 0 and 59.
$second Returns the seconds for a date as a number between 0 and 60 (leap seconds).
$millisecond Returns the milliseconds of a date as a number between 0 and 999.
$dateToString Returns the date as a formatted string.
$isoDayOfWeek Returns the weekday number in ISO 8601 format, ranging from 1 (for Monday) to 7 (for Sunday).
$isoWeek Returns the week number in ISO 8601 format, ranging from 1 to 53. Week numbers start at 1 with the week (Monday through Sunday) that contains the year’s first Thursday.
$isoWeekYear Returns the year number in ISO 8601 format. The year starts with the Monday of week 1 (ISO 8601) and ends with the Sunday of the last week (ISO 8601).

范例

假使发生一个会合 mycol

1

"_id" : 1, "item" "abc""price" : 10, "quantity" : 2, "date" : ISODate("2017-01-01T08:15:39.736Z") }

抱集合 mycol 中 date 字段的连锁日期值

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

db.mycol.aggregate(

   [

     {

       $project:

         {

           year: { $year"$date" },

           month: { $month"$date" },

           day: { $dayOfMonth: "$date" },

           hour: { $hour"$date" },

           minutes: { $minute"$date" },

           seconds: { $second"$date" },

           milliseconds: { $millisecond: "$date" },

           dayOfYear: { $dayOfYear: "$date" },

           dayOfWeek: { $dayOfWeek: "$date" },

           week: { $week: "$date" }

         }

     }

   ]

)

{

  "_id" : 1,

  "year" : 2017,

  "month" : 1,

  "day" : 1,

  "hour" : 8,

  "minutes" : 15,

  "seconds" : 39,

  "milliseconds" : 736,

  "dayOfYear" : 1,

  "dayOfWeek" : 1,

  "week" : 0

}

1.2.8、条件聚合操作(Conditional Aggregation Operators)

名称 说明
$cond A ternary operator that evaluates one expression, and depending on the result, returns the value of one of the other two expressions. Accepts either three expressions in an ordered list or three named parameters.
$ifNull Returns either the non-null result of the first expression or the result of the second expression if the first expression results in a null result. Null result encompasses instances of undefined values or missing fields. Accepts two expressions as arguments. The result of the second expression can be null.
$switch Evaluates a series of case expressions. When it finds an expression which evaluates to true$switch executes a specified expression and breaks out of the control flow.

范例

比方发生一个集结 mycol

1

2

3

"_id" : 1, "item" "abc1", qty: 300 }

"_id" : 2, "item" "abc2", qty: 200 }

"_id" : 3, "item" "xyz1", qty: 250 }

若凑 mycol 中 qty 字段值大于等于250,则归30,否则回20

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

db.mycol.aggregate(

   [

      {

         $project:

           {

             item: 1,

             discount:

               {

                 $cond: { if: { $gte: [ "$qty", 250 ] }, then: 30, else: 20 }

               }

           }

      }

   ]

)

"_id" : 1, "item" "abc1""discount" : 30 }

"_id" : 2, "item" "abc2""discount" : 20 }

"_id" : 3, "item" "xyz1""discount" : 30 }

  

1.2.9、数据类型聚合操作(Data Type Aggregation Operators)

名称 说明
$type Return the BSON data type of the field.

范例

设发生一个聚众 mycol

1

2

3

4

5

6

{ _id: 0, a : 8 }

{ _id: 1, a : [ 41.63, 88.19 ] }

{ _id: 2, a : { a : "apple", b : "banana", c: "carrot" } }

{ _id: 3, a :  "caribou" }

{ _id: 4, a : NumberLong(71) }

{ _id: 5 }

取文档中 a 字段的数据类型

1

2

3

4

5

6

7

8

9

10

11

db.mycol.aggregate([{

    $project: {

       a : { $type: "$a" }

    }

}])

{ _id: 0, "a" "double" }

{ _id: 1, "a" "array" }

{ _id: 2, "a" "object" }

{ _id: 3, "a" "string" }

{ _id: 4, "a" "long" }

{ _id: 5, "a" "missing" }

1.3、聚合管道优化

默认情况下,整个集合作为集管道的输入,为了增进处理数据的频率,可以使用一下策略:

  • 拿 $match 和 $sort
    放到管道的前,可以被集合建立目录,来增强处理多少的效率。
  • 好为此 $match、$limit、$skip
    对文档进行提前过滤,以缩减后续处理文档的数额。

当聚合管道执行命令时,MongoDB
也会指向各个阶段活动进行优化,主要包括以下几只状态:

  1. $sort + $match 顺序优化

万一 $match 出现于 $sort 之后,优化器会自动把 $match 放到 $sort 前面

  1. $skip + $limit 顺序优化

设 $skip 在 $limit 之后,优化器会把 $limit 移动及 $skip 的前方,移动后
$limit的值等于原来的价值长 $skip 的价。

例如:移动前:{$skip: 10, $limit: 5},移动后:{$limit: 15, $skip: 10}

当管道顺序吗$sort 后和$match时, $match会移动至$sort之前因缩减排序对象的多寡。例如,如果管道包含下面的阶段:

1.4、聚合管道用范围

本着聚集管道的界定重点是对准 返回结果大小 和 内存 的范围。

回去结果大小

聚结果回到的凡一个文档,不可知过 16M,从 MongoDB
2.6版后,返回的结果可以是一个游标或者存储到集中,返回的结果不深受
16M 的克。

内存

聚集管道的每个阶段最多只能用 100M
的内存,如果超过100M,会报错,如果急需处理非常数目,可以应用 allowDiskUse
选项,存储到磁盘上。

{ $sort: { age : -1 } },{ $match: { status: ‘A’ } }

2、单目的聚众操作

单目的集纳命令,常用之:count()、distinct(),与聚集管道相比,单目的聚合操作更简短,使用十分频繁。先通过 distinct()
看一下办事流程

图片 5图片 6

distinct() 的来意是去重。而 count() 是请求文档的个数。

下面用 count() 方法举例说明一下

范例

吁出集合 article 中 time 值大于 2017-04-09 的文档个数

1

2

>db.article.count( { time: { $gt: new Date('04/09/2017') } } )

3

是讲话等价于

1

db.article.find( { time: { $gt: new Date('04/09/2017') } } ).count()

参考:https://blog.csdn.net/qq\_37193537/article/details/82388638

当优化等,优化器将行顺序改变呢底这样:

{ $match: { status: ‘A’ } },{ $sort: { age : -1 } }

$skip + $limit管道顺序优化

当管道顺序吧$skip 后同$limit时, $limit会移动至$skip 之前以调减排序对象的数码。顺序改变后,$limit值增加的价为$skip的价。

比如说,如果管道包含下面的阶段:

{ $skip: 10 },{ $limit: 5 }

当优化等,优化器将行顺序改变也底这样:

{ $limit: 15 },{ $skip: 10 }

这种优化为$sort +
$limit合并提供更多之会,例如序列$sort + $skip + $limit。

对分片集合上的会师操作,这种优化减少了各级一个分片返回的结果。

$redact + $match管道顺序优化

当管道包含了之后紧跟$match阶段的$redact阶段时,尽可能地,管道会不时地于 $redact阶段前续加相同片段$match阶段。如果加上的$match阶段是管道的初始,管道会在询问的还要采取索引来界定进管道的文档数量。

诸如,如果管道包含下面的流:

{ $redact: { $cond: { if: { $eq: [ “$level”, 5 ] }, then: “$$PRUNE”,
else: “$$DESCEND” } } },

{ $match: { year: 2014, category: { $ne: “Z” } } }

优化程序会当$redact阶段前增长相同的$match阶段:

{ $match: { year: 2014 } },

{ $redact: { $cond: { if: { $eq: [ “$level”, 5 ] }, then: “$$PRUNE”,
else: “$$DESCEND” } } },

{ $match: { year: 2014, category: { $ne: “Z” } } }

$project + $skip 还是$limit管道顺序优化

3.2版本新增

当管道顺序吧$projec后及$skip或$limit时,$skip或$limit会移动至$projec之前,

如,如果管道包含下面的路:

{ $sort: { age : -1 } },

{ $project: { status: 1, name: 1 } },

{ $limit: 5 }

当优化等,优化器将行顺序改变也底这样:

{ $sort: { age : -1 } },

{ $limit: 5 },

{ $project: { status: 1, name: 1 } }

这种优化为$sort +
$limit合并提供更多之机会,例如序列$sort + $limit。

1.4.3 管道合并优化

以此优化等将一个管道等同它们之前的管道等统一。一般地,合并出在路又排序之后。

合并$sort + $limit

当$sort后面紧跟$limit时,优化程序会将$limit合并到$sort,这使排序操作才保留结果集中之前n长长的数并拍卖它,n是指定的限量,MongoDB只待以内存中储存n个条款。

当设置allowDiskUse
为true时又n条数据就越了集内存的克,上面这种优化还是会吃运用。

合并$limit + $limit

当 $limit后面紧跟另一个$limit时,两个阶段统一为一个等级,合并后的限制值为两者中极小值。

譬如,如果管道包含下面的号:

{ $limit: 100 },

{ $limit: 10 }

第二个$limit号为合并到第一单$limit品负,合并后的限制值为100跟10饱受最为小之,即10。

{ $limit: 10 }

合并$skip + $skip

当 $skip后面紧跟另一个$skip时,两独$skip合并为一个$skip,跳了之数码也双方之和。

如,如果管道包含下面的品:

{ $skip: 5 },

{ $skip: 2 }

亚个$skip被合及第一单$skip中,合并后超过了之数也5以及2之和。

{ $skip: 7 }

合并$match + $match

当 $match后面紧跟另一个$match时,两单等级统一为一个重组使用$and的$match,跳了的多寡为双边之和。

譬如说,如果管道包含下面的等级:

{ $match: { year: 2014 } },

{ $match: { status: “A” } }

次只$match被联合到第一独$match中。

{ $match: { $and: [ { “year” : 2014 }, { “status” : “A” } ] } }

合并$lookup + $unwind

3.2版新增

当$lookup之后紧跟$unwind并且$unwind 操作$lookup的字段,优化等能够用$unwind合并及$lookup中。这避免了创建于充分的中等文档。

比如,如果管道包含下面的等:

{

  $lookup: {

    from: “otherCollection”,

    as: “resultingArray”,

    localField: “x”,

    foreignField: “y”

  }

},

{ $unwind: “$resultingArray”}

优化器将$unwind合并到$lookup中。如果运行聚合的时光使用explain 选项,输出的联等也:
{

  $lookup: {

    from: “otherCollection”,

    as: “resultingArray”,

    localField: “x”,

    foreignField: “y”,

    unwinding: { preserveNullAndEmptyArrays: false }

  }

}

1.5例子

下面例子所显示之组成部分队能够运用再次排序和统一优化。一般地,合并有在还排序之后。

序列$sort + $skip + $limit

管道包含$sort阶段,其后接$skip阶段,$skip阶段后搭
$limit阶段

{ $sort: { age : -1 } },{ $skip: 10 },{ $limit: 5 }

先是,优化程序将$skip +
$limit转化为下的依次:

{ $sort: { age : -1 } },

{ $limit: 15 },

{ $skip: 10 }

当前底排为$sort阶段后以及$limit阶段,管道会合并这半单过程为调减排序阶段对内存的吃。

序列$limit + $skip + $limit +
$skip

一个管道包含了$limit和$skip交替出现的行列:

{ $limit: 100 },

{ $skip: 5 },

{ $limit: 10 },

{ $skip: 2 }

优化程序用{ $skip: 5 } 和{
$limit: 10 } 顺序反转,并附加限制数量:

{ $limit: 100 },

{ $limit: 15},

{ $skip: 5 },

{ $skip: 2 }

优化程序会将鲜独$limit合并,将片个$skip合并,结果也:

{ $limit: 15 },

{ $skip: 7 }

1.6 聚合管道限制

行使聚合命令有如下限制:

结果大小限制

2.6版中生成

从2.6本子开始,聚合命令(aggregate)能够回来一个游标或以结果存储于聚集中。当回游标或者用结果存储到集中时时,结果集中的各个一个文档受限于BSON文档大小,目前BSON文档大小最酷允许吗16MB;如果另外一个文档的尺寸超过了之价值,聚合命令将废弃来一个误。这个界定只是打算被返回的文档,在管道被于拍卖的文档有或超乎这阈值。从2.6始发,db.collection.aggregate()
方法默认返回游标。

万一未点名游标选项或者将结果存储到聚集中,aggregate 命令归来一个BSON文档,文档有一个带有结果集的字段。文档的大大小小超过了BSON文档允许的极度要命价值,聚合命令将摒弃来一个破绽百出。

以再度早的本子中,aggregate仅会返回一个包含结果集的BSON文档,如果文档的大大小小超过了BSON文档允许的最可怜价值,聚合命令将摒弃来一个荒谬。

内存限制

2.6版中生成

管道等对内存的限量为100MB。如果有平等号采取的内存超过100MB,MongoDB
会抛来一个不当。为了能够处理好数据集,

下allowDiskUse选项使聚合管道等将数据写入临时文件。

1.7集合管道与分片集合

聚拢管道支持分片集合上之操作。

行为

3.2版本被的变化

而凑管道以$match开始,精确地兼容一个片键,整个聚合管道仅运行在相当到之分片上。之前的本被,管道会给拆分,合并之做事如以主分片上成功。

于如运行在多个分片上之聚合操作,如果操作不需要周转于数据库的主分片上,这些操作以会程由于结果到自由分片来统一结果以避免数据库主分片过载。

$out阶段同$lookup阶段要周转于数据库主分片上。

优化

当把集和管道分成两单有经常,在考虑优化的气象下,拆分管道经常保证每一个分片执行阶段数量尽量多。

如查看管道什么给拆分,使用db.collection.aggregate()和explain选项。

1.8 邮政编码数据集上的聚集操作

演示中使集合zipcodes
,这个集好自:http://media.mongodb.org/zips.json处获得。使用mongoimport将数据导入你的mongod 实例。

数据模型

集合zipcodes中之每一样文档的体如下:

{

  “_id”: “10280”,

  “city”: “NEW YORK”,

  “state”: “NY”,

  “pop”: 5574,

  “loc”: [

    -74.016323,

    40.710537

  ]

}

  • _id字段值为字符串形式的邮政编码。
  • city 字段值为城市称号。一个都市可有多个邮政编码,城市之两样城区邮政编码不同。
  • State字段值为简单只假名的州名称缩写。
  • pop字段值为人口数量。
  • Loc字段值为所以经过纬度表示的方。

aggregate()方法

aggregate() 方法以聚合管道处理文档,输出聚合结果。一个汇管道由多只级次做,当文档经过聚众管道各个阶段时,管道处理上其中的文档。

于mongo shell中,aggregate() 方法提供了针对aggregate 的卷入。

回去人口数量在一千万上述的州

下的联谊操作返回所有人口数在一千万上述之州:

db.zipcodes.aggregate( [

   { $group: { _id: “$state”, totalPop: { $sum: “$pop” } } },

   { $match: { totalPop: { $gte: 10*1000*1000 } } }] )

以斯事例中,聚合管道包含 $group阶段,其后与$match阶段。

  • $group阶段根据state
    字段将zipcode
    集合分组,计算各国一个州底totalPop字段值,输出结果吧每个州对应一个文档。

初的有关每个州的消息的文档包含两单字段:_id
字段和totalPop字段。_id字段值是州的名号,totalPop字段值是由此计算后取得的各州之总人口数。为了计算是值$group阶段采取$sum操作符统计每个州的人口数。

  • 透过$group管道阶段后的在管道中之文档样式如下:

{

  “_id” : “AK”,

  “totalPop” : 550043

}

$match阶段过滤分组后底文档,仅输出那些totalPop值大于等于一千万的文档。$match阶段非会见修改文档而是输出不修改的配合到之文档。

跟聚集操作等价的SQL语句也:

SELECT state, SUM(pop) AS totalPop 

FROM zipcodes 

GROUP BY state 

HAVING totalPop >= (10*1000*1000)

回每个州的城池人口平均值

下的集纳操作返回每个州的市人口平均值

db.zipcodes.aggregate( [

   { $group: { _id: { state: “$state”, city: “$city” }, pop: { $sum:
“$pop” } } },

   { $group: { _id: “$_id.state”, avgCityPop: { $avg: “$pop” } } }]

)

当此事例中,聚合操作包含了区区个$group阶段。

  • 率先只$group 阶段根据city和state字段组合以文档分组,$sum 表达式根据每个组合计算人口数,并出口文档,每一个城市和州的组合对应一个文档。

地方十分阶段完成后,管道遭之文档样式也:
{

  “_id” : {

    “state” : “CO”,

    “city” : “EDGEWATER”

  },

  “pop” : 13154

}

  • 其次单$group阶段根据_id.state字段将文档分组(state字段在_id文档内),使用$avg表达式计算各国一个城市人口的平均值(avgCityPop)并出口文档,每个州对应一个文档。

此集操作返回文档类似于:

{

  “_id” : “MN”,

  “avgCityPop” : 5335

}

返回州面临规模极充分及无限小的城

下的聚众操作返回每个州人口数最多同极少之都市。

db.zipcodes.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” }

      }

   },

 

  // the following $project is optional, and

  // modifies the output format.

 

  { $project:

    { _id: 0,

      state: “$_id”,

      biggestCity:  { name: “$biggestCity”,  pop: “$biggestPop” },

      smallestCity: { name: “$smallestCity”, pop: “$smallestPop” }

    }

  }]

)

以斯集操作着含有了简单单$group阶段,一个$sort阶段,一个$project阶段。

  • 首先单$group 阶段根据city和state字段组合将文档分组,$sum 表达式根据每个组合计算人口数(一个城恐来差不多个邮政编码,因为一个邑的不同区有异的邮政编码),并出口文档,每一个都市和州的结对应一个文档。这个路文档类似于:

{

  “_id” : {

    “state” : “CO”,

    “city” : “EDGEWATER”

  },

  “pop” : 13154

}

  • $sort阶段根据pop字段的价为管道被的文档排序,顺序也于小到深;例如递增的逐一。这个操作不会见窜文档。
  • 仲独$group 阶段根据_id.state字段对目前已排序的文档分组(例如,state
    字段在_id文档中)并出口每个州对应之文档。

这路为每个州计算如下四个字段值:使用$last表达式,$group操作符创建biggestCity 和biggestPop字段,biggestPop字段值为极端要命之人口数,biggestCity值为biggestPop对应的都名称。使用$first 表达式,$group操作符创建了smallestCity和smallestPop,smallestPop为极小之人口数,smallestCity为smallestPop对应之城市名称。

管道被这路的文档类似于:

{

  “_id” : “WA”,

  “biggestCity” : “SEATTLE”,

  “biggestPop” : 520096,

  “smallestCity” : “BENGE”,

  “smallestPop” : 2

}

最后的$project阶段将_id字段重命名为state
并以biggestCity, biggestPop, smallestCity,
和smallestPop移到嵌入式文档biggestCity 和

smallestCity中。

面是集操作的结果类似于:

{

  “state” : “RI”,

  “biggestCity” : {

    “name” : “CRANSTON”,

    “pop” : 176404

  },

  “smallestCity” : {

    “name” : “CLAYVILLE”,

    “pop” : 45

  }

}

 

1.9 用户引用数的聚集操作

数据模型

倘一个体育俱乐部产生一个涵盖users集合数据库,users集合中之文档包含用户的在日期及喜的位移,文档样式如下:

{

  _id : “jane”,

  joined : ISODate(“2011-03-02”),

  likes : [“golf”, “racquetball”]

}

{

  _id : “joe”,

  joined : ISODate(“2012-07-02”),

  likes : [“tennis”, “golf”, “swimming”]

}

文档规范化和排序

下面的操作返回的文档中,用户称改成成特别写并依照字母顺序排序。操作如下:

db.users.aggregate(

  [

    { $project : { name:{$toUpper:”$_id”} , _id:0 } },

    { $sort : { name : 1 } }

  ])

Users集合中的具备文档都由此了管道,在管道被施行以下操作:

  • $project操作符:
  • 缔造名也name的字段。
  • 使$toUpper操作符将_id字段值转换成为稀写。然后以价值存储于号称也name
    的字段中。
  • 阻止_id字段。$project 操作符默认允许_id字段通过,除非明确地拦截。
  • $sort操作符根据name字段对结果开展排序。

集操作返回结果也:

{

  “name” : “JANE”},{

  “name” : “JILL”},{

  “name” : “JOE”

}

回根据加入时间排序后的用户称

下的集操作返回根据参加月份排序的用户称,这种集操作有助于生成会员更新提醒。

db.users.aggregate(

  [

    { $project :

       {

         month_joined : { $month : “$joined” },

         name : “$_id”,

         _id : 0

       }

    },

    { $sort : { month_joined : 1 } }

  ]

)

Users集合中的装有文档都由此了管道,在管道遭实践以下操作:

  • $project操作符:
  • 创立两只字段month_joined
    和name。
  • 截留结果集中的id输出。$project 操作符默认允许_id字段通过,除非明确地拦住。
  • $month操作符将joined字段的价值转换为为平头表示的月份。然后$project操作符将这些价值指定为month_joined字段。
  • $sort操作符根据month_joined字段对结果进行排序。

操作返回的结果也:

{

  “month_joined” : 1,

  “name” : “ruth”},{

  “month_joined” : 1,

  “name” : “harold”},{

  “month_joined” : 1,

  “name” : “kate”}{

  “month_joined” : 2,

  “name” : “jill”

}

 

回每个月参加会员的总额

脚的操作展示了每个月份来些许人口成为会员。你或可以行使这些聚集数据来设想是不是招聘新职工以及制定营销策略。

db.users.aggregate(

  [

    { $project : { month_joined : { $month : “$joined” } } } ,

    { $group : { _id : {month_joined:”$month_joined”} , number : {
$sum : 1 } } },

    { $sort : { “_id.month_joined” : 1 } }

  ]

)

users 集合中所有文档都经过管道,在管道被推行如下操作:

  • $project操作符创建了一个新字段month_joined。
  • $month操作符将joined字段的值转换为为平头表示的月。然后$project操作符将这些价值指定为month_joined字段。
  • $group操作符将所有文档按month_joined值分组,并计算每个month_joined字段值对应多少只文档。特别地,对于各级一个唯一的

    month_joined值,$group创建了一个初的“每个月份”的文档,该文档包含了少只字段:

  • _id字段,包含一个嵌入式文档,嵌入式文档有一个month_joined字段。
  • number字段,这是一个新变化的字段。对各一个含给得month_joined字段值的文档,$sum操作符将number字段值加1.
  • $sort操作符根据month_joine字段将$group操作符处理了之文档排序。

其一聚和操作的结果为:

{

  “_id” : {

    “month_joined” : 1

  },

  “number” : 3},

{

  “_id” : {

    “month_joined” : 2

  },

  “number” : 9},

{

  “_id” : {

    “month_joined” : 3

  },

  “number” : 5}

回五种植最广的“爱好”

脚的成团操作选出五独极广大“爱好”。这种类型的分析有助于提高规划。

db.users.aggregate(

  [

    { $unwind : “$likes” },

    { $group : { _id : “$likes” , number : { $sum : 1 } } },

    { $sort : { number : -1 } },

    { $limit : 5 }

  ]

)

users 集合中所有文档都经管道,在管道遭实践如下操作:

  • $unwind操作符将数组likes中之每一个要素分别,并也各国一个元素创建一个原文档的初本子。

例如:

脚的文档:

{

  _id : “jane”,

  joined : ISODate(“2011-03-02”),

  likes : [“golf”, “racquetball”]

}

$unwind操作符创建的文档为:

{

  _id : “jane”,

  joined : ISODate(“2011-03-02”),

  likes : “golf”

}

{

  _id : “jane”,

  joined : ISODate(“2011-03-02”),

  likes : “racquetball”

}

  • $group操作符根据likes字段值分组并盘算每组的数量。使用这些信息,$group创建含有一定量只字段的新文档:
  • _id字段,包含likes字段值。
  • number新生成的字段,对于富含给定likes字段值的每个文档$sum操作符将number加1。
  • $sort操作符根据number字段将文档顺序反转。
  • $limit 操作符限制结果集中仅含前五单文档。

{

  “_id” : “golf”,

  “number” : 33},

{

  “_id” : “racquetball”,

  “number” : 31},

{

  “_id” : “swimming”,

  “number” : 24},

{

  “_id” : “handball”,

  “number” : 19},

{

  “_id” : “tennis”,

  “number” : 18}

}

 —————————————————————————————–

转载和援请注明出处。

日子匆忙,水平有限,如发不当之处,欢迎指正。

 

留下评论

网站地图xml地图