如何在Mysql中存储大量数据？

我有一个nodejs脚本，它根据给定的salt生成散列和最终数字。如果我生成1000条记录，它们将被添加到数据库中，之后如果我再次生成1000条记录，将首先检查重复记录，然后添加新记录。因此，目前我需要生成大约200万条记录，由于数据量很大，记录没有生成，也没有添加到数据库中

如何正确地生成所有这些

我的代码：

const crypto = require("crypto");
var mysql = require('mysql');

var connection = mysql.createConnection({
    host: 'localhost',
    user: 'test',
    password: 'test',
    database: 'test'
});
connection.connect(function (err) {
    if (err) {
        console.error('error connecting database: ' + err.stack);
        process.exit(1);
        return;
    }
});

const crashHash = "";
const salt = "0000000000000000000fa3b65e43e4240d71762a5bf397d5304b2596d116859c";

function saltHash(hash) {
    return crypto.createHmac("sha256", hash).update(salt).digest("hex");
}

function generateHash(seed) {
    return crypto.createHash("sha256").update(seed).digest("hex");
}

function divisible(hash, mod) {
    // We will read in 4 hex at a time, but the first chunk might be a bit smaller
    // So ABCDEFGHIJ should be chunked like  AB CDEF GHIJ
    var val = 0;

    var o = hash.length % 4;
    for (var i = o > 0 ? o - 4 : 0; i < hash.length; i += 4) {
        val = ((val << 16) + parseInt(hash.substring(i, i + 4), 16)) % mod;
    }

    return val === 0;
}

function crashPointFromHash(serverSeed) {
    const hash = crypto
        .createHmac("sha256", serverSeed)
        .update(salt)
        .digest("hex");

    const hs = parseInt(100 / 5);
    if (divisible(hash, hs)) {
        return 1;
    }

    const h = parseInt(hash.slice(0, 52 / 4), 16);
    const e = Math.pow(2, 52);

    return Math.floor((100 * e - h) / (e - h)) / 100.0;
}

function getPreviousGames() {
    const previousGames = [];
    let gameHash = generateHash(crashHash);

    connection.query(`SELECT * FROM crash_numbers;`, function (err, all_crash_numbers) {
        if (err) throw err;

        let repetitions = 2000000

        for (let i = 0; i < repetitions; i++) {
            const gameResult = crashPointFromHash(gameHash);
            previousGames.push({ gameHash, gameResult });
            gameHash = generateHash(gameHash);

            if (!all_crash_numbers.find(v => v.hash == previousGames[previousGames.length - 1].gameHash)) {

                for (let aGame of previousGames)
                    var sql = "INSERT IGNORE INTO `test`.`crash_numbers` (`id`, `hash`, `multiplier`, `status`, `created_at`, `updated_at`) VALUES (NULL, '" + aGame.gameHash + "', '" + aGame.gameResult + "', '0', now(), now());";

                connection.query(sql, function (err, result) {
                    if (err) throw err;
                    console.log("Values add");

                });

            } else {
                repetitions++;
                console.log('Duplicate, skip')
            }

        }

    });

    return previousGames;
}

function verifyCrash() {
    const gameResult = crashPointFromHash(crashHash);
    const previousHundredGames = getPreviousGames();

    return { gameResult, previousHundredGames };
}

console.log(verifyCrash());

const crypto=require（“crypto”）；
var mysql=require（'mysql'）；
var connection=mysql.createConnection({
主机：“localhost”，
用户：“测试”，
密码：“测试”，
数据库：“测试”
});
connection.connect（函数（err）{
如果（错误）{
console.error（'连接数据库时出错：'+err.stack）；
过程。退出（1）；
返回；
}
});
const crashHash=“”；
const salt=“0000000000000000000 FA3B65E43E4240D71762A5BF397D5304B2596D116859C”；
函数saltHash（hash）{
返回crypto.createHmac（“sha256”，hash）.update（salt）.digest（“hex”）；
}
函数生成器hash（seed）{
返回crypto.createHash（“sha256”）.update（seed）.digest（“hex”）；
}
可除函数（散列，mod）{
//我们将一次读取4个十六进制，但是第一个块可能会小一些
//所以ABCDEFGHIJ应该像AB CDEF GHIJ一样分块
var=0；
var o=hash.length%4；
对于（变量i=o>0？o-4:0；i

也许我需要修改一下剧本