nodejs调用数据库并行调用

Question

该模块调用三个表(学生、科目、年级)，我调用三个sql查询，并设法一个接一个地调用，如下所述。查询是相互独立的。然而，选择查询是一个接一个地执行，首先是学生，然后是科目，然后是使用等待的成绩。

studentmodel.calls只用于执行数据库中的选择问题，并且位于一个模块中。其他函数在一个单独的模块中定义。

该逻辑可以并行执行三个selct查询(数据库调用)，然后将所有数据聚合和处理在一起。请让我知道如何修改，以便数据库调用可以独立执行，然后移动到一起处理所有数据。

处理模块-main启动调用

const mainstart = async () => {
    let students = 0;

    const getStudentData = await getAllStudents();

    /** checking a condition if getEmployeeData responce is not empty */
    if (getStudentData.length > 0) {
        const studentData = await processData(getStudentData);
        return 1;

    } else {
        return 0;
    }
};



same file secondcall to the function getAllStudents

const getAllStudents = async () => {
    try {
        return await studentmodel.getAllStudents();//database call 1
    } catch (err) {
        // console.log("processing", err)
    }
};




const processData = async (getStudentData) => {
    try {

        let studentData = [];

        const subjectsData = await studentModel.getStudentSubjects();//database call 2

        const gradesData = await studentModel.getStudentGrades();//database call 3

        await Promise.all(getStudentData.map(async (singleObject) => {

            let subjects = await processSubjects(subjectsData, singleObject.student_log);
            let grades = await processGrades(gradesData, singleObject.student_log);  

        //Some processing on sigleobject, subjects and grades to populate studentData array
          
        }));
        return studentData;
    } catch (err) {
        console.log("processing", err)
    }
};

const processSubjects = async (result, Name) => {
    let subjectsArr = [];

    const processArray = result.filter(ele => ele.student_log == Name)

    processArray.map((singleObject) => {
        subjectsArr.push({
            name: singleObject.name,
            startDate: singleObject.startDate,
        });
    })
    return subjectsArr;
}

const processGrades = async (result, Name) => {
    let gradesArr = [];
    const processArray = result.filter(ele => ele.student_log == Name)
    processArray.map((singleObject) => {
        gradesArr.push({
            id: singleObject.id,
            name: singleObject.name,
        });
    })
    return gradesArr;

数据库调用模块/学生模型

const getAllStudents = async () => {
    try {

        /** Populating all students */
        const sqlQuery = `SELECT * FROM STUDENTS`;

        let [result] = await bigQuery.query({
            query: sqlQuery,
            location: 'US'
        });


        return result;

    } catch (err) {
        return false;
    }

};

const getStudentSubjects = async () => {
    try {

        /** Populating all skills */
        const sqlQuery = `SELECT * FROM Subjects`;

        let [result] = await bigQuery.query({
            query: sqlQuery,
            location: 'US'
        });


        return result;

    } catch (err) {
        return false;
    }

};
const getStudentGrades = async () => {
    try {

        /** Populating all students */
        const sqlQuery = `SELECT * FROM GRADES`;

        let [result] = await bigQuery.query({
            query: sqlQuery,
            location: 'US'
        });


        return result;

    } catch (err) {
        return false;
    }

};

Answer 1

虽然我可能不完全理解您的问题是什么，但我还是尝试了一下您的代码。

我用setTimeout模拟了您的学生模型函数，并使代码类似于这样的代码，以便它首先获取所有的学生。在抓取所有学生之后，利用Promise.all获取科目和成绩的“平行”。在获取了学生、科目和成绩之后，我们将所有这些传递给processData函数，在那里您可以任意处理所有数据。

如果您还想获取与科目和成绩“并行”的学生，只需将Promise.all部分更改如下：

const [studentData, studentSubjects, studentGrades] = await Promise.all(
[
    getAllStudents(),
    getStudentSubjects(), 
    getStudentGrades()
]);

并删除const studentData = await getAllStudents();行和if-子句。因为您的代码中包含了if(studentData.length > 0)，所以我假设我们只想在有学生的情况下获取科目和成绩，因此需要首先单独进行。

请注意，如果您想并行执行这三项操作，则在调用studentData或getStudentGrades时不能使用getStudentGrades。

​

// STUDENTMODEL

const getAllStudents = async () => {
    // Simulate SQL query
    console.log("Fetching students");
    return new Promise(resolve => 
      setTimeout(() => { 
      resolve(["Student 1", "Student 2"]) 
      }, 1000));
};

const getStudentSubjects = async () => {
    // Simulate SQL query
    console.log("Fetching subjects");
    return new Promise(resolve =>
      setTimeout(() => {
        resolve(["Subject 1", "Subject 2"])
      }, 1500));
};

const getStudentGrades = async () => {
    // Simulate SQL query
    console.log("Fetching grades");
    return new Promise(resolve =>
      setTimeout(() => {
        resolve(["Grade 1", "Grade 2"])
      }, 1500));
};


const mainstart = async () => {
    // Fetch student data from database
    const studentData = await getAllStudents();

    if (studentData.length > 0) {
        // Use Promise.all to wait until both student subjects and
        // student grades have been fetched
        // The results are destructured into
        // studentSubjects and studentGrades variables
        const [studentSubjects, studentGrades] = await Promise.all(
        [
          getStudentSubjects(studentData), 
          getStudentGrades(studentData)
        ]); 
        
        // Everything is fetched, process it all
        processData([studentData, studentSubjects, studentGrades]);
        return 1;
    } else {
        return 0;
    }
};

const processData = (allData) => {
    console.log("Processing all data");
    console.log(allData);
    
    // Process data somehow
};

(async () => {
  console.log('start');
  await mainstart(); 
  console.log('end');
})();

​