Синхронные запросы к базе данных с узлом.js

вот очень простой трюк для обработки нескольких обратных вызовов.

var after = function _after(count, f) {
  var c = 0, results = [];
  return function _callback() {
    switch (arguments.length) {
      case 0: results.push(null); break;
      case 1: results.push(arguments[0]); break;
      default: results.push(Array.prototype.slice.call(arguments)); break;
    }
    if (++c === count) {
      f.apply(this, results);
    }
  };
};

пример

использование:

var handleDatabase = after(2, function (res1, res2) {
  res.render('home.ejs', { locals: { r1: res1, r2: res2 }):
})

db.execute(sql1).on('result', handleDatabase);
db.execute(sql2).on('result', handleDatabase);

Так что в основном вам нужен подсчет ссылок. Это стандартный подход в таких ситуациях. Я на самом деле использую эту небольшую функцию полезности вместо управления потоком.

Если вы хотите полномасштабное решение для управления потоком, я бы рекомендовал futuresJS

Я считаю, что асинхронная библиотека лучше всего подходит для таких вещей. https://github.com/caolan/async#parallel

Я не могу проверить это или ничего, так что простите, если есть опечатки. Я изменил вашу функцию запроса, чтобы ее можно было использовать повторно. Таким образом, вызов queryRows вернет функцию, которая соответствует формату параллельных функций обратного вызова асинхронного модуля. После завершения обоих запросов он вызовет последнюю функцию и передаст результат двух запросов в виде аргумент, который вы можете прочитать, чтобы передать в ваш шаблон.

function queryRows(col, table) {
  return function(cb) {
    var rows = [];
    db.execute('SELECT ' + col + ' FROM ' + table)
      .on('row', function(r) {
        rows.push(r)        
      })
      .on('result', function() {
        cb(rows);
      });
  }
}

app.get('/home', function(req, res) {
  async.parallel({
    users: queryRow('user_name', 'users'),
    titles: queryRow('title', 'code_samples')
  },
  function(result) {
    res.render('home.ejs', { 
      layout: false,
      locals: {user_name: result.users, title: result.titles} 
    });
  });
});

здесь есть некоторые решения, но, на мой взгляд, лучшее решение-сделать код синхронно очень простым способом.

вы можете использовать "пакет synchonize".

просто

npm install synchronize

затем var sync = require(synchronize);

положите логику, которая должна быть синхронной в волокно с помощью

sync.fiber(function() { //put your logic here }

пример для двух запросов mysql:

var express = require('express');
var bodyParser = require('body-parser');
var mysql = require('mysql');
var sync = require('synchronize');

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

db.connect(function(err) {
    if (err) {
        console.error('error connecting: ' + err.stack);
        return;
    }
});

function saveSomething() {
    var post  = {id: newId};
    //no callback here; the result is in "query"
    var query = sync.await(db.query('INSERT INTO mainTable SET ?', post, sync.defer()));
    var newId = query.insertId;
    post  = {foreignKey: newId};
    //this query can be async, because it doesn't matter in this case
    db.query('INSERT INTO subTable SET ?', post, function(err, result) {
        if (err) throw err;
    });
}

когда вызывается " saveSomething ()", он вставляет строку в основную таблицу и получает последний вставленный идентификатор. После этого будет выполнен приведенный ниже код. Нет необходимости в гнездовых обещаниях или тому подобном.

вариант первый: если все ваши запросы связаны друг с другом, создайте хранимую процедуру, поместите в нее всю логику данных и получите один db.execute

вариант второй: если ваша БД использует одно соединение, то команды гарантированно будут выполняться последовательно, и вы можете использовать это как асинхронный помощник

db.execute(sql1).on('row', function(r) {
   req.session.user_array.push(r.user);
});
db.execute(sql2)
.on('row', function(r) {
   req.session.title_array.push(r.title);
})
.on('end'), function() {
   // render data from req.session
});

вы можете использовать волокна, чтобы написать псевдо-синхронный код с узлом.JS взгляните на эти тесты для DB https://github.com/alexeypetrushin/mongo-lite/blob/master/test/collection.coffee они асинхронны, но выглядят синхронно, подробнее http://alexeypetrushin.github.com/synchronize