11

考虑以下示例：

db.article.aggregate(
  { $group : {
      _id : "$author",
      docsPerAuthor : { $sum : 1 },
      viewsPerAuthor : { $sum : "$pageViews" }
  }}
);

这按作者字段分组并计算两个字段。

我有 $author = FirstName_LastName 的值。现在，我不想按 $author 分组，而是按共享相同姓氏的所有作者分组。

我尝试 $regex 按“_”之后的所有匹配字符串进行分组

$author.match(/_[a-zA-Z0-9]+$/)

db.article.aggregate(
  { $group : {
      _id : "$author".match(/_[a-zA-Z0-9]+$/),
      docsPerAuthor : { $sum : 1 },
      viewsPerAuthor : { $sum : "$pageViews" }
  }}
);

also tried the following:

 db.article.aggregate(
  { $group : {
      _id : {$author: {$regex: /_[a-zA-Z0-9]+$/}},
      docsPerAuthor : { $sum : 1 },
      viewsPerAuthor : { $sum : "$pageViews" }
  }}
);
4

4 回答 4

6

实际上没有提供这种功能的这种方法，或者我找不到包含它的适当版本。我认为这不适用于 $regexp：http: //docs.mongodb.org/manual/reference/operator/regex/它只是用于模式匹配。

jira 中有一个改进请求：https ://jira.mongodb.org/browse/SERVER-6773

它处于打开未解决状态。但

在 github 我发现了这个讨论：https ://github.com/mongodb/mongo/pull/336

如果你检查这个提交：https ://github.com/nleite/mongo/commit/2dd175a5acda86aaad61f5eb9dab83ee19915709

它或多或少包含您可能拥有的方法。我并没有真正理解这种改进的状态：在 2.2.3 中它不起作用。

于 2013-02-09T11:16:44.583 回答
4

使用mapReduce：它是聚合的一般形式。这是如何在 mongo shell 中进行的：定义映射函数

var mapFunction = function() {
  var key = this.author.match(/_[a-zA-Z0-9]+$/)[0];
  var nb_match_bar2 = 0;
  if( this.bar.match(/bar2/g) ){
    nb_match_bar2 = 1;
  }
  var value = {
    docsPerAuthor: 1,
    viewsPerAuthor: Array.sum(this.pageViews)
  };

  emit( key, value );
};

和reduce函数

var reduceFunction = function(key, values) {

  var reducedObject = {
    _id: key,
    docsPerAuthor: 0,
    viewsPerAuthor: 0
  };

  values.forEach( function(value) {
    reducedObject.docsPerAuthor += value.docsPerAuthor;
    reducedObject.viewsPerAuthor += value.viewsPerAuthor;
  }
  );
  return reducedObject;
};

运行 mapReduce 并将结果保存在 map_reduce_result

>db.st.mapReduce(mapFunction, reduceFunction, {out:'map_reduce_result'})

查询 map_reduce_result 以获得结果

>db.map_reduce_result.find()
于 2013-07-05T17:07:20.347 回答
3

聚合框架的一种可能解决方法是使用 $project 来计算作者姓名。但是，它很脏，因为您需要手动遍历不同的名字大小：

在这里，我们将字段名称计算为 '_' 字符之后的子字符串，尝试其每个可能的位置（这就是为什么存在 $cond 链的原因），如果名字也是后备，则返回整个 $author长：

http://mongotry.herokuapp.com/#?bookmarkId=52fb5f24a0378802003b4c68

[
{
    "$project": {
        "author": 1,
        "pageViews": 1,
        "name": {
            "$cond": [
                {
                    "$eq": [
                        {
                            "$substr": [
                                "$author",
                                0,
                                1
                            ]
                        },
                        "_"
                    ]
                },
                {
                    "$substr": [
                        "$author",
                        1,
                        999
                    ]
                },
                {
                    "$cond": [
                        {
                            "$eq": [
                                {
                                    "$substr": [
                                        "$author",
                                        1,
                                        1
                                    ]
                                },
                                "_"
                            ]
                        },
                        {
                            "$substr": [
                                "$author",
                                2,
                                999
                            ]
                        },
                        {
                            "$cond": [
                                {
                                    "$eq": [
                                        {
                                            "$substr": [
                                                "$author",
                                                2,
                                                1
                                            ]
                                        },
                                        "_"
                                    ]
                                },
                                {
                                    "$substr": [
                                        "$author",
                                        3,
                                        999
                                    ]
                                },
                                {
                                    "$cond": [
                                        {
                                            "$eq": [
                                                {
                                                    "$substr": [
                                                        "$author",
                                                        3,
                                                        1
                                                    ]
                                                },
                                                "_"
                                            ]
                                        },
                                        {
                                            "$substr": [
                                                "$author",
                                                4,
                                                999
                                            ]
                                        },
                                        {
                                            "$cond": [
                                                {
                                                    "$eq": [
                                                        {
                                                            "$substr": [
                                                                "$author",
                                                                4,
                                                                1
                                                            ]
                                                        },
                                                        "_"
                                                    ]
                                                },
                                                {
                                                    "$substr": [
                                                        "$author",
                                                        5,
                                                        999
                                                    ]
                                                },
                                                "$author"
                                            ]
                                        }
                                    ]
                                }
                            ]
                        }
                    ]
                }
            ]
        }
    }
},
{
    "$group": {
        "_id": "$name",
        "viewsPerAuthor": {
            "$sum": "$pageViews"
        }
    }
}
]
于 2014-02-12T14:03:32.950 回答
3

$group结合$addFields并$arrayElemAt为我工作（版本≥ 3.4）。

假设我们在 collectionfaculty和 database中有以下数据school：

{ "_id" : ObjectId("5ed5a59b1febc4c796a88e80"), "name" : "Harry_Potter" }
{ "_id" : ObjectId("5ed5a60e1febc4c796a88e81"), "name" : "Edison_Potter" }
{ "_id" : ObjectId("5ed5a6231febc4c796a88e82"), "name" : "Jack_Potter" }
{ "_id" : ObjectId("5ed5a62f1febc4c796a88e83"), "name" : "Alice_Walker" }
{ "_id" : ObjectId("5ed5a65f1febc4c796a88e84"), "name" : "Bob_Walker" }
{ "_id" : ObjectId("5ed5a6731febc4c796a88e85"), "name" : "Will_Smith" }

以下可以按姓氏对每个文档进行分组：

db.faculty.aggregate([
  {
    $addFields: {
      lastName: {
        $arrayElemAt: [ { $split: ["$name", "_"] }, 1 ]
      }
    }
  },
  {
    $group: {
      _id: "$lastName",
      count: {$sum: 1}
    }
  }
])

运行结果是：

{ "_id" : "Potter", "count" : 3 }
{ "_id" : "Walker", "count" : 2 }
{ "_id" : "Smith", "count" : 1 }

我使用的技巧是添加一个名为lastName. 根据您对该name字段的了解，可以将其拆分为一个数组_。姓氏在索引 1 处，名字在索引 0 处。

参考

$addFields（聚合）

$arrayElemAt（聚合）

于 2020-06-02T01:32:22.517 回答