使用其他集合的属性筛选mongodb上文档的更好方法

我试图使用另一个集合中的属性筛选mongodb上的文档，但问题是我需要先获取所有对象，然后再进行筛选。以下是我目前的情况：

当前数据：

/* Message collection */
/* 1 */
{
    "_id" : ObjectId("571063533e41b42c2753828a"),
    "user" : ObjectId("570ae3d0a27d4cd44730fc38"),
    "text" : "First text",
    "enabled" : true,
    "deleted" : false,
    "__v" : 0
}

/* 2 */
{
    "_id" : ObjectId("5712a9be27adcff81ea5a39f"),
    "user" : ObjectId("5f236vgh74de563swer120rt"),
    "text" : "Second text",
    "deleted" : false,
    "enabled" : true,
    "__v" : 0
}

/* User collection */
/* 1 */
{
    "_id" : ObjectId("570ae3d0a27d4cd44730fc38"),
    "email" : "test@test.com",
    "showMessage" : true,
    "__v" : 0
}

/* 2 */
{
    "_id" : ObjectId("5f236vgh74de563swer120rt"),
    "email" : "test1@test.com",
    "showMessage" : false,
    "__v" : 0
}

Message.aggregate([{
            $match: {
                enabled: true,
                deleted: false
            }
        }, {
            $lookup: {
                from: 'users',
                localField: 'user',
                foreignField: '_id',
                as: 'user'
            }
        }], function(err, messages) {
            if (err) {
                reject(err);
            } else {
                var filteredMessages = this.filterMessages(messages);
                //do other stuff with the filtered data
            }
        });

filterMessages(messages) {
    return messages.filter((current) => {
        return current.user[0].showMessage;
    });
}

当前过滤方式：

/* Message collection */
/* 1 */
{
    "_id" : ObjectId("571063533e41b42c2753828a"),
    "user" : ObjectId("570ae3d0a27d4cd44730fc38"),
    "text" : "First text",
    "enabled" : true,
    "deleted" : false,
    "__v" : 0
}

/* 2 */
{
    "_id" : ObjectId("5712a9be27adcff81ea5a39f"),
    "user" : ObjectId("5f236vgh74de563swer120rt"),
    "text" : "Second text",
    "deleted" : false,
    "enabled" : true,
    "__v" : 0
}

/* User collection */
/* 1 */
{
    "_id" : ObjectId("570ae3d0a27d4cd44730fc38"),
    "email" : "test@test.com",
    "showMessage" : true,
    "__v" : 0
}

/* 2 */
{
    "_id" : ObjectId("5f236vgh74de563swer120rt"),
    "email" : "test1@test.com",
    "showMessage" : false,
    "__v" : 0
}

Message.aggregate([{
            $match: {
                enabled: true,
                deleted: false
            }
        }, {
            $lookup: {
                from: 'users',
                localField: 'user',
                foreignField: '_id',
                as: 'user'
            }
        }], function(err, messages) {
            if (err) {
                reject(err);
            } else {
                var filteredMessages = this.filterMessages(messages);
                //do other stuff with the filtered data
            }
        });

filterMessages(messages) {
    return messages.filter((current) => {
        return current.user[0].showMessage;
    });
}

如您所见，我试图使用属性

showMessages

从

user

获取

消息，但我在首先获取所有消息后执行筛选，这是一种效率低下的方法

是否有一种方法可以只获取我需要的消息，使用另一个集合的属性对它们进行过滤

注意：我需要使用用户属性过滤所有消息，而不是相反，我的意思是，我无法获得用户，然后过滤消息。
只需直接在聚合中执行即可：

Message.aggregate([
{“$match”：{
“启用”：正确，
“已删除”：false
}},
{“$lookup”：{
“发件人”：“用户”，
“localField”：“用户”，
“外域”：“\u id”，
“作为”：“用户”
}},
{“$unwind”：“user”}，
{“$redact”：{
“如果”：“$user.showMessage”，
“然后”：“$$KEEP”，
“else”：“$$PRUNE”
}}
]，函数（错误，消息）{
如果（错误）拒绝（错误）；
//已经过滤
})

因此，您可以使用单个关系（因为是“左连接”），然后只需在值为
true/false
的条件下使用

或者反向执行
$lookup
，这可能会更有效：

User.aggregate([
{“$match”：{“showMessage”：true}，
{“$lookup”：{
“发件人”：“邮件”，
“localField”：“\u id”，
“foreignField”：“用户”，
“作为”：“消息”
}},
{“$unwind”：“$messages”}，
{“$match”：{
“messages.enabled”：true，
“messages.deleted”：false
}},
{“$project”：{
“\u id”：“$messages.\u id”，
“用户”：{
“\u id”：“$\u id”，
“电子邮件”：“$email”，
“showMessage”：“$showMessage”
},
“文本”：“$messages.text”，
“已删除”：“$messages.deleted”，
“已启用”：“$messages.enabled”
}}
]，函数（错误，消息）{
})

目前，除了匹配“本地”和“外来”字段属性外，操作员本身不会基于任何其他条件“查询”文档。这在以后的版本中可能会发生变化

不过现在，您可以在后续聚合管道阶段进行进一步的“过滤”


另一种情况是，实际上以“反向”方式进行查询，即获取有效
用户
数据的
\u id
值，然后仅检索消息。但当然，只有当的结果列表实际上不太大时：

async.瀑布
[
函数（回调）{
User.find（{“showMesage”：true}）。选择（“\u id”）.exec（回调）；
},
函数（用户、回调）{
Message.find({
“user”：{“$in”：users.map（（当前）=>{return current.\u id}），
“启用”：正确，
“已删除”：false
}).populate（“用户”）.exec（回调）；
}
]，函数（错误，消息）{
//过滤和填充
}
)

与相比，它是额外的查询，但是它在结束匹配时处理的结果较少

这真的取决于你的案例是什么，关于哪些数据在这里效果最好，所以你真的应该测试它。我猜，选择“反向”集合与使用或仅使用后一个案例将是更好的选择。但这实际上取决于哪个查询产生的结果最少，以及哪个“顺序”“这是最好的。
谢谢你的帮助。你能推荐一些参考链接来扩展这些概念吗？