node.js + пул з'єднань mysql

Question 1

Я намагаюся зрозуміти, як структурувати мою програму так, щоб використовувати MySQL найбільш ефективно. Я використовую модуль node-mysql. Інші потоки тут пропонували використовувати пул з'єднань, тому я встановив невеликий модуль mysql.js

var mysql = require('mysql');

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

exports.pool = pool;

Тепер, коли я хочу запитати mysql, мені потрібен цей модуль, а потім запитую 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);
         })
     })
}

Це хороший підхід? Я насправді не міг знайти занадто багато прикладів використання підключень mysql, крім дуже простого, де все робиться в основному скрипті app.js, тому я насправді не знаю, що таке конвенція / найкращі практики.

Чи завжди слід використовувати connection.end () після кожного запиту? Що якщо я десь забуду про це?

Як переписати частину експорту мого модуля mysql, щоб повернути лише підключення, щоб мені не потрібно було писати getConnection () щоразу?

Question 2

Це хороший підхід.

Якщо ви просто хочете отримати з'єднання, додайте наступний код до свого модуля, де знаходиться пул:

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

module.exports = getConnection;

Вам все одно доведеться писати getConnection кожного разу. Але ви можете зберегти з'єднання в модулі при першому отриманні.

Не забудьте розірвати з'єднання, коли закінчите його використовувати:

connection.release();

Question 3

Вам слід уникати використання, pool.getConnection()якщо можете. Якщо ви телефонуєте pool.getConnection(), ви повинні зателефонувати, connection.release()коли закінчите користуватися з’єднанням. В іншому випадку ваша програма застряє, чекаючи назавжди повернення з’єднань до пулу, як тільки ви досягнете ліміту з’єднання.

Для простих запитів ви можете використовувати pool.query(). Цей стенограф автоматично зателефонує connection.release()вам - навіть за умови помилки.

function doSomething(cb) {
  pool.query('SELECT 2*2 "value"', (ex, rows) => {
    if (ex) {
      cb(ex);
    } else {
      cb(null, rows[0].value);
    }
  });
}

Однак у деяких випадках ви повинні використовувати pool.getConnection(). Ці випадки включають:

Виконання декількох запитів у межах транзакції.
Обмін об'єктами даних, такими як тимчасові таблиці, між наступними запитами.

Якщо вам потрібно скористатися pool.getConnection(), переконайтеся, що ви телефонуєте connection.release()за шаблоном, подібним до наведеного нижче:

function doSomething(cb) {
  pool.getConnection((ex, connection) => {
    if (ex) {
      cb(ex);
    } else {
      // Ensure that any call to cb releases the connection
      // by wrapping it.
      cb = (cb => {
        return function () {
          connection.release();
          cb.apply(this, arguments);
        };
      })(cb);
      connection.beginTransaction(ex => {
        if (ex) {
          cb(ex);
        } else {
          connection.query('INSERT INTO table1 ("value") VALUES (\'my value\');', ex => {
            if (ex) {
              cb(ex);
            } else {
              connection.query('INSERT INTO table2 ("value") VALUES (\'my other value\')', ex => {
                if (ex) {
                  cb(ex);
                } else {
                  connection.commit(ex => {
                    cb(ex);
                  });
                }
              });
            }
          });
        }
      });
    }
  });
}

Я особисто вважаю за краще використовувати Promises та useAsync()шаблон. Цей шаблон у поєднанні з async/ awaitробить набагато складніше випадково забути release()про підключення, оскільки він перетворює ваш лексичний обсяг на автоматичний виклик .release():

async function usePooledConnectionAsync(actionAsync) {
  const connection = await new Promise((resolve, reject) => {
    pool.getConnection((ex, connection) => {
      if (ex) {
        reject(ex);
      } else {
        resolve(connection);
      }
    });
  });
  try {
    return await actionAsync(connection);
  } finally {
    connection.release();
  }
}

async function doSomethingElse() {
  // Usage example:
  const result = await usePooledConnectionAsync(async connection => {
    const rows = await new Promise((resolve, reject) => {
      connection.query('SELECT 2*4 "value"', (ex, rows) => {
        if (ex) {
          reject(ex);
        } else {
          resolve(rows);
        }
      });
    });
    return rows[0].value;
  });
  console.log(`result=${result}`);
}

Question 4

Ви знайдете цю обгортку корисною :)

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

Вимагайте, використовуйте так:

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

Question 5

Я використовую це підключення базового класу з 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;

Просто використовуйте його так:

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

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

Question 6

Коли ви закінчите з підключенням, просто зателефонуйте, connection.release()і підключення повернеться до пулу, готового до використання кимось іншим.

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

Якщо ви хочете закрити з'єднання та видалити його з пулу, використовуйте connection.destroy()замість цього. Пул створить нове з'єднання наступного разу, коли це буде потрібно.

Джерело : https://github.com/mysqljs/mysql

Question 7

Використовуючи стандартний mysql.createPool (), з'єднання ліниво створюються пулом. Якщо ви налаштуєте пул, щоб дозволити до 100 підключень, але використовувати будь-коли 5 одночасно, буде здійснено лише 5 підключень. Однак якщо ви налаштуєте його на 500 з'єднань і використаєте всі 500, вони залишаться відкритими протягом усього процесу, навіть якщо вони не працюють!

Це означає, що якщо ваш max_connections сервера MySQL дорівнює 510, у вашій системі буде доступно лише 10 з'єднань mySQL, поки ваш сервер MySQL їх не закриє (залежить від того, на що ви встановили час очікування) або не закриє вашу програму! Єдиний спосіб їх звільнити - це вручну закрити з'єднання через екземпляр пулу або закрити пул.

Модуль mysql-connection-pool-manager був створений для виправлення цієї проблеми та автоматичного масштабування кількості підключень залежно від навантаження. Неактивні підключення закриваються, а пули підключень, що не працюють, врешті-решт закриваються, якщо не було ніяких дій.

    // 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();

Посилання: https://www.npmjs.com/package/mysql-connection-pool-manager

Question 8

я завжди використовую connection.relase (); після pool.getconnection типу

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