Mysql 嵌套承诺时调用quit后无法将查询排队

我试图遍历MySQL查询结果并进行后续查询，以构建我的数据模型。每个对象都需要多个查询，因此我将链接承诺

当我嵌套第二组承诺时，问题就出现了

所以首先，我得到一个需要使用g.getSnapshotId检索的对象列表。然后我迭代这些，并使用snapshotId检索完整的快照

var gData = {};

g.getSnapshotIds(data.gId, data.userId)
    .then(function(value) {
        gData = value;
        for ( var snapshot in value ) {
            var snapshotId = value[snapshot].snapshotId;
            var snapshot = {};
            g.getSnapshotFull(snapshotId)
                .then(function(value) {
                    console.log(value);
                    return g.getTs(snapshotId);
                })
                .then(function(value) {
                    for ( var te in value ) {
                        var name = value[te].t;
                        snapshot[name] = value[te].value;
                    }
                    console.log(snapshot);
                })
                .catch(function(err) {
                    console.log('Error:', err);
                });
        }
        g.close();
    })
    .catch(function(err) {
        console.log('Error:', err);
    });

我可以对每个ID调用g.getSnapshotFull，但当我尝试转到下一个查询（g.getTs（snapshotId））时，它会给我错误：

Error: Cannot enqueue Query after invoking quit.

我不知道为什么MySQL连接会在所有查询完成之前关闭。for循环中的所有内容不应该在继续之前按顺序执行吗

如果我注释掉g.close（），我不会得到错误，但过程不会结束

以下是相关的查询方法：

class gDB {
    close() {
        return new Promise(function(resolve, reject) {
            db.end(function(error) {
                if ( error ){
                    reject(new Error(error));
                }
                // For some reason it is necessary to reestablish this
                db = mysql.createConnection({
                    host: process.env.DBHOST,
                    user: process.env.DBUSER,
                    password: process.env.DBPASS,
                    database: process.env.DBNAME,
                    ssl: {
                        ca: fs.readFileSync(__dirname + '/' + process.env.DBCA)
                    }
                });
                resolve(true);
            });
        });
    }
    getSnapshotIds(gId, uId) {
        return new Promise(function(resolve, reject) {
            var sql = 'SELECT id AS snapshotId FROM snapshots WHERE gId=' + db.escape(gId) + ' AND   uId=' + db.escape(uId) + ' ORDER BY timestamp DESC';
            db.query(sql, function (error, results, fields) {
                if (error) {
                    db.destroy();
                    reject(new Error(error));
                } else {
                    resolve(results);
                }
            });
        });
    }
    getSnapshotFull(snapshotId) {
        return new Promise(function(resolve, reject) {
            var sql = 'SELECT s.id AS snapshotId, s.timestamp, s.gId, s.uId, s.clientId FROM snapshots s INNER JOIN controls c ON s.id = c.snapshotId INNER JOIN weathers w ON s.id = w.snapshotId WHERE s.id=' + db.escape(snapshotId);
            db.query(sql, function (error, results, fields) {
                if (error) {
                    db.destroy();
                    reject(new Error(error));
                } else {
                    resolve(results[0]);
                }
            });
        });
    }
    getTs(snapshotId) {
        return new Promise(function(resolve, reject) {
            var sql = 'SELECT t.t, st.value FROM snapshots s LEFT JOIN snapshot_t st ON  s.id = st.snapshotId INNER JOIN ts t ON st.tId = t.id WHERE s.id=' + db.escape(snapshotId);
            db.query(sql, function (error, results, fields) {
                if (error) {
                    db.destroy();
                    reject(new Error(error));
                } else {
                    resolve(results);
                }
            });
        });
    }

---

您遇到的问题是，循环是同步的，而承诺是异步的。所发生的事情是，您正在创建一组承诺，这些承诺正在等待某些事情发生（承诺接收数据），然后for循环结束（在任何承诺完成之前），然后您调用close。您将要做的事情与下面类似

var gData={}；
g、 GetSnapshotId（data.gId、data.userId）
.然后（函数（值）{
gData=值；
var承诺=[]；
用于（var快照值）{
var snapshotId=value[snapshot].snapshotId；
var snapshot={}；
var promise=g.getSnapshotFull（snapshotId）
.然后（函数（值）{
console.log（值）；
返回g.getTs（快照ID）；
})
.然后（函数（值）{
for（var te值）{
变量名称=值[te].t；
快照[名称]=值[te]。值；
}
控制台日志（快照）；
});
承诺。推动（承诺）；
}
返回承诺。全部（承诺）；
})
.然后（函数（值）{
g、 close（）；
console.log（值）；
})
.catch（函数（err）{
log（'Error:'，err）；
});