Nœud Mysql async plusieurs requêtes

Je me demandais quelle est la meilleure façon de gérer imbriquée mysql-requêtes est nodejs.

Donc quelque chose comme ceci:

connection.query("SELECT * FROM blogs ORDER BY time DESC", function(err, blogs, fields) {

   for (blog in blogs) {

        connection.query("SELECT * FROM tags WHERE blog_id='blog.id' ", function(err, tags, fields) {

        blog.tags = tags

     });

   }

   res.send(blogs)

});

De toute évidence, cela ne fonctionne pas, en raison de la nature asynchrone. Le résultat fait déjà retourné avant les balises sont récupérées.

J'ai lu sur le nœud et les rappels et les promesses semble être la voie à suivre. Mais je n'arrive pas à voir comment je pourrais les utiliser au mieux dans ce petit exemple.

Thx!

Ce serait une bonne occasion pour commencer à utiliser une promesse de la bibliothèque comme Q, dans ce cas, il est Q.spread de la méthode (ou peut-être ces exemples de réduction

OriginalL'auteur mhtsbt | 2014-06-15

  1. 3

    De sorte que vous avez à attendre pour tous les rappels de retour avant de vous envoyer la réponse. Si nous ignorons la gestion d'erreur et vide résultats pour la simplicité, ce qui peut être fait similaires à:

    var callback = function(blogs) {
    res.send(blogs);
}

connection.query("SELECT * FROM blogs ORDER BY time DESC", function(err, blogs, fields) {
    var pending = blogs.length;

   for (blog in blogs) {

        connection.query("SELECT * FROM tags WHERE blog_id='blog.id' ", function(err, tags, fields) {
        blog.tags = tags;

        if (0 === --pending) {
            callback(blogs);
        }
     });
   }
});

    Avec des promesses, regarder dans la Promesse.toute la fonction qui retourne une nouvelle promesse. Cela promet est résolu lorsque toutes les promesses passées dans le tableau sont résolus. Avec le Q de la bibliothèque, il doit être quelque chose comme:

    var getTags = function(blog) {
    var deferred = Q.defer();
    connection.query("SELECT * FROM tags WHERE blog_id='blog.id' ", function(err, tags, fields) {
        blog.tags = tags;
        deferred.resolve();
    });
    return deferred.promise;
}

var promises = blogs.map(getTags(blog));

Q.all(promises).then(res.send(blogs));

    OriginalL'auteur Alexei

  2. 3

    Vous pouvez utiliser asynchrone.module de la série(pour itérer sur les requêtes`)

    async.eachSeries(blogs,
                function (query, callback) {

                    connection.query(blogs.blog, "SELECT * FROM tags WHERE blog_id='blog.id'" , function (err, result) {
                        if (err) {

                            //throw err;
                            callback(err, null);
                            return;

                        } else {
                            console.log('Query executed successfully');
                            blogs.blog.tags = tags;
                        }
                        callback(null, blogs.blog);

                    });

                },

                function finalCallback(err, results) {

                            return callback(null, results);
                        });
                    }
                });

        });



    });`

    Vous pouvez améliorer avec et de requête.fonction (pour traiter chaque ligne)

    OriginalL'auteur randomness

  3. 2

    Vous pouvez essayer quelque chose comme cela;

    connection.query("SELECT * FROM blogs ORDER BY time DESC", fetchedBlogs);

function fetchedBlogs(err, blogs, fields) {

    if (err || !blogs || !blogs.length) {
        //an error occurred or no blogs available
        //handle error or send empty blog array
        return res.send();
    }

    var count = blogs.length;

    (function iterate(i) {
            if (i === count) {
                //all blogs processed!
                return res.send(blogs);
            }

            var blog = blogs[i];

            connection.query("SELECT * FROM tags WHERE blog_id='" + blog.id +
                "'", fetchedTags);

            function fetchedTags(err, tags, fields) {
                blog.tags = tags;
                iterate(i+1);
            });
    })(0);
}

    Espère que cette aide.

    Pourquoi est-ce une réponse downvoted? Je suis d'accord la solution idéale à ce problème serait de récupérer à la fois les données en une seule requête. Cette solution fonctionne si les deux requêtes sont nécessaires, cet extrait est aussi le partage d'une belle façon de gérer les rappels dans une boucle sans l'aide d'un flux de contrôle de la bibliothèque comme async/promesse/etc.

    OriginalL'auteur vmx