Node.js如何并行执行独立数据库查询后统一聚合处理数据

当前业务需要查询students、subjects、grades三张数据库表，原实现用await串行执行三个无依赖的SELECT查询，执行顺序为查学生→查科目→查成绩，总耗时为三个查询耗时之和。由于三个查询没有前后逻辑依赖，支持并行执行后再聚合数据，改造目标是压缩查询总耗时，待所有需要的数据返回后再进入后续处理流程。

原代码还存在几个隐性问题：变量名大小写不一致（studentmodel/studentModel）、无效异步包装、异常被吞未做处理、空值判断不兼容查询失败场景，改造时会一并修复。

数据库操作层studentModel的三个查询方法本身独立可用，不需要修改，只需要调整业务层的调用逻辑。
根据业务场景可以选择两种改造方式：

方案1：保留空学生数据的短路逻辑（推荐） #

如果学生表为空是常见场景，优先选这个方案：先查学生表，学生数据为空直接返回，不发起另外两个无效查询，学生数据存在时再并行查科目、成绩数据，平衡性能和资源开销。
改造后的业务处理模块代码如下：

const mainstart = async () => {
    try {
        // 先查询学生数据，为空则直接返回
        const studentData = await getAllStudents();
        // 兼容查询异常返回false、空数组的场景
        if (!Array.isArray(studentData) || studentData.length === 0) {
            return 0;
        }
        // 学生数据有效时，并行查询科目、成绩后统一处理
        await processData(studentData);
        return 1;
    } catch (err) {
        console.log("流程执行异常", err);
        return 0;
    }
};

const getAllStudents = async () => {
    // 修正原变量名大小写错误，统一为studentModel
    return await studentModel.getAllStudents(); // 数据库调用1
};

const processData = async (getStudentData) => {
    const studentData = [];
    // 原串行查询改为Promise.all并行执行，总耗时等于两个查询中最慢的那个的耗时
    const [subjectsData, gradesData] = await Promise.all([
        studentModel.getStudentSubjects(), // 数据库调用2
        studentModel.getStudentGrades() // 数据库调用3
    ]);

    // 校验查询结果合法性，避免后续调用filter报错
    if (!Array.isArray(subjectsData) || !Array.isArray(gradesData)) {
        throw new Error("科目或成绩数据查询异常");
    }

    // processSubjects、processGrades是纯同步逻辑，不需要async/await包装，直接循环处理即可
    getStudentData.forEach(singleObject => {
        const subjects = processSubjects(subjectsData, singleObject.student_log);
        const grades = processGrades(gradesData, singleObject.student_log);
        // 此处保留原有单条数据加工逻辑，将处理后结果塞入studentData数组
        studentData.push({
            ...singleObject,
            subjects,
            grades
        })
    });
    
    return studentData;
};

// 去掉不必要的async声明，内部无异步IO操作，同步返回即可
const processSubjects = (result, Name) => {
    return result
        .filter(ele => ele.student_log == Name)
        .map(singleObject => ({
            name: singleObject.name,
            startDate: singleObject.startDate
        }));
}

// 去掉不必要的async声明，内部无异步IO操作，同步返回即可
const processGrades = (result, Name) => {
    return result
        .filter(ele => ele.student_log == Name)
        .map(singleObject => ({
            id: singleObject.id,
            name: singleObject.name
        }));
}

方案2：三个查询全并行（追求极致耗时） #

如果学生表为空是极小概率场景，可以直接在入口处把三个查询全部并行发起，总耗时等于三个查询中最慢的那个的耗时，是理论最快的实现，缺点是学生数据为空时会多做两次无用查询，浪费数据库连接资源。
核心入口代码调整如下：

const mainstart = async () => {
    try {
        // 三个查询直接并行发起
        const [studentData, subjectsData, gradesData] = await Promise.all([
            getAllStudents(),
            studentModel.getStudentSubjects(),
            studentModel.getStudentGrades()
        ]);
        if (!Array.isArray(studentData) || studentData.length === 0) {
            return 0;
        }
        // 直接用已经返回的科目、成绩数据做加工，不需要重复查库
        const processedData = [];
        studentData.forEach(singleObject => {
            const subjects = processSubjects(subjectsData, singleObject.student_log);
            const grades = processGrades(gradesData, singleObject.student_log);
            processedData.push({...singleObject, subjects, grades})
        })
        return 1;
    } catch (err) {
        console.log("流程执行异常", err);
        return 0;
    }
}

• 核心性能优化：用Promise.all替代await串行执行无依赖的数据库查询，将多查询总耗时从「各查询耗时之和」压缩为「最慢查询的耗时」
• 修复原代码问题：
  • 修正变量名大小写不一致的问题，避免运行时引用错误
  • 补全异常捕获逻辑，原代码空catch块直接吞错，会导致后续访问属性时出现undefined报错
  • 去掉同步函数上不必要的async声明，去掉遍历数组时无效的Promise.all+async map写法，减少不必要的微任务开销
  • 增加查询结果类型校验，兼容数据库查询异常返回false的场景，避免数组方法调用报错
  • 清理原代码中无关的错误注释（原注释残留getEmployeeData的无关描述）

内容的提问来源于stack exchange，提问作者maneesh murali