Node.js
MySQL-integratie

Invoering

Een verbindingsobject met parameters opvragen

Wanneer u door gebruikers gegenereerde inhoud in de SQL wilt gebruiken, gebeurt dit met parameters. Om bijvoorbeeld de gebruiker met de naam aminadav , moet u het volgende doen:

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

Een verbindingspool gebruiken

een. Meerdere zoekopdrachten tegelijkertijd uitvoeren

Alle vragen in MySQL-verbinding worden na elkaar gedaan. Het betekent dat als u 10 query's wilt doen en elke query 2 seconden duurt, het 20 seconden duurt om de volledige uitvoering te voltooien. De oplossing is om 10 verbindingen te maken en elke query in een andere verbinding uit te voeren. Dit kan automatisch worden gedaan met behulp van de verbindingspool

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

Alle 10 query's worden parallel uitgevoerd.

Wanneer u pool gebruikt pool u de verbinding niet meer nodig. U kunt rechtstreeks naar de pool zoeken. MySQL-module zoekt naar de volgende gratis verbinding om uw zoekopdracht uit te voeren.

b. Multi-tenancy bereiken op databaseserver met verschillende daarop gehoste databases.

Multitenancy is tegenwoordig een veelvoorkomende vereiste voor bedrijfstoepassingen en het wordt afgeraden om een verbindingspool voor elke database in de databaseserver te maken. dus kunnen we in plaats daarvan een verbindingspool met databaseserver maken en deze vervolgens schakelen tussen databases die op aanvraag op de databaseserver worden gehost.

Stel dat onze applicatie verschillende databases heeft voor elk bedrijf dat op de databaseserver wordt gehost. We zullen verbinding maken met de respectieve bedrijfsdatabase wanneer de gebruiker de applicatie raakt. Hier is het voorbeeld hoe dat te doen: -

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

Laat me het voorbeeld opsplitsen: -

Bij het definiëren van de poolconfiguratie gaf ik niet de databasenaam maar alleen de databaseserver, dwz

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

dus wanneer we de specifieke database op de databaseserver willen gebruiken, vragen we de verbinding om de database te raken met behulp van: -

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

u kunt de officiële documentatie hier raadplegen

Maak verbinding met MySQL

Een van de gemakkelijkste manieren om verbinding te maken met MySQL is met behulp van de mysql module. Deze module zorgt voor de verbinding tussen de Node.js-app en de MySQL-server. U kunt het installeren zoals elke andere module:

npm install --save mysql

Nu moet u een MySQL-verbinding maken, die u later kunt opvragen.

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

In het volgende voorbeeld leert u hoe u het connection opvraagt.

Een verbindingsobject zonder parameters opvragen

U verzendt de vraag als een tekenreeks en als antwoord wordt terugbellen met het antwoord ontvangen. De callback geeft u een error , een reeks rows en velden. Elke rij bevat alle kolommen van de geretourneerde tabel. Hier is een fragment voor de volgende uitleg.

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

Voer een aantal query's uit met een enkele verbinding vanuit een pool

Er kunnen situaties zijn waarin u een pool van MySQL-verbindingen hebt ingesteld, maar u hebt een aantal vragen die u achtereenvolgens wilt uitvoeren:

SELECT 1;
SELECT 2;

Je zou gewoon kunnen draaien en vervolgens pool.query zoals elders gezien , maar als je maar één vrije verbinding in de pool hebt, moet je wachten tot er een verbinding beschikbaar is voordat je de tweede query kunt uitvoeren.

U kunt echter een actieve verbinding vanuit de pool behouden en zoveel query's uitvoeren als u wilt met een enkele verbinding met 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();
    });
  });
});

Opmerking: vergeet niet release de verbinding vrij te geven, anders is er een MySQL-verbinding minder beschikbaar voor de rest van de pool!

Bekijk de MySQL-documenten voor meer informatie over het poolen van MySQL-verbindingen.

Retourneer de zoekopdracht wanneer er een fout optreedt

U kunt de uitgevoerde query aan uw err koppelen als er een fout optreedt:

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

Verbindingspool exporteren

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