使用聚合[重复]在mongoDB中限制和排序每个分组

Question

我如何在mongoDB中按对每个组进行排序和限制。

考虑以下数据：

Country:USA,name:xyz,rating:10,id:x
Country:USA,name:xyz,rating:10,id:y
Country:USA,name:xyz,rating:10,id:z
Country:USA,name:abc,rating:5,id:x
Country:India,name:xyz,rating:5,id:x
Country:India,name:xyz,rating:5,id:y
Country:India,name:abc,rating:10,id:z
Country:India,name:abc,rating:10,id:x

现在，我将按国家分组，按评级排序，并将每组的数据限制为2。

所以答案是：

Country:USA
name:xyz,rating:10,id:x
name:xyz,rating:10,id:y
Country:India
name:abc,rating:10,id:x
name:abc,rating:10,id:z

我想只使用聚合框架来实现这一点。

我试图包括排序的评级，但简单的查询后处理没有结果。

Answer 1

您最好的选择是为每个“国家”运行单独的查询（理想情况下是并行）并返回组合结果。查询非常简单，只需在对评级值应用排序后返回前2个值，即使您需要执行多个查询以获得完整的结果，也会执行得非常快。

聚合框架现在甚至在不久的将来都不适合这种情况。问题是没有这样的操作符以任何方式“限制”任何分组的结果。因此，要做到这一点，您基本上需要将所有内容推送到一个数组中，并从中提取“前n个”值。

当前需要执行的操作非常可怕，核心问题是，在大多数真实数据源上，结果可能会超过BSON对每个文档16MB的限制。

此外，由于您现在必须执行的操作方式，此操作也很复杂。但仅用两个项目进行演示：

db.collection.aggregate([
    // Sort content by country and rating
    { "$sort": { "Country": 1, "rating": -1 } },

    // Group by country and push all items, keeping first result
    { "$group": {
        "_id": "$Country",
        "results": {
            "$push": {
                "name": "$name", 
                "rating": "$rating",
                "id": "$id"
            }
        },
        "first": { 
            "$first": {
                "name": "$name", 
                "rating": "$rating",
                "id": "$id"
            }
        }
    }},

    // Unwind the array
    { "$unwind": "results" },

    // Remove the seen result from the array
    { "$redact": {
        "$cond": {
            "if": { "$eq": [ "$results.id", "$first.id" ] },
            "then": "$$PRUNE",
            "else": "$$KEEP"
        }
    }},

    // Group to return the second result which is now first on stack
    { "$group": {
        "_id": "$_id",
        "first": { "$first": "$first" },
        "second": { 
            "$first": {
                "name": "$results.name", 
                "rating": "$results.rating",
                "id": "$results.id"
            }
        }
    }},

    // Optionally put these in an array format
    { "$project": {
        "results": { 
            "$map": {
                "input": ["A","B"],
                "as": "el",
                "in": {
                    "$cond": {
                        "if": { "$eq": [ "$$el", "A" ] },
                        "then": "$first",
                        "else": "$second"
                    }
                }
            }
        }
    }}
])

这会得到结果，但这不是一个很好的方法，而且随着迭代次数的增加，会变得更加复杂，以获得更高的限制，甚至在某些情况下分组返回的结果可能少于n。

截至编写时，当前的开发系列（3.1. x）有一个$切片运算符，它使这变得更简单，但仍然具有相同的“大小”陷阱：

db.collection.aggregate([
    // Sort content by country and rating
    { "$sort": { "Country": 1, "rating": -1 } },

    // Group by country and push all items, keeping first result
    { "$group": {
        "_id": "$Country",
        "results": {
            "$push": {
                "name": "$name", 
                "rating": "$rating",
                "id": "$id"
            }
        }
    }},
    { "$project": {
        "results": { "$slice": [ "$results", 2 ] }
    }}
])

但基本上，直到聚合框架有某种方法“限制”$ush或类似的分组“限制”运算符产生的项目数量，那么聚合框架并不是这种类型的问题的最佳解决方案。

像这样的简单查询：

js prettyprint-override">db.collection.find({ "Country": "USA" }).sort({ "rating": -1 }).limit(1)

为每个不同的国家运行，理想情况下通过线程的事件循环并行处理，并结合结果产生当前最优化的方法。它们只获取所需的内容，这是聚合框架在这种分组中尚无法处理的大问题。

因此，请寻找支持，以最理想的方式为您选择的语言执行此“组合查询结果”，因为这将比将此应用于聚合框架要简单得多，性能也要高得多。