MongoDB 分组, 去重(转)

最新推荐文章于 2024-05-21 14:08:51 发布
最新推荐文章于 2024-05-21 14:08:51 发布
阅读量2.8k 收藏
点赞数

原文 http://my.oschina.net/huzorro/blog/73879


文档结构如下：

?
1
2
3
4
5
6
7
8
9
Spcode
Spname
Consignid
Consname
Region
Regionname
Serviceid
Servicename
Srctermid

一个月数据量大约1000w左右。

要实现任意字段的组合, 分组,  对Srctermid做去重操作。

MySQL:

?
1
2
SELECT Spcode, Spname, Consignid, Consname, COUNT ( DISTINCT (Srctermid))
FROM mt_log_201208 GROUP BY Spcode, Spname, Consignid, Consname

mapreduce： 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
res = db.runCommand({
     mapreduce: 'mo_log_201208' ,
     query:{Logtime:{$gte: '20120801' , $lte: '20120821' }},
     map: function () {
         emit({Spcode:this.Spcode, Spname:this.Spname,
         Consignid:this.Consignid, Consname:this.Consname},
         { "data" :[{ "Srctermid" :this.Srctermid}]});
     },
     reduce: function ( key , value) {
         var ret = {data:[]};
         var srctermid = {};
         for (var i in value) {
             var ia = value[i];         
             for (var j in ia.data) {
                 if(!srctermid[ia.data[j].Srctermid]) {
                     srctermid[ia.data[j].Srctermid] = true ;
                     ret.data.push(ia.data[j]);
                 }
             }
         }
         return ret;
     },
     finalize: function ( key , values ){
         return { count : values .data.length};
     },
     out : 'tmp_mo_spcode_consignid_1' ,
     verbose: true
})
?
1
2
3
4
5
6
7
8
9
10
11
12
> db[res.result].findOne();
{
     "_id" : {
         "Spcode" : "20017" ,
         "Spname" : "es" ,
         "Consignid" : "000000" ,
         "Consname" : "pa"
     },
     "value" : {
         "count" : 978
     }
}

 因为是对任意字段的组合分组, 对Srctermid字段去重, 为了降低每次查询扫描的记录数, 可以按照完整条件, 生成中间结果集。

mapreduce:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
res = db.runCommand({
     mapreduce: 'mo_log_201208' ,
     query:{Logtime:{$gte: '20120801' , $lte: '20120821' }},
     map: function () {
         emit({Spcode:this.Spcode, Spname:this.Spname,
                         Consignid:this.Consignid, Consname:this.Consname,
                         Region:this.Region, Regionname:this.Regionname,
                         Serviceid:this.Serviceid, Servicename:this.Servicename},
                         { "data" :[{ "Srctermid" :this.Srctermid}]});
     },
     reduce: function ( key , value) {
         var ret = {data:[]};
         var srctermid = {};
         for (var i in value) {
             var ia = value[i];         
             for (var j in ia.data) {
                 if(!srctermid[ia.data[j].Srctermid]) {
                     srctermid[ia.data[j].Srctermid] = true ;
                     ret.data.push(ia.data[j]);
                 }
             }
         }
         return ret;
     },
     out : 'tmp_mo_spcode_consignid_region_serviceid_1' ,
     verbose: true
})
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
> db.tmp_mo_spcode_consignid_region_serviceid_20120819_1.findOne();
{
     "_id" : {
         "Spcode" : "20017" ,
         "Spname" : "es" ,
         "Consignid" : "000000" ,
         "Consname" : "pa" ,
         "Region" : "0000" ,
         "Regionname" : "sa" ,
         "Serviceid" : "BZ" ,
         "Servicename" : "aa"
     },
     "value" : {
         "data" : [
             {
                 "Srctermid" : "1864741xxxx"
             },
             {
                 "Srctermid" : "1862370xxxx"
             },
             {
                 "Srctermid" : "1862061xxxx"
             },
         ]
     }
}
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
res = db.runCommand({
     mapreduce: 'tmp_mo_spcode_consignid_region_serviceid_20120819_1' ,
     map: function () {
         emit({Spcode:this._id.Spcode, Spname:this._id.Spname,
                         Consignid:this._id.Consignid, Consname:this._id.Consname},
                         { "data" :this.value.data});
     },
     reduce: function ( key , value) {
         var ret = {data:[]};
         var srctermid = {};
         for (var i in value) {
             var ia = value[i];         
             for (var j in ia.data) {
                 if(!srctermid[ia.data[j].Srctermid]) {
                     srctermid[ia.data[j].Srctermid] = true ;
                     ret.data.push(ia.data[j]);
                 }
             }
         }
         return ret;
     },
     finalize: function ( key , values ){
         return { count : values .data.length};
     },
     verbose: true
})
?
1
2
3
4
5
6
7
8
9
10
11
12
> db[res.result].findOne();
{
     "_id" : {
         "Spcode" : "20017" ,
         "Spname" : "es" ,
         "Consignid" : "000000" ,
         "Consname" : "pa"
     },
     "value" : {
         "count" : 978
     }
}

mongodb对单个文档大小的限制是>v1.8版本的16MB, <v1.8的版本4MB

mongodb 单表最大索引数为64

无索引排序的最大数据量为4M, 超过则报错退出。

在上面的操作中, 如果reduce的values超过这个限制会报错退出, 严重的mongodb服务直接dbexit

?
1
2
3
4
5
6
{
     "assertion" : "invoke failed: JS Error: out of memory nofile_b:5" ,
     "assertionCode" : 9004,
     "errmsg" : "db assertion failure" ,
     "ok" : 0
}
那么我们采用下面的方式来实现：先去重->再分组
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
res = db.runCommand({
     mapreduce: 'mo_log_201208' ,
     map: function () {
         emit({Spcode:this.Spcode, Spname:this.Spname,
                         Consignid:this.Consignid, Consname:this.Consname,
                         Srctermid:this.Srctermid}, { count :1});
     },
     reduce: function ( key , value) {
         var ret = { count :0};
         ret. count ++;
         return ret;
     },
     out : 'tmp_mo_spcode_consignid_region_serviceid_1' ,
     verbose: true
})
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
res = db.runCommand({
     mapreduce: 'tmp_spcode_consignid_region_serviceid_1' ,
     map: function () {
         emit({Spcode:this._id.Spcode, Spname:this._id.Spname,       
                         Consignid:this._id.Consignid, Srct:this._id.Consname},
                        { count :this.value. count });
     },
     reduce: function ( key , value) {
         var ret = { count :0};
         for (var i in value) {
             ret. count += value[i]. count ;
         }
         return ret;
     },
     verbose: true
})
同样为了减少每次查询扫描的记录数量, 可以生成中间结果集
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
res = db.runCommand({
     mapreduce: 'mo_log_201208' ,
     map: function () {
         emit({Spcode:this.Spcode, Spname:this.Spname,
                         Consignid:this.Consignid, Consname:this.Consname,
                         Region:this.Region, Regionname:this.Regionname,
                         Serviceid:this.Serviceid, Servicename:this.Servicename,
                         Srctermid:this.Srctermid}, { count :1});
     },
     reduce: function ( key , value) {
         var ret = { count :0};
         ret. count ++;
         return ret;
     },
     out : 'tmp_mo_spcode_consignid_region_serviceid_1' ,
     verbose: true
})
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
res = db.runCommand({
     mapreduce: 'tmp_mo_spcode_consignid_region_serviceid_1' ,
     map: function () {
         emit({Spcode:this._id.Spcode, Spname:this._id.Spname,
                         Consignid:this._id.Consignid, Consname:this._id.Consname,
                         Srctermid:this._id.Srctermid}, { count :1});
     },
     reduce: function ( key , value) {
         var ret = { count :0};
         ret. count ++;
         return ret;
     },
     out : 'tmp_mo_spcode_consignid_region_serviceid_2' ,
     verbose: true
})
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
res = db.runCommand({
     mapreduce: 'tmp_spcode_consignid_region_serviceid_2' ,
     map: function () {
         emit({Spcode:this._id.Spcode, Spname:this._id.Spname,       
                         Consignid:this._id.Consignid, Srct:this._id.Consname},
                        { count :this.value. count });
     },
     reduce: function ( key , value) {
         var ret = { count :0};
         for (var i in value) {
             ret. count += value[i]. count ;
         }
         return ret;
     },
     verbose: true
})
?
1
2
3
4
5
6
7
8
9
10
11
12
> db[res.result].findOne();
{
     "_id" : {
         "Spcode" : "20017" ,
         "Spname" : "es" ,
         "Consignid" : "000000" ,
         "Consname" : "pa"
     },
     "value" : {
         "count" : 978
     }
}

 总结:mongodb 对map/reduce 的支持是单线程的,   灰常消耗系统资源, 避免在前台使用。

 送上萌妹之音一枚～～～～

走错路的程序员
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringBoot+mongodb实现分组统计、时间范围查询、去重排序查询、组合排序、分页查询
web18224617243的博客
08-02 6614
SpringBoot+mongodb实现分组统计、时间范围查询、去重排序查询、组合排序。
MongoDB操作（一）
qq_45346273的博客
11-06 180
简介 SQL术语/概念 MongoDB术语/概念 解释/说明 database database 数据库 table collection 数据库表/集合 row document 数据记录行/文档 column field 数据字段/域 index index 索引 table joins 表连接，MongoDB不支持 primary key prima...
mongodb-对数据去重后再进行统计 group
cxu123321的博客
07-27 4670
mongodb 对数据去重后再进行统计 2018年12月27日 18:54:57chenwch阅读数 1353 版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/heihu_malice7/article/details/85298322 自身是mongo小白，对此问题，浏览好多博客文档，都没有找到太好的答案，汇总一下： distinc...
MongoDB 去重 分组
最新发布
DS_Watson的博客
05-21 591
MongoDB 去重 分组
mongodb分组去重
我的专栏
04-14 3948
db.runCommand({ distinct:"person",//表 key:"country"//为person表中的country去重 }) db.runCommand({group:{ ns:"persons",//集合的名称 key:{"country":true},//分组的键对象 initial:{m:0},
MongoDB数据去重（单字段和多字段去重）（百万级数据）
m0_61720747的博客
01-03 1万+
MongoDB数据去重（单字段和多字段去重）（百万级数据处理） 1、打开Mongo数据库，查询是否有数据重复 ①、查询DB_Name数据库中的item_id字段重复数据： 2、数据去重处理 原理：先将重复的数据加入到一个数组dups中，然后再利用forEach循环将dups数组的数据全部删除
MongoDB之去重总结（详细注解）
我愿做一个聆听者，以学习为伴！
12-26 1671
mongoDB中去重方式: use 集合名 # 数据库下的show dbs 中的 集合 db.createCollection(集合名,{size:1024}) #-创建集合，大小1024条 #——————————————————————以上是进入表的步骤—————————————————————————— db.getCollection('表名').aggregat...
Thinkphp使用mongodb数据库实现多条件查询方法
10-25
主要介绍了Thinkphp使用mongodb数据库实现多条件查询方法,修改了mongodb驱动文件来实现复合查询、多条件查询,需要的朋友可以参考下
MongoDB参考手册.zip_MongoDB_T6U_mongodb中文手册
09-21
此外，还有聚合框架，允许对数据进行复杂的数据处理和分析，包括管道操作符、分组、排序、去重等。 在性能优化方面，手册会讲解索引的创建与管理，以及如何根据查询模式设计有效的索引策略。MongoDB支持单字段索引...
MongoDB教程之聚合（count、distinct和group）
09-10
在进行数据处理时，除了基本的查询操作，MongoDB 还提供了聚合框架，它允许用户执行更复杂的分析任务，比如统计、分组和数据转换。在本教程中，我们将深入探讨MongoDB中的三个关键聚合操作：`count`、`distinct`和`...
mongoTemplate实现统计和分组
11-29
附件为mongoDB之Java通过group函数来实现统计和分组的文档描述
mongodb聚合_动力节点Java学院整理
09-09
总结来说，MongoDB的聚合功能提供了丰富的数据分析工具，从简单的计数和去重到复杂的分组和分布式计算。游标机制则优化了数据检索过程，确保只在需要时加载数据，从而提高性能。掌握这些概念对于高效地使用MongoDB...
Mongodb聚合函数count、distinct、group如何实现数据聚合操作
09-10
请注意，从 MongoDB 2.2 版本开始，`group` 函数对于返回的分组记录数量有限制，超过一定数量可能需要使用聚合管道或 MapReduce 进行更高效的操作。 总的来说，`count`、`distinct` 和 `group` 是 MongoDB 中进行...
java mongo 去重_MongoDB 如何对嵌套子文档分组去重计算
weixin_29540599的博客
03-04 278
MongoDB的数据存储使用嵌套结构非常普遍，它通过嵌套子文档，实现一对多的关联关系。但嵌套结构分组进行子文档去重数据计算时，常需要将嵌套结构提升为扁平结构，再通过 $group 聚集运算来实现。下面以集合 fund 为例说明，按 id 分组获取 shares、trade 子文档下的不重复 fundcode 数量。具体数据如下：{"id" : 1,"shares" : [{"fundcode" :...
MongoDB用$group实现组合项去重
Mike_ToUp
08-28 1万+
问题描述：有下列sql语句:// 查找名字性别唯一的学生 select distinct name,sex from student// 转换成MongoDB的话，需要把这种组合列去重,MongoDB好像只支持单个field的去重 db.student.distinct("name"); // 只支持一个field db.student.distinct("name","sex"); // 错误的，
mongoDB 去重统计， group实现版
Strangedbly
06-19 4394
db.collection.aggregate([ {$group: {_id: '$myData'}}, {$count: 'myCount'} ], { maxTimeMS: 60000, // aggregate 超时时间，数据量大时需设置大些 allowDiskUse: true, // 数据量大时需启用 }) NodeJS 版完整代码： /* 在...
Mongodb数据统计分析：group by、count(distinct userId)
热门推荐
yown的专栏
12-30 2万+
最近在做mongodb数据统计查询，需求：统计一段时间内每天的分享次数和分享人数? 查了众多资料，居然未找到好的方案，最终还是自己写函数解决了，现分享出来（若有好的方法请指出）： 表t_share_log结构(习惯这么叫，虽mongodb中为collection): 字段名 类型 说明 id string 记录id gmtCreate date 创建时间 user
mongodb 去重
09-26
首先，使用$group操作符对集合进行分组，指定要去重的字段为分组的依据，然后使用$first操作符选择每个分组中的第一个文档。这样就可以保留每个去重字段的唯一值。示例代码如下： db.collection.aggregate([ { $...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值