mongodb使用记录----常用操作符

作者: 一缕清风一世情_百度 | 来源:发表于2020-04-15 17:14 被阅读0次

1.查询和投影

1.1 比较操作符

$eq:匹配等于（=）指定值的文档

{ <field>: { $eq: <value> } }

$gt:匹配大于（>）指定值的文档

{ <field>: { $gt: <value> } }

$gte:匹配大于等于（>=）指定值的文档

{ <field>: { $gte: <value> } }

$lt:匹配小于（<）指定值的文档

{ <field>: { $lt: <value> } }

$lte:匹配小于等于（<=）指定值的文档

{ <field>: { $lte: <value> } }

$ne:匹配不等于（≠）指定值的文档

{ <field>: { $ne: <value> } }

$in:匹配数组中的任一值

{ <field>: { $in: [<value1>, <value2>, ... <valueN>]} }

{ <field>: { $in: value }}

$nin:不匹配数组中的值

{ <field>: { $nin: [<value1>, <value2>, ... <valueN>] } }

{ <field>: { $nin: value }}

1.2 逻辑操作符

$or:或条件查询,满足其中一个条件即为符合条件

{ $or: [ { <expression1> }, { <expression2> }, ... , { <expressionN> } ] }

$and:与条件查询,必须满足其中的所有条件

{ $and: [ { <expression1> }, { <expression2> }, ... , { <expressionN> } ] }

$not:查询与表达式不匹配的文档，即取查询条件的相反值。

{ <field>: { $not: { <operator-expression> } } }

$nor:查询与任一表达式都不匹配的文档，即不满足其中的所有条件。

{ $nor: [ { <expression1> }, { <expression2> }, ... { <expressionN> } ] }

1.2 元素操作符

$exists:查询指定字段是否存在，true(存在)，false(不存在)

{ field: { $exists: <boolean> } }

$type:查询字段类型为指定类型的文档
详细类型查看：https://www.runoob.com/mongodb/mongodb-operators-type.html

{ <field>: {$type: <BSON type number> | <String alias> } }

1.4 计值(Evaluation)操作符

$mod:取余条件查询(只能用于数值类型的数据)

{ <field>: { $mod: [ 除数, 余数 ] } }

$regex:正则表达式查询

{ <field>: { $regex: /pattren/, $options: <options>} }
{ <field>: { $regex: /pattern/<options> } }
{ <field>: { $regex: new RegExp(pattern, options) } }

$text:执行文本搜索

{
$text: {
$search: <string>,//关键词
$language: <string>,//语言
$caseSensitive: <boolean>,//是否区分大小写，默认false
$diacriticSensitive: <boolean>//是否区分读音，默认false
}
}

$where:使用$where运算符可将包含JavaScript表达式的字符串或完整的JavaScript函数传递给查询系统。$where提供了更大的灵活性，但是需要数据库为集合中的每个文档处理JavaScript表达式或函数。
使用this或obj在JavaScript表达式或函数中引用文档。

{ $where: "this.credits == this.debits" }
{ $where: function() { return obj.credits == obj.debits; } }

1.5 地理位置

详细见：https://mongoing.com/docs/reference/operator/query-geospatial.html

1.6 数组操作符

$all:匹配返回数组字段符合所有条件的文档

{ <field>: { $all: [ <value1> , <value2> ... ] } }

$elemMatch:匹配内嵌文档或数组中的部分field

{ <field>: { $elemMatch: { <query1>, <query2>, ... } } }

$size:匹配数组长度为指定大小的文档

{ <field>: { $size: <number> } }

1.7 按位操作符

详细见：https://mongoing.com/docs/reference/operator/query-bitwise.html

1.8 投影操作符

$:查询数组中首个匹配条件的元素

//文档
{ "_id" : 1, "semester" : 1, "grades" : [ 70, 87, 90 ] }
{ "_id" : 2, "semester" : 1, "grades" : [ 90, 88, 92 ] }
{ "_id" : 3, "semester" : 1, "grades" : [ 85, 100, 90 ] }
{ "_id" : 4, "semester" : 2, "grades" : [ 79, 85, 80 ] }
{ "_id" : 5, "semester" : 2, "grades" : [ 88, 88, 92 ] }
{ "_id" : 6, "semester" : 2, "grades" : [ 95, 90, 96 ] }
//查询
db.students.find(
   { 
      semester: 1, 
      grades: { 
          $gte: 85 
      }
   },
   { "grades.$": 1 } 
)
//返回
{ "_id" : 1, "grades" : [ 87 ] }
{ "_id" : 2, "grades" : [ 90 ] }
{ "_id" : 3, "grades" : [ 85 ] }

//文档
{ "_id" : 7, semester: 3, "grades" : [ { grade: 80, mean: 75, std: 8 },
                                       { grade: 85, mean: 90, std: 5 },
                                       { grade: 90, mean: 85, std: 3 } ] }

{ "_id" : 8, semester: 3, "grades" : [ { grade: 92, mean: 88, std: 8 },
                                       { grade: 78, mean: 90, std: 5 },
                                       { grade: 88, mean: 85, std: 3 } ] }
//查询
db.students.find(
   { "grades.mean": { $gt: 70 } },
   { "grades.$": 1 }
)
//返回
{ "_id" : 7, "grades" : [  {  "grade" : 80,  "mean" : 75,  "std" : 8 } ] }
{ "_id" : 8, "grades" : [  {  "grade" : 92,  "mean" : 88,  "std" : 8 } ] }

$elemMatch:投影与指定的$ elemMatch条件匹配的数组中的第一个元素。

//文档
{
 _id: 1,
 zipcode: "63109",
 students: [
              { name: "john", school: 102, age: 10 },
              { name: "jess", school: 102, age: 11 },
              { name: "jeff", school: 108, age: 15 }
           ]
}
{
 _id: 2,
 zipcode: "63110",
 students: [
              { name: "ajax", school: 100, age: 7 },
              { name: "achilles", school: 100, age: 8 },
           ]
}
{
 _id: 3,
 zipcode: "63109",
 students: [
              { name: "ajax", school: 100, age: 7 },
              { name: "achilles", school: 100, age: 8 },
           ]
}
{
 _id: 4,
 zipcode: "63109",
 students: [
              { name: "barney", school: 102, age: 7 },
              { name: "ruth", school: 102, age: 16 },
           ]
}
//查询
db.schools.find( { zipcode: "63109" },
                 { students: { $elemMatch: { school: 102 } } } )
//返回
{ "_id" : 1, "students" : [ { "name" : "john", "school" : 102, "age" : 10 } ] }
{ "_id" : 3 }
{ "_id" : 4, "students" : [ { "name" : "barney", "school" : 102, "age" : 7 } ] }

$meta:投影$text操作期间分配的文档分数。

详细见https://mongoing.com/docs/reference/operator/query/text.html#op._S_text

db.articles.find(
{ $text: { $search: "coffee" } },
{ score: { $meta: "textScore" } }
).sort( { score: { $meta: "textScore" } } ).limit(2)

$slice:截取数组。

截取comments的前5项

db.posts.find( {}, { comments: { $slice: 5 } } )

截取comments的后5项

db.posts.find( {}, { comments: { $slice: -5 } } )

截取comments的后20-30项

db.posts.find( {}, { comments: { $slice: [20 ,10] } } )

2.更新操作符

2.1 字段更新

$inc:将字段的值增加指定数量

{ $inc: { <field1>: <amount1>, <field2>: <amount2>, ... } }

//文档
{
  _id: 1,
  sku: "abc123",
  quantity: 10,
  metrics: {
    orders: 2,
    ratings: 3.5
  }
}
//操作
db.products.update(
   { sku: "abc123" },
   { $inc: { quantity: -2, "metrics.orders": 1 } }
)
//结果
{
   "_id" : 1,
   "sku" : "abc123",
   "quantity" : 8,
   "metrics" : {
      "orders" : 3,
      "ratings" : 3.5
   }
}

$inc:将字段的值乘以指定数量

{ $mul: { field: <number> } }

$rename:重命名字段

{$rename: { <field1>: <newName1>, <field2>: <newName2>, ... } }

$setOnInsert:upsert: true时，如果更新导致插入文档，则设置字段的值。对修改现有文档的更新操作没有影响。

db.collection.update(
<query>,
{ $setOnInsert: { <field1>: <value1>, ... } },
{ upsert: true }
)

$set:设置字段的值，值更新指定字段，其他字段不修改。

{ $set: { <field1>: <value1>, ... } }

$unset:删除指定字段。

{ $unset: { <field1>: "", ... } }

$min:仅当指定值小于现有字段值时才更新该字段。

{ $min: { <field1>: <value1>, ... } }

$max:仅当指定值大于现有字段值时才更新该字段。

{ $max: { <field1>: <value1>, ... } }

$currentDate:将字段的值设置为当前日期（日期或时间戳）。
<typeSpecification1>:1.布尔值true，用于将字段值设置为当前日期作为Date，2.明确指定类型的文档{$ type：“ timestamp”}或{$ type：“ date”}。运算符区分大小写，并且仅接受小写的“时间戳”或小写的“日期”。

{ $currentDate: { <field1>: <typeSpecification1>, ... } }

db.person.update( { _id: 1 }, { $currentDate: { "lastLogin": { $type: "timestamp" } } })

2.2 数组更新

$:充当占位符，以在更新中更新与查询条件匹配的第一个元素。

{ "<array>.$" : value }

//文档
{ "_id" : 1, "grades" : [ 80, 85, 90 ] }
{ "_id" : 2, "grades" : [ 88, 90, 92 ] }
{ "_id" : 3, "grades" : [ 85, 100, 90 ] }
//操作
db.students.update(
   { _id: 1, grades: 80 },
   { $set: { "grades.$" : 82 } }
)
//结果
{ "_id" : 1, "grades" : [ 82, 85, 90 ] }
{ "_id" : 2, "grades" : [ 88, 90, 92 ] }
{ "_id" : 3, "grades" : [ 85, 100, 90 ] }

//文档
{
  _id: 4,
  grades: [
     { grade: 80, mean: 75, std: 8 },
     { grade: 85, mean: 90, std: 5 },
     { grade: 90, mean: 85, std: 3 }
  ]
}
//操作
db.students.update(
   { _id: 4, "grades.grade": 85 },
   { $set: { "grades.$.std" : 6 } }
)
//结果
{
  _id: 4,
  grades: [
     { grade: 80, mean: 75, std: 8 },
     { grade: 85, mean: 90, std: 6 },
     { grade: 90, mean: 85, std: 3 }
  ]
}

$addToSet:仅当元素不存在于集合中时才将它们添加到数组中。

{ $addToSet: { <field1>: <value1>, ... } }

//文档
{ _id: 1, letters: ["a", "b"] }
//操作
db.test.update(
   { _id: 1 },
   { $addToSet: {letters: [ "c", "d" ] } }
)
//结果
{ _id: 1, letters: [ "a", "b", [ "c", "d" ] ] }

//文档
{ _id: 1, letters: ["a", "b"] }
//操作
db.test.update(
   { _id: 1 },
   { $addToSet: {letters:  "a" } }
)
//结果
{ _id: 1, letters: [ "a", "b"] }

//文档
{ _id: 1, letters: ["a", "b"] }
//操作
db.test.update(
   { _id: 1 },
   { $addToSet: {letters: { $each: [ "a", "c", "e"] } } }
)
//结果
{ _id: 1, letters: [ "a", "b", "c", "e"] }

$pop:删除数组的第一项或最后一项。
-1删除第一项，1删除最后一项

{ $pop: { <field>: <-1 | 1>, ... } }

//文档
{ _id: 1, letters: ["a", "b", "c"] }
//操作
db.test.update(
   { _id: 1 },
   { $pop: {letters: 1 } }
)
//结果
{ _id: 1, letters: [ "a", "b"] }

$pullAll:从数组中删除所有匹配的值。

{ $pullAll: { <field1>: [ <value1>, <value2> ... ], ... } }

//文档
{ _id: 1, scores: [ 0, 2, 5, 5, 1, 0 ] }
//操作
db.survey.update( { _id: 1 }, { $pullAll: { scores: [ 0, 5 ] } } )
//结果
{ "_id" : 1, "scores" : [ 2, 1 ] }

$pull:删除与指定查询匹配的所有数组元素。

{ $pull: { <field1>: <value|condition>, <field2>: <value|condition>, ... } }

//文档
{
   _id: 1,
   fruits: [ "apples", "pears", "oranges", "grapes", "bananas" ],
   vegetables: [ "carrots", "celery", "squash", "carrots" ]
}
{
   _id: 2,
   fruits: [ "plums", "kiwis", "oranges", "bananas", "apples" ],
   vegetables: [ "broccoli", "zucchini", "carrots", "onions" ]
}
//操作
db.stores.update(
    { },
    { $pull: { fruits: { $in: [ "apples", "oranges" ] }, vegetables: "carrots" } },
    { multi: true }
)
//结果
{
  "_id" : 1,
  "fruits" : [ "pears", "grapes", "bananas" ],
  "vegetables" : [ "celery", "squash" ]
}
{
  "_id" : 2,
  "fruits" : [ "plums", "kiwis", "bananas" ],
  "vegetables" : [ "broccoli", "zucchini", "onions" ]
}

$pushAll:不推荐使用。将多个项目添加到数组。

2.4版本之后已经移除。请代替使用$push运算符与$each一起使用。

$push:将项目添加到数组,如果文档中数组不存在，则创建并添加。

{ $push: { <field1>: <value1>, ... } }
{ $push: { <field1>: { <modifier1>: <value1>, ... }, ... } }

你可以将$push运算符与下列修饰符一起使用。

$each: 将多个值附加到数组字段。
$slice: 限制数组元素的数量。需要使用$ each修饰符。
$sort: 排序数组的元素。需要使用$ each修饰符。
$position: 指定数组中要插入新元素的位置。需要使用$each修饰符。如果没有$position修饰符，则$push会将元素追加到数组的末尾。

//文档
{_id: 1, scores: [1,100]}
//操作1
db.students.update(
   { _id: 1 },
   { $push: { scores: 89 } }
)
//结果1
{_id: 1, scores: [1,100, 89]}

//操作2
db.students.update(
   { _id: 1 },
   { $push: { scores: { $each: [ 90, 92, 85 ] } } }
)
//结果2
{_id: 1, scores: [1,100, 90, 92, 85]}

//操作3
db.students.update(
   { _id: 1 },
   { $push: { 
      scores: { 
        $each: [ 90, 92, 85 ],
        $position: 1
      }
   } 
})
//结果3
{_id: 1, scores: [1,90, 92, 85,100]}

//文档
{
   "_id" : 5,
   "quizzes" : [
      { "wk": 1, "score" : 10 },
      { "wk": 2, "score" : 8 },
      { "wk": 3, "score" : 5 },
      { "wk": 4, "score" : 6 }
   ]
}
//操作1
db.students.update(
   { _id: 5 },
   {
     $push: {
       quizzes: {
          $each: [ { wk: 5, score: 8 }, { wk: 6, score: 7 }, { wk: 7, score: 6 } ],
          $sort: { score: -1 },
          $slice: 3
       }
     }
   }
)
//结果1
{
  "_id" : 5,
  "quizzes" : [
     { "wk" : 1, "score" : 10 },
     { "wk" : 2, "score" : 8 },
     { "wk" : 5, "score" : 8 }
  ]
}

$each: 需要搭配$push $addToSet使用。
$slice: 需要搭配$push使用
$sort: 需要搭配$push使用
$position: 需要搭配$push使用

3.聚合管道

在db.collection.aggregate方法中，管道阶段出现在数组中。
文档按顺序通过各个阶段。

db.collection.aggregate( [ { <stage> }, ... ] )

3.1 管道聚合阶段(Pipeline Aggregation Stages)

$collStats: 返回有关集合或视图的统计信息。

$project: 将仅具有指定字段的文档传递到管道的下一个阶段。指定的字段可以是输入文档中的现有字段，也可以是新计算的字段。

{ $project: { <specifications> } }

//文档
{
  "_id" : 1,
  title: "abc123",
  isbn: "0001122223334",
  author: { last: "zzz", first: "aaa" },
  copies: 5
}
//操作
db.books.aggregate( [ { $project : { title : 1 , author : 1 } } ] )
//结果
{ "_id" : 1, "title" : "abc123", "author" : { "last" : "zzz", "first" : "aaa" } }

//文档
{
  "_id" : 1,
  title: "abc123",
  isbn: "0001122223334",
  author: { last: "zzz", first: "aaa" },
  copies: 5
}
//操作
db.books.aggregate(
   [
      {
         $project: {
            title: 1,
            isbn: {
               prefix: { $substr: [ "$isbn", 0, 3 ] },
               group: { $substr: [ "$isbn", 3, 2 ] },
               publisher: { $substr: [ "$isbn", 5, 4 ] },
               title: { $substr: [ "$isbn", 9, 3 ] },
               checkDigit: { $substr: [ "$isbn", 12, 1] }
            },
            lastName: "$author.last",
            copiesSold: "$copies"
         }
      }
   ]
)
//结果
{
   "_id" : 1,
   "title" : "abc123",
   "isbn" : {
      "prefix" : "000",
      "group" : "11",
      "publisher" : "2222",
      "title" : "333",
      "checkDigit" : "4"
   },
   "lastName" : "zzz",
   "copiesSold" : 5
}

$match: 筛选文档以仅将符合指定条件的文档传递到下一个管道阶段。类似于find。
1.不能在$match查询中使用$where作为聚合管道的一部分。
2.要在$match阶段使用$text，$match阶段必须是管道的第一阶段

{ $match: { <query> } }

$redact: 详细见https://mongoing.com/docs/reference/operator/aggregation/redact.html

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

{ $limit: <positive integer> }

$skip: 跳过传递到阶段的指定数量的文档，并将剩余的文档传递到管道中的下一个阶段。

{ $skip: <positive integer> }

$unwind: 从输入文档中解构一个数组字段，以输出每个元素的文档。每个输出文档都是输入文档，其中array字段的值被元素替换。

{ $unwind: <field path> }

3.2新版

说明：path：数组字段的字段路径。要指定字段路径，请在字段名称前加上美元符号$并用引号引起来；includeArrayIndex：可选的。一个新字段的名称，用于保存元素的数组索引。名称不能以美元符号$开头；preserveNullAndEmptyArrays：可选的。如果为true，则如果路径为null，丢失或为空数组，则$unwind输出文档。如果为false，则如果路径为null，缺少或为空数组，则$unwind将不输出文档。

{
$unwind:
{
path: <field path>,
includeArrayIndex: <string>,
preserveNullAndEmptyArrays: <boolean>
}
}

//文档
{ "_id" : 1, "item" : "ABC1", sizes: [ "S", "M", "L"] }
//操作
db.inventory.aggregate( [ { $unwind : "$sizes" } ] )
//结果
{ "_id" : 1, "item" : "ABC1", "sizes" : "S" }
{ "_id" : 1, "item" : "ABC1", "sizes" : "M" }
{ "_id" : 1, "item" : "ABC1", "sizes" : "L" }

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

//操作1
db.inventory.aggregate( [ { $unwind: { path: "$sizes" } } ] )
//结果1
{ "_id" : 1, "item" : "ABC", "sizes" : "S" }
{ "_id" : 1, "item" : "ABC", "sizes" : "M" }
{ "_id" : 1, "item" : "ABC", "sizes" : "L" }
{ "_id" : 3, "item" : "IJK", "sizes" : "M" }

//操作2
db.inventory.aggregate( [ { $unwind: { path: "$sizes", includeArrayIndex: "arrayIndex" } } ] )
//结果2
{ "_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 }

//操作3
db.inventory.aggregate( [
   { $unwind: { path: "$sizes", preserveNullAndEmptyArrays: true } }
] )
//结果3
{ "_id" : 1, "item" : "ABC", "sizes" : "S" }
{ "_id" : 1, "item" : "ABC", "sizes" : "M" }
{ "_id" : 1, "item" : "ABC", "sizes" : "L" }
{ "_id" : 2, "item" : "EFG" }
{ "_id" : 3, "item" : "IJK", "sizes" : "M" }
{ "_id" : 4, "item" : "LMN" }
{ "_id" : 5, "item" : "XYZ", "sizes" : null }

$group: 分组操作符，用于对文档集合进行分组

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

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

accumulator1一定是下列之一：

$sum:返回数值的总和。忽略非数字值。在$group和$project阶段均可用。
$avg: 返回数值的平均值。忽略非数字值。在$group和$project阶段均可用。
$fisrt:从每个组的第一个文档返回一个值。仅当文档按定义的顺序定义顺序。仅在$group阶段使用。
$last:从每个组的最后一个文档返回一个值。仅当文档按定义的顺序定义顺序。仅在$group阶段使用。
$max:返回每个组的最高表达式值。在$group和$project阶段均可用。
$min: 返回每个组的最低表达式值。在$group和$project阶段均可用。
$push: 返回每个组的表达式值的数组。仅在$group阶段使用。
$addToSet: 返回每个组的唯一表达式值的数组。数组元素的顺序未定义。仅在$group阶段使用。

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

//操作1
db.sales.aggregate([{$group : {_id : '$item'}}])
//结果1
{ "_id" : "xyz" }
{ "_id" : "jkl" }
{ "_id" : "abc" }

//操作2
db.sales.aggregate(
   [
      {
        $group : {
           _id : { month: { $month: "$date" }, day: { $dayOfMonth: "$date" }, year: { $year: "$date" } },
           totalPrice: { $sum: { $multiply: [ "$price", "$quantity" ] } },
           averageQuantity: { $avg: "$quantity" },
           count: { $sum: 1 }
        }
      }
   ]
)
//结果2
{ "_id" : { "month" : 3, "day" : 15, "year" : 2014 }, "totalPrice" : 50, "averageQuantity" : 10, "count" : 1 }
{ "_id" : { "month" : 4, "day" : 4, "year" : 2014 }, "totalPrice" : 200, "averageQuantity" : 15, "count" : 2 }
{ "_id" : { "month" : 3, "day" : 1, "year" : 2014 }, "totalPrice" : 40, "averageQuantity" : 1.5, "count" : 2 }

//操作3
db.sales.aggregate(
   [
      {
        $group : {
           _id : null,
           totalPrice: { $sum: { $multiply: [ "$price", "$quantity" ] } },
           averageQuantity: { $avg: "$quantity" },
           count: { $sum: 1 }
        }
      }
   ]
)
//结果3
{ "_id" : null, "totalPrice" : 290, "averageQuantity" : 8.6, "count" : 5 }

/*以下聚合操作将数据转换为按item分组的价格。*/
//操作4
db.sales.aggregate(
   [
      {
        $group : {
           _id :"$item",
           allprice: {
              $push: "$price"
          }
        }
      }
   ]
)
//结果4
{ "_id" : "xyz", allprice: [5, 5] }
{ "_id" : "jkl", allprice: [20] }
{ "_id" : "abc", allprice: [10, 10] }

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

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

$geoNear: 以距指定点最近到最远的顺序输出文档。

$lookup: 用于连接同一个数据库中另一个集合，并获取指定的文档，类似于populate

{
$lookup:
{
from: <collection to join>,
localField: <field from the input documents>,
foreignField: <field from the documents of the "from" collection>,
as: <output array field>
}
}

说明：from: 在同一数据库中指定要执行联接的集合。from集合无法分片。
localField: 本集合中需要查找的字段，和foreignField字段匹配是否相等。
foreignField：另外一个集合中需要关联的字段，和localField字段匹配是否相等。
as：输出的字段名

//orders文档
{ "_id" : 1, "item" : "abc", "price" : 12, "quantity" : 2 }
{ "_id" : 2, "item" : "jkl", "price" : 20, "quantity" : 1 }
{ "_id" : 3  }
//inventory文档
{ "_id" : 1, "sku" : "abc", description: "product 1", "instock" : 120 }
{ "_id" : 2, "sku" : "def", description: "product 2", "instock" : 80 }
{ "_id" : 3, "sku" : "ijk", description: "product 3", "instock" : 60 }
{ "_id" : 4, "sku" : "jkl", description: "product 4", "instock" : 70 }
{ "_id" : 5, "sku": null, description: "Incomplete" }
{ "_id" : 6 }

//操作1
db.orders.aggregate([
    {
      $lookup:
        {
          from: "inventory",
          localField: "item",
          foreignField: "sku",
          as: "inventory_docs"
        }
   }
])
//结果1
{
  "_id" : 1,
   "item" : "abc",
  "price" : 12,
  "quantity" : 2,
  "inventory_docs" : [
    { "_id" : 1, "sku" : "abc", description: "product 1", "instock" : 120 }
  ]
}
{
  "_id" : 2,
  "item" : "jkl",
  "price" : 20,
  "quantity" : 1,
  "inventory_docs" : [
    { "_id" : 4, "sku" : "jkl", "description" : "product 4", "instock" : 70 }
  ]
}
{
  "_id" : 3,
  "inventory_docs" : [
    { "_id" : 5, "sku" : null, "description" : "Incomplete" },
    { "_id" : 6 }
  ]
}

$out: 获取聚合管道返回的文档，并将它们写入指定的集合。$out运算符必须是管道中的最后阶段。$out运算符使聚合框架返回任何大小的结果集。

$indexStats: 返回有关集合中每个索引的使用情况的统计信息。如果使用访问控制运行，则用户必须具有包括indexStats操作的特权。

$facet

$bucket

$bucketAuto

$sortByCount: 根据指定表达式的值对传入文档进行分组，然后计算每个不同组中的文档数。

$addFields: 将新字段添加到文档。$addFields输出包含输入文档中所有现有字段和新添加的字段的文档。

$replaceRoot: 将指定的文档提升到顶层，并替换所有其他字段。

$count: 统计文档的数量。

{ $count: <string> }

//文档
{ "_id" : 1, "subject" : "History", "score" : 88 }
{ "_id" : 2, "subject" : "History", "score" : 92 }
{ "_id" : 3, "subject" : "History", "score" : 97 }
{ "_id" : 4, "subject" : "History", "score" : 71 }
{ "_id" : 5, "subject" : "History", "score" : 79 }
{ "_id" : 6, "subject" : "History", "score" : 83 }
//操作
db.scores.aggregate(
  [
    {
      $match: {
        score: {
          $gt: 80
        }
      }
    },
    {
      $count: "passing_scores"
    }
  ]
)
//结果
{ "passing_scores" : 4 }

$graphLookup: 对集合执行递归搜索，其中包含用于通过递归深度和查询过滤器限制搜索的选项。

3.2 布尔聚合(Boolean Aggregation Operators)

$and: 仅当其所有表达式的计算结果均为true时，才返回true。接受任意数量的参数表达式。

$or: 当其任何表达式的计算结果为true时，返回true。接受任意数量的参数表达式。

$not: 返回与其参数表达式相反的布尔值。接受单个参数表达式。