节点mysqljs如何正确关闭连接

Question

我使用mysqljs使用javascript访问MySQL。

我要指出的是，如果一个单一的数据，这一过程似乎运作良好。我将大量的数据输入到我的代码中，逐行作为一批处理。

我创建这样的连接：

var connection = mysql.createConnection({
    //debug: ['ComQueryPacket'],
    host        : dataSource.host,
    user        : dataSource.user,
    password: dataSource.password,
    database: dataSource.database
});

我有三个函数来进行数据库查询。

包含SELECT查询的函数构建如下：

dbSearch(data){
  var sql = "SELECT * from table where field =? and otherfield=?";
  return new Promise((resolve, reject) => {
    connection.query(sql, [data[0], data[1], (error, results, fields) => {
        if (error){
          console.log(error);
          reject("Database connection error: " + error);
         } else {
          resolve(results);
         }  
    });
  });
}

代码在另一个函数中执行：

if (dataItem){
  dbSearch(dataItem)
    .then((row) => {
        processingfunction(row);
    });

如果省略了connection.end()，代码将挂起，数据流将在正在处理的第一项中被搁置。

如果将connection.end()放入函数中，则会得到以下错误：

数据库连接错误:错误:无法在调用退出后进行队列查询。

我把connection.end()作为代码的最后一行，一切都很好

不过，问题在于更新和插入函数：

updateRecord(data){
  var sql = "UPDATE table set field=? where id=?";
  return new Promise((resolve, reject) => {
    connection.query(sql, [data[0], data[1], (error, results, fields) => {
     if (error){
      console.log(error);
      reject("Database connection error: " + error);
     } else {
      resolve(results);
     }
    });
  });
}

inputRecord(data){
  var sql = "INSERT INTO table (field1, field2, field3) VALUES(?,?,?)";
  return new Promise((resolve, reject) => {
    connection.query(sql, [data[0], data[1], data[2]], (error, results, fields) => {
      if (error){
        console.log(error);
        reject("Database connection error: " + error);
      } else {
        resolve(results);
      } 
    });
  });
}

对于函数中的connection.end()，我得到了这个错误。

Database connection error: Error: Cannot enqueue Query after invoking quit.
(node:40700) UnhandledPromiseRejectionWarning: Database connection error: Error: Cannot enqueue Query after invoking quit.
(node:40700) UnhandledPromiseRejectionWarning: Unhandled promise rejection. This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch(). (rejection id: 1)
(node:40700) [DEP0018] DeprecationWarning: Unhandled promise rejections are deprecated. In the future, promise rejections that are not handled will terminate the Node.js process with a non-zero exit code.

根据文档，我不清楚如何正确处理关闭连接，以便代码能够正确处理。

不知道我做错了什么。是否可以使用一些经验丰富的人使用连接来处理大块数据，以及如何正确地处理关闭连接？

注意：类似的问题发生在我尝试连接池时，所以这不是一个可行的解决方案。

Answer 1

如果使用连接池，则不必手动关闭康涅狄格。有一个.query()方便的方法。由于您已经在使用.query()，所以不要在函数的末尾关闭它。

--这是pool.getConnection() -> connection.query() -> connection.release()代码流的快捷方式。

var mysql = require('mysql');
var pool  = mysql.createPool({
  connectionLimit : 10,
  host            : 'example.org',
  user            : 'bob',
  password        : 'secret',
  database        : 'my_db'
});

pool.query('SELECT 1 + 1 AS solution', function (error, results, fields) {
  if (error) throw error;
  console.log('The solution is: ', results[0].solution);
});

Answer 2

您使用的是隐式连接。这意味着，您正在尝试查询数据库，而不首先显式连接。这意味着每次运行这一行时：

reject("Database connection error: " + error);

您不能确定这是连接错误。可能是查询错误。我认为最好是显式地创建/破坏您的连接。

inputRecord(data){
    var sql = "INSERT INTO table (field1, field2, field3) VALUES(?,?,?)";
    return new Promise((resolve, reject) => {
        connection.connect(function(err){
            if(err) reject("Database connection error: " + error);
            connection.query(sql, [data[0], data[1], data[2]], (error, results, fields) => {
                connection.end(); // Now you are certain a connection was made, and can be terminated
                if (error){
                    console.log(error);
                    reject("Database connection error: " + error);
                } else {
                    resolve(results);
                } 
            });
        });
    });
}

因为这是一种将被反复使用的模式，所以我建议将它移到它自己的功能上：

executeQuery(query, params){
    return new Promise((resolve, reject) => {
        connection.connect(function(err){
            if(err) reject("Database connection error: " + error); // Connection error with certainty
            connection.query(query, params, (error, results, fields) => {
                connection.end(); // Now you are certain a connection was made, and can be terminated
                if (error){
                    console.log(error);
                    reject("Database query error: " + error);  // Query error
                } else {
                    resolve(results);
                } 
            });
        });
    });
}

然后简单地调用该函数：

inputRecord(data){
    var sql = "INSERT INTO table (field1, field2, field3) VALUES(?,?,?)";
    return executeQuery(sql,[data[0],data[1],data[2]]);
}

updateRecord(data){
    var sql = "UPDATE table set field=? where id=?";
    return executeQuery(sql,[data[0],data[1]]);
}

dbSearch(data){
    var sql = "SELECT * from table where field =? and otherfield=?";
    return executeQuery(sql,[data[0],data[1]]);
}

要使用连接池，executeQuery将变成：

executeQuery(query, params){
    return new Promise((resolve, reject) => {
        pool.query(query, params,function(err,res){ // shortcut for connect, query,end - no need to terminate the connection
            if(err) reject(err);
            else    resolve(res);
        });
    });
}

这应该可以解决您的问题，但是如果不是，它至少应该通过打破错误条件并将所有与查询相关的代码放在同一个函数中来帮助缩小可能性。

检查连接优先

getConnection(){
   return new Promise((resolve, reject) => {
       if(connection.state === 'connected') resolve(connection);
       else {
            connection.connect(function(err) => {
                if(err) reject ("Connection error: " + error);
                else resolve(connection);
            });
       }
    });
 }

 executeQuery(query, params){

    return new Promise((resolve, reject) => {
        getConnection().then(connection =>{
            connection.query(query, params, (error, results, fields) => {
                connection.end(); // Now you are certain a connection was made, and can be terminated
                if (error){
                    console.log(error);
                    reject("Database query error: " + error);  // Query error
                } else {
                    resolve(results);
                } 
            });
        });
    });
}