得知道啊一个整个流程的一个办事阶段stage其他的管道也分组和排序提供有器。转一个旁人总结的。

管道概念

POSIX多线程的用方式遭,
有雷同种植十分关键之道—–流水线(亦曰“管道”)方式,“数据元素”流串行地被同一组线程按梯次执行。它的下架构可参看下图:

图片 1

因为面向对象的思维去解,整个工艺流程,可以清楚呢一个数据传的管道;该管道遭之每一个行事线程,可以掌握啊一个全方位工艺流程的一个办事阶段stage,这些工作线程之间的合作是千篇一律环绕扣一环绕之。靠输入人越近的行事线程,是时序较早的办事阶段stage,它的劳作成果会影响下一个干活线程阶段(stage)的工作结出,即下单号负让上一个品的出口,上一个阶段的出口成为以等的输入。这为是pipeline的一个共有特点!

为酬答用户指向简易多少看的要求,MongoDB2.2本引入新的效果汇聚框架(Aggregation
Framework) ,它是数聚合的一个初框架,其定义类似于数处理的管道。
每个文档通过一个出于多独节点组成的管道,每个节点有谈得来独特的功能(分组、过滤等),文档经过管道处理后,最后输出相应的结果。管道基本的功效来有限个:

一致凡针对性文档进行“过滤”,也即是罗产生符合条件的文档;

次凡对准文档进行“变换”,也就算是移文档的出口形式。

其它的有职能还连按照有指定的字段分组和排序等。而且以每个阶段还可运用表达式操作符计算平均值和拼接字符串等有关操作。管道提供了一个MapReduce
的代表方案,MapReduce使用相对来说比较复杂,而管道的装有稳定的接口(操作符表达),使用比较简单,对于大部分的聚众任务管道一般的话是首选办法。

欠框架下声明性管道符号来支撑类似于SQL Group
By操作的效应,而不再需要用户编写自定义的JavaScript例程。

大部管道操作会在“aggregate”子句后会见跟达到“$match”打头。它们用当并,就象是于SQL的from和where子句,或是MongoDB的find函数。“$project”子句看起吧充分类似SQL或MongoDB中的某某概念(和SQL不同之是,它放在表达式尾端)。

接通下去介绍的操作以MongoDB聚合框架中凡无可比拟的。与大部分关系数据库不同,MongoDB天生就可以以行/文档内存储数组。尽管该特性对全有全无的数看异常便宜,但是其于用做投影、分组和过滤操作来修报告的劳作,却显得相当复杂。“$unwind”子句将数组分解为单个的元素,并跟文档的其余部分一同回到。

“$group”操作以及SQL的Group
By子句用途相同,但是使用起来却还像是LINQ中之分组运算符。与取回一行平面数据不同,“$group”操作的结果会呈现为一个连连的嵌套结构。正因如此,使用“$group”可以回聚合信息,例如对于每个分组中的其实文档,计算文档整体还是一些的数码及平均值。

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

db.userId5555.aggregate({$unwind:”$tcjl”},{$match:{“_id”:”0e549864-2a56-43ca-bab9-ba28e2216a73″}},{“$project”:{“tcjl.tradeTime”:1}},{$sort:{“tcjl.tradeTime”:-1}},{$skip:5},{$limit:3})
 

管道操作符

管道是由于一个个效应节点组成的,这些节点用管道操作符来开展表示。聚合管道以一个汇中之有着文档作为开,然后这些文档从一个操作节点
流向下一个节点
,每个操作节点对文档做相应的操作。这些操作可能会见创造新的文档或者过滤掉一部分非符合条件的文档,在管道遭可对文档进行重复操作。

优先押一个管道聚合的事例:

图片 2

管道操作符的品种:

Name

Description

$project

Reshapes a document stream. $project can rename, add, or remove fields as well as create computed values and sub-documents.

$match

Filters the document stream, and only allows matching documents to pass into the next pipeline stage.$match uses standard MongoDB queries.

$limit

Restricts the number of documents in an aggregation pipeline.

$skip

Skips over a specified number of documents from the pipeline and returns the rest.

$unwind

Takes an array of documents and returns them as a stream of documents.

$group

Groups documents together for the purpose of calculating aggregate values based on a collection of documents.

$sort

Takes all input documents and returns them in a stream of sorted documents.

$geoNear

Returns an ordered stream of documents based on proximity to a geospatial point.

管道操作符详细使用说明

  1.  $project: 数据投影,主要用于更命名、增加和去字段

例如:

db.article.aggregate(

{ $project : {

title : 1 ,

author : 1 ,

}}

);

这样的话结果负就是单纯还有_id,tilte和author三独字段了,默认情况下_id字段是深受含有的,如果要想不含_id话可以这么:

db.article.aggregate(

{ $project : {

_id : 0 ,

title : 1 ,

author : 1

}});

为可以$project内采取算术类型表达式操作符,例如:

db.article.aggregate(

{ $project : {

title : 1,

doctoredPageViews : { $add:[“$pageViews”, 10] }

}});

通过采取$add给pageViews字段的值加10,然后拿结果赋值给一个初的字段:doctoredPageViews

横流:必须用$add计算表达式放到中括号里

除此之外使用$project还可以重命名字段名和子文档的字段名:

db.article.aggregate(

{ $project : {

title : 1 ,

page_views : “$pageViews” ,

bar : “$other.foo”

}});

啊足以补充加子文档:

db.article.aggregate(

{ $project : {

title : 1 ,

stats : {

pv : “$pageViews”,

foo : “$other.foo”,

dpv : { $add:[“$pageViews”, 10] }

}

}});

生了一个子文档stats,里面含有pv,foo,dpv三独字段。

2.$match: 滤波操作,筛选符合条件文档,作为下一阶段的输入

   $match的语法和查询表达式(db.collection.find())的语法相同

db.articles.aggregate( [

{ $match : { score : { $gt : 70, $lte : 90 } } },

{ $group: { _id: null, count: { $sum: 1 } } }

] );

  
$match用于获取分数大于70低于或顶90记下,然后用符合条件的记录送至下一阶段$group管道操作符进行拍卖。

留神:1.勿可知在$match操作符中使用$where表达式操作符。

         
2.$match尽量出现在管道的面前,这样可提前过滤文档,加快集聚速度。

          3.假如$match出现在绝前的话,可以使用索引来加快查询。

3.  $limit:  限制经过管道的文档数量

     $limit的参数只能是一个刚整数

db.article.aggregate(

{ $limit : 5 });

这样的话经过$limit管道操作符处理后,管道内即独自剩余前5只文档了

  1. $skip: 从待操作集合起来的岗位跳了文档的数码

    $skip参数为只好为一个恰恰整数

db.article.aggregate(

{ $skip : 5 });

经$skip管道操作符处理后,前五个文档被“过滤”掉

5.$unwind:将数组元素拆分为单身字段

比如:article文档中发生一个名字吧tags数组字段:

> db.article.find()
  { “_id” : ObjectId(“528751b0e7f3eea3d1412ce2”),

“author” : “Jone”, “title” : “Abook”,

“tags” : [  “good”,  “fun”,  “good” ] }

行使$unwind操作符后:

>
db.article.aggregate({$project:{author:1,title:1,tags:1}},{$unwind:”$tags”})
{
        “result” : [
                {
                        “_id” : ObjectId(“528751b0e7f3eea3d1412ce2”),
                        “author” : “Jone”,
                        “title” : “A book”,
“tags” : “good”
                },
                {
                        “_id” : ObjectId(“528751b0e7f3eea3d1412ce2”),
                        “author” : “Jone”,
                        “title” : “A book”,
“tags” : “fun”
                },
                {
                        “_id” : ObjectId(“528751b0e7f3eea3d1412ce2”),
                        “author” : “Jone”,
                        “title” : “A book”,
  “tags” : “good”
                }
        ],
        “ok” : 1
}

在意:a.{$unwind:”$tags”})不要遗忘了$符号

         
b.如果$unwind目标字段未在的话,那么该文档将吃忽视了滤掉,例如:

     >
db.article.aggregate({$project:{author:1,title:1,tags:1}},{$unwind:”$tag”})
    { “result” : [ ], “ok” : 1 }
拿$tags改吧$tag因不存在拖欠字段,该文档被忽略,输出的结果吗空

        c.如果$unwind目标字段不是一个数组的话,将会晤发错误,例如:

  >
db.article.aggregate({$project:{author:1,title:1,tags:1}},{$unwind:”$title”})

    Error: Printing Stack Trace
    at printStackTrace (src/mongo/shell/utils.js:37:15)
    at DBCollection.aggregate (src/mongo/shell/collection.js:897:9)
    at (shell):1:12
    Sat Nov 16 19:16:54.488 JavaScript execution failed: aggregate
failed: {
        “errmsg” : “exception: $unwind:  value at end of field path must
be an array”,
        “code” : 15978,
        “ok” : 0
} at src/mongo/shell/collection.js:L898

      d.如果$unwind目标字段往往组为空的言辞,该文档也拿会晤为忽略。

  6.$group 对数码进行分组

   
$group的时光要使指定一个_id域,同时也得蕴涵有算术类型的表达式操作符:

db.article.aggregate(

{ $group : {

_id : “$author”,

docsPerAuthor : { $sum : 1 },

viewsPerAuthor : { $sum : “$pageViews” }

}});

瞩目:  1.$group的出口是无序的。

         
2.$group操作时是在内存中进行的,所以不能够为此其来针对大量个数的文档进行分组。

7.$sort : 对文档按照指定字段排序

运办法如下:

db.users.aggregate( { $sort : { age : -1, posts: 1 } });

遵循年龄进行降序操作,按照posts进行升序操作

顾:1.使用$sort放到管道前面的话语可以动用索引,提高效率

        2.MongoDB
24.对准内存做了优化,在管道被如$sort出现在$limit之前的话,$sort只会指向前$limit单文档进行操作,这样在内存中呢特会保留前$limit只文档,从而可以极大的省内存

       
3.$sort操作是于内存中展开的,如果其占据的内存超过物理内存的10%,程序会发出错误

8.$goNear

       
$goNear会返回一些坐标值,这些价值为按距离指定点去由接近到多进行排序

现实运用参数见下表:

Field

Type

Description

near

GeoJSON point orlegacy coordinate pairs

The point for which to find the closest documents.

distanceField

string

The output field that contains the calculated distance. To specify a field within a subdocument, use dot notation.

limit

number

Optional. The maximum number of documents to return. The default value is 100. See also the num option.

num

number

Optional. The num option provides the same function as the limitoption. Both define the maximum number of documents to return. If both options are included, the num value overrides the limit value.

maxDistance

number

Optional. A distance from the center point. Specify the distance in radians. MongoDB limits the results to those documents that fall within the specified distance from the center point.

query

document

Optional. Limits the results to the documents that match the query. The query syntax is the usual MongoDB read operation query syntax.

spherical

Boolean

Optional. If true, MongoDB references points using a spherical surface. The default value is false.

distanceMultiplier

number

Optional. The factor to multiply all distances returned by the query. For example, use the distanceMultiplier to convert radians, as returned by a spherical query, to kilometers by multiplying by the radius of the Earth.

includeLocs

string

Optional. This specifies the output field that identifies the location used to calculate the distance. This option is useful when a location field contains multiple locations. To specify a field within a subdocument, usedot notation.

uniqueDocs

Boolean

Optional. If this value is true, the query returns a matching document once, even if more than one of the document’s location fields match the query. If this value is false, the query returns a document multiple times if the document has multiple matching location fields. See $uniqueDocsfor more information.

例如:

db.places.aggregate([

{

$geoNear: {

near: [40.724, -73.997],

distanceField: “dist.calculated”,

maxDistance: 0.008,

query: { type: “public” },

includeLocs: “dist.location”,

uniqueDocs: true,

num: 5

}

}

])

该结果为:

{

“result” : [

{ “_id” : 7,

“name” : “Washington Square”,

“type” : “public”,

“location” : [

[ 40.731, -73.999 ],

[ 40.732, -73.998 ],

[ 40.730, -73.995 ],

[ 40.729, -73.996 ]

],

“dist” : {

“calculated” : 0.0050990195135962296,

“location” : [ 40.729, -73.996 ]

}

},

{ “_id” : 8,

“name” : “Sara D. Roosevelt Park”,

“type” : “public”,

“location” : [

[ 40.723, -73.991 ],

[ 40.723, -73.990 ],

[ 40.715, -73.994 ],

[ 40.715, -73.994 ]

],

“dist” : {

“calculated” : 0.006082762530298062,

“location” : [ 40.723, -73.991 ]

}

}

],

“ok” : 1}

里头,dist.calculated中寓了算的结果,而dist.location中蕴藏了匡距离时实际应用的坐标

顾: 1.运$goNear只能在管道处理的上马率先只级次展开

         2.务必指定distanceField,该字段用来控制是否包含距离字段

3.$gonNear和geoNear命令比较相似,但是呢发局部异:distanceField在$geoNear中凡是必选的,而在geoNear遭是可选的;includeLocs在$geoNear中凡是string类型,而当geoNear中凡是boolen类型。

聚合

内嵌文档按某字段排序,从索引5(索引从0开始)的多少3修

管道表达式

管道操作符作为“键”,所对应之“值”叫做管道表达式。例如地方例子中{$match:{status:”A”}},$match称为管道操作符,而{status:”A”}称为管道表达式,它好看作是管道操作符的操作数(Operand),每个管道表达式是一个文档结构,它是由于字段名、字段值、和有表达式操作符组成的,例如地方例子中管道表达式就含了一个表达式操作符$sum进行劳动加求和。

每个管道表达式只能作用为处理时正在处理的文档,而未克开展跨文档的操作。管道表达式对文档的拍卖还是当内存中进行的。除了能够进行添加计算的管道表达式外,其他的表达式都是管状态的,也就算是不见面保留上下文的音讯。累加性质的表达式操作符通常和$group操作符一起用,来统计该组内无限老价值、最小值等,例如地方的例证中我们以$group管道操作符中使用了有丰富的$sum来计量总和。

而外$sum以为,还有以下性质的表达式操作符:

组聚集操作符

Name

Description

$addToSet

Returns an array of all the unique values for the selected field among for each document in that group.

$first

Returns the first value in a group.

$last

Returns the last value in a group.

$max

Returns the highest value in a group.

$min

Returns the lowest value in a group.

$avg

Returns an average of all the values in a group.

$push

Returns an array of all values for the selected field among for each document in that group.

$sum

Returns the sum of all the values in a group.

Bool类型聚合操作符

Name

Description

$and

Returns true only when all values in its input array are true.

$or

Returns true when any value in its input array are true.

$not

Returns the boolean value that is the opposite of the input value.

正如类型聚合操作符

Name

Description

$cmp

Compares two values and returns the result of the comparison as an integer.

$eq

Takes two values and returns true if the values are equivalent.

$gt

Takes two values and returns true if the first is larger than the second.

$gte

Takes two values and returns true if the first is larger than or equal to the second.

$lt

Takes two values and returns true if the second value is larger than the first.

$lte

Takes two values and returns true if the second value is larger than or equal to the first.

$ne

Takes two values and returns true if the values are not equivalent.

算术类型聚合操作符

Name

Description

$add

Computes the sum of an array of numbers.

$divide

Takes two numbers and divides the first number by the second.

$mod

Takes two numbers and calcualtes the modulo of the first number divided by the second.

$multiply

Computes the product of an array of numbers.

$subtract

Takes two numbers and subtracts the second number from the first.

字符串类型聚合操作符

Name

Description

$concat

Concatenates two strings.

$strcasecmp

Compares two strings and returns an integer that reflects the comparison.

$substr

Takes a string and returns portion of that string.

$toLower

Converts a string to lowercase.

$toUpper

Converts a string to uppercase.

日期类型聚合操作符

Name

Description

$dayOfYear

Converts a date to a number between 1 and 366.

$dayOfMonth

Converts a date to a number between 1 and 31.

$dayOfWeek

Converts a date to a number between 1 and 7.

$year

Converts a date to the full year.

$month

Converts a date into a number between 1 and 12.

$week

Converts a date into a number between 0 and 53

$hour

Converts a date into a number between 0 and 23.

$minute

Converts a date into a number between 0 and 59.

$second

Converts a date into a number between 0 and 59. May be 60 to account for leap seconds.

$millisecond

Returns the millisecond portion of a date as an integer between 0 and 999.

条件类型聚合操作符

Name

Description

$cond

A ternary operator that evaluates one expression, and depending on the result returns the value of one following expressions.

$ifNull

Evaluates an expression and returns a value.

流动:以上操作符都得在管道操作符的表达式内来使。

各个表达式操作符的切实可行行使方法参见:

http://docs.mongodb.org/manual/reference/operator/aggregation-group/

汇聚操作处理数量记录并返回计算后的结果。聚合操作以大半只文档分组,并会针对已经分组的多寡实行同样多元操作而回到单一结果。MongoDB提供了三栽实施聚合的章程:聚合管道,map-reduce方法与单一目的聚合操作。

 

集合管道的优化

   1.$sort  +  $skip  +  $limit顺序优化

苟当实践管道聚合时,如果$sort、$skip、$limit依次出现吧,例如:

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

{ $skip: 10 },

{ $limit: 5 }

那么实际上执行的依次吗:

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

{ $limit: 15 },

{ $skip: 10 }

$limit会提前交$skip前面去执行。

此时$limit = 优化前$skip+优化前$limit

然做的裨益来少只:1.以通过$limit管道后,管道内的文档数量独数会“提前”减多少,这样会节省内存,提高内存利用效率。2.$limit提内外,$sort紧邻$limit这样的话,当进行$sort的下当得到前“$limit”个文档的时段便见面停下。

2.$limit + $skip + $limit + $skip Sequence Optimization

要是凑管道外反复起下面的聚众序列:

  { $limit: 100 },

  { $skip: 5 },

  { $limit: 10},

  { $skip: 2 }

先是进行部分优化为:可以遵循点所云的先用第二独$limit提前:

{ $limit: 100 },

  { $limit: 15},

  { $skip: 5 },

  { $skip: 2 }

越来越优化:两单$limit可以直接沾最好小值 ,两只$skip可以一直相加:

{ $limit: 15 },

  { $skip: 7 }

3.Projection Optimization

过早的应用$project投影,设置需要使用的字段,去丢不用的字段,可以大大减少内存。除此之外也得以过早下

咱们啊当过早下$match、$limit、$skip操作符,他们好提前减少管道外文档数量,减少内存占用,提供聚合效率。

除开,$match尽量放到聚合的首先个阶段,如果这样的话$match相当给一个据标准查询的话语,这样的话可以行使索引,加快查询效率。

集合管道

更改一个旁人总结的:

会师管道的限

    1.类型限制

于管道外未可知操作 Symbol, MinKey, MaxKey, DBRef, Code,
CodeWScope类型的数额( 2.4本子解除了对二进制数据的范围).

     2.结果大小限制

管道线的出口结果莫可知超过BSON 文档的深浅(16M),如果盖的言辞会发出错误.

     3.外存限制

一经一个管道操作符在实践的经过中所占的内存超过系统内存容量的10%底早晚,会来一个错误。

当$sort和$group操作符执行的下,整个输入还见面于加载到外存中,如果这些占有内存超过系统内存的%5的时节,会以一个warning记录到日志文件。同样,所占据的内存超过系统内存容量的10%之当儿,会来一个误。

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

MongoDB aggregate 运用篇(转):http://www.cnblogs.com/qq78292959/p/4440679.html

多年来一直当就此mongodb,有时候会用为此到统计,在网上查阅了有的材料,最适合用之虽是用aggregate,以下介绍一下协调用的体验。。

人家写了之本人就算只是大多描述了,大家一样抄能检索到N多一致的,我勾勒一下本人的总。

基础知识

告大家自行检索更多,以下是任重而道远文档。

操作符介绍:

$project:包含、排除、重命名暨展示字段

$match:查询,需要同find()一样的参数

$limit:限制结果数量

$skip:忽略结果的数

$sort:按照给定的字段排序结果

$group:按照让得表达式组合结果

$unwind:分割嵌入数组到好顶层文件

文档:MongoDB 官方aggregate说明。

系以:

db.collection.aggregate([array]);

array可是是另一个或者多个操作符。

group和match的用法,使用了sqlserver,group的用法很好掌握,根据指定列进行分组统计,可以统计分组的数额,也能够统计分组中之以及要平均值等。

group之前的match,是对源数据开展查询,group之后的match是对group之后的数开展筛选;

同理,sort,skip,limit也是平的原理;

1.``1 {_id:``1``,name:``"a"``,status:``1``,num:``1``}

2.``2 {_id:``2``,name:``"a"``,status:``0``,num:``2``}

3.``3 {_id:``3``,name:``"b"``,status:``1``,num:``3``}

4.``4 {_id:``4``,name:``"c"``,status:``1``,num:``4``}

5.``5 {_id:``5``,name:``"d"``,status:``1``,num:``5``}

以下是现身说法:

动相同:统计name的多少与总数;

db.collection.aggregate([

  {$group:{_id:”$name”,count:{$sum:1},total:{$sum:”$num”}}

]);

应用二:统计status=1的name的数量;

db.collection.aggregate([

  {$match:{status:1}},

  {$group:{_id:”$name”,count:{$sum:1}}}

]);

下三:统计name的数据,并且数量为小于2之;

db.collection.aggregate([

  {$group:{_id:”$name”,count:{$sum:1}},

  {$match:{count:{$lt:2}}}

]);

应用四:统计stauts=1的name的数目,并且数量为1之;

db.collection.aggregate([

  {$match:{status:1}},

  {$group:{_id:”$name”,count:{$sum:1}}},

  {$match:{count:1}}

]);

多排group,根据name和status进行多列

db.collection.aggregate([

  {$group:{_id:{name:”$name”,st:”$status”},count:{$sum:1}}}

]);

$project该操作符很简单,

db.collection.aggregate([

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

]);

结果是,只有_id,name,status三独字段的表数据,相当给sql表达式 select
_id,name,status from collection

$unwind

此操作符可以拿一个数组的文档拆分为多条文档,在异常规则下出因此,本人暂时无开展过多的钻。

如上基本就是可实现多数统计了,group前极,group后极,是非同小可。

分片上动聚合管道

汇聚管道支持于就分片的集上进行联谊操作。当分片集合上进展联谊操纵的时节,聚合管道被分成两成为稀只有,分别以mongod实例和mongos上拓展操作。

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

汇管道用

率先下充斥测试数据:http://media.mongodb.org/zips.json 并导入到数据库中。

1.查询各州的人口数

var connectionString =
ConfigurationManager.AppSettings[“MongodbConnection”];

var client = new MongoClient(connectionString);

var DatabaseName = ConfigurationManager.AppSettings[“DatabaseName”];

string collName = ConfigurationManager.AppSettings[“collName”];

MongoServer mongoDBConn = client.GetServer();

MongoDatabase db = mongoDBConn.GetDatabase(DatabaseName);

MongoCollection<BsonDocument> table = db[collName];

var group = new BsonDocument

{

{“$group”, new BsonDocument

{

{

“_id”,”$state”

},

{

“totalPop”, new BsonDocument

{

{ “$sum”,”$pop” }

}

}

}

}

};

var sort = new BsonDocument

{

{“$sort”, new BsonDocument{ { “_id”,1 }}}

};

var pipeline = new[] { group, sort };

var result = table.Aggregate(pipeline);

var matchingExamples = result.ResultDocuments.Select(x =>
x.ToDynamic()).ToList();

foreach (var example in matchingExamples)

{

var message = string.Format(“{0}- {1}”, example[“_id”],
example[“totalPop”]);

Console.WriteLine(message);

}

2.划算每个州平均每个市打人口数

>
db.zipcode.aggregate({$group:{_id:{state:”$state”,city:”$city”},pop:{$sum:”$pop”}}},

                             
{$group:{_id:”$_id.state”,avCityPop:{$avg:”$pop”}}},

                                       {$sort:{_id:1}})

var group1 = new BsonDocument

{

{“$group”, new BsonDocument

{

{

“_id”,new BsonDocument

{

{“state”,”$state”},

{“city”,”$city”}

}

},

{

“pop”, new BsonDocument

{

{ “$sum”,”$pop” }

}

}

}

}

};

var group2 = new BsonDocument

{

{“$group”, new BsonDocument

{

{

“_id”,”$_id.state”

},

{

“avCityPop”, new BsonDocument

{

{ “$avg”,”$pop” }

}

}

}

}

};

var pipeline1 = new[] { group1,group2, sort };

var result1 = table.Aggregate(pipeline1);

var matchingExamples1 = result1.ResultDocuments.Select(x =>
x.ToDynamic()).ToList();

foreach (var example in matchingExamples1)

{

var message = string.Format(“{0}- {1}”, example[“_id”],
example[“avCityPop”]);

Console.WriteLine(message);

}

3.计量每个州人口最多同无限少之都名

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

var sort1 = new BsonDocument

{

{“$sort”, new BsonDocument{ { “pop”,1 }}}

};

var group3 = new BsonDocument

{

{

“$group”, new BsonDocument

{

{

“_id”,”$_id.state”

},

{

“biggestCity”,new BsonDocument

{

{“$last”,”$_id.city”}

}

},

{

“biggestPop”,new BsonDocument

{

{“$last”,”$pop”}

}

},

{

“smallestCity”,new BsonDocument

{

{“$first”,”$_id.city”}

}

},

{

“smallestPop”,new BsonDocument

{

{“$first”,”$pop”}

}

}

}

}

};

var project = new BsonDocument

{

{

“$project”, new BsonDocument

{

{“_id”,0},

{“state”,”$_id”},

{“biggestCity”,new BsonDocument

{

{“name”,”$biggestCity”},

{“pop”,”$biggestPop”}

}},

{“smallestCity”,new BsonDocument

{

{“name”,”$smallestCity”},

{“pop”,”$smallestPop”}

}

}

}

}

};

var pipeline2 = new[] { group1,sort1 ,group3, project };

var result2 = table.Aggregate(pipeline2);

var matchingExamples2 = result2.ResultDocuments.Select(x =>
x.ToDynamic()).ToList();

foreach (var example in matchingExamples2)

{

Console.WriteLine(example.ToString());

//var message = string.Format(“{0}- {1}”, example[“_id”],
example[“avCityPop”]);

//Console.WriteLine(message);

}

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

总结

对大部分的集合操作,聚合管道可以提供充分好之性及同样的接口,使用起来比较简单,
和MapReduce一样,它吗得以作用为分片集合,但是出口的结果不得不保留在一个文档中,要恪守BSON
Document大小限制(当前凡16M)。

管道对数据的色以及结果的分寸会生一部分限,对于片简的定位的集合操作可以采取管道,但是于部分复杂的、大量数据集的会师任务还是利用MapReduce。

连锁文章:

http://mikaelkoskinen.net/mongodb-aggregation-framework-examples-in-c/

聚拢管道支持在分片集合上实行操作。

会合管道在其的一些阶段会使用索引来提高性。另外,聚合管道有一个内部优化等。

 图片 3

Map-Reduce

MongoDB也会提供map-reduce操作来就聚合。一般地,map-reduce操作有一定量只级次:map 阶段处理每一个文档并拿诸一个输入文档映射成一个要么多只目标,reduce合成map等级的输出。可挑选的,map-reduce操作可以产生一个finalize号为对出口做最终之转。像另的成团操作一样,

 map-reduce操作会指定询问条件筛选输入文档和对结果进行排序和范围。

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

然map-reduce比聚合管道效率低且比聚合管道又扑朔迷离。

map-reduce可以以分片集合上实施操作。map-reduce操作为能够以数据输出及分片集合上。

注:

从2.4版开始,某些mongo shell 方法和特征不支持map-reduce操作。2.4本子也支撑以运行多独JavaScript操作。2.4前的本,

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

 图片 4

单一目的聚合操作

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

抱有这些操作自一个聚集中汇聚文档。虽然这些操作提供了简便的实现集操作的方式,但是她不够灵活性和和集管道和

map-reduce相似的习性。

 图片 5

1 聚合管道

汇管道是一个成立于多少处理管道模型概念基础及之框架。文档进入多号管道遭,管道用文档转换为集结果。

 图片 6

汇聚管道提供了map-reduce 的替代品,并且于 map-reduce的扑朔迷离是剩下的会师任务以来,聚合管道可能是首选的解决方案。

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

1.1 管道

MongoDB 聚合管道由多单等级做。当文档经过逐一管道时,每个管道对文档进行换。对于各一个输入文档,管道各等不需要来输出文档。例如,某些阶段可能会见变动新文档或过滤掉一部分文档。聚合管道的组成部分路可以在管道遭出现反复。

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

1.2 聚合管道表达式

好几管道等采取聚合管道表达式作为其的操作数。聚合管道表达式指定了动用为输入文档的易。聚合管道表达式采用文档结构以可分包其他聚合管道表达式。

会合管道表达式能够单独作用被管道被之当前文档并且不会见波及其他文档数据:聚合管道表达式支持于内存中施行文档转换。

诚如地,聚合管道表达式是无论状态的而就以叫凑处理过程发现时才让求值,但累加器表达式除外。

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

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

1.3 会合管道行为

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

管道操作符合索引

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

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

3.2本子中之转变:从3.2本开始索引能够覆盖一个集结管道。在2.6
和3.0版本被,索引不可知遮住聚合管道,因为就管道用了目录,聚合还是待采取实际的文档。

比较早地过滤

如您的会师操作就需要汇聚中之一个数码子集,那么下$match, $limit,和$skip阶段来界定最开始上管道的文档。当给放置管道的始处于时,$match操作下方便的目录,只扫描集合中相当到之文档。

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

另外的表征

聚集管道发生一个间尽优化等,这个路改进了一点操作的特性。

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

1.4 聚合管道优化

聚拢管道操作发生一个优化等,此路试图重塑管道以改进性能。

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

1.4.1 投影器优化

聚拢管道会判明是否用集合中字段的一个子集来取结果。如果采取子集,那么聚集管道将只有会使用那些需要的字段以减小管道中传的数据量。

1.4.2 管道顺序优化

$sort + $match管道顺序优化

当管道顺序为$sort 后同$match时, $match会移动及$sort之前因为减少排序对象的多少。例如,如果管道包含下面的品:

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

于优化等,优化器将行顺序改变为底这样:

{ $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}

}

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

转载和援请注明出处。

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

 

相关文章