通过键字段查找MongoDB集合中的所有重复文档

假设我有一个包含一组文档的集合。像这样。

{ "_id" : ObjectId("4f127fa55e7242718200002d"), "id":1, "name" : "foo"}
{ "_id" : ObjectId("4f127fa55e7242718200002d"), "id":2, "name" : "bar"}
{ "_id" : ObjectId("4f127fa55e7242718200002d"), "id":3, "name" : "baz"}
{ "_id" : ObjectId("4f127fa55e7242718200002d"), "id":4, "name" : "foo"}
{ "_id" : ObjectId("4f127fa55e7242718200002d"), "id":5, "name" : "bar"}
{ "_id" : ObjectId("4f127fa55e7242718200002d"), "id":6, "name" : "bar"}

我想通过"名称"字段查找此集合中的所有重复条目。例如，"foo"出现两次，"bar"出现3次。

接受的答案在大型集合上非常慢，并且不会返回重复记录的_id。

聚合速度要快得多，并且可以返回_id s：

db.collection.aggregate([
  { $group: {
    _id: { name: "$name" },   // replace `name` here twice
    uniqueIds: { $addToSet: "$_id" },
    count: { $sum: 1 } 
  } }, 
  { $match: { 
    count: { $gte: 2 } 
  } },
  { $sort : { count : -1} },
  { $limit : 10 }
]);

在聚合管道的第一阶段，$group运算符按name字段聚合文档，并在分组记录的每个_id值uniqueIds存储。$sum运算符将传递给它的字段的值相加，在本例中为常量1 - 从而将分组记录的数量计入count字段中。

在管道的第二阶段，我们使用$match过滤count至少为 2 的文档，即重复项。

然后，我们首先对最常见的重复项进行排序，并将结果限制在前 10 名。

此查询将输出最多 $limit 条具有重复名称的记录及其_id。例如：

{
  "_id" : {
    "name" : "Toothpick"
},
  "uniqueIds" : [
    "xzuzJd2qatfJCSvkN",
    "9bpewBsKbrGBQexv4",
    "fi3Gscg9M64BQdArv",
  ],
  "count" : 3
},
{
  "_id" : {
    "name" : "Broom"
  },
  "uniqueIds" : [
    "3vwny3YEj2qBsmmhA",
    "gJeWGcuX6Wk69oFYD"
  ],
  "count" : 2
}

注意：此解决方案最容易理解，但不是最好的。

您可以使用mapReduce来了解文档包含特定字段的次数：

var map = function(){
   if(this.name) {
        emit(this.name, 1);
   }
}
var reduce = function(key, values){
    return Array.sum(values);
}
var res = db.collection.mapReduce(map, reduce, {out:{ inline : 1}});
db[res.result].find({value: {$gt: 1}}).sort({value: -1});

有关通用 Mongo 解决方案，请参阅 MongoDB 说明书中用于使用 group 查找重复项的方法。请注意，聚合更快、更强大，因为它可以返回重复记录的_id。

对于pymongo来说，接受的答案(使用mapReduce(并不是那么有效。相反，我们可以使用 group 方法：

$connection = 'mongodb://localhost:27017';
$con        = new Mongo($connection); // mongo db connection
$db         = $con->test; // database 
$collection = $db->prb; // table
$keys       = array("name" => 1); Select name field, group by it
// set intial values
$initial    = array("count" => 0);
// JavaScript function to perform
$reduce     = "function (obj, prev) { prev.count++; }";
$g          = $collection->group($keys, $initial, $reduce);
echo "<pre>";
print_r($g);

输出将是这样的：

Array
(
    [retval] => Array
        (
            [0] => Array
                (
                    [name] => 
                    [count] => 1
                )
            [1] => Array
                (
                    [name] => MongoDB
                    [count] => 2
                )
        )
    [count] => 3
    [keys] => 2
    [ok] => 1
)

等效的 SQL 查询为：SELECT name, COUNT(name) FROM prb GROUP BY name 。请注意，我们仍然需要从数组中过滤掉计数为 0 的元素。同样，请参考 MongoDB 食谱使用 group 查找重复项的配方，以获取使用 group 的规范解决方案。

聚合管道框架可用于轻松识别具有重复键值的文档：

// Desired unique index: 
// db.collection.ensureIndex({ firstField: 1, secondField: 1 }, { unique: true})
db.collection.aggregate([
  { $group: { 
    _id: { firstField: "$firstField", secondField: "$secondField" }, 
    uniqueIds: { $addToSet: "$_id" },
    count: { $sum: 1 } 
  }}, 
  { $match: { 
    count: { $gt: 1 } 
  }}
])

~ 参考：官方 mongo 实验室博客上的有用信息：

https://blog.mlab.com/2014/03/finding-duplicate-keys-with-the-mongodb-aggregation-framework

这里接受的最高答案是这样的：

uniqueIds: { $addToSet: "$_id" },

这也会返回一个名为uniqueIds的新字段，其中包含ID列表。但是，如果您只想要字段及其计数怎么办？那么它将是这样的：

db.collection.aggregate([ 
  {$group: { _id: {name: "$name"}, 
             count: {$sum: 1} } }, 
  {$match: { count: {"$gt": 1} } } 
]);

为了解释这一点，如果你来自像MySQL和PostgreSQL这样的SQL数据库，你习惯于聚合函数(例如COUNT((，SUM((，MIN((，MAX(((，它们与GROUP BIY语句一起工作，例如，允许您找到列值出现在表中的总计数。

SELECT COUNT(*), my_type FROM table GROUP BY my_type;
+----------+-----------------+
| COUNT(*) | my_type         |
+----------+-----------------+
|        3 | Contact         |
|        1 | Practice        |
|        1 | Prospect        |
|        1 | Task            |
+----------+-----------------+

如您所见，我们的输出显示每个my_type值出现的计数。为了在MongoDB中查找重复项，我们将以类似的方式解决问题。MongoDB拥有聚合操作，可以将来自多个文档的值分组在一起，并且可以对分组数据执行各种操作以返回单个结果。这与 SQL 中的聚合函数类似。

假设有一个名为联系人的集合，初始设置如下所示：

db.contacts.aggregate([ ... ]);

这个聚合函数采用一个聚合运算符数组，在我们的例子中，我们需要$group运算符，因为我们的目标是按字段的计数(即字段值的出现次数(对数据进行分组。

db.contacts.aggregate([  
    {$group: { 
        _id: {name: "$name"} 
        } 
    }
]);

这种方法有一点特殊性。_id字段是使用分组依据运算符所必需的。在本例中，我们对$name字段进行分组。_id中的键名称可以具有任何名称。但是我们使用名称，因为它在这里很直观。

通过仅使用 $group 运算符运行聚合，我们将获得所有名称字段的列表(无论它们在集合中出现一次还是多次(：

db.contacts.aggregate([  
  {$group: { 
    _id: {name: "$name"} 
    } 
  }
]);
{ "_id" : { "name" : "John" } }
{ "_id" : { "name" : "Joan" } }
{ "_id" : { "name" : "Stephen" } }
{ "_id" : { "name" : "Rod" } }
{ "_id" : { "name" : "Albert" } }
{ "_id" : { "name" : "Amanda" } }

请注意上面的聚合工作原理。它获取了具有名称字段的文档，并返回提取的名称字段的新集合。

但我们想知道的是字段值重新出现多少次。$group运算符采用一个计数字段，该字段使用 $sum 运算符将表达式 1 添加到组中每个文档的总计中。因此，$group和$sum一起返回给定字段(例如名称(的所有数值的总和。

db.contacts.aggregate([  
  {$group: { 
    _id: {name: "$name"},
    count: {$sum: 1}
    } 
  }
]);
{ "_id" : { "name" : "John" },  "count" : 1  }
{ "_id" : { "name" : "Joan" },  "count" : 3  }
{ "_id" : { "name" : "Stephen" },  "count" : 2 }
{ "_id" : { "name" : "Rod" },  "count" : 3 }
{ "_id" : { "name" : "Albert" },  "count" : 2 }
{ "_id" : { "name" : "Amanda" },  "count" : 1 }

由于目标是消除重复项，因此需要一个额外的步骤。要仅获取计数为多个的组，我们可以使用 $match 运算符来过滤结果。在 $match 运算符中，我们将告诉它查看计数字段，并告诉它使用表示"大于"和数字 1 的$gt运算符查找大于 1 的计数。

db.contacts.aggregate([ 
  {$group: { _id: {name: "$name"}, 
             count: {$sum: 1} } }, 
  {$match: { count: {"$gt": 1} } } 
]);
{ "_id" : { "name" : "Joan" },  "count" : 3  }
{ "_id" : { "name" : "Stephen" },  "count" : 2 }
{ "_id" : { "name" : "Rod" },  "count" : 3 }
{ "_id" : { "name" : "Albert" },  "count" : 2 }

作为旁注，如果你通过像Mongoid for Ruby这样的ORM使用MongoDB，你可能会得到这个错误：

The 'cursor' option is required, except for aggregate with the explain argument

这很可能意味着您的ORM已过时，并且正在执行MongoDB不再支持的操作。因此，要么更新您的ORM要么找到修复程序。对于Mongoid来说，这对我来说是解决方案：

module Moped
  class Collection
    # Mongo 3.6 requires a `cursor` option be passed as part of aggregate queries.  This overrides
    # `Moped::Collection#aggregate` to include a cursor, which is not provided by Moped otherwise.
    #
    # Per the [MongoDB documentation](https://docs.mongodb.com/manual/reference/command/aggregate/):
    #
    #   Changed in version 3.6: MongoDB 3.6 removes the use of `aggregate` command *without* the `cursor` option unless
    #   the command includes the `explain` option. Unless you include the `explain` option, you must specify the
    #   `cursor` option.
    #
    #   To indicate a cursor with the default batch size, specify `cursor: {}`.
    #
    #   To indicate a cursor with a non-default batch size, use `cursor: { batchSize: <num> }`.
    #
    def aggregate(*pipeline)
      # Ordering of keys apparently matters to Mongo -- `aggregate` has to come before `cursor` here.
      extract_result(session.command(aggregate: name, pipeline: pipeline.flatten, cursor: {}))
    end
    private
    def extract_result(response)
      response.key?("cursor") ? response["cursor"]["firstBatch"] : response["result"]
    end
  end
end

相关内容

最新更新

热门标签：