MongoDB 高级聚合查询

最新推荐文章于 2024-04-28 07:28:19 发布

@航空母舰

最新推荐文章于 2024-04-28 07:28:19 发布

阅读量992

点赞数

本文链接：https://blog.csdn.net/hudeyong926/article/details/106447436

版权

菜鸟教程地址:　http://www.runoob.com/mongodb/mongodb-tutorial.html

/* 显示当前数据库的版本 */
db.version();
/* 删除当前数据库 */
db.dropDatabase();
/* 创建集合（相当于创建数据库中的表）*/
db.createCollection("demo");
/* 获取当前db的所有集合 */
db.getCollectionNames();

/* insert(json或json数组)：插入一条或多条数据 */
db.demo.insert(
    {
        "username":"user5",
        "age":"22"
    }
)


/* 获取当前db的所有文档 */
db.demo.find();

/* 会把值覆盖，即只有当前更新的内容 */
db.demo.update(
    {
        "username":"user3"
    },
    {
        "sex":"男"
    }
);

/* 删除文档（删） */
db.demo.remove(
    {"username":"user2"},true
);

//修改字段名称，把demo表的username修改为name
db.getCollection('demo').update({}, {$rename : {"username" : "name"}}, false, true);

//添加一个字段content。 字符串类型。
db.demo.update({}, {$set: {content:""}}, {multi: 1});

//删除一个字段content
db.demo.update({},{$unset:{'content':''}},false, true);

正则匹配

#1、select * from demo where name regexp '^j.*?(g|n)$';
db.demo.find({'name':/^j.*?(g|n)$/i})

//查询商品名称长度大于25个字符的商品
db.item.find({"item_name": {"$exists": true, "$regex": /^.{25,}$/}}).limit(5)
 
//查询商品名称长度小于5个字符的商品
db.item.find({"item_name": {"$regex": /^.{0,5}$/}}).limit(5)

指定的字段

#1、select name,age from demo where id=3;
db.demo.find({'_id':3},{'_id':0,'name':1,'age':1})
1:代表要，类似True
0：代表不要，类似Flase,默认是0

排序

# 排序:1代表升序，-1代表降序
db.user.find().sort({"name":1})
db.user.find().sort({"age":-1,'_id':1})

成员运算

# SQL：in，not in
# MongoDB："$in","$nin"

#1、select * from db1.user where age in (20,30,31);
db.user.find({"age":{"$in":[20,30,31]}})

#查询集合c中y的值为null，（仅返回y的值为null的数据，不会返回不存在的）
db.c.find( { 'y' : { $type : 10 } } )

#2、select * from db1.user where name not in ('alex','yuanhao');
db.user.find({"name":{"$nin":['alex','yuanhao']}})

分页查询：按_id升序排序后的第10-19条的数据

db.demo.find().sort({"_id":1}).skip(10).limit(10);

获取数量

# 获取数量,age类型为数字，如果是字符串'30'
db.user.count({'age':{"$gt":30}}) 

--或者
db.user.find({'age':{"$gt":30}}).count()

去重

# select distinct age from user where name='zhansan'
db.user.distinct("age", { "name": "zhansan" })

添加删除数组内元素：push, push,push,pop,$pull

#添加删除数组内元素
    
往数组内添加元素:$push
#1、为名字为wang5的人添加一个爱好read
db.user.update({"name":"wang5"},{"$push":{"hobbies":"read"}})

#2、为名字为wang5的人一次添加多个爱好tea，dancing
db.user.update({"name":"wang5"},{"$push":{
    "hobbies":{"$each":["tea","dancing"]}
}})

按照位置且只能从开头或结尾删除元素：$pop
#3、{"$pop":{"key":1}} 从数组末尾删除一个元素

db.user.update({"name":"wang5"},{"$pop":{
    "hobbies":1}
})

#4、{"$pop":{"key":-1}} 从头部删除
db.user.update({"name":"wang5"},{"$pop":{
    "hobbies":-1}
})

#5、按照条件删除元素,："$pull" 把符合条件的统统删掉，而$pop只能从两端删
db.user.update({'addr.country':"China"},{"$pull":{
    "hobbies":"read"}
},
{
    "multi":true
}
)

避免添加重复："$addToSet" 添加值到一个数组中去，如果数组中已经存在该值那么将不会有任何的操作。$each修饰符允许$addToSet操作符添加多个元素到数组字段中。

#避免添加重复："$addToSet"
db.urls.insert({"_id":1,"urls":[]})

db.urls.update({"_id":1},{"$addToSet":{"urls":'http://www.baidu.com'}})
db.urls.update({"_id":1},{"$addToSet":{"urls":'http://www.baidu.com'}})
db.urls.update({"_id":1},{"$addToSet":{"urls":'http://www.baidu.com'}})

db.urls.update({"_id":1},{
    "$addToSet":{
        "urls":{
        "$each":[
            'http://www.baidu.com',
            'http://www.baidu.com',
            'http://www.xxxx.com'
            ]
            }
        }
    }
)

asdf

#1、了解：限制大小"$slice"，只留最后n个
db.user.update({"_id":5},{
    "$push":{"hobbies":{
        "$each":["read",'music','dancing'],
        "$slice":-2
    }
    }
})

#2、了解：排序The $sort element value must be either 1 or -1"
db.user.update({"_id":5},{
    "$push":{"hobbies":{
        "$each":["read",'music','dancing'],
        "$slice":-1,
        "$sort":-1
    }
    }
})

#注意：不能只将"$slice"或者"$sort"与"$push"配合使用，且必须使用"$eah"

Mongodb百万级数据进行数据去重操作

db.getCollection('表名').aggregate([
    {
        $group: { _id: {name: '$name'},count: {$sum: 1},dups: {$addToSet: '$_id'}}
    },
    {
        $match: {count: {$gt: 1}}
    }
]，
  //加上这个条件就是避免出现超出内存阈值的异常
 { allowDiskUse: true }
).forEach( //（使用forEach循环根据_id删除数据）
    function(doc){ 
        doc.dups.shift(); 
        db.getCollection('表名').remove(
            {
                _id: {
                    $in: doc.dups
                }
            }
        ); 
    }
)

把时间戳转为指定日期格式

db.test.aggregate(
   [
     {
       $project: {
          timestamp: 1,
          date1Str: {$dateToString: {format: "%Y-%m-%d %H:%M:%S:%L", date:{"$add":[new Date(0),"$timestamp"]}}},
          date2Str: {$dateToString: {format: "%Y-%m-%d %H:%M:%S:%L", date:{"$add":[new Date(0),"$timestamp",28800000]}}}
       }
     }
   ]
)

"$add":[new Date(0),"$timestamp"] ，这是为了把$timestamp的值转为Date类型

mongodb的聚合框架（aggregate）提供了很多修改器用来修改去获取IOSDate类型的字段的年、月、日、时、分、秒、等；同时mongodb也提供了相关的修改器去把IOSDate类型的时间转换为通常我们可以接受的时间格式；

$dayOfYear: 返回该日期是这一年的第几天。（全年366天）
$dayOfMonth: 返回该日期是这一个月的第几天。（1到31）
$dayOfWeek: 返回的是这个周的星期几。（1：星期日，7：星期六）
$year: 返回该日期的年份部分 $month：返回该日期的月份部分（between 1and12.）
$week：返回该日期是所在年的第几个星期（between 0and53）
$hour：返回该日期的小时部分 $minute: 返回该日期的分钟部分
$second: 返回该日期的秒部分（以0到59之间的数字形式返回日期的第二部分，但可以是60来计算闰秒。）
$millisecond：返回该日期的毫秒部分（between 0and999.）
$dateToString： { $dateToString: { format: <formatString>, date: <dateExpression> } }
formatString：需要返回的日期式，日期格式通常为以：

%Y   Year (4 digits, zero padded)   0000-9999
%m   Month (2 digits, zero padded)   01-12
%d   Day of Month (2 digits, zero padded)   01-31
%H   Hour (2 digits, zero padded, 24-hour clock)   00-23
%M   Minute (2 digits, zero padded)   00-59
%S   Second (2 digits, zero padded)   00-60
%L   Millisecond (3 digits, zero padded)   000-999
%j   Day of year (3 digits, zero padded)   001-366
%w   Day of week (1-Sunday, 7-Saturday)   1-7
%U   Week of year (2 digits, zero padded)   00-53
%%   Percent Character as a Literal

按照sendTime按照时间区间查询

db.demo.find({'sendTime':{'$gte':new Date('2017-05-12'),'$gte':new Date('2017-05-16')}).count();

查询2019年02月的数据

db.getCollection('demo').find({"useDate":{"$regex":"2019-02"}})

随机选取n个：$sample

sql:Select * From table_name Order By RAND() Limit 10
db.getCollection("table_name").aggregate({ $sample: { size:10 }})

在工作中会经常遇到一些mongodb的聚合操作，特此总结下。mongo存储的可以是复杂类型，比如数组、对象等mysql不善于处理的文档型结构，并且聚合的操作也比mysql复杂很多。

mongo与mysql聚合类比

为了便于理解，先将常见的mongo的聚合操作和mysql的查询做下类比：

下面举了一些常用的mongo聚合例子和mysql对比，假设有一条如下的数据库记录（表名：orders）作为例子：sku:库存单位(Stock Keeping Unit) qty:数量（quantity）

{
    "cust_id" : "1",
    "add_date" : ISODate("2019-01-13T13:57:41.803Z"),
    "status" : "A",
    "price" : 99.99,
    "items" : [ 
        {
            "sku" : "xxx",
            "qty" : 2,
            "price" : 66.66
        }, 
        {
            "sku" : "yyy",
            "qty" : 2,
            "price" : 33.33
        }
    ]
}
 
{
    "cust_id" : "2",
    "add_date" : ISODate("2019-01-13T13:57:41.803Z"),
    "status" : "A",
    "price" : 77.77,
    "items" : [ 
        {
            "sku" : "xxx",
            "qty" : 1,
            "price" : 55.55
        }, 
        {
            "sku" : "yyy",
            "qty" : 1,
            "price" : 22.22
        }
    ]
}

1. 统计orders表所有记录

db.orders.aggregate( [
   {
     $group: {
        _id: null,
        count: { $sum: 1 }
     }
   }
] )
 
类似mysql:
SELECT COUNT(*) AS count   FROM orders

2.对orders表计算所有price求和

db.orders.aggregate( [
   {
     $group: {
        _id: null,
        total: { $sum: "$price" }
     }
   }
] )
 
类似mysql;
SELECT SUM(price) AS total  FROM orders

3.对每一个唯一的cust_id, 计算price总和

db.orders.aggregate( [
   {
     $group: {
        _id: "$cust_id",
        total: { $sum: "$price" }
     }
   }
] )
 
类似mysql:
SELECT cust_id,
       SUM(price) AS total
FROM orders
GROUP BY cust_id

4.对每一个唯一对cust_id和add_date分组，计算price总和，不包括日期的时间部分

db.orders.aggregate( [
   {
     $group: {
        _id: {
           cust_id: "$cust_id",
           add_date: {
               month: { $month: "$add_date" },
               day: { $dayOfMonth: "$add_date" },
               year: { $year: "$add_date"}
           }
        },
        total: { $sum: "$price" }
     }
   }
] )
 
类似mysql：
SELECT cust_id,
       add_date,
       SUM(price) AS total
FROM orders
GROUP BY cust_id,
         add_date

5.对于有多个记录的cust_id，返回cust_id和对应的数量

db.orders.aggregate( [
   {
     $group: {
        _id: "$cust_id",
        count: { $sum: 1 }
     }
   },
   { $match: { count: { $gt: 1 } } }
] )
 
类似mysql:
SELECT cust_id,
       count(*)
FROM orders
GROUP BY cust_id
HAVING count(*) > 1

6.对每个唯一的cust_id和add_date分组，计算价格总和，并只返回price总和大于1的记录，且排除日期的时间部分

db.orders.aggregate( [
   {
     $group: {
        _id: {
           cust_id: "$cust_id",
           add_date: {
               month: { $month: "$add_date" },
               day: { $dayOfMonth: "$add_date" },
               year: { $year: "$add_date"}
           }
        },
        total: { $sum: "$price" }
     }
   },
   { $match: { total: { $gt: 1} } }
] )
 
类似mysql:
SELECT cust_id,
       add_date,
       SUM(price) AS total
FROM orders
GROUP BY cust_id,
         add_date
HAVING total > 1

7.对每个唯一的cust_id且status='A'，计算price总和

db.orders.aggregate( [
   { $match: { status: 'A' } },
   {
     $group: {
        _id: "$cust_id",
        total: { $sum: "$price" }
     }
   }
] )
 
 
类似mysql:
SELECT cust_id,
       SUM(price) as total
FROM orders
WHERE status = 'A'
GROUP BY cust_id

8.对每个唯一的cust_id且status=A，计算price总和并且只返回price总和大于250的记录

db.orders.aggregate( [
   { $match: { status: 'A' } },
   {
     $group: {
        _id: "$cust_id",
        total: { $sum: "$price" }
     }
   },
   { $match: { total: { $gt: 250 } } }
] )

类似mysql:
SELECT cust_id,
       SUM(price) as total
FROM orders
WHERE status = 'A'
GROUP BY cust_id
HAVING total > 250

9.对于每个唯一的cust_id，将与orders相关联的相应订单项order_lineitem的qty字段进行总计

db.orders.aggregate( [
   { $unwind: "$items" },
   {
     $group: {
        _id: "$cust_id",
        qty: { $sum: "$items.qty" }
     }
   }
] )

类似mysql:
SELECT cust_id,
       SUM(li.qty) as qty
FROM orders o,
     order_lineitem li
WHERE li.order_id = o.id
GROUP BY cust_id

10.统计不同cust_id和ord_date分组的数量，排除日期的时间部分

db.orders.aggregate( [
   {
     $group: {
        _id: {
           cust_id: "$cust_id",
           ord_date: {
               month: { $month: "$ord_date" },
               day: { $dayOfMonth: "$ord_date" },
               year: { $year: "$ord_date"}
           }
        }
     }
   },
   {
     $group: {
        _id: null,
        count: { $sum: 1 }
     }
   }
] )

类似mysql:
SELECT COUNT(*)
FROM (SELECT cust_id, ord_date
      FROM orders
      GROUP BY cust_id, ord_date)
      as DerivedTable

Aggregate简介

db.collection.aggregate()是基于数据处理的聚合管道，每个文档通过一个由多个阶段（stage）组成的管道，可以对每个阶段的管道进行分组、过滤等功能，然后经过一系列的处理，输出相应的结果。通过这张图，可以了解Aggregate处理的过程。

1、db.collection.aggregate() 可以用多个构件创建一个管道，对于一连串的文档进行处理。这些构件包括：筛选操作的match、映射操作的project、分组操作的group、排序操作的sort、限制操作的limit、和跳过操作的skip。
2、db.collection.aggregate()使用了MongoDB内置的原生操作，聚合效率非常高,支持类似于SQL Group By操作的功能，而不再需要用户编写自定义的JavaScript例程。
3、每个阶段管道限制为100MB的内存。如果一个节点管道超过这个极限,MongoDB将产生一个错误。为了能够在处理大型数据集,可以设置allowDiskUse为true来在聚合管道节点把数据写入临时文件。这样就可以解决100MB的内存的限制。
4、db.collection.aggregate()可以作用在分片集合，但结果不能输在分片集合，MapReduce可以作用在分片集合，结果也可以输在分片集合。
5、db.collection.aggregate()方法可以返回一个指针（cursor），数据放在内存中，直接操作。跟Mongo shell 一样指针操作。
6、db.collection.aggregate()输出的结果只能保存在一个文档中，BSON Document大小限制为16M。可以通过返回指针解决，版本2.6中后面：DB.collect.aggregate()方法返回一个指针，可以返回任何结果集的大小。

Aggregate语法

基本格式:

db.collection.aggregate(pipeline, options)

参数说明：

注意：
使用db.collection.aggregate()直接查询会提示错误，但是传一个空数组如db.collection.aggregate([])则不会报错，且会和find一样返回所有文档。
pipeline有很多stage，详见官网。接下来介绍这几个常用的stage:
$count , $group, $match, $project, $unwind, $limit, $skip, $sort, $sortByCount, $lookup, $out, $addFields

$count 返回包含输入到stage的文档的计数，理解为返回与表或视图的find()查询匹配的文档的计数。
db.collection.count()方法不执行find()操作，而是计数并返回与查询匹配的结果数。示例数据：

{ "_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 }

执行 :

$match 阶段排除score小于等于80的文档，将大于80的文档传到下个阶段。
$count阶段返回聚合管道中剩余文档的计数，并将该值分配给名为passing_scores的字段。

db.getCollection('test').aggregate([{
	$match: {
		score: {
			$gt: 80
		}
	}
},
{
	$count: "passing_scores"
}])

执行结果：

{
	"passing_scores": 4
}

$group 按指定的表达式对文档进行分组，并将每个不同分组的文档输出到下一个阶段。
输出文档包含一个_id字段，该字段按键包含不同的组。输出文档还可以包含计算字段，该字段保存由$group的_id字段分组的一些accumulator表达式的值。 $group不会输出具体的文档而只是统计信息

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

_id字段是必填的;但是，可以指定_id值为null来为整个输入文档计算累计值。
剩余的计算字段是可选的，并使用<accumulator>运算符进行计算。
_id和<accumulator>表达式可以接受任何有效的表达式。

accumulator操作符：

友情备注：

"$addToSet":expr，如果当前数组中不包含expr，那就将它添加到数组中。
"$push":expr，不管expr是什么只，都将它添加到数组中。返回包含所有值的数组。

在版本2.6中进行了更改：对于$group阶段，MongoDB引入了100M内存的限制以及allowDiskUse选项来处理大数据集的操作。

示例数据：

{ "_id" : 1, "item" : "abc", "price" : 10, "quantity" : 2, "date" : ISODate("2019-01-14T14:09:54.757Z") }
{ "_id" : 2, "item" : "jkl", "price" : 20, "quantity" : 1, "date" : ISODate("2019-02-14T14:09:54.757Z") }
{ "_id" : 3, "item" : "xyz", "price" : 5, "quantity" : 10, "date" : ISODate("2019-02-14T14:09:54.757Z") }
{ "_id" : 4, "item" : "xyz", "price" : 5, "quantity" : 20, "date" : ISODate("2019-03-14T14:09:54.757Z") }
{ "_id" : 5, "item" : "abc", "price" : 10, "quantity" : 10, "date" : ISODate("2019-04-14T14:09:54.757Z") }

1.以下汇总操作使用$group阶段按月份，日期和年份对文档进行分组，并计算total price和average quantity，并计算每个组的文档数量：

db.getCollection('test').aggregate([{
	$group: {
		_id: {
			month: {
				$month: "$date"
			},
			day: {
				$dayOfMonth: "$date"
			},
			year: {
				$year: "$date"
			}
		},
		total: {
			$sum: {
				$multiply: ["$price", "$quantity"]
			}
		},
		avg: {
			$avg: "$quantity"
		},
		count: {
			$sum: 1
		}
	}
}])

结果：

/* 1 */
{
    "_id" : {
        "month" : 4,
        "day" : 14,
        "year" : 2019
    },
    "total" : 100,
    "avg" : 10.0,
    "count" : 1.0
}
 
/* 2 */
{
    "_id" : {
        "month" : 2,
        "day" : 14,
        "year" : 2019
    },
    "total" : 70,
    "avg" : 5.5,
    "count" : 2.0
}
 
/* 3 */
{
    "_id" : {
        "month" : 3,
        "day" : 14,
        "year" : 2019
    },
    "total" : 100,
    "avg" : 20.0,
    "count" : 1.0
}
 
/* 4 */
{
    "_id" : {
        "month" : 1,
        "day" : 14,
        "year" : 2019
    },
    "total" : 20,
    "avg" : 2.0,
    "count" : 1.0
}

2. group null , 以下聚合操作将指定组_id为null，计算集合中所有文档的总价格和平均数量以及计数：

db.getCollection('test').aggregate([{
	$group: {
		_id: null,
		total: {
			$sum: {
				$multiply: ["$price", "$quantity"]
			}
		},
		avg: {
			$avg: "$quantity"
		},
		count: {
			$sum: 1
		}
	}
}])

结果：

/* 1 */
{
    "_id" : null,
    "total" : 290,
    "avg" : 8.6,
    "count" : 5.0
}

3. 查询distinct values

db.getCollection('test').aggregate([{
    $group:{_id:"$item"}     
}])

结果：

/* 1 */
{
    "_id" : "xyz"
}
 
/* 2 */
{
    "_id" : "jkl"
}
 
/* 3 */
{
    "_id" : "abc"
}

4. 数据转换

1）将集合中的数据按price分组转换成item数组
返回的数据id值是group中指定的字段，items可以自定义，是分组后的列表

db.getCollection('test').aggregate([{
    $group:{_id:"$price",items:{$push:"$item"}}     
}])

结果：

/* 1 */
{
    "_id" : 5,
    "items" : [ 
        "xyz", 
        "xyz"
    ]
}
 
/* 2 */
{
    "_id" : 20,
    "items" : [ 
        "jkl"
    ]
}
 
/* 3 */
{
    "_id" : 10,
    "items" : [ 
        "abc", 
        "abc"
    ]
}

2）下面聚合操作实用系统变量$$ROOT按item对文档进行分组，生成的文档不得超过BSON文档大小限制。

db.getCollection('test').aggregate([{
    $group:{_id:"$item",books:{$push:"$$ROOT"}}     
}])

结果：

/* 1 */
{
    "_id" : "xyz",
    "books" : [ 
        {
            "_id" : 3,
            "item" : "xyz",
            "price" : 5,
            "quantity" : 10,
            "date" : ISODate("2019-02-14T14:09:54.757Z")
        }, 
        {
            "_id" : 4,
            "item" : "xyz",
            "price" : 5,
            "quantity" : 20,
            "date" : ISODate("2019-03-14T14:09:54.757Z")
        }
    ]
}
 
/* 2 */
{
    "_id" : "jkl",
    "books" : [ 
        {
            "_id" : 2,
            "item" : "jkl",
            "price" : 20,
            "quantity" : 1,
            "date" : ISODate("2019-02-14T14:09:54.757Z")
        }
    ]
}
 
/* 3 */
{
    "_id" : "abc",
    "books" : [ 
        {
            "_id" : 1,
            "item" : "abc",
            "price" : 10,
            "quantity" : 2,
            "date" : ISODate("2019-01-14T14:09:54.757Z")
        }, 
        {
            "_id" : 5,
            "item" : "abc",
            "price" : 10,
            "quantity" : 10,
            "date" : ISODate("2019-04-14T14:09:54.757Z")
        }
    ]
}

$match 过滤文档，仅将符合指定条件的文档传递到下一个管道阶段。$match接受一个指定查询条件的文档。查询语法与读操作查询语法相同语法：

{ $match: { <query> } }

管道优化：

$match用于对文档进行筛选，之后可以在得到的文档子集上做聚合，$match可以使用除了地理空间之外的所有常规查询操作符，在实际应用中尽可能将$match放在管道的前面位置。这样有两个好处：一是可以快速将不需要的文档过滤掉，以减少管道的工作量；二是如果再投射和分组之前执行$match，查询可以使用索引。

限制：

不能在$ match查询中使用$作为聚合管道的一部分。
要在$match阶段使用$text，$match阶段必须是管道的第一阶段。
视图不支持文本搜索。

举例：

{ "_id" : ObjectId("512bc95fe835e68f199c8686"), "author" : "dave", "score" : 80, "views" : 100 }
{ "_id" : ObjectId("512bc962e835e68f199c8687"), "author" : "dave", "score" : 85, "views" : 521 }
{ "_id" : ObjectId("55f5a192d4bede9ac365b257"), "author" : "ahn", "score" : 60, "views" : 1000 }
{ "_id" : ObjectId("55f5a192d4bede9ac365b258"), "author" : "li", "score" : 55, "views" : 5000 }
{ "_id" : ObjectId("55f5a1d3d4bede9ac365b259"), "author" : "annT", "score" : 60, "views" : 50 }
{ "_id" : ObjectId("55f5a1d3d4bede9ac365b25a"), "author" : "li", "score" : 94, "views" : 999 }
{ "_id" : ObjectId("55f5a1d3d4bede9ac365b25b"), "author" : "ty", "score" : 95, "views" : 1000 }

1.使用 $match做简单的匹配查询

db.getCollection('match').aggregate([{
        $match:{author:"dave"}
}])

结果：

/* 1 */
{
    "_id" : ObjectId("512bc95fe835e68f199c8686"),
    "author" : "dave",
    "score" : 80,
    "views" : 100
}
 
/* 2 */
{
    "_id" : ObjectId("512bc962e835e68f199c8687"),
    "author" : "dave",
    "score" : 85,
    "views" : 521
}

2. 使用$match管道选择要处理的文档，然后将结果输出到$group管道以计算文档的计数：

db.getCollection('match').aggregate([
        {$match:{$or:[{score:{$gt:70,$lt:90}},{views:{$gte:1000}}]}},
        {$group:{_id:null,count:{$sum:1}}}
])

结果：

/* 1 */
{
    "_id" : null,
    "count" : 5.0
}

$unwind 从输入文档解构数组字段以输出每个元素的文档。简单说就是可以将数组拆分为单独的文档。语法：

{ $unwind: <field path> }

要指定字段路径，在字段名称前加上$符并用引号括起来。v3.2+支持如下语法

{
  $unwind:
    {
      path: <field path>,
      includeArrayIndex: <string>,  #可选,一个新字段的名称用于存放元素的数组索引。该名称不能以$开头。
      preserveNullAndEmptyArrays: <boolean> #可选，default :false，若为true,如果路径为空，缺少或为空数组，则$unwind输出文档
 
 } 
}

如果为输入文档中不存在的字段指定路径，或者该字段为空数组，则$unwind默认会忽略输入文档，并且不会输出该输入文档的文档。版本3.2中的新功能：要输出数组字段丢失的文档，null或空数组，请使用选项preserveNullAndEmptyArrays。

示例数据1：

{ "_id" : 1, "item" : "ABC1", sizes: [ "S", "M", "L"] }

以下聚合使用$unwind为sizes数组中的每个元素输出一个文档：

db.getCollection('unwind').aggregate(
 [ { $unwind : "$sizes" } ]
)

结果：

/* 1 */
{
    "_id" : 1,
    "item" : "ABC1",
    "sizes" : "S"
}
 
/* 2 */
{
    "_id" : 1,
    "item" : "ABC1",
    "sizes" : "M"
}
 
/* 3 */
{
    "_id" : 1,
    "item" : "ABC1",
    "sizes" : "L"
}

每个文档与输入文档相同，除了sizes字段的值是原始sizes数组的值。

再如下示例数据：

{ "_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）以下$unwind操作使用includeArrayIndex选项来输出数组元素的数组索引。

db.getCollection('unwind').aggregate( [ { $unwind: { path: "$sizes", includeArrayIndex: "arrayIndex" } } ] )

结果：

/* 1 */
{
    "_id" : 1,
    "item" : "ABC",
    "sizes" : "S",
    "arrayIndex" : NumberLong(0)
}
 
/* 2 */
{
    "_id" : 1,
    "item" : "ABC",
    "sizes" : "M",
    "arrayIndex" : NumberLong(1)
}
 
/* 3 */
{
    "_id" : 1,
    "item" : "ABC",
    "sizes" : "L",
    "arrayIndex" : NumberLong(2)
}
 
/* 4 */
{
    "_id" : 3,
    "item" : "IJK",
    "sizes" : "M",
    "arrayIndex" : null
}

2）以下$unwind操作使用preserveNullAndEmptyArrays选项在输出中包含缺少size字段，null或空数组的文档。

db.getCollection('unwind').aggregate([{$unwind:{path:"$sizes",preserveNullAndEmptyArrays: true }}])

结果：

/* 1 */
{
    "_id" : 1,
    "item" : "ABC",
    "sizes" : "S"
}
 
/* 2 */
{
    "_id" : 1,
    "item" : "ABC",
    "sizes" : "M"
}
 
/* 3 */
{
    "_id" : 1,
    "item" : "ABC",
    "sizes" : "L"
}
 
/* 4 */
{
    "_id" : 2,
    "item" : "EFG"
}
 
/* 5 */
{
    "_id" : 3,
    "item" : "IJK",
    "sizes" : "M"
}
 
/* 6 */
{
    "_id" : 4,
    "item" : "LMN"
}
 
/* 7 */
{
    "_id" : 5,
    "item" : "XYZ",
    "sizes" : null
}

$project 可以从文档中选择想要的字段，和不想要的字段（指定的字段可以是来自输入文档或新计算字段的现有字段），也可以通过管道表达式进行一些复杂的操作，例如数学操作，日期操作，字符串操作，逻辑操作。语法：

{ $project: { <specification(s)> } }

$project 管道符的作用是选择字段（指定字段，添加字段，不显示字段,_id：0，排除字段等），重命名字段，派生字段。

specifications有以下形式：
<field>: <1 or true> 是否包含该字段，field:1/0，表示选择/不选择 field
_id: <0 or false> 是否指定_id字段
<field>: <expression> 添加新字段或重置现有字段的值。在版本3.6中更改：MongoDB 3.6添加变量REMOVE。如果表达式的计算结果为$$REMOVE，则该字段将排除在输出中。
<field>:<0 or false> v3.4新增功能，指定排除字段

默认情况下，_id字段包含在输出文档中。要在输出文档中包含输入文档中的任何其他字段，必须明确指定$project中的包含。如果指定包含文档中不存在的字段，$project将忽略该字段包含，并且不会将该字段添加到文档中。
默认情况下，_id字段包含在输出文档中。要从输出文档中排除_id字段，必须明确指定$project中的_id字段为0。
v3.4版新增功能-如果指定排除一个或多个字段，则所有其他字段将在输出文档中返回。如果指定排除_id以外的字段，则不能使用任何其他$project规范表单：即，如果排除字段，则不能指定包含字段，重置现有字段的值或添加新字段。此限制不适用于使用REMOVE变量条件排除字段。
v3.6版本中的新功能- 从MongoDB 3.6开始，可以在聚合表达式中使用变量REMOVE来有条件地禁止一个字段。
要添加新字段或重置现有字段的值，请指定字段名称并将其值设置为某个表达式。
要将字段值直接设置为数字或布尔文本，而不是将字段设置为解析为文字的表达式，请使用$literal操作符。否则，$project会将数字或布尔文字视为包含或排除该字段的标志。
通过指定新字段并将其值设置为现有字段的字段路径，可以有效地重命名字段。
从MongoDB 3.2开始，$project阶段支持使用方括号[]直接创建新的数组字段。如果数组规范包含文档中不存在的字段，则该操作会将空值替换为该字段的值。
在版本3.4中更改-如果$project 是一个空文档，MongoDB 3.4和更高版本会产生一个错误。

投影或添加/重置嵌入文档中的字段时，可以使用点符号。如：

"contact.address.country": <1 or 0 or expression>
或
contact: { address: { country: <1 or 0 or expression> } }

示例数据：

{
  "_id" : 1,
  title: "789",
  isbn: "000000000",
  author: { last: "zzz", first: "xxx" },
  copies: 5,
  lastModified: "2019-07-28"
}

1. 以下$project阶段的输出文档中只包含_id，title和author字段：

db.getCollection('project').aggregate( [ { $project : { title : 1 , author : 1 } } ] )

结果:

/* 1 */
{
    "_id" : 1,
    "title" : "789",
    "author" : {
        "last" : "zzz",
        "first" : "xxx"
    }
}

2. _id字段默认包含在内。要从$ project阶段的输出文档中排除_id字段，请在project文档中将_id字段设置为0来指定排除_id字段。

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

结果：

/* 1 */
{
    "title" : "789",
    "author" : {
        "last" : "zzz",
        "first" : "xxx"
    }
}

3.从嵌套文档中排除字段，在$ project阶段从输出中排除了author.first和lastModified字段：

db.project.aggregate( [ { $project : { "author.first" : 0, "lastModified" : 0 } } ] )

或者可以将排除规范嵌套在文档中：

db.project.aggregate( [ { $project: { "author": { "first": 0}, "lastModified" : 0 } } ] )

结果：

/* 1 */
{
    "_id" : 1,
    "title" : "789",
    "isbn" : "000000000",
    "author" : {
        "last" : "zzz"
    },
    "copies" : 5
}

从MongoDB 3.6开始，可以在聚合表达式中使用变量REMOVE来有条件地禁止一个字段。示例数据：

{
  "_id" : 1,
  title: "abc",
  isbn: "111111111",
  author: { last: "aaa", first: "bbb" },
  copies: 5,
  lastModified: "2019-07-20"
}
{
  "_id" : 2,
  title: "Baked Goods",
  isbn: "222222222",
  author: { last: "abc", first: "xyz", middle: "" },
  copies: 2,
  lastModified: "2019-07-21"
}
{
  "_id" : 3,
  title: "Ice Cream Cakes",
  isbn: "333333333",
  author: { last: "nnn", first: "uuu", middle: "mmm" },
  copies: 5,
  lastModified: "2019-07-22"
}

5. 下面的$project阶段使用REMOVE变量来排除author.middle字段，前提是它等于""：

db.project.aggregate( [
   {
      $project: {
         title: 1,
         "author.first": 1,
         "author.last" : 1,
         "author.middle": {
            $cond: {
               if: { $eq: [ "", "$author.middle" ] },
               then: "$$REMOVE",
               else: "$author.middle"
            }
         }
      }
   }
] )

结果：

/* 1 */
{
    "_id" : 1,
    "title" : "abc",
    "author" : {
        "last" : "aaa",
        "first" : "bbb"
    }
}
 
/* 2 */
{
    "_id" : 2,
    "title" : "Baked Goods",
    "author" : {
        "last" : "abc",
        "first" : "xyz"
    }
}
 
/* 3 */
{
    "_id" : 3,
    "title" : "Ice Cream Cakes",
    "author" : {
        "last" : "nnn",
        "first" : "uuu",
        "middle" : "mmm"
    }
}

包含来自嵌入文档的指定字段（结果只返回包含嵌套文档的字段，当然也包括_id）

示例文档：

/* 1 */
{
    "_id" : 1,
    "user" : "1234",
    "stop" : {
        "title" : "a",
        "author" : "xyz",
        "page" : 32
    }
}
 
/* 2 */
{
    "_id" : 2,
    "user" : "6789",
    "stop" : [ 
        {
            "title" : "b",
            "author" : "abc",
            "page" : 5
        }, 
        {
            "title" : "c",
            "author" : "ijk",
            "page" : 100
        }
    ]
}

语句：

db.project.aggregate( [ { $project: { "stop.title": 1 } } ] )
或者
db.project.aggregate( [ { $project: { stop: { title: 1 } } } ] )

结果：

/* 1 */
{
    "_id" : 1,
    "stop" : {
        "title" : "a"
    }
}
 
/* 2 */
{
    "_id" : 2,
    "stop" : [ 
        {
            "title" : "b"
        }, 
        {
            "title" : "c"
        }
    ]
}

包含计算字段

示例数据：

/* 1 */
{
    "_id" : 1,
    "title" : "身份",
    "id_number" : "411325199604193511",
    "address" : "Shang Hai"
}

返回字段新增了mailing_address, info

db.project.aggregate(
   [
      {
         $project: {
            title: 1,
            info: {
               yyyy: { $substr: [ "$id_number", 6, 4 ] }
            },
            mailing_address : "$address"
         }
      }
   ]
)

结果：

/* 1 */
{
    "_id" : 1,
    "title" : "身份",
    "info" : {
        "yyyy" : "1996"
    },
    "mailing_address" : "Shang Hai"
}

投影出新数组字段

示例数据：

{ "_id" : ObjectId("55ad167f320c6be244eb3b95"), "x" : 1, "y" : 1 }

下面的聚合操作将返回新的数组字段myArray:

db.project.aggregate( [ { $project: { myArray: [ "$x", "$y" ] } } ] )

结果：

/* 1 */
{
    "_id" : ObjectId("55ad167f320c6be244eb3b95"),
    "myArray" : [ 
        1, 
        1
    ]
}

如果返回的数组包含了不存在的字段，则会返回null:

db.project.aggregate( [ { $project: { myArray: [ "$x", "$y", "$someField" ] } } ] )

结果：

/* 1 */
{
    "_id" : ObjectId("55ad167f320c6be244eb3b95"),
    "myArray" : [ 
        1, 
        1, 
        null
    ]
}

$limit 限制传递到管道中下一阶段的文档数语法：

{ $limit: <positive integer> }

示例：

db.article.aggregate(
    { $limit : 5 }
);

此操作仅返回管道传递给它的前5个文档。 $limit对其传递的文档内容没有影响。

注意：

当$sort在管道中的$limit之前立即出现时，$sort操作只会在过程中维持前n个结果，其中n是指定的限制，而MongoDB只需要将n个项存储在内存中。当allowDiskUse为true并且n个项目超过聚合内存限制时，此优化仍然适用。

$skip 跳过进入stage的指定数量的文档，并将其余文档传递到管道中的下一个阶段语法：

{ $skip: <positive integer> }

示例：

db.article.aggregate(
    { $skip : 5 }
);

此操作将跳过管道传递给它的前5个文档。 $skip对沿着管道传递的文档的内容没有影响。

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

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

$sort指定要排序的字段和相应的排序顺序的文档。 <sort order>可以具有以下值之一：

1指定升序。
-1指定降序。
{$meta：“textScore”}按照降序排列计算出的textScore元数据。

示例：

要对字段进行排序，请将排序顺序设置为1或-1，以分别指定升序或降序排序，如下例所示：

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

$sortByCount v3.4新增。根据指定表达式的值对传入文档分组，然后计算每个不同组中文档的数量。每个输出文档都包含两个字段：包含不同分组值的_id字段和包含属于该分组或类别的文档数的计数字段，文件按降序排列。语法：

{ $sortByCount:  <expression> }

@航空母舰

关注

0
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
MongoDB 高级聚合查询

asdfa/* 显示当前数据库的版本 */db.version();/* 删除当前数据库 */db.dropDatabase();/* 创建集合（相当于创建数据库中的表）*/db.createCollection("demo");/* 获取当前db的所有集合 */db.getCollectionNames();/* insert(json或json数组)：插入一条或多条数据 */db.demo.insert( { "username":"user5", .
复制链接

扫一扫