node.js + łączenie mysql pooling

Question

Próbuję dowiedzieć się, jak zorganizować moją aplikację, aby użyć najbardziej wydajnego sposobu MySQL. Używam modułu node-mysql. Inne wątki tutaj zasugerował, aby korzystać z puli połączeń więc założyć mały moduł mysql.js

var mysql = require('mysql'); 

var pool = mysql.createPool({ 
    host  : 'localhost', 
    user  : 'root', 
    password : 'root', 
    database : 'guess' 
}); 

exports.pool = pool; 

Teraz gdy chcę MySQL Query wymagam tego modułu, a następnie kwerendy databse

var mysql = require('../db/mysql').pool; 

var test = function(req, res) { 
    mysql.getConnection(function(err, conn){ 
     conn.query("select * from users", function(err, rows) { 
       res.json(rows); 
     }) 
    }) 
} 

Czy to dobre podejscie? Nie mogłem znaleźć zbyt wielu przykładów używania połączeń mysql poza tym bardzo prostym, w którym wszystko jest wykonywane w głównym skrypcie app.js, więc nie wiem, co to jest konwencja/najlepsze praktyki.

Czy zawsze powinienem używać connection.end() po każdym zapytaniu? Co jeśli zapomnę o tym gdzieś?

Jak przepisać część eksportu mojego modułu mysql, aby zwrócić tylko połączenie, więc nie muszę pisać getConnection() za każdym razem?

Answer 1

To dobre podejście.

Jeśli tylko chcesz uzyskać połączenie dodać następujący kod do modułu, gdzie basen jest w:

var getConnection = function(callback) { 
    pool.getConnection(function(err, connection) { 
     callback(err, connection); 
    }); 
}; 

module.exports = getConnection; 

Trzeba jeszcze napisać getConnection za każdym razem. Ale możesz zapisać połączenie w module po raz pierwszy.

Nie zapomnij, aby zakończyć połączenie, gdy skończysz go używać:

connection.release(); 

Answer 2

Znajdziesz tego otoki przydatnych :)

tego wymagają, należy je tak:

db.connection.query("SELECT * FROM `table` WHERE `id` = ? ", row_id) 
      .on('result', function (row) { 
      setData(row); 
      }) 
      .on('error', function (err) { 
      callback({error: true, err: err}); 
      }); 

Answer 3

Zawsze używam connection.relase(); po pool.getconnetion jak

pool.getConnection(function (err, connection) { 
     connection.release(); 
     if (!err) 
     { 
      console.log('*** Mysql Connection established with ', config.database, ' and connected as id ' + connection.threadId); 
      //CHECKING USERNAME EXISTENCE 
      email = receivedValues.email 
      connection.query('SELECT * FROM users WHERE email = ?', [email], 
       function (err, rows) { 
        if (!err) 
        { 
         if (rows.length == 1) 
         { 
          if (bcrypt.compareSync(req.body.password, rows[0].password)) 
          { 
           var alldata = rows; 
           var userid = rows[0].id; 
           var tokendata = (receivedValues, userid); 
           var token = jwt.sign(receivedValues, config.secret, { 
            expiresIn: 1440 * 60 * 30 // expires in 1440 minutes 
           }); 
           console.log("*** Authorised User"); 
           res.json({ 
            "code": 200, 
            "status": "Success", 
            "token": token, 
            "userData": alldata, 
            "message": "Authorised User!" 
           }); 
           logger.info('url=', URL.url, 'Responce=', 'User Signin, username', req.body.email, 'User Id=', rows[0].id); 
           return; 
          } 
          else 
          { 
           console.log("*** Redirecting: Unauthorised User"); 
           res.json({"code": 200, "status": "Fail", "message": "Unauthorised User!"}); 
           logger.error('*** Redirecting: Unauthorised User'); 
           return; 
          } 
         } 
         else 
         { 
          console.error("*** Redirecting: No User found with provided name"); 
          res.json({ 
           "code": 200, 
           "status": "Error", 
           "message": "No User found with provided name" 
          }); 
          logger.error('url=', URL.url, 'No User found with provided name'); 
          return; 
         } 
        } 
        else 
        { 
         console.log("*** Redirecting: Error for selecting user"); 
         res.json({"code": 200, "status": "Error", "message": "Error for selecting user"}); 
         logger.error('url=', URL.url, 'Error for selecting user', req.body.email); 
         return; 
        } 
       }); 
      connection.on('error', function (err) { 
       console.log('*** Redirecting: Error Creating User...'); 
       res.json({"code": 200, "status": "Error", "message": "Error Checking Username Duplicate"}); 
       return; 
      }); 
     } 
     else 
     { 
      Errors.Connection_Error(res); 
     } 
    }); 

Answer 4

używam tego połączenia klasy bazowej z MySQL:

"base.js"

var mysql = require("mysql"); 

var pool = mysql.createPool({ 
    connectionLimit : 10, 
    host: Config.appSettings().database.host, 
    user: Config.appSettings().database.username, 
    password: Config.appSettings().database.password, 
    database: Config.appSettings().database.database 
}); 


var DB = (function() { 

    function _query(query, params, callback) { 
     pool.getConnection(function (err, connection) { 
      if (err) { 
       connection.release(); 
       callback(null, err); 
       throw err; 
      } 

      connection.query(query, params, function (err, rows) { 
       connection.release(); 
       if (!err) { 
        callback(rows); 
       } 
       else { 
        callback(null, err); 
       } 

      }); 

      connection.on('error', function (err) { 
       connection.release(); 
       callback(null, err); 
       throw err; 
      }); 
     }); 
    }; 

    return { 
     query: _query 
    }; 
})(); 

module.exports = DB; 

Wystarczy użyć go tak:

var DB = require('../dal/base.js'); 

DB.query("select * from tasks", null, function (data, error) { 
    callback(data, error); 
}); 

Answer 5

Po zakończeniu połączenia po prostu zadzwoń pod numer connection.release(), a połączenie wróci do puli, gotowe do ponownego użycia przez kogoś innego.

var mysql = require('mysql'); 
var pool = mysql.createPool(...); 

pool.getConnection(function(err, connection) { 
    // Use the connection 
    connection.query('SELECT something FROM sometable', function (error, results, fields) { 
    // And done with the connection. 
    connection.release(); 

    // Handle error after the release. 
    if (error) throw error; 

    // Don't use the connection here, it has been returned to the pool. 
    }); 
}); 

Jeśli chcesz zakończyć połączenie i wyjąć ją z basenu, zamiast używać connection.destroy(). Pula utworzy nowe połączenie następnym razem, gdy będzie potrzebna.

Źródło: https://github.com/mysqljs/mysql