Node.js
MySQL-integration

Introduktion

Fråga ett anslutningsobjekt med parametrar

När du vill använda användargenererat innehåll i SQL är det gjort med parametrar. Till exempel för att söka användare med namnet aminadav bör du göra:

var username = 'aminadav';
var querystring = 'SELECT name, email from users where name = ?'; 
connection.query(querystring, [username], function(err, rows, fields) {
  if (err) throw err;
  if (rows.length) {
    rows.forEach(function(row) {
      console.log(row.name, 'email address is', row.email);
    });
  } else {
    console.log('There were no results.');
  }
});

Använda en anslutningspool

a. Kör flera frågor samtidigt

Alla frågor i MySQL-anslutning görs en efter en. Det betyder att om du vill göra 10 frågor och varje fråga tar 2 sekunder kommer det att ta 20 sekunder att slutföra hela exekveringen. Lösningen är att skapa 10 anslutningar och köra varje fråga i en annan anslutning. Detta kan göras automatiskt med anslutningspool

var pool  = mysql.createPool({
  connectionLimit : 10,
  host            : 'example.org',
  user            : 'bobby',
  password        : 'pass',
  database        : 'schema'
});

for(var i=0;i<10;i++){
  pool.query('SELECT ` as example', function(err, rows, fields) {
    if (err) throw err;
    console.log(rows[0].example); //Show 1
  });
 }

Den kör alla 10 frågor parallellt.

När du använder pool behöver du inte anslutningen längre. Du kan fråga direkt poolen. MySQL-modulen söker efter nästa gratisanslutning för att utföra din fråga.

b. Uppnå flera hyresgäster på databaseserver med olika databaser som finns på den.

Multitenancy är ett vanligt krav för företagstillämpningar idag och det rekommenderas inte att skapa anslutningspool för varje databas i databaseserver. så vad vi kan göra istället är att skapa anslutningspool med databaseserver och sedan byta dem mellan databaser som finns på databaseserver på begäran.

Anta att vår ansökan har olika databaser för varje företag som är värd på databasservern. Vi kommer att ansluta till respektive fast databas när användaren träffar applikationen. Här är exemplet på hur du gör det: -

var pool  = mysql.createPool({
      connectionLimit : 10,
      host            : 'example.org',
      user            : 'bobby',
      password        : 'pass'
    });
    
pool.getConnection(function(err, connection){
    if(err){
        return cb(err);
    }
    connection.changeUser({database : "firm1"});
    connection.query("SELECT * from history", function(err, data){
        connection.release();
        cb(err, data);
    });
});

Låt mig dela upp exemplet: -

När jag definierade poolkonfigurationen gav jag inte databasnamnet utan gav bara databasservern, dvs

{
  connectionLimit : 10,
  host            : 'example.org',
  user            : 'bobby',
  password        : 'pass'
}

så när vi vill använda den specifika databasen på databasservern ber vi anslutningen att träffa databasen genom att använda: -

    connection.changeUser({database : "firm1"});

Du kan hänvisa till den officiella dokumentationen här

Anslut till MySQL

Ett av de enklaste sätten att ansluta till MySQL är genom att använda mysql modulen. Den här modulen hanterar anslutningen mellan Node.js-appen och MySQL-servern. Du kan installera den som alla andra moduler:

npm install --save mysql

Nu måste du skapa en mysql-anslutning, som du senare kan fråga.

const mysql      = require('mysql');
const connection = mysql.createConnection({
  host     : 'localhost',
  user     : 'me',
  password : 'secret',
  database : 'database_schema'
});

connection.connect();

// Execute some query statements
// I.e. SELECT * FROM FOO

connection.end();

I nästa exempel kommer du att lära dig hur du frågar connection .

Fråga ett anslutningsobjekt utan parametrar

Du skickar frågan som en sträng och som svar återuppringning med svaret tas emot. Återuppringningen ger dig error , rad av rows och fält. Varje rad innehåller alla kolumnerna i den returnerade tabellen. Här är ett utdrag för följande förklaring.

connection.query('SELECT name,email from users', function(err, rows, fields) {
  if (err) throw err;

  console.log('There are:', rows.length,' users');
  console.log('First user name is:',rows[0].name)
});

Kör ett antal frågor med en enda anslutning från en pool

Det kan finnas situationer där du har konfigurerat en pool med MySQL-anslutningar, men du har ett antal frågor du vill köra i följd:

SELECT 1;
SELECT 2;

Du kan bara köra och använda pool.query som man ser någon annanstans , men om du bara har en gratis anslutning i poolen måste du vänta tills en anslutning blir tillgänglig innan du kan köra den andra frågan.

Du kan dock behålla en aktiv anslutning från poolen och köra så många frågor du vill använda med en enda anslutning med pool.getConnection :

pool.getConnection(function (err, conn) {
  if (err) return callback(err);

  conn.query('SELECT 1 AS seq', function (err, rows) {
    if (err) throw err;

    conn.query('SELECT 2 AS seq', function (err, rows) {
      if (err) throw err;

      conn.release();
      callback();
    });
  });
});

Obs! Du måste komma ihåg att release anslutningen, annars finns det en mindre MySQL-anslutning tillgänglig för resten av poolen!

För mer information om att samla MySQL-anslutningar, kolla in MySQL-dokumenten .

Returnera frågan när ett fel uppstår

Du kan bifoga frågan som körts till ditt err objekt när ett fel uppstår:

var q = mysql.query('SELECT `name` FROM `pokedex` WHERE `id` = ?', [ 25 ], function (err, result) {
  if (err) {
    // Table 'test.pokedex' doesn't exist
    err.query = q.sql; // SELECT `name` FROM `pokedex` WHERE `id` = 25
    callback(err);
  }
  else {
    callback(null, result);
  }
});

Exportera anslutningspool

// db.js

const mysql = require('mysql');

const pool = mysql.createPool({
  connectionLimit : 10,
  host            : 'example.org',
  user            : 'bob',
  password        : 'secret',
  database        : 'my_db'
});

module.export = {
  getConnection: (callback) => {
    return pool.getConnection(callback);
  } 
}

// app.js

const db = require('./db');

db.getConnection((err, conn) => {
  conn.query('SELECT something from sometable', (error, results, fields) => {
    // get the results
    conn.release();
  });
});