Massieve inzetstukken met pg-belofte

UPDATE

Het beste is om het volgende artikel te lezen:Gegevensimport .

Als de auteur van pg-promise Ik was genoodzaakt om eindelijk het juiste antwoord op de vraag te geven, omdat de eerder gepubliceerde vraag niet echt recht deed.

Om een enorm/oneindig aantal records in te voegen, moet uw aanpak gebaseerd zijn op de methode reeks , die beschikbaar is binnen taken en transacties.

var cs = new pgp.helpers.ColumnSet(['col_a', 'col_b'], {table: 'tableName'});

// returns a promise with the next array of data objects,
// while there is data, or an empty array when no more data left
function getData(index) {
    if (/*still have data for the index*/) {
        // - resolve with the next array of data
    } else {
        // - resolve with an empty array, if no more data left
        // - reject, if something went wrong
    }        
}

function source(index) {
    var t = this;
    return getData(index)
        .then(data => {
            if (data.length) {
                // while there is still data, insert the next bunch:
                var insert = pgp.helpers.insert(data, cs);
                return t.none(insert);
            }
            // returning nothing/undefined ends the sequence
        });
}

db.tx(t => t.sequence(source))
    .then(data => {
        // success
    })
    .catch(error => {
        // error
    });

Dit is de beste manier om een enorm aantal rijen in de database in te voegen, zowel vanuit het oogpunt van prestaties als vanuit het oogpunt van belastingbeperking.

Het enige wat u hoeft te doen is uw functie getData . implementeren volgens de logica van uw app, d.w.z. waar uw grote gegevens vandaan komen, op basis van de index van de reeks, om zo'n 1.000 - 10.000 objecten tegelijk te retourneren, afhankelijk van de grootte van de objecten en de beschikbaarheid van gegevens.

Zie ook enkele API-voorbeelden:

Gerelateerde vraag:node-postgres met enorme hoeveelheid queries .

En in gevallen waarin u gegenereerde ID's van alle ingevoegde records moet verkrijgen, zou u de twee regels als volgt wijzigen:

// return t.none(insert);
return t.map(insert + 'RETURNING id', [], a => +a.id);

// db.tx(t => t.sequence(source))
db.tx(t => t.sequence(source, {track: true}))

wees voorzichtig, want het bewaren van te veel record-ID's in het geheugen kan een overbelasting veroorzaken.