MongoDB系列：管道操作：聚合阶段操作符（二）

已于 2024-02-23 17:15:15 修改
阅读量1.2k 收藏 15
点赞数 14
分类专栏： MongoDB 文章标签： mongodb 数据库
于 2024-02-05 10:58:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhengguofeng0328/article/details/135857773
版权

MongoDB系列：管道操作：聚合阶段操作符（二）

聚合阶段操作符介绍

本节只编写了个人认为可能用到的操作符，详细更多的操作符以及使用注意事项请前往MongoDB官网。

$match

过滤匹配数据。

// 插入数据
db.orders.insertMany( [
  { "_id" : 1, "item" : "almonds", "price" : 12, "ordered" : 2 },
  { "_id" : 2, "item" : "pecans", "price" : 20, "ordered" : 1 },
  { "_id" : 3, "item" : "cookies", "price" : 10, "ordered" : 60 }
] )

// 查询 item = almonds的文档
db.orders.aggregate([{
    $match: {
        item:"almonds"
    }
}])
// 查询orice >=10 的数据
db.orders.aggregate([{
    $match: {
        price:{$gte:10}
    }
}])

$group

聚合分组，类似于sql种的分组用法。

{
 $group:
   {
     _id: <expression>, // Group key
     <field1>: { <accumulator1> : <expression1> }, // 返回的值，通常是聚合函数
     ...
   }
 }

$limit

限制输出文档的个数。

// 获取books表中第一条数据
db.getCollection("books").aggregate([{
    $limit: 1
}])

$skip

跳过指定的个数的文档。

// 语法
{ $skip: <positive 64-bit integer> }

1、跳过第一条数据

// 插入10条数据
db.stastistic.insertMany([
    { "_id": "2019Q1", "sales": 1950, "purchased": 1200 },
    { "_id": "2019Q2", "sales": 500, "purchased": 1700 }，
    { "_id": "2019Q3", "sales": 1950, "purchased": 1200 },
    { "_id": "2019Q4", "sales": 500, "purchased": 1700 },
    { "_id": "2019Q5", "sales": 1950, "purchased": 1200 },
    { "_id": "2019Q6", "sales": 500, "purchased": 1700 },
    { "_id": "2019Q7", "sales": 1950, "purchased": 1200 },
    { "_id": "2019Q8", "sales": 500, "purchased": 1700 },
    { "_id": "2019Q9", "sales": 1950, "purchased": 1200 },
    { "_id": "2019Q10", "sales": 500, "purchased": 1700 },
])

// 跳过第一条数据
db.stastistic.aggregate([
    {
        $skip: 1
    }
])

2、配合上述$limit可以完成分页查询的效果

如按照每页5条，查询第二页的数据。

设 pageNumber：第几页，pageSize：数量，则

$skip 的 变量是 (pageNumber - 1) * pageSize。

// 每页5条，查询第二页的树。
// （2 - 1） * 5 = 5
db.stastistic.aggregate([
    {
        $skip: 5
    },
    {
        $limit: 5
    }
])

$sort

排序。

// 说明：1：正序排列；-1：倒叙排列。也可以指定计算规则进行排序。
{ $sort: { <field1>: <sort order>, <field2>: <sort order> ... } }

1、按照id正序排列

db.stastistic.aggregate([
    {
        $sort: {_id:1}
    }
])

$count

统计文档的数量。

// 查询score>80分的数据的个数为passing_scores
db.scores.aggregate(
    [{
        $match: {
            score: {
                $gt: 80
            }
        }
    },
    {
        $count: "passing_scores"
    }]
)

$unionWith

类似于sql中的union all的用法，将结果集进行合并。

// 定义
{ $unionWith: { coll: "<collection>", pipeline: [ <stage1>, ... ] } }
或
{ $unionWith: "<collection>" }  // Include all documents from the specified collection

1、合并数据

// 插入数据
db.suppliers.insertMany([
  { _id: 1, supplier: "Aardvark and Sons", state: "Texas" },
  { _id: 2, supplier: "Bears Run Amok.", state: "Colorado"},
  { _id: 3, supplier: "Squid Mark Inc. ", state: "Rhode Island" },
])

db.warehouses.insertMany([
  { _id: 1, warehouse: "A", region: "West", state: "California" },
  { _id: 2, warehouse: "B", region: "Central", state: "Colorado"},
  { _id: 3, warehouse: "C", region: "East", state: "Florida" },
])

// 获取两个表中state
db.suppliers.aggregate([
    {
        $project: { state: 1, _id: 0 }
    },
    {
        $unionWith: {
            coll: "warehouses", pipeline: [{
                $project: { state: 1, _id: 0 }
            }]
        }
    }, {
        $group: { _id: "$state" }
    }
])
  • 第一阶段：只查询state属性
  • 第二阶段：合并warehouses的state属性
  • 第三阶段：利用分组过滤数据

2、统计多表中的数据进行分析

// 插入2017、2018、2019、2020销售数据清单
db.sales_2017.insertMany( [
  { store: "General Store", item: "Chocolates", quantity: 150 },
  { store: "ShopMart", item: "Chocolates", quantity: 50 },
  { store: "General Store", item: "Cookies", quantity: 100 },
  { store: "ShopMart", item: "Cookies", quantity: 120 },
  { store: "General Store", item: "Pie", quantity: 10 },
  { store: "ShopMart", item: "Pie", quantity: 5 }
] )

db.sales_2018.insertMany( [
  { store: "General Store", item: "Cheese", quantity: 30 },
  { store: "ShopMart", item: "Cheese", quantity: 50 },
  { store: "General Store", item: "Chocolates", quantity: 125 },
  { store: "ShopMart", item: "Chocolates", quantity: 150 },
  { store: "General Store", item: "Cookies", quantity: 200 },
  { store: "ShopMart", item: "Cookies", quantity: 100 },
  { store: "ShopMart", item: "Nuts", quantity: 100 },
  { store: "General Store", item: "Pie", quantity: 30 },
  { store: "ShopMart", item: "Pie", quantity: 25 }
] )

db.sales_2019.insertMany( [
  { store: "General Store", item: "Cheese", quantity: 50 },
  { store: "ShopMart", item: "Cheese", quantity: 20 },
  { store: "General Store", item: "Chocolates", quantity: 125 },
  { store: "ShopMart", item: "Chocolates", quantity: 150 },
  { store: "General Store", item: "Cookies", quantity: 200 },
  { store: "ShopMart", item: "Cookies", quantity: 100 },
  { store: "General Store", item: "Nuts", quantity: 80 },
  { store: "ShopMart", item: "Nuts", quantity: 30 },
  { store: "General Store", item: "Pie", quantity: 50 },
  { store: "ShopMart", item: "Pie", quantity: 75 }
] )

db.sales_2020.insertMany( [
  { store: "General Store", item: "Cheese", quantity: 100, },
  { store: "ShopMart", item: "Cheese", quantity: 100},
  { store: "General Store", item: "Chocolates", quantity: 200 },
  { store: "ShopMart", item: "Chocolates", quantity: 300 },
  { store: "General Store", item: "Cookies", quantity: 500 },
  { store: "ShopMart", item: "Cookies", quantity: 400 },
  { store: "General Store", item: "Nuts", quantity: 100 },
  { store: "ShopMart", item: "Nuts", quantity: 200 },
  { store: "General Store", item: "Pie", quantity: 100 },
  { store: "ShopMart", item: "Pie", quantity: 100 }
] )

// 统计四年各个产品的销售数量
db.sales_2017.aggregate([
    {$unionWith: "sales_2018"},
    {$unionWith: "sales_2019"},
    {$unionWith: "sales_2020"},
    {
        $group: {
            _id: "$item",
            total: {
                $sum: "$quantity"
            }
        }
    }
])

// 执行结果
{ "_id" : "Chocolates", "total" : 1250 }
{ "_id" : "Cookies", "total" : 1720 }
{ "_id" : "Pie", "total" : 395 }
{ "_id" : "Cheese", "total" : 350 }
{ "_id" : "Nuts", "total" : 510 }

$unset

删除字段，在管道中等同于$project状态为0的操作。

// 删除单个属性
{ $unset: "<field>" }
// 删除多个属性
{ $unset: [ "<field1>", "<field2>", ... ] }

插入数据：

db.books.insertMany([
   { "_id" : 1, title: "Antelope Antics", isbn: "0001122223334", author: { last:"An", first: "Auntie" }, copies: [ { warehouse: "A", qty: 5 }, { warehouse: "B", qty: 15 } ] },
   { "_id" : 2, title: "Bees Babble", isbn: "999999999333", author: { last:"Bumble", first: "Bee" }, copies: [ { warehouse: "A", qty: 2 }, { warehouse: "B", qty: 5 } ] }
])

1、删除单个及多个字段

// 删除title字段
db.books.aggregate([{
    $unset: "title"
}])
// 删除title和isbn字段
db.books.aggregate([{
    $unset: ["title", "isbn"]
}])

2、删除对象以及数组中对象

// 删除对象中first属性
db.books.aggregate([{
    $unset: "author.first"
}])

// 删除数组中对象的属性warehouse
db.books.aggregate([{
    $unset: "copies.warehouse"
}])

$unwind

将数组元素进行平铺并提取到外层。

// 语法
{
  $unwind:
    {
      path: <field path>,			// 数组元素字段名
      includeArrayIndex: <string>,	// 指定平铺出来之后当前数据位于数组索引的名称
      preserveNullAndEmptyArrays: <boolean>	//当数组元素为null或空数组的处理
    }
}
  • preserveNullAndEmptyArrays：true 若为null或空数组的时候保留数据，false忽略数据。默认false

1、提取数组到外层

// 插入数据
db.inventory.insertOne({ "_id" : 1, "item" : "ABC1", sizes: [ "S", "M", "L"] })

// 将数组元素提取出来平铺到外层
db.inventory.aggregate([{
    $unwind: {
        path: "$sizes"
    }
}])

// 执行结果
{ "_id" : 1, "item" : "ABC1", "sizes" : "S" }
{ "_id" : 1, "item" : "ABC1", "sizes" : "M" }
{ "_id" : 1, "item" : "ABC1", "sizes" : "L" }

2、元素为null或空数组的处理，以及输出在数组中的索引位置

// 插入元素
db.inventory2.insertMany([
   { "_id" : 1, "item" : "ABC", price: NumberDecimal("80"), "sizes": [ "S", "M", "L"] },
   { "_id" : 2, "item" : "EFG", price: NumberDecimal("120"), "sizes" : [ ] },
   { "_id" : 3, "item" : "IJK", price: NumberDecimal("160"), "sizes": "M" },
   { "_id" : 4, "item" : "LMN" , price: NumberDecimal("10") },
   { "_id" : 5, "item" : "XYZ", price: NumberDecimal("5.75"), "sizes" : null }
])

// 当为false时，忽略null和空数组的数据，平铺到外层时在数组的索引指定为arrayIndex
db.inventory2.aggregate([{
    $unwind: {
        path: "$sizes",
        includeArrayIndex: "arrayIndex",
        preserveNullAndEmptyArrays: false
    }
}])

// 执行结果
{ "_id" : 1, "item" : "ABC", "price" : { "$numberDecimal" : "80" }, "sizes" : "S", "arrayIndex" : { "$numberLong" : "0" } }
{ "_id" : 1, "item" : "ABC", "price" : { "$numberDecimal" : "80" }, "sizes" : "M", "arrayIndex" : { "$numberLong" : "1" } }
{ "_id" : 1, "item" : "ABC", "price" : { "$numberDecimal" : "80" }, "sizes" : "L", "arrayIndex" : { "$numberLong" : "2" } }
{ "_id" : 3, "item" : "IJK", "price" : { "$numberDecimal" : "160" }, "sizes" : "M", "arrayIndex" : null }

// 修改preserveNullAndEmptyArrays为true，展示出列所有的数据
{ "_id" : 1, "item" : "ABC", "price" : { "$numberDecimal" : "80" }, "sizes" : "S", "arrayIndex" : { "$numberLong" : "0" } }
{ "_id" : 1, "item" : "ABC", "price" : { "$numberDecimal" : "80" }, "sizes" : "M", "arrayIndex" : { "$numberLong" : "1" } }
{ "_id" : 1, "item" : "ABC", "price" : { "$numberDecimal" : "80" }, "sizes" : "L", "arrayIndex" : { "$numberLong" : "2" } }
{ "_id" : 2, "item" : "EFG", "price" : { "$numberDecimal" : "120" }, "arrayIndex" : null }
{ "_id" : 3, "item" : "IJK", "price" : { "$numberDecimal" : "160" }, "sizes" : "M", "arrayIndex" : null }
{ "_id" : 4, "item" : "LMN", "price" : { "$numberDecimal" : "10" }, "arrayIndex" : null }
{ "_id" : 5, "item" : "XYZ", "price" : { "$numberDecimal" : "5.75" }, "sizes" : null, "arrayIndex" : null }

3、平铺数组中是对象的且对象中还是数组

插入数据

db.sales.insertMany([
  {
    _id: "1",
    "items" : [
     {
      "name" : "pens",
      "tags" : [ "writing", "office", "school", "stationary" ],
      "price" : NumberDecimal("12.00"),
      "quantity" : NumberInt("5")
     },
     {
      "name" : "envelopes",
      "tags" : [ "stationary", "office" ],
      "price" : NumberDecimal("19.95"),
      "quantity" : NumberInt("8")
     }
    ]
  },
  {
    _id: "2",
    "items" : [
     {
      "name" : "laptop",
      "tags" : [ "office", "electronics" ],
      "price" : NumberDecimal("800.00"),
      "quantity" : NumberInt("1")
     },
     {
      "name" : "notepad",
      "tags" : [ "stationary", "school" ],
      "price" : NumberDecimal("14.95"),
      "quantity" : NumberInt("3")
     }
    ]
  }
])

执行命令：

db.sales.aggregate([
  // First Stage
  { $unwind: "$items" },

  // Second Stage
  { $unwind: "$items.tags" },

  // Third Stage
  {
    $group:
      {
        _id: "$items.tags",
        totalSalesAmount:
          {
            $sum: { $multiply: [ "$items.price", "$items.quantity" ] }
          }
      }
  }
])

db.sales.aggregate([{
    $unwind: {
        path: "$items"
    }
}, {
    $unwind: {
        path: "$items.tags"
    }
}, {
    $group: {
        _id: "$items.tags",
        sumSale: { $sum: { $multiply: ["$items.price", "$items.quantity"] } }
    }
}, {
    $sort: {
        sumSale: 1
    }
}])

// 输出结果
{
    "_id" : "writing",
    "sumSale" : 60.0
}
{
    "_id" : "school",
    "sumSale" : 104.85
}
{
    "_id" : "stationary",
    "sumSale" : 264.45
}
{
    "_id" : "electronics",
    "sumSale" : 800.0
}
{
    "_id" : "office",
    "sumSale" : 1019.6
}
  • 第一阶段：将items的数组进行平铺提取，这时tags成了items中的一个属性。
  • 第二阶段：将items中的tags再次平铺提取。
  • 第三阶段：按照tages进行分组，计算销售额，price * quantity再求和。

$addFields / $set

添加字段，可以添加一个普通的字段以及添加嵌入式字段如对象中添加新的属性。

创建并插入数据到文档中：

db.vehicles.insertMany(
    [
        { _id: 1, type: "car", specs: { doors: 4, wheels: 4 }, times: [2, 3, 4, 5] },
        { _id: 2, type: "motorcycle", specs: { doors: 0, wheels: 2 }, times: [77, 89, 21] },
        { _id: 3, type: "jet ski" }
    ]
)

1、直接插入字段值到文档中

// 插入了sumTimes是根据times的和，address是American。
db.vehicles.aggregate([
    {
        $addFields: {
            sumTimes: { $sum: "$times" },
            address: "American"
        }
    }
])

// 结果
{ "_id" : 1, "type" : "car", "specs" : { "doors" : 4, "wheels" : 4 }, "times" : [ 2, 3, 4, 5 ], "sumTimes" : 14, "address" : "American" }
{ "_id" : 2, "type" : "motorcycle", "specs" : { "doors" : 0, "wheels" : 2 }, "times" : [ 77, 89, 21 ], "sumTimes" : 187, "address" : "American" }
{ "_id" : 3, "type" : "jet ski", "sumTimes" : 0, "address" : "American" }

2、插入文档到对象类型中

// 在specs对象中添加ball属性，值设置为 小球
// 下面有两种写发，第一种就是点来进行对象下穿，第二种就是利用json分层，最终效果是一样的
db.vehicles.aggregate([{
    $addFields: {
        //"specs.ball": "小球",
        specs: { ball: "小球" }
    }
}])

// 结果
{ "_id" : 1, "type" : "car", "specs" : { "doors" : 4, "wheels" : 4, "ball" : "小球" }, "times" : [ 2, 3, 4, 5 ] }
{ "_id" : 2, "type" : "motorcycle", "specs" : { "doors" : 0, "wheels" : 2, "ball" : "小球" }, "times" : [ 77, 89, 21 ] }
{ "_id" : 3, "type" : "jet ski", "specs" : { "ball" : "小球" } }

3、插入文档到数组类型中

利用$concatArrays操作符，指定一个数组表达式，然后拼接数组类型的数据

  • $concatArrays 合并数组，按照输入文档的顺序合并，后续会详细介绍。
// 将id等于1的数据，times数组中将 1 插入到 times的前面。
db.vehicles.aggregate([
    { $match: { _id: 1 } },
    {
        $addFields: {
            times: { $concatArrays: [[1], "$times"] }
        }
    }])
    
// 结果，原本是 2，3，4，5
{ "_id" : 1, "type" : "car", "specs" : { "doors" : 4, "wheels" : 4 }, "times" : [ 1, 2, 3, 4, 5 ] }

$bucket

$bucket 是 MongoDB 聚合管道中的一个阶段，它用于将文档按照指定的范围进行分组成桶（buckets）。每个桶都包含一个特定范围的文档数量。

创建并插入数据

db.artists.insertMany([
  { "_id" : 1, "last_name" : "Bernard", "first_name" : "Emil", "year_born" : 1868, "year_died" : 1941, "nationality" : "France" },
  { "_id" : 2, "last_name" : "Rippl-Ronai", "first_name" : "Joszef", "year_born" : 1861, "year_died" : 1927, "nationality" : "Hungary" },
  { "_id" : 3, "last_name" : "Ostroumova", "first_name" : "Anna", "year_born" : 1871, "year_died" : 1955, "nationality" : "Russia" },
  { "_id" : 4, "last_name" : "Van Gogh", "first_name" : "Vincent", "year_born" : 1853, "year_died" : 1890, "nationality" : "Holland" },
  { "_id" : 5, "last_name" : "Maurer", "first_name" : "Alfred", "year_born" : 1868, "year_died" : 1932, "nationality" : "USA" },
  { "_id" : 6, "last_name" : "Munch", "first_name" : "Edvard", "year_born" : 1863, "year_died" : 1944, "nationality" : "Norway" },
  { "_id" : 7, "last_name" : "Redon", "first_name" : "Odilon", "year_born" : 1840, "year_died" : 1916, "nationality" : "France" },
  { "_id" : 8, "last_name" : "Diriks", "first_name" : "Edvard", "year_born" : 1855, "year_died" : 1930, "nationality" : "Norway" }
])

示例：

$bucket 有一下几个参数配置：

  • groupBy：分组字段
  • boundaries：桶的边界项，数组
  • default：没有分配给桶的项，_id使用默认的值
  • output：输出项。
// 按照year_born分组，分成[1840,1850),[1850,1860),[1860,1870),[1870,1880)的组称为桶。
// 输出每个桶的数量为count，并将桶中的name，year_born组成对象用$push放入到数组中。
// 最后获取count>3的数据

db.artists.aggregate( [
  // First Stage
  {
    $bucket: {
      groupBy: "$year_born",                        // Field to group by
      boundaries: [ 1840, 1850, 1860, 1870, 1880 ], // Boundaries for the buckets
      default: "Other",                             // Bucket ID for documents which do not fall into a bucket
      output: {                                     // Output for each bucket
        "count": { $sum: 1 },
        "artists" :
          {
            $push: {
              "name": { $concat: [ "$first_name", " ", "$last_name"] },
              "year_born": "$year_born"
            }
          }
      }
    }
  },
  // Second Stage
  {
    $match: { count: {$gt: 3} }
  }
] )

// 输出结果：
{ "_id" : 1860.0, "count" : 4.0, "artists" : [ { "name" : "Emil Bernard", "year_born" : 1868 }, { "name" : "Joszef Rippl-Ronai", "year_born" : 1861 }, { "name" : "Alfred Maurer", "year_born" : 1868 }, { "name" : "Edvard Munch", "year_born" : 1863 } ] }

$fill

填充为null的值或者缺失的字段值。

{
   $fill: {
      partitionBy: <expression>,		//分组表达式，如按照部门分组partitionBy:$org
      partitionByFields: [ <field 1>, <field 2>, ... , <field n> ],
      sortBy: {
         <sort field 1>: <sort order>,
         <sort field 2>: <sort order>,
         ...,
         <sort field n>: <sort order>	//排序表达式：create_time:1正序排列
      },
      output: {
         <field 1>: { value: <expression> },
         <field 2>: { method: <string> },	// 当前阶段输出，填充score:99或score:{method:linear or locf}
         ...
      }
   }
}
  • linear：线性填充
  • locf：获取排序分组后同一组的前一个值
// 按照时间正序并且按照restaurant属性分组之后，填充score为每一组当前填充排序的前一个值
db.restaurantReviewsMultiple.aggregate( [
   {
      $fill:
         {
            sortBy: { date: 1 },
            partitionBy:  "$restaurant",
            output:
               {
                  "score": { method: "locf" }
               }
         }
   }
] )

创建并插入数

db.sales.insertMany([
  { "_id" : 1, "item" : "abc", "price" : Decimal128("10"), "quantity" : Int32("2"), "date" : ISODate("2014-03-01T08:00:00Z") },
  { "_id" : 2, "item" : "jkl", "price" : Decimal128("20"), "quantity" : Int32("1"), "date" : ISODate("2014-03-01T09:00:00Z") },
  { "_id" : 3, "item" : "xyz", "price" : Decimal128("5"), "quantity" : Int32( "10"), "date" : ISODate("2014-03-15T09:00:00Z") },
  { "_id" : 4, "item" : "xyz", "price" : Decimal128("5"), "quantity" :  Int32("20") , "date" : ISODate("2014-04-04T11:21:39.736Z") },
  { "_id" : 5, "item" : "abc", "price" : Decimal128("10"), "quantity" : Int32("10") , "date" : ISODate("2014-04-04T21:23:13.331Z") },
  { "_id" : 6, "item" : "def", "price" : Decimal128("7.5"), "quantity": Int32("5" ) , "date" : ISODate("2015-06-04T05:08:13Z") },
  { "_id" : 7, "item" : "def", "price" : Decimal128("7.5"), "quantity": Int32("10") , "date" : ISODate("2015-09-10T08:43:00Z") },
  { "_id" : 8, "item" : "abc", "price" : Decimal128("10"), "quantity" : Int32("5" ) , "date" : ISODate("2016-02-06T20:20:13Z") },
])

1、查询文档种的数量

db.sales.aggregate( [
  {
    $group: {
       _id: null,
       count: { $count: { } }
    }
  }
] )

// 结果
{ "_id" : null, "count" : 8 }

// 等同于
// select count(1) from sales

2、分组之后过滤

// 查询每种类型的售出额，按照item分组，然后求售出额
// 最后获取售出额>=100的文档
db.sales.aggregate(
  [
    // First Stage
    {
      $group :
        {
          _id : "$item",
          totalSaleAmount: { $sum: { $multiply: [ "$price", "$quantity" ] } }
        }
     },
     // Second Stage
     {
       $match: { "totalSaleAmount": { $gte: 100 } }
     }
   ]
 )

sql表达式：

select item,sum(price * quantity) as totalSaleAmount from sales group by item having totalSaleAmount>=100

3、分组之后添加合并分类

// 插入数据
db.books.insertMany([
  { "_id" : 8751, "title" : "The Banquet", "author" : "Dante", "copies" : 2 },
  { "_id" : 8752, "title" : "Divine Comedy", "author" : "Dante", "copies" : 1 },
  { "_id" : 8645, "title" : "Eclogues", "author" : "Dante", "copies" : 2 },
  { "_id" : 7000, "title" : "The Odyssey", "author" : "Homer", "copies" : 10 },
  { "_id" : 7020, "title" : "Iliad", "author" : "Homer", "copies" : 10 }
])

// 按照author分组，把每个组的数据插入到booksList数组中，最后统计每组复制的次数。
db.getCollection("books").aggregate([{
    $group: {
        _id: "$author",
        booksList: { $push: "$$ROOT" }
    }
}, {
    $addFields: {
        copyCount: { $sum: "$booksList.copies" }
    }
}])


// 结果，以返回的一条数据为例
{
  "_id": "Dante",
  "booksList": [
    {
      "_id": 8751,
      "title": "The Banquet",
      "author": "Dante",
      "copies": 2
    },
    {
      "_id": 8752,
      "title": "Divine Comedy",
      "author": "Dante",
      "copies": 1
    },
    {
      "_id": 8645,
      "title": "Eclogues",
      "author": "Dante",
      "copies": 2
    }
  ],
  "copyCount": 5
}

$lookup

MongoDB的左外连接处理数据，也可用于子查询。

{
   $lookup:
      {
         from: <foreign collection>,	// 关联的表
         localField: <field from local collection's documents>,	// 当前表的关联字段
         foreignField: <field from foreign collection's documents>,	// 关联表的关联字段
         let: { <var_1>: <expression>, …, <var_n>: <expression> }, // 当前表的字段取别名,在pipeline使用
         pipeline: [ <pipeline to run> ],		// 当前表与关联表的关联关系，可多字段且配合表达式使用
         as: <output array field>	// 输出字段名
      }
}

1、通过单字段关联查询

// 插入数据
db.orders.insertMany( [
   { "_id" : 1, "item" : "almonds", "price" : 12, "quantity" : 2 },
   { "_id" : 2, "item" : "pecans", "price" : 20, "quantity" : 1 },
   { "_id" : 3  }
] )

db.inventory.insertMany( [
   { "_id" : 1, "sku" : "almonds", "description": "product 1", "instock" : 120 },
   { "_id" : 2, "sku" : "bread", "description": "product 2", "instock" : 80 },
   { "_id" : 3, "sku" : "cashews", "description": "product 3", "instock" : 60 },
   { "_id" : 4, "sku" : "pecans", "description": "product 4", "instock" : 70 },
   { "_id" : 5, "sku": null, "description": "Incomplete" },
   { "_id" : 6 }
] )


// orders表左外关联inventory，然后根据item与sku的关联关系，对inventory的数据赋值到skuTt数组中
db.orders.aggregate([{
    $lookup: {
        from: "inventory",
        localField: "item",
        foreignField: "sku",
        as: "skuTt"
    }
}])

// 结果
{
   "_id" : 1,
   "item" : "almonds",
   "price" : 12,
   "quantity" : 2,
   "inventory_docs" : [
      { "_id" : 1, "sku" : "almonds", "description" : "product 1", "instock" : 120 }
   ]
}
{
   "_id" : 2,
   "item" : "pecans",
   "price" : 20,
   "quantity" : 1,
   "inventory_docs" : [
      { "_id" : 4, "sku" : "pecans", "description" : "product 4", "instock" : 70 }
   ]
}
{
   "_id" : 3,
   "inventory_docs" : [
      { "_id" : 5, "sku" : null, "description" : "Incomplete" },
      { "_id" : 6 }
   ]
}

其实和sql中的左外连接类似，以左表为基准，匹配右表中的数据，最后返回，但是MongoDB是将右表的数据输出到指定的字段数组上，而sql是平铺出来。值得注意的是，如果orders表中item字段是数组，该写法也同样适配。

sql写法为：

select o.*,i.* from orders o left join inventory i on o.item = i.sku

2、通过单字段关联，利用$mergeObjects将数据平铺

意思是返回和sql关联查询一对多场景中一样的结果，如A关联B，A有2条数据，B有4条数据，且相关联，则最终结果返回4条数据。

示例：

// 插入文档
db.orders.insertMany( [
   { "_id" : 1, "item" : "almonds", "price" : 12, "quantity" : 2 },
   { "_id" : 2, "item" : "pecans", "price" : 20, "quantity" : 1 }
] )
db.items.insertMany( [
  { "_id" : 1, "item" : "almonds", description: "almond clusters", "instock" : 120 },
  { "_id" : 2, "item" : "bread", description: "raisin and nut bread", "instock" : 80 },
  { "_id" : 3, "item" : "pecans", description: "candied pecans", "instock" : 60 }，
  { "_id" : 4, "item" : "almonds", description: "almond clusters copy", "instock" : 240 }
] )

//
db.orders.aggregate([
    // 第一阶段，形成了类似于 示例 1 中的格式
    {
        $lookup: {
            from: "items",	// 右表
            localField: "item",    // 左表关联字段
            foreignField: "item",  // 右表关联字段
            as: "fromItems" // 输出字段
        }
    },
    // 第二阶段
    // $unwind 这儿简要说明一下，意思是将数组进行平铺出来，每个数组中的值都成为了一条数据
    {
        $unwind: "$fromItems"
    },
    // 第三阶段
    // $mergeObjects 合并第二阶段的结果与左表的文档，若字段key一致则使用左表的值。将多个文档合并成单个文档。
    // $replaceRoot 替换回原文档中
    {
        $replaceRoot: { newRoot: { $mergeObjects: ["$fromItems", "$$ROOT"] } }
    },
    // 第四阶段，隐藏fromItems字段
    {
        $project: { "fromItems": 0 }
    }
])

解析：

  • 第一阶段与上述 示例一 一个意思，把右表的数据根据关联关系生成formItems的数组，成为左表orders表的一个属性。

  • 第二阶段将formItems数组平铺到orders表的上，formItems不再是一个数组而是一个对象，orders文档数据根据数组内的个数进行增加

    { "_id" : 1, "item" : "almonds", "price" : 12, "quantity" : 2, "fromItems" : { "_id" : 1, "item" : "almonds", "description" : "almond clusters", "instock" : 120 } }
{ "_id" : 1, "item" : "almonds", "price" : 12, "quantity" : 2, "fromItems" : { "_id" : 4, "item" : "almonds", "description" : "都大大大大大", "instock" : 111 } }
{ "_id" : 2, "item" : "pecans", "price" : 20, "quantity" : 1, "fromItems" : { "_id" : 3, "item" : "pecans", "description" : "candied pecans", "instock" : 60 } }

  • 第三阶段提取formItems内的数据到外面。

  • 第四阶段隐藏formItems属性，最终结果如下

    { "_id" : 1, "item" : "almonds", "description" : "almond clusters", "instock" : 120, "price" : 12, "quantity" : 2 }
{ "_id" : 1, "item" : "almonds", "description" : "都大大大大大", "instock" : 111, "price" : 12, "quantity" : 2 }
{ "_id" : 2, "item" : "pecans", "description" : "candied pecans", "instock" : 60, "price" : 20, "quantity" : 1 }

3、多个条件的关联查询

//插入数据
db.orders.insertMany( [
  { "_id" : 1, "item" : "almonds", "price" : 12, "ordered" : 2 },
  { "_id" : 2, "item" : "pecans", "price" : 20, "ordered" : 1 },
  { "_id" : 3, "item" : "cookies", "price" : 10, "ordered" : 60 }
] )

db.warehouses.insertMany( [
  { "_id" : 1, "stock_item" : "almonds", warehouse: "A", "instock" : 120 },
  { "_id" : 2, "stock_item" : "pecans", warehouse: "A", "instock" : 80 },
  { "_id" : 3, "stock_item" : "almonds", warehouse: "B", "instock" : 60 },
  { "_id" : 4, "stock_item" : "cookies", warehouse: "B", "instock" : 40 },
  { "_id" : 5, "stock_item" : "cookies", warehouse: "A", "instock" : 80 }
] )

// orders与warehouses根据item与stock_item和warehouses.instock>orders.order_qty的文档关联。
// 不获取stock_item和_id
// pipeline内的写法是固定写法，太**了
db.orders.aggregate([
    {
        $lookup:
            {
                from: "warehouses",
                let: { order_item: "$item", order_qty: "$ordered" },
                pipeline: [
                    {
                        $match:
                            {
                                $expr:
                                    {
                                        $and:
                                            [
                                                { $eq: ["$stock_item", "$$order_item"] },
                                                { $gte: ["$instock", "$$order_qty"] }
                                            ]
                                    }
                            }
                    },
                    { $project: { stock_item: 0, _id: 0 } }
                ],
                as: "stockdata"
            }
    }
])

// 结果
{ "_id" : 1, "item" : "almonds", "price" : 12, "ordered" : 2, "stockdata" : [ { "warehouse" : "A", "instock" : 120 }, { "warehouse" : "B", "instock" : 60 } ] }
{ "_id" : 2, "item" : "pecans", "price" : 20, "ordered" : 1, "stockdata" : [ { "warehouse" : "A", "instock" : 80 } ] }
{ "_id" : 3, "item" : "cookies", "price" : 10, "ordered" : 60, "stockdata" : [ { "warehouse" : "A", "instock" : 80 } ] }

还可以利用localField和foreignField来进行关联item与stock_item。

$merge

合并数据，并输出到指定的表中，该阶段只能位于聚合得最后一个阶段中。

{ $merge: {
     into: <collection> -or- { db: <db>, coll: <collection> },
     on: <identifier field> -or- [ <identifier field1>, ...],  // Optional
     let: <variables>,                                         // Optional
     whenMatched: <replace|keepExisting|merge|fail|pipeline>,  // Optional
     whenNotMatched: <insert|discard|fail>                     // Optional
} }
  • into：必选；指定集合名称，有两种用法。一直接写表名，表示再当前数据库下输出；二指定数据库输出。
    • into:xxx
    • {db:xxx,coll:xxx}
  • on：可选；指定输出时得唯一得字段，默认是_id。换言之也就是输出到哪条数据上。
  • let：可选：指定变量，应用在下面两个属性中。
  • whenMatched：可选；管道输出结果与原文档匹配时：replace、keepExisting、merge、fail，也可用表达式。
    • replace：替换，管道数据直接覆盖原数据。
    • keepExisting：使用原文档数据。
    • merge：管道数据与原数据合并，若字段一致得使用管道数据。默认的
    • fail：直接失败。
  • whenNotMatched：可选；管道输出结果与原文档无匹配时：insert、discard、fail。
    • insert：直接插入，默认的。
    • discard：丢弃。
    • fail：直接失败。

1、统计数据合并到表中

// 插入数据
db.salaries.insertMany([
    { "_id": 1, employee: "Ant", dept: "A", salary: 100000, fiscal_year: 2017 },
    { "_id": 2, employee: "Bee", dept: "A", salary: 120000, fiscal_year: 2017 },
    { "_id": 3, employee: "Cat", dept: "Z", salary: 115000, fiscal_year: 2017 },
    { "_id": 4, employee: "Ant", dept: "A", salary: 115000, fiscal_year: 2018 },
    { "_id": 5, employee: "Bee", dept: "Z", salary: 145000, fiscal_year: 2018 },
    { "_id": 6, employee: "Cat", dept: "Z", salary: 135000, fiscal_year: 2018 },
    { "_id": 7, employee: "Gecko", dept: "A", salary: 100000, fiscal_year: 2018 },
    { "_id": 8, employee: "Ant", dept: "A", salary: 125000, fiscal_year: 2019 },
    { "_id": 9, employee: "Bee", dept: "Z", salary: 160000, fiscal_year: 2019 },
    { "_id": 10, employee: "Cat", dept: "Z", salary: 150000, fiscal_year: 2019 },
    { "_id": 11, "employee": "Wren", "dept": "Z", "salary": 100000, "fiscal_year": 2019 },
    { "_id": 12, "employee": "Zebra", "dept": "A", "salary": 150000, "fiscal_year": 2019 },
    { "_id": 13, "employee": "headcount1", "dept": "Z", "salary": 120000, "fiscal_year": 2020 },
    { "_id": 14, "employee": "headcount2", "dept": "Z", "salary": 120000, "fiscal_year": 2020 }
])

// 查询统计某年某部门发放薪资得情况
db.getCollection("salaries").aggregate([
    {
        $group: {
            _id: { fiscal_yeal: "$fiscal_year", dept: "$dept" },
            employee: { $push: "$employee" },
            sumSalary: { $sum: "$salary" }
        }
    }, {
        $merge: {
            into: "my_statistics",
            on: "_id",
            whenMatched: "merge",
            whenNotMatched: "insert"
        }
    }
])

// merge中into也可用{db:"my_database",coll:"my_statistics"}表示生成到my_database库中得my_statistics表中。
  • 第一阶段：按照fiscal_yeal和dept分组，将部门和年份绑定成一组，并求和salary和将员工放入数组。
  • 第二阶段：将第一阶段的_id作为唯一值区分，whenMatched定义了当聚合管道数据与表my_statistics中的 _id相等的时候进行合并策略，whenNotMatched根据_id判断缺失时使用插入策略。

2、将多个表统计合并为一个表

统计季度销售额与支出额。

// 插入数据
db.purchaseorders.insertMany( [
   { _id: 1, quarter: "2019Q1", region: "A", qty: 200, reportDate: new Date("2019-04-01") },
   { _id: 2, quarter: "2019Q1", region: "B", qty: 300, reportDate: new Date("2019-04-01") },
   { _id: 3, quarter: "2019Q1", region: "C", qty: 700, reportDate: new Date("2019-04-01") },
   { _id: 4, quarter: "2019Q2", region: "B", qty: 300, reportDate: new Date("2019-07-01") },
   { _id: 5, quarter: "2019Q2", region: "C", qty: 1000, reportDate: new Date("2019-07-01") },
   { _id: 6, quarter: "2019Q2", region: "A", qty: 400, reportDate: new Date("2019-07-01") },
] )

db.reportedsales.insertMany( [
   { _id: 1, quarter: "2019Q1", region: "A", qty: 400, reportDate: new Date("2019-04-02") },
   { _id: 2, quarter: "2019Q1", region: "B", qty: 550, reportDate: new Date("2019-04-02") },
   { _id: 3, quarter: "2019Q1", region: "C", qty: 1000, reportDate: new Date("2019-04-05") },
   { _id: 4, quarter: "2019Q2", region: "B", qty: 500, reportDate: new Date("2019-07-02") },
] )

// 统计支出额
db.purchaseorders.aggregate([
    {
        $group: {
            _id: "$quarter",
            purchased: { $sum: "$qty" }
        }
    },
    {
        $merge: {
            into: "my_account",
            on: "_id",
            whenMatched: "merge",
            whenNotMatched: "insert"
        }
    }
])
// 计算销售额
db.reportedsales.aggregate([
    {
        $group: {
            _id: "$quarter",
            sales: { $sum: "$qty" }
        }
    },
    {
        $merge: {
            into: "my_account",
            on: "_id",
            whenMatched: "merge",
            whenNotMatched: "insert"
        }
    }
])
  • 第一个聚合管道，统计支出额purchased，并统计到my_account表中，结构如下：
{ "_id" : "2019Q1", "purchased" : 1200 }
{ "_id" : "2019Q2", "purchased" : 1700 }
  • 第二个聚合管道，统计销售额slaes，并用合并策略根据id作为唯一键与第一个聚合管道的数据进行合并。
{ "_id" : "2019Q1", "purchased" : 1200, "sales" : 1950 }
{ "_id" : "2019Q2", "purchased" : 1700, "sales" : 500 }

3、自定义匹配策略

// 插入数据
db.votes.insertMany( [
   { date: new Date("2019-05-01"), "thumbsup" : 1, "thumbsdown" : 1 },
   { date: new Date("2019-05-02"), "thumbsup" : 3, "thumbsdown" : 1 },
   { date: new Date("2019-05-03"), "thumbsup" : 1, "thumbsdown" : 1 },
   { date: new Date("2019-05-04"), "thumbsup" : 2, "thumbsdown" : 2 },
   { date: new Date("2019-05-05"), "thumbsup" : 6, "thumbsdown" : 10 },
   { date: new Date("2019-05-06"), "thumbsup" : 13, "thumbsdown" : 16 }
] )
// 先默认生成一个五月的统计数据，5.1-5.6的统计数据
db.monthlytotals.insertOne(
   { "_id" : "2019-05", "thumbsup" : 26, "thumbsdown" : 31 }
)
// 插入一条5.7号的数据
db.votes.insertOne(
   { date: new Date("2019-05-07"), "thumbsup" : 14, "thumbsdown" : 10 }
)

// 将5.7日的数据也计算到月度统计表中。
db.votes.aggregate([
    {
        $match:
            {
                date: {
                    $gte: new Date("2019-05-07")
                }
            }
    },
    {
        $project: { "_id": { $dateToString: { format: "%Y-%m", date: "$date" } }, thumbsup: 1, thumbsdown: 1 }
    },
    {
        $merge: {
            into: "monthlytotals",
            on: "_id",
            whenMatched: [{
                $addFields: {
                    thumbsup: { $add: ["$thumbsup", "$$new.thumbsup"] },
                    thumbsdown: { $add: ["$thumbsdown", "$$new.thumbsdown"] }
                }
            }]

        }
    }
])
  • 第一阶段：过滤时间大于5.7号的数据
  • 第二阶段：将年月日格式日期 转换成 年月输出
  • 第三阶段：管道数据thumbsup和thumbsdown与monthlytotals表匹配的数据相加。
    • $thumbsup是monthlytotals表中的数据。
    • $$new.thumbsup是管道前一阶段的数据。
//输出结果：统计5.1-5.7的数据
{ "_id" : "2019-05", "thumbsup" : 40.0, "thumbsdown" : 41.0 }

$out

算是上述$merge的简化版本，只能根据_id替换对应的数据。

{ $out: { db: "<output-db>", coll: "<output-collection>" } }
或者
{ $out: ""}

1、将结果输出到文档中

// 插入数据
db.getSiblingDB("test").books.insertMany([
   { "_id" : 8751, "title" : "The Banquet", "author" : "Dante", "copies" : 2 },
   { "_id" : 8752, "title" : "Divine Comedy", "author" : "Dante", "copies" : 1 },
   { "_id" : 8645, "title" : "Eclogues", "author" : "Dante", "copies" : 2 },
   { "_id" : 7000, "title" : "The Odyssey", "author" : "Homer", "copies" : 10 },
   { "_id" : 7020, "title" : "Iliad", "author" : "Homer", "copies" : 10 }
])

db.books.aggregate([
    {
        $group: {
            _id: "$author",
            books: { $push: "$title" }
        }
    },
    {
        $out:"authors"

    }
])


{ "_id" : "Dante", "books" : [ "The Banquet", "Divine Comedy", "Eclogues" ] }
{ "_id" : "Homer", "books" : [ "The Odyssey", "Iliad" ] }
  • 第一阶段：按照author分组，将title放入到books数组中。
  • 第二阶段：输出结果到authors表中。

$replaceRoot / $replaceWith

替换数据，也可以理解为上述$merge的替换的简化版本。另有一些详细的注意地方请关注官网。

// 语法
{ $replaceRoot: { newRoot: <replacementDocument> } }
 
{ $replaceWith: <replacementDocument> }

1、提取对象数据

// 插入数据
db.people.insertMany([
    { "_id": 1, "name": "Arlene", "age": 34, "pets": { "dogs": 2, "cats": 1 } },
    { "_id": 2, "name": "Sam", "age": 41, "pets": { "cats": 1, "fish": 3 } },
    { "_id": 3, "name": "Maria", "age": 25 }
])
// 提取每个人宠物的个数 
// $replaceRoot用法
db.people.aggregate([
    {
        $replaceRoot: { newRoot:{ $mergeObjects: [{ name:"$name","dogs": 0, "cats": 0, "fish": 0, "birds": 0 }, "$pets"] }}
    }
])
// $replaceWith用法
db.people.aggregate([
    {
        $replaceWith: { $mergeObjects: [{ name:"$name","dogs": 0, "cats": 0, "fish": 0, "birds": 0 }, "$pets"] }
    }  
])

// 输出结果
{ "name" : "Arlene", "dogs" : 2, "cats" : 1, "fish" : 0.0, "birds" : 0.0 }
{ "name" : "Sam", "dogs" : 0.0, "cats" : 1, "fish" : 3, "birds" : 0.0 }
{ "name" : "Maria", "dogs" : 0.0, "cats" : 0.0, "fish" : 0.0, "birds" : 0.0 }

2、提取数组对象数据

db.students.insertMany([
   {
      "_id" : 1,
      "grades" : [
         { "test": 1, "grade" : 80, "mean" : 75, "std" : 6 },
         { "test": 2, "grade" : 85, "mean" : 90, "std" : 4 },
         { "test": 3, "grade" : 95, "mean" : 85, "std" : 6 }
      ]
   },
   {
      "_id" : 2,
      "grades" : [
         { "test": 1, "grade" : 90, "mean" : 75, "std" : 6 },
         { "test": 2, "grade" : 87, "mean" : 90, "std" : 3 },
         { "test": 3, "grade" : 91, "mean" : 85, "std" : 4 }
      ]
   }
])

// 获取分数大于等于90的学生数据
db.students.aggregate([
    {
        $unwind: "$grades"
    },
    {
        $match: {
            "grades.grade": { $gte: 90 }
        }
    },
    { $replaceRoot: { newRoot: "$grades" } }
])

// 执行结果
{ "test" : 3, "grade" : 95, "mean" : 85, "std" : 6 }
{ "test" : 1, "grade" : 90, "mean" : 75, "std" : 6 }
{ "test" : 3, "grade" : 91, "mean" : 85, "std" : 4 }

  • 第一阶段：提取grades数组元素。

    { "_id" : 1, "grades" : { "test" : 1, "grade" : 80, "mean" : 75, "std" : 6 } }
{ "_id" : 1, "grades" : { "test" : 2, "grade" : 85, "mean" : 90, "std" : 4 } }
{ "_id" : 1, "grades" : { "test" : 3, "grade" : 95, "mean" : 85, "std" : 6 } }
{ "_id" : 2, "grades" : { "test" : 1, "grade" : 90, "mean" : 75, "std" : 6 } }
{ "_id" : 2, "grades" : { "test" : 2, "grade" : 87, "mean" : 90, "std" : 3 } }
{ "_id" : 2, "grades" : { "test" : 3, "grade" : 91, "mean" : 85, "std" : 4 } }

  • 第二阶段：过滤grade>=90的数据

  • 第三阶段：将grades提取到最外层

炸了毛的猫
关注
  • 14
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MongoDB 管道的介绍及操作符实例
09-09
主要介绍了MongoDB 管道的介绍及操作符实例的相关资料,MongoDB的聚合管道将MongoDB文档在一个管道处理完毕后将结果传递给下一个管道处理,需要的朋友可以参考下
一篇文章带你搞定 MongoDB 中的管道操作符（$group、$unwind、$sort、$limit、$skip）
南淮北安的博客
08-24 3686
上篇文章中我们已经学习了MongoDB中几个基本的管道操作符，本文我们再来看看其他的管道操作符。 文章目录一、$group1. 基本操作2. 算术操作符3. 极值操作符二、$unwind三、其他操作符：sort/limit/skip四、总结 一、$group 1. 基本操作 $group可以用来对文档进行分组，比如我想将订单按照城市进行分组，并统计出每个城市的订单数量： db.sang_collect.aggregate({$group:{_id:"$orderAddressL",count:{$sum:1
MongoDB管道操作符(一)
weixin_34163553的博客
12-06 378
熟悉Linux操作系统的小伙伴们应该知道Linux中有管道的说法，可以用来方便的处理数据。MongoDB2.2版本也引入了新的数据聚合框架，一个文档可以经过多个节点组成的管道，每个节点都有自己特殊的功能，比如文档分组、文档过滤等，每一个节点都会接受一连串的文档，对这些文档做一些类型转换，然后将转换后的文档传递给下一个节点，最后一个节点则会...
MongoDB 中的管道操作符（$group、$unwind、$sort、$limit、$skip）
lbx
06-09 2922
一、$group 1. 基本操作 $group可以用来对文档进行分组，比如我想将订单按照城市进行分组，并统计出每个城市的订单数量： db.sang_collect.aggregate({$group:{_id:"$orderAddressL",count:{$sum:1}}}) 我们将要分组的字段传递给$group函数的_id字段，然后每当查到一个，就给count加1，这样就可以统计出每个城市的订单数量。 2. 算术操作符 通过算术操作符我们可以对分组后的文档进行求和或者求平均数。比如我想计算每个城市订
MongoDB&管道概念
xy2953396112的博客
03-12 645
管道在Unix和Linux中一般用于将当前命令的输出结果作为下一个命令的参数。 MongoDB的聚合管道将MongoDB文档在一个管道处理完毕后将结果传递给下一个管道处理。管道操作是可以重复的。 表达式：处理输入文档并输出。表达式是无状态的，只能用于计算当前聚合管道的文档，不能处理其它的文档。 聚合框架中常用的几个操作： $project：修改输入文档的结构。可以用来重命名、增加或删除
mongo:MongoDB 聚合管道的交互式解释
06-21
在 MongoDB 中，聚合通过一系列阶段（即“管道”）进行，每个阶段都会接收上一阶段的输出作为输入，并对其进行处理。这些阶段可以包括过滤、排序、分组、计算统计信息等。在 JavaScript 中，你可以使用 `db....
MongoDB 高级查询 aggregate 聚合管道
12-14
2. MongoDB Aggregation 管道操作符与表达式 常用的管道操作符有以下这些： MySQL 和 MongoDB 的聚合对比:     管道操作符作为“键”，所对应的“值”叫做管道表达式，如 {$match:{status:”A”}}，$match ...
基于Morphia实现MongoDB按小时、按天聚合操作方法
09-09
在本场景中，我们将探讨如何使用 Morphia 实现基于MongoDB的按小时和按天的聚合操作。 首先，我们来看一下数据模型。`RawDevStatus` 类表示原始设备状态数据，它包含了用户 ID(`userId`)、时间戳(`time`)和一系列...
mongodb 分组聚合_MongoDB 聚合
weixin_39602637的博客
12-19 210
MongoDB 聚合MongoDB 中聚合(aggregate)主要用于处理数据(诸如统计平均值，求和等)，并返回计算后的数据结果。有点类似 SQL 语句中的 count(*)。aggregate() 方法MongoDB中聚合的方法使用aggregate()。语法aggregate() 方法的基本语法格式如下所示：>db.COLLECTION_NAME.aggregate(AGGREGATE...
初识MongoDB(十二) MongoDB管道操作符一
NameiCc
12-21 782
MongoDB管道操作符(一)
mongodb常用的聚合管道操作
小菜鸟的博客
06-11 484
# 常用的一些mg的聚合管道操作 ``` db.mg_live_gather_data.aggregate([{ $project:{ _id:0, answerStatus:1, clientName:{$multiply:["$type",2]} //可以输出自定义列的名称 } }]) ``` 可以输出想要的列和自定义列的名称，将某个列重新起别名的是要如下代码 ``` db.mg_live_gather_data.aggregate([{ $project:{ _id:0,...
mongodb的聚合操作
weixin_30443747的博客
08-13 128
1. mongodb的聚合是什么 聚合(aggregate)是基于数据处理的聚合管道，每个文档通过一个由多个阶段（stage）组成的管道，可以对每个阶段的管道进行分组、过滤等功能，然后经过一系列的处理，输出相应的结果。 语法：db.集合名称.aggregate({管道:{表达式}}) 2. mongodb的常用管道和表达式 2.1 常用管道命令 在mongodb中，⽂档处理完毕...
MongoDB聚合和管道
未知的无限可能
07-31 580
聚合(aggregate)是基于数据处理的聚合管道，每个文档通过一个由多个阶段（stage）组成的管道，可以对每个阶段的管道进行分组、过滤等功能。修改输入文档的结构，如重命名、增加、删除字段、创建计算结果；将文档中的某一个数组类型字段拆分成多条，每条包含数组中的一个值。跳过指定数量的文档，并返回余下的文档。将集合中的文档分组，可用于统计结果。用于过滤数据，只输出符合条件的文档。取不同的字段的值需要使用。将输入文档排序后输出。
Mongo---聚合管道操作符将文档定制格式输出！！
nuhao的博客
11-21 402
有时候我们并不会用到文档的全部内容，只是使用其中几列，这时候就可以使用 $project 进行操作；或者有时候要重命名键值（列名），也可以使用 $project。该操作比较常用，因为文档分组后利于我们的统计。比如，按照作者分组我们就可以统计出该集合总共有几个作者。有时候我们要在集合中筛选出符合特定条件的文档，这时候使用 $match 便可以很快实现。与 $limit 相反，$skip 是跳过前 n 条文档，显示剩余文档。
MongoDB Pipeline
minihuabei的博客
07-07 2075
MongoDB Pipeline
一篇文章带你搞定 MongoDB 中的管道操作符（$match、$project）
南淮北安的博客
08-24 9535
熟悉Linux操作系统的小伙伴们应该知道Linux中有管道的说法，可以用来方便的处理数据。 MongoDB2.2版本也引入了新的数据聚合框架，一个文档可以经过多个节点组成的管道，每个节点都有自己特殊的功能，比如文档分组、文档过滤等，每一个节点都会接受一连串的文档，对这些文档做一些类型转换，然后将转换后的文档传递给下一个节点，最后一个节点则会将结果返回给客户端。 文章目录一、$match二、$project1. 基本用法2. 数学表达式3. 日期表达式4. 字符串表达式5. 逻辑表达式 一、$match ma
小程序云函数用pipeline的project筛选联表字段
frankmail的博客
02-05 492
cloud.init({ env: cloud.DYNAMIC_CURRENT_ENV }) // 使用当前云环境。return await db.collection('主表a').aggregate()$.eq(['$b的ID, '$$a的ID']) //关联匹配。as: 'binfo' // 随便你喜欢的名字，存放筛选出b表的字段。b表字段x: 0 //0为隐藏，1为显示，b表字段y: 0 //0为隐藏，1为显示。a的ID: '$a的ID', // 主表的。// 云函数入口函数。
微信小程序 三表联合查询 lookup pipeline project
oldcoder2000的博客
07-01 1734
订单微信小程序使用lookup进行多表联合，有两种方式方式1：将输入记录（输入记录：就是源数据表集合）的一个字段和被连接集合的一个字段进行相等匹配时， 方式2： 如果需要指定除相等匹配之外的连接条件，或指定多个相等匹配条件，或需要拼接被连接集合的子查询结果............
MongDB数据库操作
最新发布
03-27
聚合操作通过管道（pipeline）来处理数据，每个阶段可以是数据过滤、转换或计算等。例如，可以使用`$match`阶段进行条件筛选，`$group`阶段进行分组聚合，`$sort`阶段进行排序，以及`$project`阶段来重塑输出文档的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值