MongoDB从入门到实战（七）：MongoDB 聚合aggregate

转x33g5p2x  于2021-12-25 转载在 Go  
字(12.7k)|赞(0)|评价(0)|浏览(362)

聚合框架aggregate

聚合框架用于查询操作，使用聚合框架agregate可以通过多个操作符对文档进行处理，将前一个操作符处理后的结果传给下一个操作符，最后一个操作符处理的结果就是聚合的最后的结果。

> db.book.insertMany([{"_id": 1, "author": "monday", "book": "《Java》", "like": 10}, {"_id": 2, "author": "monday", "book": "《Java Core》", "like": 20}, {"_id": 3, "author": "mengday", "book": "《Spring Boot》", "like": 15}])

> db.book.find()
{ "_id" : 1, "author" : "monday", "book" : "《Java》", "like" : 10 }
{ "_id" : 2, "author" : "monday", "book" : "《Java Core》", "like" : 20 }
{ "_id" : 3, "author" : "mengday", "book" : "《Spring Boot》", "like" : 15 }

$match 筛选

筛选条件，相当于SQL中的where部分，过滤掉不满足条件的文档,可以使用常规的查询操作符，如 $gt、$lt、$in等。

> db.book.aggregate({"$match": {"like": {"$gt": 10}}})
{ "_id" : 2, "author" : "monday", "book" : "《Java Core》", "like" : 20 }
{ "_id" : 3, "author" : "mengday", "book" : "《Spring Boot》", "like" : 15 }

$project 投射

投射相当于SQL中的 select 投射 from 之间的部分，用于指定要查询的字段，或者对字段进行一些处理。
投射常用的3个功能：

  • 用于包含、排除字段: 设置要查询或者要过滤掉的字段，0: 要过滤掉的字段，不显示，1：需要查询的字段。
  • 对字段重命名。
  • 在投射中使用一些表达式对字段值进行处理:数学表达式、日期表达式、字符串表达式、逻辑表达式(比较表达式、布尔表达式、控制语句)。
// 查询自定的字段
> db.book.aggregate({"$project": {"_id": 0, "book": 1, "like": 1}})
{ "book" : "《Java》", "like" : 10 }
{ "book" : "《Java Core》", "like" : 20 }
{ "book" : "《Spring Boot》", "like" : 15 }

// 对字段起别名，相当于SQL中的as的作用
> db.book.aggregate({"$project": {"_id": 0, "book name": "$book", "like": 1}})
{ "like" : 10, "book name" : "《Java》" }
{ "like" : 20, "book name" : "《Java Core》" }
{ "like" : 15, "book name" : "《Spring Boot》" }

// 如果对 _id进行起别名会将别名作为一个新的字段加入到文档中，而_id保持不变
> db.book.aggregate({"$project": {"id": "$_id", "book name": "$book", "like": 1}})
{ "_id" : 1, "like" : 10, "id" : 1, "book name" : "《Java》" }
{ "_id" : 2, "like" : 20, "id" : 2, "book name" : "《Java Core》" }
{ "_id" : 3, "like" : 15, "id" : 3, "book name" : "《Spring Boot》" }

// 使用算术表达式 $add、$subtract、$multiply、$divide、$mod 处理数字类型的字段
> db.book.aggregate({"$project": {"like": {"$add": ["$like", "$like", 1]}}})
{ "_id" : 1, "like" : 21 }
{ "_id" : 2, "like" : 41 }
{ "_id" : 3, "like" : 31 }

// $substrCP: [exp, startOffset, numToReturn] : 字符串截取操作
> db.book.aggregate({"$project": {"newValue": {"$substrCP": ["$book", 1, 4]}}})
{ "_id" : 1, "newValue" : "Java" }
{ "_id" : 2, "newValue" : "Java" }
{ "_id" : 3, "newValue" : "Spri" }

// $concat：[exp1, exp2, ..., expN]: 字符串操作：将数组中的多个元素拼接在一起
> db.book.aggregate({"$project": {"newValue": {"$concat": ["$book", "(", "$author", ")"]}}})
{ "_id" : 1, "newValue" : "《Java》(monday)" }
{ "_id" : 2, "newValue" : "《Java Core》(monday)" }
{ "_id" : 3, "newValue" : "《Spring Boot》(mengday)" }

// $toUpper: 字符串操作，转大写
// $toLower : exp, 字符串转小写
> db.book.aggregate({"$project": {"newValue": {"$toUpper": "$book"}}})
{ "_id" : 1, "newValue" : "《JAVA》" }
{ "_id" : 2, "newValue" : "《JAVA CORE》" }
{ "_id" : 3, "newValue" : "《SPRING BOOT》" }

// 日期表达式：用于获取日期中的任意一部分，年月日时分秒 星期等
// $year、$month、$dayOfMonth、$dayOfWeek、$dayOfYear、$hour、$minute、$second
> db.book.find()
{ "_id" : 1, "author" : "monday", "book" : "《Java》", "like" : 10, "publishDate" : ISODate("2021-04-12T13:38:14.829Z") }
{ "_id" : 2, "author" : "monday", "book" : "《Java Core》", "like" : 20, "publishDate" : ISODate("2021-04-12T13:38:14.829Z") }
{ "_id" : 3, "author" : "mengday", "book" : "《Spring Boot》", "like" : 15, "publishDate" : ISODate("2021-04-12T13:38:14.829Z") }

> db.book.aggregate({"$project": {"year": {"$year": "$publishDate"}}})
{ "_id" : 1, "year" : 2021 }
{ "_id" : 2, "year" : 2021 }
{ "_id" : 3, "year" : 2021 }

// $cmp: [exp1, exp2]: 用于比较两个非字符串类型的值，exp1 == exp2 返回 0， 小于返回一个负数，大于返回一个正数
> db.book.aggregate({"$project": {"result": {"$cmp": ["$like", 15]}}})
{ "_id" : 1, "result" : -1 }
{ "_id" : 2, "result" : 1 }
{ "_id" : 3, "result" : 0 }

// $strcasecmp: 用于比较字符串, 不区分大小写，相等返回0
> db.book.aggregate({"$project": {"result": {"$strcasecmp": ["$author", "Monday"]}}})
{ "_id" : 1, "result" : 0 }
{ "_id" : 2, "result" : 0 }
{ "_id" : 3, "result" : -1 }

// $eq: 用于判断两个表达式是否相等，相等返回true，不相等返回false, 区分大小写
// $ne: 不相等
// $gt: 大于
// $gte： 大于等于
// $lt： 小于
// $lte： 小于等于
// 注意：{"$eq": ["$author", "monday"]} $eq键的值是个数组而不是一个对象
> db.book.aggregate({"$project": {"result": {"$eq": ["$author", "monday"]}}})
{ "_id" : 1, "result" : true }
{ "_id" : 2, "result" : true }
{ "_id" : 3, "result" : false }

// $and:[exp1, exp2, ..., expN] 用于连接多个条件，当所有条件为真的时候为true
> db.book.aggregate({"$project": {"result": {"$and": [{"$eq": ["$author", "monday"]}, {"$gt": ["$_id", 1]}]}}})
{ "_id" : 1, "result" : false }
{ "_id" : 2, "result" : true }
{ "_id" : 3, "result" : false }

// $or: [exp1, exp2, ..., expN]
> db.book.aggregate({"$project": {"result": {"$or": [{"$eq": ["$author", "monday"]}, {"$eq": ["$_id", 1]}]}}})
{ "_id" : 1, "result" : true }
{ "_id" : 2, "result" : true }
{ "_id" : 3, "result" : false }

// $not: exp 用于取反操作
> db.book.aggregate({"$project": {"result": {"$not": {"$eq": ["$author", "monday"]}}}})
{ "_id" : 1, "result" : false }
{ "_id" : 2, "result" : false }
{ "_id" : 3, "result" : true }

// $cond: [booleanExp, trueExp, falseExp]: 三位运算符
> db.book.aggregate({"$project": {"result": {"$cond": [ {"$eq": ["$author", "monday"]}, "M", "F" ]}}})
{ "_id" : 1, "result" : "M" }
{ "_id" : 2, "result" : "M" }
{ "_id" : 3, "result" : "F" }

// $ifNull: [expr, replacementExpr]: 如果字段不存在或者字段值为null会返回replacementExpr，否则返回原来的值，即字段为空时给一个默认值
> db.book.find()
{ "_id" : 1, "author" : "monday", "book" : "《Java》", "like" : 10, "publishDate" : ISODate("2021-04-12T13:38:14.829Z"), "price" : 66 }
{ "_id" : 2, "author" : "monday", "book" : "《Java Core》", "like" : 20, "publishDate" : ISODate("2021-04-12T13:38:14.829Z"), "price" : null }
{ "_id" : 3, "author" : "mengday", "book" : "《Spring Boot》", "like" : 15, "publishDate" : ISODate("2021-04-12T13:38:14.829Z") }

// IFNULL(bool, default_value)
> db.book.aggregate({"$project": {"result": {"$ifNull": ["$price", "0.00"]}}})
{ "_id" : 1, "result" : 66 }
{ "_id" : 2, "result" : "0.00" }
{ "_id" : 3, "result" : "0.00" }

$group 分组

相当于SQL中的group by 部分。

// $group 表示分组
// _id: 用于指定要分组的字段
// count: 是聚合后的结果的字段别名，类似于SQL中的as后面的别名，可以任意定义，字段前面使用$表示应用某个字段而不是一个普通的字符串
// $sum: 对分组中的每个文档做什么类型的聚合，是求和还是求平均数等，1：表示对分组的每一条文档都加1进行统计，这就相当于SQL中的count(*)
// select _id, count(*) from book group by author
> db.book.aggregate({"$group": {"_id": "$author", "count": {"$sum": 1}}})
{ "_id" : "monday", "count" : 2 }
{ "_id" : "mengday", "count" : 1 }

// 对多个字段进行分组
// select _id, count(*) from book group by author, like
> db.book.aggregate({"$group": {"_id": {"author": "$author", "like": "$like"}, "count": {"$sum": 1}}})
{ "_id" : { "author" : "monday", "like" : 10 }, "count" : 1 }
{ "_id" : { "author" : "monday", "like" : 20 }, "count" : 1 }
{ "_id" : { "author" : "mengday", "like" : 15 }, "count" : 1 }

// $avg: 求分组中某个字段的平均值
// $max: 求分组中某个字段的最大值
// $min: 求分组中某个字段最小的值
// $first: 求分组中的第一个值
// $last: 求分组中最后一个值
> db.book.aggregate( {"$group": {"_id": "$author", "avg": {"$avg": "$like"}}} )
{ "_id" : "monday", "avg" : 15 }
{ "_id" : "mengday", "avg" : 15 }

// $addToSet: 字段引用, 将分组后的每个文档指定的值放在set集合中，集合不重复，无序
> db.book.aggregate( {"$group": {"_id": "$author", "likes": {"$addToSet": "$like"}}} )
{ "_id" : "monday", "likes" : [ 20, 10 ] }
{ "_id" : "mengday", "likes" : [ 15 ] }

// $push: exp, 将分组后的每个文档指定的值放在数组中，允许重复，有序
> db.book.aggregate( {"$group": {"_id": "$author", "likes": {"$push": "$like"}}} )
{ "_id" : "mengday", "likes" : [ 15 ] }
{ "_id" : "monday", "likes" : [ 10, 20 ] }

$unwind

将数组的每一个元素都单独作为一条文档进行拆分。

> db.comments.insert({"_id": 1, "title": "java", "comment": ["good", "very good"]})
> db.comments.find()
{ "_id" : 1, "title" : "java", "comment" : [ "good", "very good" ] }
> db.comments.aggregate( {"$unwind": "$comment"} )
{ "_id" : 1, "title" : "java", "comment" : "good" }
{ "_id" : 1, "title" : "java", "comment" : "very good" }

$sort

对文档进行排序，相当于SQL中的order by。

> db.book.aggregate( {"$sort": {"_id": -1}} )
{ "_id" : 3, "author" : "mengday", "book" : "《Spring Boot》", "like" : 15, "publishDate" : ISODate("2021-04-12T13:38:14.829Z") }
{ "_id" : 2, "author" : "monday", "book" : "《Java Core》", "like" : 20, "publishDate" : ISODate("2021-04-12T13:38:14.829Z"), "price" : null }
{ "_id" : 1, "author" : "monday", "book" : "《Java》", "like" : 10, "publishDate" : ISODate("2021-04-12T13:38:14.829Z"), "price" : 66 }

$limit

限制返回的条数，相当于SQL中的limit count 语句。

> db.book.aggregate( {"$limit": 2} )
{ "_id" : 1, "author" : "monday", "book" : "《Java》", "like" : 10, "publishDate" : ISODate("2021-04-12T13:38:14.829Z"), "price" : 66 }
{ "_id" : 2, "author" : "monday", "book" : "《Java Core》", "like" : 20, "publishDate" : ISODate("2021-04-12T13:38:14.829Z"), "price" : null }

$skip

跳过前N条文档，和limit结合可用于分页。

> db.book.aggregate( {"$skip": 2}, {"$limit": 2} )
{ "_id" : 3, "author" : "mengday", "book" : "《Spring Boot》", "like" : 15, "publishDate" : ISODate("2021-04-12T13:38:14.829Z") }

聚合框架，就是将上一个操作符处理的结果交个下一个操作符继续处理（这就是Linux中的管道操作），可以使用任意多个操作符，同一个操作符也可以使用多次

// 首先通过$match: 过滤掉不匹配的文档，
// 接着讲满足条件的文档交给$group进行分组，
// 分组后将将分组后的结果交给$sort进行排序，
// 然后将排序后的结果交给$skip处理，跳过前1条，
// 把剩下的文档交给$limit处理，获取最终的聚合结果。

> db.book.aggregate( 
    {"$match": {"like": {"$gte" : 10} }}, 
    {"$group": {"_id": "$author", "count": {"$sum": 1}}},
    {"$sort": {"count": -1}},
    {"$skip": 1},
    {"$limit": 1} 
)

{ "_id" : "mengday", "count" : 1 }

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://monday.blog.csdn.net/article/details/115620006

内容来源于网络，如有侵权，请联系作者删除！

mongodb

相关文章

    查看更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com