insertar - node js read mysql

agrupación de conexiones node.js+mysql

Question

Estoy tratando de averiguar cómo estructurar mi aplicación para usar MySQL de la manera más eficiente. Estoy usando el módulo nodo-mysql. Aquí se sugieren otros subprocesos para usar la agrupación de conexiones, así que configuré un pequeño módulo mysql.js

var mysql = require(''mysql'');

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

exports.pool = pool;

Ahora, cada vez que quiera consultar mysql, requiero este módulo y luego pregunto en la base de datos

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

¿Es este buen enfoque? Realmente no pude encontrar demasiados ejemplos de uso de conexiones mysql además de uno muy simple en el que se hace todo en el script principal de app.js, por lo que no sé cuáles son las convenciones / mejores prácticas.

¿Debo usar siempre connection.end () después de cada consulta? ¿Y si me olvido de eso en alguna parte?

¿Cómo reescribir la parte de las exportaciones de mi módulo mysql para devolver solo una conexión para que no tenga que escribir getConnection () todas las veces?

Answer 1

Cuando haya terminado con una conexión, simplemente llame a connection.release() y la conexión volverá al grupo, lista para ser utilizada por otra persona.

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

Si desea cerrar la conexión y eliminarla del grupo, use connection.destroy() lugar. El grupo creará una nueva conexión la próxima vez que se necesite una.

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

Answer 2

Es un buen enfoque.

Si solo desea obtener una conexión, agregue el siguiente código a su módulo donde se encuentra el grupo:

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

module.exports = getConnection;

Todavía tienes que escribir getConnection cada vez. Pero puede guardar la conexión en el módulo la primera vez que lo obtenga.

No olvides finalizar la conexión cuando hayas terminado de usarla:

connection.release();

Answer 3

Estoy usando esta conexión de clase base con 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;

Sólo úsalo así:

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

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

Answer 4

Usted encontrará este envoltorio útil :)

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

Requierenlo, utilícenlo así:

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 5

yo siempre uso connection.relase (); después de pool.getconnetion like

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