Node.js并行查询实现及基于Promise的性能优化咨询

1. 如何在Node.js中编写并行查询？ #

在Node.js中实现数据库并行查询，核心是利用Promise.all() 方法，它可以同时触发多个异步查询请求，等待所有请求完成后统一处理结果，避免串行执行带来的性能损耗。具体步骤：

• 转换回调式查询为Promise：如果数据库驱动是回调风格，用Node.js内置的util.promisify将其转换为返回Promise的函数
• 构造查询任务数组：把多个查询Promise放入一个数组中
• 执行并行查询：通过Promise.all()执行数组中的所有Promise，它会返回一个新Promise，当所有查询成功时，结果按原数组顺序返回；只要有一个查询失败，就会触发错误捕获

基础实现框架：

const util = require('util');
// 假设db.query是回调风格的数据库查询方法
const queryAsync = util.promisify(db.query).bind(db);

async function runParallelQueries() {
  try {
    // 定义并行查询任务
    const queryTasks = [
      queryAsync('SELECT * FROM table1 WHERE id = ?', [param1]),
      queryAsync('SELECT * FROM table2 WHERE id = ?', [param2])
    ];
    // 执行并行查询，等待所有结果返回
    const [result1, result2] = await Promise.all(queryTasks);
    // 处理查询结果
    console.log('查询1结果:', result1);
    console.log('查询2结果:', result2);
  } catch (err) {
    // 捕获任意查询的错误
    console.error('查询失败:', err);
  }
}

2. 基于Promise优化现有async库代码 #

原代码使用async.waterfall和async.parallel实现流程控制，但存在回调嵌套深、数据处理冗余、变量未定义等问题，改用Promise + async/await 可简化代码结构，提升执行效率与可读性，优化后的代码如下：

优化后代码 #

var form = require('express-form');
var { validationResult } = require('express-validator');
const util = require('util');

// 假设db是已初始化的数据库连接实例
const queryAsync = util.promisify(db.query).bind(db);

module.exports = async function(req, res, groupid) {
  // 请求参数校验
  const errors = validationResult(req);
  if (!errors.isEmpty()) {
    return res.status(400).json({ errors: errors.array() });
  }

  const programid = req.params.programid;
  const format = req.query.format;
  let scrubbed_values = { programid };

  if (format && /^json$/i.test(format)) {
    console.log("Debug json");
  }

  try {
    // 校验并转换programid格式
    if (!programid) {
      localfunctions.display_error_message(res, scrubbed_values);
      return;
    }
    if (typeof programid === "string") {
      if (!programid.match(/^[0-9]+$/)) {
        localfunctions.display_error_message(res, scrubbed_values);
        return;
      }
      scrubbed_values.programid = parseInt(programid);
    } else {
      scrubbed_values.programid = parseInt(programid);
    }

    // 并行执行两个数据库查询及数据处理
    const [result1, result2] = await Promise.all([
      // 第一个查询与数据处理逻辑
      (async () => {
        const query1 = "INSERT YOUR ACTUAL QUERY HERE"; // 替换为实际SQL语句
        const queryResult = await queryAsync(query1, [groupid, programid]);
        
        const firstData = [];
        if (queryResult.length > 0) {
          // 提取摘要文本
          firstData.push([queryResult[0].ab_text]);
          
          // 整理终端用户数据
          const userArray = {};
          queryResult.forEach(item => {
            const label = "End User(s)";
            const list = item.end_users;
            if (list != null) {
              if (!userArray[label]) {
                userArray[label] = [];
              }
              // 避免重复添加数据
              if (!userArray[label].includes(list)) {
                userArray[label].push(list);
              }
            }
          });
          
          const userResult = Object.entries(userArray).map(([label, list]) => ({
            label,
            list
          }));
          firstData.push(...userResult);
        }
        return firstData;
      })(),
      // 第二个查询与数据处理逻辑
      (async () => {
        const query2 = "INSERT YOUR ACTUAL QUERY HERE"; // 替换为实际SQL语句
        const queryResult = await queryAsync(query2, [groupid, programid]);
        
        const categoryArray = {};
        queryResult.forEach(item => {
          const label = item.mem_role;
          const list = `${item.mem_name}, ${item.mem_org}`;
          if (label != null && list != null) {
            if (!categoryArray[label]) {
              categoryArray[label] = [];
            }
            // 避免重复添加数据
            if (!categoryArray[label].includes(list)) {
              categoryArray[label].push(list);
            }
          }
        });
        
        return Object.entries(categoryArray).map(([label, list]) => ({
          label,
          list
        }));
      })()
    ]);

    // 构造响应数据结构
    const ab_data = result1[0]?.[0] || '';
    const wrapper = {
      content: [
        [
          {
            type: "text-element",
            detail: {
              title: "Abstract",
              format: "text_element",
              payload: [{ items: ab_data }]
            }
          }
        ],
        [
          {
            type: "list-element",
            detail: {
              title: "Participants",
              format: "label_list",
              payload: [{ items: result2 }]
            }
          }
        ]
      ]
    };

    db.end();
    return res.status(200).json(wrapper);
  } catch (err) {
    console.error(err);
    db.end();
    return res.status(500).json({ error: 'An error occurred' });
  }
};

优化说明 #

• 移除第三方依赖：去掉async库，使用Node.js原生Promise与async/await，减少库的性能开销与依赖复杂度
• 简化错误处理：用try/catch统一捕获所有流程中的错误，替代原多层回调的分散错误处理
• 修复数据处理冗余：原代码中result1.map内嵌套for循环重复遍历数据，改为单次forEach遍历，提升处理效率
• 修复变量错误：修正原代码中EndUserArray未定义的问题，改为userArray
• 提升并行效率：用Promise.all()直接执行并行任务，避免async.parallel的封装开销
• 代码结构扁平化：替代多层回调嵌套，逻辑更清晰，便于维护与调试

内容的提问来源于stack exchange，提问作者shumana chowdhury