Question

我有两个与promise一起运行的mysql查询。

第一个是更新mysql表的信息，然后解决问题并调用下一个mysql查询。问题是，当它调用下一个mysql查询时，promise返回UNDEFINED，我不知道为什么。当我在我的节点js服务器发布请求中控制它时，它给出了undefined。我在代码中记录了哪些方面存在问题。

blank-padded ( 1..31)

在服务器中，它会像这样被调用。

UpdateUserPath = (data) => new Promise((resolve,reject)=>{
    data.UPDATE_DT = getDateTime();
    db.query('UPDATE path  UPDATE_DT = ?  where Owner = ?',
        [data.UPDATE_DT, data.Owner], function(err,results,fields){
        if(err){
            reject('Could not update user path');
        }else{
            if(results.affectedRows > 0){
                data.ID = null;
                data.UPDATE_DT = null;
                // The problem is here, when this gets resolved it calls the other function SaveUserPath
                resolve(saveUserPath(data));
            }else{
                reject('Could not update user path');
            }
        }
    });
});


saveUserPath = (data) => new Promise((resolve, reject) => {
    db.query('INSERT INTO path SET ?', data, function (error, results, fields) {
        if (error) {
            reject('Could not insert path');
        }else{
            var Id = results.insertId;

            db.query('UPDATE path SET ORIG_ID = ? where ID = ?',[Id, Id], function(err,results,fields){
                if(err){
                    reject('Could not insert row to path  table - saveuserpath');
                }else{
                    if(results.affectedRows > 0){
                       // THIS INFORMATION HERE IS UNDEFINED
                        return resolve(results[0]);
                    }else{
                        reject('Could not update path');
                    }
                }
            });
        }
    });
});

我想知道getUserPath(req.session.userid).then((path_data)=>{ path_data.status = 1; UpdateUserPath(path_data).then((result)=>{ console.log(result); // THIS IS UNDEFINED }); });是否是调用另一个不在服务器外部的承诺的正确方法。我想的就是这样做。

resolve(saveUserPath(data));

但为什么正常的方法是错误的。

Answer 1

我有几个猜测它为什么不起作用，但是有很多错误，以便将代码清理到更好的设计更好。

在基于承诺的其他接口中组合多个异步回调驱动的操作时，您确实希望在最低级别实现底层函数，然后使用promises的优势实现所有控制流和错误处理。我认为这也会让你的问题消失，并可能解决其他一些错误。

// promisify db.query()
// if a promisified interface is built into your database, use that one instead
db.queryP = function(q, d) {
    return new Promise((resolve, reject) {
        db.query(q, d, (err, results, fields) => {
            if (err) {
                reject(err);
            } else {
                resolve(results);
            }
        });
    });
}

UpdateUserPath = function(data) {
    data.UPDATE_DT = getDateTime();
    let q = 'UPDATE path  UPDATE_DT = ?  where Owner = ?';
    return db.queryP(q, [data.UPDATE_DT, data.Owner]).then(results => {
        if (results.affectedRows > 0) {
            data.ID = null;
            data.UPDATE_DT = null;
            return saveUserPath(data);
        } else {
            throw new Error('Could not update user path');
        }
    });
}

saveUserPath = function(data) {
    let q = 'INSERT INTO path SET ?'
    return db.queryP(q, data).then(results => {
        let q2 = 'UPDATE path SET ORIG_ID = ? where ID = ?';
        var Id = results.insertId;
        return db.queryP(q2, [Id, Id]).then(results2 => {
            if (results2.affectedRows > 0) {
                return results2[0];
            } else {
                throw new Error('Could not update path');
            }
        });
    });
}

getUserPath(req.session.userid).then(path_data => {
    path_data.status = 1;
    return UpdateUserPath(path_data);
}).then(result => {
    // process result here
}).catch(err => {
    // process error here
});

promise从两个不同的mysql查询调用时返回undefined

1 个答案: