节点MySQL-承诺永无止境

Question

I'm having an issue with promises in node, specifically in the following code, which I wrote to execute a MySQL query so all my other 100+ functions can share this instead of writing it inline. Coming from PHP development, it's been a learning curve to understand the benefits of promises and whatnot, and now I have hit a bit of a problem. Here is the function that takes query as a parameter, executes it, and returns the response:

var mysql = require('mysql');
const myDBConnection = mysql.createPool({
    host: '127.0.0.1',
    user: "username",
    password: "password",
    database: "dbName",
    connectionLimit: 101,
});


class DBQueryRunner {
    query(query) {
        return new Promise((resolve, reject) => {
            myDBConnection.getConnection((err, connection) => {


                const myQuery = mysql.format(query.string, query.params);
                connection.query(myQuery, function(err, data) {
                    return (err ? reject(err) : resolve(data));
                    connection.release();
                });

            });

        });


    }
}

The code runs fine and the value gets returned to the caller, but it just doesn't seem to terminate, regardless of what I try and I'm concerned it's eating CPU resource.

Here is an example function you can run to use with the function above in command line, to see what is happening.

function test() {
let DBQueryRunner = require("./theAboveCode.js");
const myDB = new DBQueryRunner();

let query = {
    string: `SELECT 1+1 AS Output`,
    params: []
};


return myDB.query(query).then(rows => {
console.log(rows)
    return (rows);
});

}

Questions:
- is it necessary for the promise to terminate?
- Is there a mistake in my code?
- Is there a better way to make a reusable database execution function like I have?

UPDATE - I have also tried an alternative method using Bluebird to "promisify" the mysql library. The function still never ends and I have to CTRL+C in my terminal to quit it.

let mysql = require('mysql');
let Promise = require('bluebird');

Promise.promisifyAll(require("mysql/lib/Connection").prototype);
Promise.promisifyAll(require("mysql/lib/Pool").prototype);


let myDBConnection = mysql.createPool({
  host: '127.0.0.1',
  user: "username",
  password: "password",
  myDBConnection: "dbName",
  connectionLimit: 101,
});




class DBQueryRunner {
  query(query) {
    let pool = Promise.promisifyAll(mysql);

        return myDBConnection.getConnectionAsync()
            .then(function (conn) {
                 myDBConnection = Promise.promisifyAll(conn);
                 return myDBConnection.queryAsync(query.string, query.params);
            })
            .then(function (results) {
                 if (results.length < 1) {
                     return "No results were found";
                 } else {
                     return results;
                    //  resolve(results);  //This method doesn't work with resolve/reject so I already am confused by it.
                 }
            })
            .catch(function (err) {
                 console.log(err);
                 throw err;
            })
            .finally(function () {
                 if (myDBConnection) {
                     myDBConnection.release();
                     console.log("Released the connection")
                 }
            });
    }

}

Answer 1

I found the solution that fixes my issue.

Using connection.destroy() allows the functions to properly end, so they no longer cause the "hanging".

The two sets of code I posted in my original post do work, so it might help someone else in future.

Answer 2

You should call resolve('some data to return'); when all operations and you release the mysql descriptor. Try to change it to

connection.release(); 
return (err ? reject(err) : resolve(data)); // The return operator will EXIT from function before connection released. Maybe this is what causes the problem

is it necessary for the promise to terminate?

Promise is not terminating. Promise has three states: Running, Rejected, Resolved. So .then() chain won't be called if your previous promise is still executing. So yes, you MUST set appropriate state for your promise: resolved or rejected in order to call next chained operations.

Is there a mistake in my code?

Yes you definetely mistaken in usage of return statement. Be aware that as soon as you called return , your function is terminated and code after return statement won't be executed