在NodeJS中处理多个、顺序的、依赖的mongo查询结果的最佳方式

Best way to process results of multiple, sequential, dependent mongo queries in NodeJS

本文关键字：依赖 mongo 结果 方式 最佳 查询 顺序 NodeJS 处理      更新时间：2023-09-26

高级

我是JS和Node的新手。我正在处理一个API端点，它应该返回一个状态值。为了计算状态值，我需要进行两个连续的mongo查询，其中第二组查询依赖于第一个查询。第二组查询将为第一个查询中找到的每个值提供一个状态，我将根据一些逻辑选择其中一个。在NodeJS中最好的方法是什么？

规格

以下是我第一次尝试的部分内容。

function getItemStatus(key, value, callback) {
        MongoClient.connect(mongo_url, function(err, db) {
            if (err) { return console.dir(err); }
            db.collection('status', function(err, coll) {
                if (err) { return console.dir(err); }
                coll.distinct("_id.metric", function(err, metrics) {
                    if (err) { return console.dir(err); }
                    console.log('metrics : ', metrics);
                    _.foreach(metrics, function(metric) {
                        var query = {"_id": {
                            "$gte" : {key: key, value: value, created: new Date("1800-01-01T00:00:00"), metric : metric},
                            "$lte" : {key: key, value: value, created: new Date("2100-01-01T00:00:00"), metric : metric}}};
                        coll.find(query, {sort: {"_id.created": -1}, limit: 1})

我建立了一个连接，使用一个不同的查询来查询一组度量值。对于每个指标，我都想询问最新的状态。理想情况下，我希望拥有完整的状态集，这样我就可以编写一个函数，接受这一集并决定返回哪个状态。我的问题是将状态传递回"上链"，这样我就可以处理这组状态。

在同步的情况下，我会简单地写一些类似的东西

val metrics = getDistinctMetrics(key, value)
val statuses = metrics.map(getStatusForMetric)
val status = filterStatuses(statuses)

如何在JavaScript/NodeJS中实现这一点？

更新以强调第一个查询将在第二步中触发多个查询，即第一个查询找到的每个结果一个查询。

根据我对您的问题的理解，您希望并行或以瀑布模式执行查询，并对最终结果进行一些逻辑运算。您应该研究一个允许并行/瀑布执行的库。像这个

瀑布：瀑布

    async.waterfall([
    function(callback) {
        callback(null, 'one', 'two');
    },
    function(arg1, arg2, callback) {
        // arg1 now equals 'one' and arg2 now equals 'two'
        callback(null, 'three');
    },
    function(arg1, callback) {
        // arg1 now equals 'three'
        callback(null, 'done');
    }
], function (err, result) {
    // result now equals 'done'
});

并行：并行

async.parallel({
    collectionOne: function (callback) {
        collectionOne.find(query, function (err, result) {
            if (err) {
                return handleError(res, err);
            }
            callback(null, result);
        })
    },
    collectionTwo: function (callback) {
        collectionTwo.find(query, function (err, result) {
            if (err) {
                return handleError(res, err);
            }
            callback(null, result);
        })
    },
    collectionThree: function (callback) {
        collectionThree.find(query, function (err, result) {
            if (err) {
                return handleError(res, err);
            }
            callback(null, result);
        })
    },
    collectionFour: function (callback) {
        collectionFour.find(query, function (err, result) {
            if (err) {
                return handleError(res, err);
            }
            callback(null, result);
        })
    },
}, function (err, results) {
    return res.status(200).json(results);
});

在最后的回调中，您可以取消一些逻辑或返回响应。

在您的示例代码中，您在另一个网络调用中进行网络调用，这可能会导致回调地狱，这可能导致查询的错误行为，为了克服这一点，您可以使用promise。

这将帮助您避免回调地狱，您的查询也将得到解决。

示例代码：-

new Promise (function(resolve, reject){
      return db.collection.find(function).exec()
      .then(function(result_of_first_query){
            return db.collection.findOne(function).exec()   //in this yopu can user the result of first query
      }).then(function(result_of_second_query){
             resolve(result_of_second_query);
      })
})

您可以使用每个.then 添加更多查询

相关文章：