नोड .js + mysql कनेक्शन पूलिंग

Question 1

मैं यह पता लगाने की कोशिश कर रहा हूं कि MySQL का सबसे प्रभावशाली तरीके से उपयोग करने के लिए मेरे एप्लिकेशन को कैसे तैयार किया जाए। मैं नोड- mysql मॉड्यूल का उपयोग कर रहा हूं। यहां अन्य थ्रेड्स ने कनेक्शन पूलिंग का उपयोग करने का सुझाव दिया है इसलिए मैंने थोड़ा मॉड्यूल mysql.js स्थापित किया है

var mysql = require('mysql');

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

exports.pool = pool;

अब जब भी मुझे mysql की क्वेरी करनी है तो मुझे इस मॉड्यूल की आवश्यकता है और फिर डेटाबेस की क्वेरी करें

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 स्क्रिप्ट में किया जाता है, इसलिए मैं वास्तव में नहीं जानता कि सम्मेलन / सर्वोत्तम प्रथाओं क्या हैं।

क्या मुझे हमेशा प्रत्येक क्वेरी के बाद कनेक्शन.एंड () का उपयोग करना चाहिए? अगर मैं इसके बारे में कहीं भूल जाता हूं तो क्या होगा?

कैसे एक कनेक्शन वापस करने के लिए 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);
                  });
                }
              });
            }
          });
        }
      });
    }
  });
}

मैं व्यक्तिगत रूप से Promiseएस और useAsync()पैटर्न का उपयोग करना पसंद करता हूं । यह पैटर्न गलती से कनेक्शन के लिए भूल जाता है async/ के साथ संयुक्त होता है क्योंकि यह आपके लेक्सिकल स्कूपिंग को स्वचालित कॉल में बदल देता है :awaitrelease().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 का उपयोग करते हैं, तो वे प्रक्रिया की अवधि के लिए खुले रहेंगे, भले ही वे निष्क्रिय हों!

इसका मतलब है कि यदि आपका MySQL Server मैक्स_कनेक्ट्स 510 है तो आपके सिस्टम में केवल 10 MySQL कनेक्शन उपलब्ध होंगे, जब तक कि आपका MySQL सर्वर उन्हें बंद नहीं करता (निर्भर करता है कि आपने अपना Wait_timeout क्या सेट किया है) या आपका एप्लिकेशन बंद हो जाता है! उन्हें मुक्त करने का एकमात्र तरीका पूल उदाहरण के माध्यम से कनेक्शन को मैन्युअल रूप से बंद करना या पूल को बंद करना है।

mysql-कनेक्शन-पूल-प्रबंधक मॉड्यूल इस समस्या को ठीक करने के लिए बनाया गया था और स्वचालित रूप से लोड पर निर्भर कनेक्शन की संख्या को मापता है। निष्क्रिय कनेक्शन बंद हैं और निष्क्रिय कनेक्शन पूल अंततः बंद हो गए हैं यदि कोई गतिविधि नहीं हुई है।

    // 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

Question 8

मैं हमेशा connection.relase () का उपयोग करता हूं; जैसे पूल के बाद

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