对于池连接和执行查询JavaScript的承诺 [英] javascript promises for pooling connections and executing query

问题描述

我想知道如果这种做法是正确的还是需要进一步改进，也许promisify定制的MySQL 的getConnection 方法以及???

 要求：功能（queryRequest）{
        返回新希望（函数（解析，拒绝）{
            Database.getConnection（功能（错误连接）{
                如果（错误）{
                    拒绝（{错误：错误，queryRequest：queryRequest}）;
                }其他{
                    connection.query（queryRequest.sql，queryRequest.values​​，功能（错误，行，场）{
                        如果（错误）{
                            拒绝（{错误：错误，queryRequest：queryRequest}）;
                        }其他{
                            决心（{行：行，字段：字段queryRequest：queryRequest}）;
                        }
                    }）;
                }
            }）;
        }）;
    }，
 

中定义的的getConnection 方法数据库模块。

 的getConnection：函数（回调）{
        this.pool.getConnection（功能（错误连接）{
            回调（错误，连接）;
        }）;
    }，
 

解决方案

  

也许promisify定制的MySQL 的getConnection 的方法呢？

仅也许。虽然它可以被认为是一个有点清洁，使您的回调金字塔有点平坦的，它不会提高code多少：

 功能要求（queryRequest）{
    返回新希望（函数（解析，拒绝）{
        Database.getConnection（功能（错误连接）{
            如果（错误）
                拒绝（错误）;
            其他
                解决（连接）;
        }）;
    }），然后（功能（连接）{
        VAR解析度=新的承诺（函数（解析，拒绝）{
            connection.query（queryRequest.sql，queryRequest.values​​，功能（错误，行，场）{
                如果（错误）
                    拒绝（错误）;
                其他
                    决心（{行：行，字段：字段queryRequest：queryRequest}）;
            }）;
        }）;
        返回水库;
    }）赶上（功能（错误）{
        抛出{错误：错误，queryRequest：queryRequest};
    }）;
}
 

  

我想知道如果这种做法是正确的。

有关数据库连接，你可能想看看在处置模式。如果你不需要它，你还是要记得随时释放你的连接，使用类似

  ...。然后（功能（连接）{
    VAR解析度= ...;
    其中，支持//最好是使用`finally`解决
    返回res.then（结束，结束）;
    函数结束（）{
        connection.release（）;
        返回水库;
    }
}）
 

此外，拒绝承诺与没有 Error对象 s是一个不好的做法，你可能会做的更好。

  ... .catch（功能（错误）{
    error.queryRequest = queryRequest;
    抛出的错误;
}）
 

或你原来的模式相当。

I'm wondering if this approach is correct or does it need further refinements, maybe promisify custom mySQL getConnection method as well???

    request: function(queryRequest) {
        return new Promise(function(resolve, reject){
            Database.getConnection(function(error, connection){
                if(error) {
                    reject({error: error, queryRequest: queryRequest});
                } else {
                    connection.query(queryRequest.sql, queryRequest.values, function(error, rows, fields){
                        if(error) {
                            reject({error: error, queryRequest: queryRequest});
                        } else {
                            resolve({rows: rows, fields: fields, queryRequest: queryRequest});
                        }
                    });
                }
            });
        });
    },

The getConnection method defined in Database module.

    getConnection: function(callback) {
        this.pool.getConnection(function(error, connection){
            callback(error, connection);
        });
    },

解决方案

maybe promisify custom mySQL getConnection method as well?

Only maybe. While it could be considered a bit cleaner, and makes your callback pyramid a bit flatter, it doesn't improve the code much:

function request(queryRequest) {
    return new Promise(function(resolve, reject) {
        Database.getConnection(function(error, connection) {
            if (error)
                reject(error);
            else
                resolve(connection);
        });
    }).then(function(connection) {
        var res = new Promise(function(resolve, reject) {
            connection.query(queryRequest.sql, queryRequest.values, function(error, rows, fields) {
                if (error)
                    reject(error);
                else
                    resolve({rows: rows, fields: fields, queryRequest: queryRequest});
            });
        });
        return res;
    }).catch(function(error) {
        throw {error: error, queryRequest: queryRequest};
    });
}

I'm wondering if this approach is correct

For database connections, you might want to have a look at the disposer pattern. If you don't need it, you still should remember to always release your connections, using something like

….then(function (connection) {
    var res = …;
    // better be solved using `finally` where supported
    return res.then(end, end);
    function end() {
        connection.release();
        return res;
    }
})

Also, rejecting promises with objects that are no Errors is a bad practise, you might better do

….catch(function(error) {
    error.queryRequest = queryRequest;
    throw error;
})

or the equivalent in your original pattern.

这篇关于对于池连接和执行查询JavaScript的承诺的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！