【问题标题】:Node JS for loop and database query用于循环和数据库查询的节点 JS
【发布时间】:2021-03-19 12:53:43
【问题描述】:

我在一个函数上运行一个 for 循环,并且每次循环都会更新数据库。然后,它使用 for 循环再次调用数据库来更新数据库上的值。但是,似乎我正在获取缓存的结果。这个错误有什么原因吗?

我可以发布我的代码,但这有点乏味。 这是一个调用数据库请求的模块函数上的简单 for 循环,然后更新该数据库。

module.exports.newElectronicHyperCredit = function(request){
    gt = request.body.custom + "-" + Date.now()
    db.query(
        "SELECT * FROM Tenderizer.Stats ORDER BY ID DESC LIMIT 1",
        [

        ],
        function(error, stats){
            bsr = stats[0]['BuySellRate'];
            dv = stats[0]['DollarValue'];           
            credits = stats[0]['Credits'];
            for(i = 0; i < request.body.quantity; i++){
                bsr = dv / credits;
                dv = Number(dv) + 10;
                credits = Number(credits) + (7 / BSR);
                denomination = 7 / bsr;
                db.query(
                    "INSERT INTO Tenderizer.Stats SET ?",
                    {
                        BuySellRate: bsr,
                        DollarValue: dv,
                        Credits: credits
                    },
                    function(error, stats){

                    }
                )
                db.query(
                    "SELECT * FROM Tenderizer.Withdrawals ORDER BY case when Withdrawals.Owner = 'Rah1337' then 1 else 2 end, Withdrawals.ID DESC",
                    [

                    ],
                    function(error, withdrawals){
                        withdrawn = 0;
                        for(x in withdrawals){
                            if(denomination != 0){
                                if(withdrawals[x]['Denomination'] > denomination){
                                    withdrawn = withdrawn + denomination;
                                    db.query(
                                        "UPDATE Tenderizer.Withdrawals SET Denomination = Denomination - ? WHERE ID = ?",
                                        [
                                            denomination,
                                            withdrawals[x]['ID']
                                        ],
                                        function(error, points){

                                        }
                                    );
                                    db.query(
                                        "INSERT INTO Tenderizer.Points SET ?",
                                        {
                                            GenerationTag: withdrawals[x]['GenerationTag'],
                                            Owner: request.body.custom,
                                            Denomination: denomination,
                                            BoughtPoint: bsr,
                                            Since: Date.now()
                                        },
                                        function(error, points){

                                        }
                                    );
                                    db.query(
                                        "INSERT INTO Tenderizer.Payouts SET ?",
                                        {
                                            GenerationTag: withdrawals[x]['GenerationTag'],
                                            Owner: withdrawals[x]['Owner'],
                                            DollarValue: bsr * withdrawals[x]['Denomination'],
                                            Denomination: denomination,
                                            Processed: 0,
                                            Since: Date.now()
                                        },
                                        function(error, payouts){

                                        }
                                    );
                                    denomination = 0;
                                }else{
                                    withdrawn = withdrawn + denomination;
                                    db.query(
                                        "DELETE FROM Tenderizer.Withdrawals WHERE ID = ?",
                                        [
                                            withdrawals[x]['ID']
                                        ],
                                        function(error, withdrawals){

                                        }
                                    );

                                    db.query(
                                        "INSERT INTO Tenderizer.Points SET ?",
                                        {
                                            GenerationTag: withdrawals[x]['GenerationTag'],
                                            Owner: request.body.custom,
                                            Denomination: withdrawals[x]['Denomination'],
                                            BoughtPoint: bsr,
                                            Since: Date.now()
                                        },
                                        function(error, points){

                                        }
                                    );
                                    db.query(
                                        "INSERT INTO Tenderizer.Payouts SET ?",
                                        {
                                            GenerationTag: withdrawals[x]['GenerationTag'],
                                            Owner: withdrawals[x]['Owner'],
                                            DollarValue: bsr * withdrawals[x]['Denomination'],
                                            Denomination: withdrawals[x]['Denomination'],
                                            Processed: 0,
                                            Since: Date.now()
                                        },
                                        function(error, payouts){

                                        }
                                    );
                                    denomination = denomination - withdrawals[x]['Denomination'];
                                }
                            }
                        }
                        if(denomination > 0){
                            db.query(
                                "INSERT INTO Tenderizer.Pool SET ?",
                                {
                                    GenerationTag: gt,
                                    Username: request.body.custom,
                                    DollarValue: 10 - (withdrawn * bsr),
                                    Withdrawn: 0,
                                    Since: Date.now()
                                },
                                function(error, pool){

                                }
                            );
                            db.query(
                                "INSERT INTO Tenderizer.Points SET ?",
                                {
                                    GenerationTag: gt,
                                    Owner: request.body.custom,
                                    Denomination: denomination,
                                    BoughtPoint: bsr,
                                    Since: Date.now()
                                },
                                function(error, points){

                                }
                            );
                        }
                        db.query(
                            "UPDATE Tenderizer.EHC_Count SET Credits = Credits + ? WHERE Username = ?",
                            [
                                7 / bsr
                            ],
                            function(error, ehc_count){

                            }
                        );
                    }
                );
            }
        }
    );
};

它不是一个一个地插入记录,而是一次插入所有记录,或者使用缓存的结果。因为我在数据库中收到的行是 重复行而不是递增行。在面额栏中的积分表和购买的积分中。

【问题讨论】:

  • 无论如何,请添加在您的问题范围内有意义的代码
  • 我添加了代码...
  • 这不是添加,而是仅发布您知道可能存在错误、异常或得到意外结果的相关代码段
  • 我建议你把你的模块分解成更易于管理的小块,并一点一点地调试你的代码......你的模块很复杂,有大量嵌套的数据库调用,回调函数, if/else 语句等
  • 好的,我试试看。

标签: mysql node.js database


【解决方案1】:

您正在使用大量回调,但实际上您并没有做任何事情来等待这些回调被调用。这很难使用回调来解决,但如果您使用支持 Promises 的库,则可以更轻松地解决。

例如,如果您使用 @databases/mysql 正确等待每个查询,代码将如下所示

const createConnectionPool = require('@databases/mysql');
const {sql} = require('@databases/mysql');

const db = createConnectionPool();

module.exports.newElectronicHyperCredit = async function(request){
    let gt = request.body.custom + "-" + Date.now()
    const stats = await db.query(
        sql`SELECT * FROM Tenderizer.Stats ORDER BY ID DESC LIMIT 1`,
    );
    let bsr = stats[0]['BuySellRate'];
    let dv = stats[0]['DollarValue'];           
    let credits = stats[0]['Credits'];
    for(let i = 0; i < request.body.quantity; i++){
        bsr = dv / credits;
        dv = Number(dv) + 10;
        credits = Number(credits) + (7 / BSR);
        denomination = 7 / bsr;
        await db.query(sql`
            INSERT INTO Tenderizer.Stats (BuySellRate, DollarValue, Credits)
            VALUES (${bsr}, ${dv}, ${credits}
        `)
        const withdrawals = await db.query(sql`
            SELECT * FROM Tenderizer.Withdrawals
            ORDER BY case when Withdrawals.Owner = 'Rah1337' then 1 else 2 end, Withdrawals.ID DESC
        `)
        withdrawn = 0;
        for(x in withdrawals){
            if(denomination != 0){
                if(withdrawals[x]['Denomination'] > denomination){
                    withdrawn = withdrawn + denomination;
                    await db.query(sql`
                        UPDATE Tenderizer.Withdrawals
                        SET Denomination = Denomination - ${denomination}
                        WHERE ID = ${withdrawals[x]['ID']}
                    `);
                    await db.query(sql`
                        INSERT INTO Tenderizer.Points (GenerationTag, Owner, Denomination, BoughtPoint, Since)
                        VALUES (
                            ${withdrawals[x]['GenerationTag']},
                            ${request.body.custom},
                            ${denomination},
                            ${bsr},
                            ${Date.now()}
                        )
                    `);
                    await db.query(sql`
                        INSERT INTO Tenderizer.Payouts (GenerationTag, Owner, DollarValue, Denomination, Processed, Since)
                        VALUES (
                            ${withdrawals[x]['GenerationTag']},
                            ${withdrawals[x]['Owner']},
                            ${bsr * withdrawals[x]['Denomination']},
                            ${denomination},
                            ${0},
                            ${Date.now()}
                        )
                    `);
                    denomination = 0;
                }else{
                    withdrawn = withdrawn + denomination;
                    await db.query(
                        sql`DELETE FROM Tenderizer.Withdrawals WHERE ID = ${withdrawals[x]['ID']}`
                    );

                    await db.query(sql`
                        INSERT INTO Tenderizer.Points (GenerationTag, Owner, Denomination, BoughtPoint, Since)
                        VALUES (
                            ${withdrawals[x]['GenerationTag']},
                            ${request.body.custom},
                            ${withdrawals[x]['Denomination']},
                            ${bsr},
                            ${Date.now()}
                        )
                    `);
                    await db.query(sql`
                        INSERT INTO Tenderizer.Payouts (GenerationTag, Owner, DollarValue, Denomination, Processed, Since)
                        VALUES (
                            ${withdrawals[x]['GenerationTag']},
                            ${withdrawals[x]['Owner']},
                            ${bsr * withdrawals[x]['Denomination']},
                            ${withdrawals[x]['Denomination']},
                            ${0},
                            ${Date.now()}
                        )
                    `);
                    denomination = denomination - withdrawals[x]['Denomination'];
                }
            }
        }
        if(denomination > 0){
            await db.query(sql`
                INSERT INTO Tenderizer.Pool (GenerationTag, Username, DollarValue, Withdrawn, Since)
                VALUES (
                    ${gt},
                    ${request.body.custom},
                    ${10 - (withdrawn * bsr)},
                    ${0},
                    ${Date.now()}
                )
            `);
            await db.query(sql`
                INSERT INTO Tenderizer.Points (GenerationTag, Owner, Denomination, BoughtPoint, Since)
                VALUES (
                    ${gt},
                    ${request.body.custom},
                    ${denomination},
                    ${bsr},
                    ${Date.now()}
                )
            `);
        }
        await db.query(sql`UPDATE Tenderizer.EHC_Count SET Credits = Credits + ${7 / bsr} WHERE Username = ${request.body.custom}`)
    }
};

附:看起来您也忘记实际声明变量(在为变量赋值之前使用 letconst

P.P.S 在一个循环中执行所有这些查询可能会很慢,因为每个查询都会按顺序执行。如果每个查询都依赖于前一个查询的结果,这将是必要的,但如果不是这种情况,您可以用await Promise.all(list.map(async (value, index) =&gt; {...})) 替换一个/所有循环,这将为列表中的每个值运行该函数,但是将并行运行。

【讨论】:

  • 如果我知道这种方法,我会使用它。我调制了这个功能,现在它工作正常,但我不知道它是如何解决问题的。
猜你喜欢
  • 2019-05-27
  • 2018-08-02
  • 2017-09-29
  • 2017-08-29
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 2021-08-15
  • 1970-01-01
相关资源
最近更新 更多