update - npm mysql promise




node.js+MySQL-Verbindungspooling (5)

Ich versuche herauszufinden, wie ich meine Anwendung so strukturieren kann, dass sie MySQL am effizientesten nutzt. Ich verwende node-mysql-Modul. Andere Threads hier schlagen vor, das Verbindungspooling zu verwenden, also habe ich ein kleines Modul mysql.js eingerichtet

var mysql = require('mysql');

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

exports.pool = pool;

Wann immer ich mysql abfragen möchte, benötige ich dieses Modul und frage dann die Datenbank ab

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);
         })
     })
}

Ist das ein guter Ansatz? Ich konnte nicht wirklich viele Beispiele für die Verwendung von Mysql-Verbindungen finden, abgesehen von den sehr einfachen, bei denen alles im main app.js-Skript ausgeführt wird. Daher weiß ich nicht wirklich, was die bewährten Methoden sind.

Soll ich nach jeder Abfrage immer connection.end () verwenden? Was ist, wenn ich es irgendwo vergesse?

Wie schreibe ich den Export-Teil meines mysql-Moduls um, um nur eine Verbindung zurückzugeben, damit ich nicht jedes Mal getConnection () schreiben muss?


Es ist ein guter Ansatz.

Wenn Sie nur eine Verbindung erhalten möchten, fügen Sie dem Modul, in dem sich der Pool befindet, folgenden Code hinzu:

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

module.exports = getConnection;

Sie müssen immer noch getConnection schreiben. Sie können die Verbindung jedoch beim ersten Aufruf im Modul speichern.

Vergessen Sie nicht, die Verbindung zu beenden, wenn Sie damit fertig sind:

connection.release();

Ich verwende diese Basisklassenverbindung mit 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;

Verwenden Sie es einfach so:

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

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

Mit dem Standard mysql.createPool () werden die Verbindungen vom Pool faul erstellt. Wenn Sie den Pool so konfigurieren, dass er bis zu 100 Verbindungen zulässt, aber immer nur 5 gleichzeitig verwenden, werden nur 5 Verbindungen hergestellt. Wenn Sie es jedoch für 500 Verbindungen konfigurieren und alle 500 verwenden, bleiben diese für die Dauer des Prozesses offen, selbst wenn sie nicht verwendet werden.

Das bedeutet, wenn Ihr MySQL Server max_connections den Wert 510 hat, stehen Ihrem System nur 10 MySQL-Verbindungen zur Verfügung, bis Ihr MySQL Server diese Verbindungen (abhängig davon, was Sie für wait_timeout festgelegt haben) oder Ihre Anwendung schließt! Sie können sie nur freigeben, indem Sie die Verbindungen manuell über die Poolinstanz oder den Pool schließen.

Das Modul mysql-connection-pool-manager wurde erstellt, um dieses Problem zu beheben und die Anzahl der von der Last abhängigen Verbindungen automatisch zu skalieren. Inaktive Verbindungen werden geschlossen und inaktive Verbindungspools werden schließlich geschlossen, wenn noch keine Aktivität erfolgt ist.

    // Load modules
const PoolManager = require('mysql-connection-pool-manager');

// Options
const options = {
  ...example settings
}

// Initialising the instance
const mySQL = PoolManager(options);

// Accessing mySQL directly
var connection = mySQL.raw.createConnection({
  host     : 'localhost',
  user     : 'me',
  password : 'secret',
  database : 'my_db'
});

// Initialising connection
connection.connect();

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

// Ending connection
connection.end();

Ref: https://www.npmjs.com/package/mysql-connection-pool-manager


Sie finden diesen Wrapper nützlich :)

var pool = mysql.createPool(config.db);

exports.connection = {
    query: function () {
        var queryArgs = Array.prototype.slice.call(arguments),
            events = [],
            eventNameIndex = {};

        pool.getConnection(function (err, conn) {
            if (err) {
                if (eventNameIndex.error) {
                    eventNameIndex.error();
                }
            }
            if (conn) { 
                var q = conn.query.apply(conn, queryArgs);
                q.on('end', function () {
                    conn.release();
                });

                events.forEach(function (args) {
                    q.on.apply(q, args);
                });
            }
        });

        return {
            on: function (eventName, callback) {
                events.push(Array.prototype.slice.call(arguments));
                eventNameIndex[eventName] = callback;
                return this;
            }
        };
    }
};

Fordern Sie es so an:

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});
          });

Wenn Sie mit der Verbindung fertig sind, rufen Sie einfach connection.release() und die Verbindung wird wieder in den Pool zurückkehren, um von einer anderen Person erneut verwendet zu werden.

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.
  });
});

Wenn Sie die Verbindung schließen und aus dem Pool entfernen möchten, verwenden Sie stattdessen connection.destroy() . Der Pool erstellt beim nächsten Mal eine neue Verbindung.

Quelle : https://github.com/mysqljs/mysql





node.js