L'approche à plusieurs requêtes MySQL avec Node.js

Je suis un newbie à la fois sur l'événement/rappel style de programmation et NodeJS. Je suis en train de mettre en œuvre un petit serveur http qui sert ddbb de données à l'aide d'un noeud-module mysql.

Mes problèmes vient de requêtes de structuration. Car il y a souvent des requêtes qui nécessitent résultats de précédentes requêtes à exécuter, je ne suis pas en mesure d'exécuter tous en même temps (de manière asynchrone) et je suis obligé d'attendre des résultats.

Ma première approche a été d'exécuter tous les non-personne à la charge de requêtes en même temps et ensuite en boucle jusqu'à ce que tous d'entre eux ont mis un drapeau jusqu'à dire que je suis fait pour que je puisse continuer avec la personne à charge (synchronisé), mais je ne sais pas si c'est la bonne approche.

Quelque chose comme ceci:

function x(){
    var result_for_asynch_query_1 = null
    var result_for_asynch_query_2 = null

    mainLoop(){
        //call non-dependant query 1
        //call non-dependant query 2

        //loop until vars are != null

        //continue with queries that require data from the first ones
    }
}

//for each browser request
httpServer{
     call_to_x();
}.listen();

Cette façon, je peux gagner du temps dans le résultat final, puisque je n'attends pas toutes les réponses à une série façon, mais juste à la plus longue.

Est a t-il un moyen de faire cela? Tout modèle de conception, je ne suis pas la suite?

InformationsquelleAutor luso | 2011-07-08
  1. 11

    essayez de penser à autre manière (il existe une bonne introduction sur async flux howtonode.org)

    var db = get_link_or_pool();

do_queries( callback ) {
    db.query(sql1, function(err, res1) {
        if (err) {
             callback(err);
             return;
        }
        //use res1 ...
        db.query(sql2, function(err, res2) {
             if (err) {
                 callback(err);
                 return;
             }
             callback(null, res2); //think 'return'
        }
    });
}

request_handler(req) {
    do_queries( function(err, result) {
        if(err)
            report_error(err);
        else
            write_result(req, result);
    });
}
    • Merci beaucoup Andrey. Je vais essayer de regarder cela d'un autre point de vue... Pas facile de passer 😀
    • Et si vous avez 100 requêtes db, j'avais suppose que vous feriez nid 100 funcs? Méchant et laid comme tout l'enfer. Si il n'y a pas de meilleure réponse, alors la réponse est, vous ne devriez pas (plutôt que vous ne pouvez pas).
    • si vous avez 100 requêtes il y a quelque chose de mal dans votre db design
    • C'est certainement la bonne solution SI query2 dépend de la requête1; toutefois, si les requêtes peuvent fonctionner de manière indépendante, j'irais avec @programaths réponse ci-dessous, qui pourrait revenir jusqu'à deux fois plus rapidement.
    • non, malheureusement pour exécuter des requêtes en parallèle, vous devez exécuter chacun dans sa propre connexion. La façon mysql protocole est qu'il faut attendre le résultat de la commande précédente avant que vous êtes autorisé à envoyer prochaine. Lorsque vous ne db.query(sql1); db.query(sql2); sql2 est dans les commandes de la file d'attente jusqu'à ce que sql1 complète
    • vous disposez de 100 requêtes il y a quelque chose de mal dans votre db design. Apparemment, vous n'avez jamais été impliqué dans des projets d'envergure.
    • Je ne parle pas de "100 requêtes différentes dans un projet", je parle de "100 requêtes où chaque côté dépendent à la suite de la précédente"
    • Dans le cas de requêtes dépendantes, au lieu de l'imbrication des requêtes, vous devez créer de nouvelles fonctions pour chaque requête et de l'appel suivant de la fonction de rappel de la requête; De cette façon, vous pouvez réutiliser votre code et aura un meilleur aspect.

    InformationsquelleAutor Andrey Sidorov
  2. 43

    On doit éviter de la pyramide de doom:

    var express = require('express');
var Q = require('Q');
var app = express();

app.get('/',function(req,res){
    var mysql      = require('mysql');

    var connection = mysql.createConnection({
        host     : 'localhost',
        user     : 'root',
        password : ''
    });

    connection.connect();

    function doQuery1(){
        var defered = Q.defer();
        connection.query('SELECT 1 AS solution',defered.makeNodeResolver());
        return defered.promise;
    }

    function doQuery2(){
        var defered = Q.defer();
        connection.query('SELECT 2 AS solution',defered.makeNodeResolver());
        return defered.promise;
    }

    Q.all([doQuery1(),doQuery2()]).then(function(results){
        res.send(JSON.stringify(results[0][0][0].solution+results[1][0][0].solution));
        //Hint : your third query would go here
    });

    connection.end();

});

app.listen(80);
console.log('Listening on port 80');

    Cet exemple montre un résultat qui dépend de 2 indépendants des valeurs calculées.
    Chacune de ces valeurs a demandé, dans doQuery1 et doQuery2. Ils sont exécutés dans l'ordre, mais de manière asynchrone.

    Ensuite, vous pouvez voir Q.all(... qui, fondamentalement, l'appel ", puis sur" rappel sur la réussite. Au sein de ce rappel, le calcul est fait.

    À l'aide de promesses (détails : Github Q: la promesse de Javascript et wikipédia ) permettent de rendre votre code plus propre, distincte de calcul et de manipulation des résultats et de déplacer des choses autour.

    Regardez comment il serait facile d'ajouter "doQuery3" comme prerequisit pour votre calcul !

    Et ci-dessous le "paquet.json" bellonging à l'exemple de code:

    {
    "name": "hello-world",
    "description": "hello world test app",
    "version": "0.0.1",
    "private": true,
    "dependencies": {
        "express": "3.2.0",
        "q": "0.9.3",
        "mysql":"2.0.0-alpha7"
    }
}
    • Merci, je ne pouvais pas pour la vie de me comprendre la syntaxe pour gérer le flux de contrôle de plusieurs mysql nodejs appels!
    • Je ne crois pas que ces requêtes seront exécutés en parallèle.
    • En fait, la documentation clairement dit qu'ils ne sont pas: "Chaque méthode, vous appelez sur une connexion est en attente et exécutés dans l'ordre." npmjs.com/package/mysql#introduction
    • En fait, cette solution fonctionne bien en plus de cas génériques. Et en fait, c'éviter la pyramide de doom ou de passer à travers englobe champ d'application pour le partage de données.
    • ES6 a promises intégré maintenant
    InformationsquelleAutor programaths
  3. 13

    Une autre solution consiste à concaténer tous les états, se terminant par un point-virgule. Par exemple, pour sélectionner à partir de plusieurs tables, vous pouvez utiliser cette requête:

    var sql = 'select * from user; select * from admin;'

    Ensuite, vous pouvez utiliser une seule connexion pour exécuter les multiples déclarations:

    var connection = mysql.createConnection({multipleStatements: true})
    connection.query(sql)

    Remarque: Plusieurs états est désactivé par défaut pour éviter d'injection SQL. Veillez à bien échapper à toutes les valeurs (voir docs).

    InformationsquelleAutor Hafiz Arslan
  4. 4

    J'ai trouvé le dessous très utile pour obtenir plus de ce problème:

    Prises de http://book.mixu.net/node/ch7.html - une foule d'autres exemples ici!! 

    function async(arg, callback) {
  console.log('do something with \''+arg+'\', return 1 sec later');
  //replace setTimeout with database query  
  setTimeout(function() { callback(arg * 2); }, 1000);
}
//Final task (return data /perform further operations)
function final() { console.log('Done', results); }

//A simple async series:
var items = [ 1, 2, 3, 4, 5, 6 ];
var results = [];
function series(item) {
  if(item) {
    async( item, function(result) {
      results.push(result);
      return series(items.shift());
    });
  } else {
    return final();
  }
}
series(items.shift());

    "Prendre un ensemble d'éléments et d'appeler la série de flux de contrôle de la fonction avec le premier élément. La série lance un async() de l'opération, et passe un rappel à elle. Le rappel pousse le résultat dans les résultats de tableau, puis appelle la série avec l'élément suivant dans les éléments de tableau. Lorsque les éléments de tableau est vide, nous en appelons à la finale() la fonction". (à partir de http://book.mixu.net/node/ch7.html)

    InformationsquelleAutor Dave