是否可以查询按“加权平均”排序

从 1-5 中有 5 个可能的值。加权平均为

(n5*5 + n4*4 + n3*3 + n2*2 + n1*1)/(n5+n4+n3+n2+n1)

其中 n5 是评分为 5 的对象的数量

我有以下示例。如果您找到更好的存储结构，我很高兴听到。

{
    "_id" : "wPg4jzJsEFXNxR5Wf",
    "caveId" : "56424a93819e7419112c883e",
    "data" : [
        {
            "value" : 1
        },
        {
            "value" : 3
        },
        {
            "value" : 4
        },
        {
            "value" : 2
        }
    ]
}
{
    "_id" : "oSrtv33MgnkJFvNan",
    "caveId" : "56424a93819e7419112c949f",
    "data" : [
        {
            "value" : 1
        },
        {
            "value" : 4
        },
        {
            "value" : 4
        },
        {
            "value" : 2
        }
    ]
}
{
    "_id" : "gJRMMQPwDwjFrL7zz",
    "caveId" : "56424a93819e7419112c8727",
    "data" : [
        {
            "value" : 5
        },
        {
            "value" : 1
        },
        {
            "value" : 4
        }
    ]
}

_ID 示例:oSrtv33MgnkJFvNan(第二个)

(2*4 + 1*2 + 1*1)/(2+1+1) = 2.75

然后我想按该值对所有文档进行排序。

顺序是

1. gJRMMQPwDwjFrL7zz:值:3.33
2. oSrtv33MgnkJFvNan:值 2.75
3. wPg4jzJsEFXNxR5Wf:值 2.5

最佳答案

关于 MongoDB 是否可以像这样从计算中排序数据，答案实际上既是"is"又是“否”。它当然可以做到，但可能无法以实用的方式实现您的目的。

MongoDB 必须执行任何类型的计算的两个工具是 ggregation framework和 mapReduce .前者目前缺乏运营商来真正以实用的方式处理这个问题。第二个可以被“欺骗”进行排序，作为 mapReduce 工作方式的产物，通过将要排序的组件放在分组键中(即使没有实际分组)。

所以你基本上可以像这样应用数学:

db.data.mapReduce(
    function() {
        var vals = this.data.map(function(el){ return el.value }),
            uniq = {};

        vals.forEach(function(el) {
            if (!uniq.hasOwnProperty(el)) {
                uniq[el] = 1;
            } else {
                uniq[el]++;
            }
        });

        var weight = Array.sum(Object.keys(uniq).map(function(key) {
            return uniq[key] * key
        })) / Array.sum(Object.keys(uniq).map(function(key) {
            return uniq[key];
        }))

        var id = this._id;
        delete this._id;

        emit({ "weight": weight, "orig": id },this);

    },
    function() {},
    { "out": { "inline": 1 } }
)

这给你这个输出:

{
    "results" : [
            {
                    "_id" : {
                            "weight" : 2.5,
                            "orig" : "wPg4jzJsEFXNxR5Wf"
                    },
                    "value" : {
                            "caveId" : "56424a93819e7419112c883e",
                            "data" : [
                                    {
                                            "value" : 1
                                    },
                                    {
                                            "value" : 3
                                    },
                                    {
                                            "value" : 4
                                    },
                                    {
                                            "value" : 2
                                    }
                            ]
                    }
            },
            {
                    "_id" : {
                            "weight" : 2.75,
                            "orig" : "oSrtv33MgnkJFvNan"
                    },
                    "value" : {
                            "caveId" : "56424a93819e7419112c949f",
                            "data" : [
                                    {
                                            "value" : 1
                                    },
                                    {
                                            "value" : 4
                                    },
                                    {
                                            "value" : 4
                                    },
                                    {
                                            "value" : 2
                                    }
                            ]
                    }
            },
            {
                    "_id" : {
                            "weight" : 3.3333333333333335,
                            "orig" : "gJRMMQPwDwjFrL7zz"
                    },
                    "value" : {
                            "caveId" : "56424a93819e7419112c8727",
                            "data" : [
                                    {
                                            "value" : 5
                                    },
                                    {
                                            "value" : 1
                                    },
                                    {
                                            "value" : 4
                                    }
                            ]
                    }
            }
    ]
}

所以所有的结果都被排序了，但是当然有一个限制，即 mapReduce 只能产生低于 16MB BSON 限制的“内联”输出，或者将结果写入另一个集合。

即使在此处可以提供帮助的聚合框架中添加了新功能(来自当前的开发系列 3.1.x)，这仍然需要使用 $unwind 来获得“总和”元素以任何方式(还没有“减少”功能这样的功能)，这并不能使其成为稳定或实用的替代方案。

所以你可以用 mapReduce 来做，但为了我的钱，我会有另一个过程来计算它以定期运行(或在更新时触发)并更新文档上的标准“权重”字段，然后可以直接使用用于排序。

在您的文档中放置一个值始终是最有效的选择。

出于好奇，您可以获取 MongoDB 的开发分支版本(3.1.x 系列)或之后的任何版本，然后像这样应用聚合管道:

db.data.aggregate([
    {  "$project": {
        "caveId": 1,
        "data": 1,
        "conv": {
            "$setUnion": [
                { "$map": {
                    "input": "$data",
                    "as": "el",
                    "in": "$$el.value"
                }},
                []
            ]
        },
        "orig": { 
            "$map": {
                "input": "$data",
                "as": "el",
                "in": "$$el.value"
            }
        }
    }},
    { "$project": {
        "caveId": 1,
        "data": 1,
        "conv": 1,
        "orig": 1,
        "counts": { "$map": {
            "input": "$conv",
            "as": "el",
            "in": {
                "$size": {
                    "$filter": {
                        "input": "$orig",
                        "as": "o",
                        "cond": { 
                            "$eq": [ "$$o", "$$el" ]
                        }
                    }
                }
            }
        }}
    }},
    { "$unwind": { "path": "$conv", "includeArrayIndex": true } },
    { "$group": {
        "_id": "$_id",
        "caveId": { "$first": "$caveId" },
        "data": { "$first": "$data" },
        "counts": { "$first": "$counts" },
        "mult": { 
            "$sum": { 
                "$multiply": [ 
                    "$conv.value", 
                    { "$arrayElemAt": [ "$counts", "$conv.index" ] }
                ]
            }
        }
    }},
    { "$unwind": "$counts" },
    { "$group": {
        "_id": "$_id",
        "caveId": { "$first": "$caveId" },
        "data": { "$first": "$data" },
        "count": { "$sum": "$counts" },
        "mult": { "$first": "$mult" }
    }},
    { "$project": {
        "data": 1,
        "weight": { "$divide": [ "$mult", "$count" ] }
    }},
    { "$sort": { "weight": 1 } }
])

但即使在 $unwind 中有像 $filter 和“includeArrayIndex”这样的助手，而 $arrayElemAt 运算符稍后也会使用该索引来匹配不同的元素及其计数，以任何方式使用 $unwind 都会使该解决方案性能不佳。

如果像 $map 这样的运算符可以产生配对所需的索引值，并且引入任何方法来类似地进行“内联求和”运算或其他数学运算，那么将来可能会变得实用在不处理 $unwind 的数组结果上。但在撰写本文时，这并不存在，即使在开发中也是如此。

关于mongodb - 通过 mongodb 加权平均评级，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/33666418/