Question

我正在使用nodejs环境开发AWS Lambda。我有一个API，其中我使用递归函数来实现某些功能。

实际上，大多数人说避免使用递归函数，但是根据我的功能，我需要这样做。我的功能如下。

我有一个表table1，其中有两列pid和cid被定义为唯一约束。这意味着两列的组合应该是唯一的。

因此，如果我在table1中插入任何组合，并且该组合已经存在，那么它会给我重复的输入错误，根据我的功能是正确的。

因此，为了处理此重复的输入错误，我使用了try..catch块。因此，在catch块中，我检查了是否发生重复的条目错误，然后调用一个递归函数，该递归函数尝试不同的组合，直到在table1中创建新条目为止。

我的递归函数是基于promise的。但是当成功创建新条目时，我将兑现承诺。但是诺言不会从我第一次调用递归函数的地方返回。并且由于该超时发生。

因此，请有人向我提出解决方案，以便我的诺言得以解决，并且我的功能将从我第一次调用递归函数的位置继续。因此超时不会到来。

我提供我的代码以供参考。

var mysql = require('mysql');

var con = mysql.createConnection({
    "host": "somehost.com",
    "user": "myusername",
    "password": "mypassword",
    "database": "mydatabase"
});

exports.handler = async (event, context) => {

    try {
        con.connect();
    } catch (error) {
        throw error;
        return 0;
    }

    let tableId = '';
    let count = '';

    try {

        var tempUsageData = {
            user_id: userId,
            code: code,
            platform: source,
            some_id: some_id,
            count: count
        };

        dbColumns = 'user_id, code, platform, added_on, count, some_id';
        let usageData = [
            [userId, code, source, new Date(), count, some_id]
        ];
        var tableInsert = await databaseInsert(con, constants.DB_CONSTANTS.DB_USAGE, dbColumns, usageData);
        tableId = tableInsert.insertId;
    } catch (error) {
        console.log('@@ error insert table1 @@', error);

        if (error.errno == 1062) {

            try {
                // calling recursive function here
                let newTableData = await createTableEntry(con, tempUsageData);
                tableId = newTableData.new_usage_id;
                count = newTableData.new_count;

            } catch (error) {
                console.log('Error', error);
                return 0;
            }

        } else {
            return 0;
        }
    };

    console.log('@@ EXECUTION DONE @@');
    return 1;

}

var createTableEntry = (con, dataObject) => {

    return new Promise(async function (resolve, reject) {
        console.log('createTableEntry Called for count', dataObject.count);
        try {
            var newCounter = await getDataFromDatabase(con, dataObject.some_id);

            dbColumns = 'user_id, code, platform, added_on, count, some_id';
            let tableData = [
                [userId, code, source, new Date(), Number(newCounter[0].counter + 1), some_id]
            ];
            var tableInsert = await databaseInsert(con, 'table1', dbColumns, tableData);


            let response = {
                new_table_id: tableInsert.insertId,
                new_count: Number(newCounter[0].counter + 1)
            }
            return resolve(response);

            //function not returning from here once successful entry done and timeout occures

        } catch (error) {
            console.log('@@ ERROR @@', error);

            if (error.errno == 1062) {

                console.log('@@ CALL FUNCTION AGAIN @@');

                dataObject.count = Number(newCounter[0].counter + 1);

                await createTableEntry(con, dataObject);

            } else {
                return reject(error);
            }
        }
    });
};

我的最终输出应该是执行完成后应显示消息“ EXECUTION DONE”。

请为此建议我一个好的解决方案。预先感谢。

Answer 1

更新您的捕获块

catch (error) {
            console.log('@@ ERROR @@', error);

            if (error.errno == 1062) {

                console.log('@@ CALL FUNCTION AGAIN @@');

                dataObject.count = Number(newCounter[0].counter + 1);

                let result = await createTableEntry(con, dataObject);
                return resolve(result);

            } else {
                return reject(error);
            }
        }

基于承诺的递归函数中的问题

1 个答案: