He implementado el siguiente código:

module.exports = {
    getDataFromUserGps: function(callback)
    {
        connection.connect();
        connection.query("SELECT * FROM usergps", 
            function(err, results, fields) {
                if (err) return callback(err, null);
                return callback(null, results);
            }
        ); 
        connection.end();
    },
    loginUser: function(login, pass, callback)
    {
        connection.connect();
        connection.query(
            "SELECT id FROM users WHERE login = ? AND pass = ?",
            [login, pass],
            function(err, results, fields) 
            {
                if (err) return callback(err, null);
                return callback(null, results);
            }
        ); 
        connection.end();
    },
    getUserDetails: function(userid, callback)
    {
        connection.connect();
        connection.query(
            "SELECT * FROM userProfilDetails LEFT JOIN tags ON userProfilDetails.userId = tags.userId WHERE userProfilDetails.userid = ?",
            [userid],
            function(err, results, fields)
            {
                if (err) return callback(err, null);
                return callback(null, results);
            }
        );
        connection.end();
    },
    addTags: function(userId, tags)
    {
        connection.connect();
        connection.query(
            "INSERT INTO tag (userId, tag) VALUES (?, ?)",
            [userId, tags],
            function(err, results, fields)
            {
                if (err) throw err;
            }
        )
        connection.end();
    }
}

Todo funciona muy bien solo por primera vez. Si quiero "usar" la consulta por segunda vez, aparece el siguiente error:

Cannot enqueue Handshake after invoking quit

He intentado no hacer .end()conexiones pero no ayudó.

¿Cómo puedo solucionar este problema?

Si está utilizando el módulo node-mysql, simplemente elimine el .connect y .end. Solo resolví el problema yo mismo. Aparentemente, introdujeron código innecesario en su última iteración que también tiene errores. No es necesario que se conecte si ya ha ejecutado la llamada createConnection

De acuerdo a:

• Arreglando Node Mysql "Error: No se puede poner en cola el Apretón de manos después de invocar salir":

  http://codetheory.in/fixing-node-mysql-error-cannot-enqueue-handshake-after-invoking-quit/

TL; DR Debe establecer una nueva conexión llamando al createConnectionmétodo después de cada desconexión.

y

Nota: Si está atendiendo solicitudes web, no debería finalizar las conexiones en cada solicitud. Simplemente cree una conexión al iniciar el servidor y use el objeto de conexión / cliente para consultar todo el tiempo. Puede escuchar el evento de error para manejar la desconexión del servidor y para fines de reconexión. Código completo aquí .

Desde:

• Readme.md - El servidor se desconecta:

  https://github.com/felixge/node-mysql#server-disconnects

Dice:

El servidor se desconecta

Puede perder la conexión a un servidor MySQL debido a problemas de red, el tiempo de espera del servidor o el bloqueo del servidor. Todos estos eventos se consideran errores fatales y tendrán laerr.code = 'PROTOCOL_CONNECTION_LOST' . Consulte la sección Manejo de errores para obtener más información.

La mejor manera de manejar tales desconexiones inesperadas se muestra a continuación:

function handleDisconnect(connection) {
  connection.on('error', function(err) {
    if (!err.fatal) {
      return;
    }

    if (err.code !== 'PROTOCOL_CONNECTION_LOST') {
      throw err;
    }

    console.log('Re-connecting lost connection: ' + err.stack);

    connection = mysql.createConnection(connection.config);
    handleDisconnect(connection);
    connection.connect();
  });
}

handleDisconnect(connection);

Como puede ver en el ejemplo anterior, la reconexión de una conexión se realiza estableciendo una nueva conexión. Una vez terminado, un objeto de conexión existente no se puede volver a conectar por diseño.

Con Pool, las conexiones desconectadas se eliminarán del pool, liberando espacio para que se cree una nueva conexión en la próxima llamada getConnection.

He modificado la función de modo que cada vez que se necesita una conexión, una función de inicialización agrega los controladores automáticamente:

function initializeConnection(config) {
    function addDisconnectHandler(connection) {
        connection.on("error", function (error) {
            if (error instanceof Error) {
                if (error.code === "PROTOCOL_CONNECTION_LOST") {
                    console.error(error.stack);
                    console.log("Lost connection. Reconnecting...");

                    initializeConnection(connection.config);
                } else if (error.fatal) {
                    throw error;
                }
            }
        });
    }

    var connection = mysql.createConnection(config);

    // Add handlers.
    addDisconnectHandler(connection);

    connection.connect();
    return connection;
}

Inicializando una conexión:

var connection = initializeConnection({
    host: "localhost",
    user: "user",
    password: "password"
});

Sugerencia menor: es posible que esto no se aplique a todos, pero me encontré con un problema menor relacionado con el alcance. Si el OP considera que esta edición es innecesaria, puede optar por eliminarla. Para mí, tuve que cambiar una línea initializeConnection, que era var connection = mysql.createConnection(config);simplemente

connection = mysql.createConnection(config);

La razón es que si connectiones una variable global en su programa, entonces el problema anterior era que estaba creando una nueva connectionvariable al manejar una señal de error. Pero en mi código de nodejs, seguí usando la misma connectionvariable global para ejecutar consultas, por lo que la nueva connectionse perdería en el alcance local del initalizeConnectionmétodo. Pero en la modificación, asegura que la connectionvariable global se restablezca. Esto puede ser relevante si está experimentando un problema conocido como

No se puede poner en cola la consulta después de un error fatal

después de intentar realizar una consulta después de perder la conexión y luego reconectarse con éxito. Esto puede haber sido un error tipográfico del OP, pero solo quería aclararlo.

Tuve el mismo problema y Google me trajo hasta aquí. Estoy de acuerdo con @Ata en que no es correcto simplemente eliminar end(). Después de buscar más en Google, creo que usar poolinges una mejor manera.

Documento de node-mysql sobre la agrupación

Es como esto:

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

pool.getConnection(function(err, connection) {
    connection.query( 'bla bla', function(err, rows) {
        connection.release();
    });
});

No conecte () y end () dentro de la función. Esto causará problemas en llamadas repetidas a la función. Haz la conexión solamente

var connection = mysql.createConnection({
      host: 'localhost',
      user: 'node',
      password: 'node',
      database: 'node_project'
    })

connection.connect(function(err) {
    if (err) throw err

});

una vez y reutilice esa conexión.

Dentro de la función

function insertData(name,id) {

  connection.query('INSERT INTO members (name, id) VALUES (?, ?)', [name,id], function(err,result) {
      if(err) throw err
  });


}

Funciones de AWS Lambda

Utilice mysql.createPool () con connection.destroy ()

De esta manera, las nuevas invocaciones usan el grupo establecido, pero no mantienen la función en ejecución. Aunque no obtiene el beneficio completo de la agrupación (cada nueva conexión usa una nueva conexión en lugar de una existente), hace que una segunda invocación pueda establecer una nueva conexión sin que la anterior tenga que cerrarse primero.

Respecto a connection.end()

Esto puede provocar que una invocación posterior arroje un error. La invocación se reintentará más tarde y funcionará, pero con un retraso.

Respecto mysql.createPool()aconnection.release()

La función Lambda seguirá ejecutándose hasta el tiempo de espera programado, ya que todavía hay una conexión abierta.

Ejemplo de código

const mysql = require('mysql');

const pool = mysql.createPool({
  connectionLimit: 100,
  host:     process.env.DATABASE_HOST,
  user:     process.env.DATABASE_USER,
  password: process.env.DATABASE_PASSWORD,
});

exports.handler = (event) => {
  pool.getConnection((error, connection) => {
    if (error) throw error;
    connection.query(`
      INSERT INTO table_name (event) VALUES ('${event}')
    `, function(error, results, fields) {
      if (error) throw error;
      connection.destroy();
    });
  });
};

en lugar de connection.connect();uso -

if(!connection._connectCalled ) 
{
connection.connect();
}

si ya está llamado entonces connection._connectCalled =true,
& no se ejecutará connection.connect();

nota - no usarconnection.end();

Creo que este problema es similar al mío:

1. Conectarse a MySQL
2. Finalizar el servicio MySQL (no debe salir del script del nodo)
3. Inicie el servicio MySQL, el nodo se vuelve a conectar a MySQL
4. Consultar la base de datos -> FAIL (No se puede poner en cola la consulta después de un error fatal).

Resolví este problema recreando una nueva conexión con el uso de promesas (q).

mysql-con.js

'use strict';
var config          = require('./../config.js');
var colors          = require('colors');
var mysql           = require('mysql');
var q               = require('q');
var MySQLConnection = {};

MySQLConnection.connect = function(){
    var d = q.defer();
    MySQLConnection.connection = mysql.createConnection({
        host                : 'localhost',
        user                : 'root',
        password            : 'password',
        database            : 'database'
    });

    MySQLConnection.connection.connect(function (err) {
        if(err) {
            console.log('Not connected '.red, err.toString().red, ' RETRYING...'.blue);
            d.reject();
        } else {
            console.log('Connected to Mysql. Exporting..'.blue);
            d.resolve(MySQLConnection.connection);
        }
    });
    return d.promise;
};

module.exports = MySQLConnection;

mysqlAPI.js

var colors          = require('colors');
var mysqlCon        = require('./mysql-con.js');
mysqlCon.connect().then(function(con){
   console.log('connected!');
    mysql = con;
    mysql.on('error', function (err, result) {
        console.log('error occurred. Reconneting...'.purple);
        mysqlAPI.reconnect();
    });
    mysql.query('SELECT 1 + 1 AS solution', function (err, results) {
            if(err) console.log('err',err);
            console.log('Works bro ',results);
    });
});

mysqlAPI.reconnect = function(){
    mysqlCon.connect().then(function(con){
      console.log("connected. getting new reference");
        mysql = con;
        mysql.on('error', function (err, result) {
            mysqlAPI.reconnect();
        });
    }, function (error) {
      console.log("try again");
        setTimeout(mysqlAPI.reconnect, 2000);
    });
};

Espero que esto ayude.

SOLUCIÓN: para evitar este error (para AWS LAMBDA):

Para salir del "bucle de eventos de Nodejs", debe finalizar la conexión y luego volver a conectarse. Agregue el siguiente código para invocar la devolución de llamada:

connection.end( function(err) {
        if (err) {console.log("Error ending the connection:",err);}

       //  reconnect in order to prevent the"Cannot enqueue Handshake after invoking quit"

         connection = mysql.createConnection({
                host     : 'rds.host',
                port     :  3306,
                user     : 'user',
               password : 'password',
               database : 'target database'

               });
        callback(null, {
            statusCode: 200,
            body: response,

        });
    });

Si está tratando de obtener una lambda, descubrí que terminar el controlador con hace context.done()que la lambda termine. Antes de agregar esa 1 línea, simplemente se ejecutaría y se ejecutaría hasta que se agotara el tiempo.

Puede usar debug: false,

Ejemplo: // conexión mysql

var dbcon1 = mysql.createConnection({
      host: "localhost",
      user: "root",
      password: "",
      database: "node5",
      debug: false,
    });