Node.js数据库查询中undefined错误的异步处理与作用域解析

getSubData: () => {
    let dbc = require('./mods/db.js');
    dbc.query(`...`, function (err, rows) {
        if (err) {
            console.log(' Error 3: ', err);
        } else {
            console.log('arows: ', rows.length);
            return(rows); // 这个return只作用于回调函数内部
        }
    });
    // getSubData函数本身在这里没有明确的return语句，因此默认返回 undefined
}

// themod.js
module.exports = {
   getData: (callback) => { // getData现在也接受一个回调函数
      let dbc = require('./mods/db.js');
      dbc.query(`
         SELECT 1 rn, 'One' rt UNION
         SELECT 2 rn, 'Two' rt UNION
         SELECT 3 rn, 'Three' rt ;
         `,
         function (err, rows) {
            if (err) {
              console.log ( ' Error 1: ' , err );
              return callback(err); // 错误也通过回调传递
            } else {
               // 调用 getSubData，并将一个回调函数传递给它
               module.exports.getSubData(function(subErr, arows) {
                   if (subErr) {
                       console.log ( ' Error calling getSubData: ' , subErr );
                       return callback(subErr);
                   }
                   console.log ( 'arows.length: ', arows.length );
                   // 这里可以进一步处理数据，然后通过 getData 的回调返回
                   callback(null, rows.concat(arows)); // 假设合并结果并返回
               });
            }
          })
   },

   getSubData: (callback) => { // getSubData现在接受一个回调函数
         let dbc = require('./mods/db.js');
         dbc.query(`
         SELECT 10 rn, 'Ten' rt UNION
         SELECT 20 rn, 'Twenty' rt UNION
         SELECT 30 rn, 'Thirty' rt ;
         `,
         function (err, rows) {
            if (err) {
              console.log ( ' Error 3: ' , err );
              return callback(err); // 错误通过回调传递
            } else {
               console.log ( 'getSubData rows.length: ', rows.length );
               return callback(null, rows); // 将结果通过回调传递给调用者
            }
          })
   }
}

// theapp.js
let tm = require('./themod.js');

tm.getData(function(err, allRows) {
    if (err) {
        console.error('An error occurred:', err);
    } else {
        console.log('All data received. Total rows:', allRows.length);
        // 在这里处理最终的数据
    }
});

// mods/db.js
var mysql = require('mysql');

var dbConn = mysql.createConnection({
   host     : 'localhost',
   user     : 'unam',
   password : 'pwrd',
   database : 'dbname'
});

dbConn.connect ( function(err) {
   if (err) {
      console.error( "DB Connect failed ", err);
   } else {
      console.log("Database connected successfully.");
   }
});

// 封装 dbConn.query 为一个返回 Promise 的函数
dbConn.queryAsync = function(sql, values) {
    return new Promise((resolve, reject) => {
        this.query(sql, values, (err, rows) => {
            if (err) {
                return reject(err);
            }
            resolve(rows);
        });
    });
};

module.exports = dbConn;

// themod.js
module.exports = {
   getData: async () => { // 标记为 async 函数
      let dbc = require('./mods/db.js');
      try {
         const rows1 = await dbc.queryAsync(`
            SELECT 1 rn, 'One' rt UNION
            SELECT 2 rn, 'Two' rt UNION
            SELECT 3 rn, 'Three' rt ;
            `);
         console.log ( 'rows1.length: ', rows1.length );

         const arows = await module.exports.getSubData(); // 等待 getSubData 完成
         console.log ( 'arows.length: ', arows.length );

         // 合并或处理数据
         const allRows = rows1.concat(arows);
         console.log('Total combined rows:', allRows.length);
         return allRows; // getData 现在可以返回一个 Promise，其解析值为 allRows
      } catch (err) {
         console.error ( ' Error in getData: ' , err );
         throw err; // 抛出错误以便调用者捕获
      }
   },

   getSubData: async () => { // 标记为 async 函数
         let dbc = require('./mods/db.js');
         try {
            const rows = await dbc.queryAsync(`
            SELECT 10 rn, 'Ten' rt UNION
            SELECT 20 rn, 'Twenty' rt UNION
            SELECT 30 rn, 'Thirty' rt ;
            `);
            console.log ( 'getSubData rows.length: ', rows.length );
            return rows; // 返回查询结果
         } catch (err) {
            console.error ( ' Error in getSubData: ' , err );
            throw err; // 抛出错误以便调用者捕获
         }
   }
}

// theapp.js
let tm = require('./themod.js');

// 由于 tm.getData() 现在是一个 async 函数，它返回一个 Promise
tm.getData()
    .then(allData => {
        console.log('Final data received in app.js. Total rows:', allData.length);
        // 在这里处理最终的数据
    })
    .catch(error => {
        console.error('An error occurred in app.js:', error);
    });