Ondersteunt Mongoose v3.6+nu batch-invoegingen? Ik heb een paar minuten gezocht, maar alles dat aan deze zoekopdracht voldoet, is een paar jaar oud en het antwoord was ondubbelzinnig nee.

Bewerken:

Voor toekomstig gebruik is het antwoord Model.create()te gebruiken. create()accepteert een array als eerste argument, dus je kunt je documenten doorgeven om als array ingevoegd te worden.

Zie Model.create()-documentatie

Antwoord 1, autoriteit 100%

Model.create() vs Model.collection.insert(): een snellere aanpak

Model.create()is een slechte manier om invoegingen te doen als je te maken hebt met een zeer grote bulk. Het zal erg langzaamzijn. In dat geval moet u Model.collection.insertgebruiken, dat veel beterpresteert. Afhankelijk van de grootte van de bulk, zal Model.create()zelfs crashen! Geprobeerd met een miljoen documenten, geen geluk. Met Model.collection.insertduurde het maar een paar seconden.

Model.collection.insert(docs, options, callback)

• docsis de reeks documenten die moet worden ingevoegd;
• optionsis een optioneel configuratieobject – zie de documenten
• callback(err, docs)wordt aangeroepen nadat alle documenten zijn opgeslagen of als er een fout optreedt. Bij succes, docs is de reeks van persistente documenten.

Zoals de auteur van Mongoose hieraangeeft, zal deze methode omzeil eventuele validatieprocedures en krijg direct toegang tot de Mongo-driver. Het is een afweging die je moet maken omdat je een grote hoeveelheid gegevens verwerkt, anders zou je het helemaal niet in je database kunnen invoegen (onthoud dat we het hier over honderdduizenden documenten hebben).

Een eenvoudig voorbeeld

var Potato = mongoose.model('Potato', PotatoSchema);
var potatoBag = [/* a humongous amount of potato objects */];
Potato.collection.insert(potatoBag, onInsert);
function onInsert(err, docs) {
    if (err) {
        // TODO: handle error
    } else {
        console.info('%d potatoes were successfully stored.', docs.length);
    }
}

Update 22-06-2019: hoewel insert()nog steeds prima kan worden gebruikt, is het verouderd ten gunste van insertMany(). De parameters zijn precies hetzelfde, dus je kunt het gewoon gebruiken als een drop-in vervanging en alles zou prima moeten werken (nou ja, de retourwaarde is een beetje anders, maar je gebruikt het waarschijnlijk toch niet).

Referentie

• Mongo-documentatie
• Aaron Heckman op Google Discussiegroepen over bulkinvoegingen

Antwoord 2, autoriteit 68%

Mongoose 4.4.0 ondersteunt nu bulkinvoeging

Mongoose 4.4.0 introduceert –true– bulk insert met de modelmethode .insertMany(). Het is veel sneller dan het herhalen van .create()of het voorzien van een array.

Gebruik:

var rawDocuments = [/* ... */];
Book.insertMany(rawDocuments)
    .then(function(mongooseDocuments) {
         /* ... */
    })
    .catch(function(err) {
        /* Error handling */
    });

Of

Book.insertMany(rawDocuments, function (err, mongooseDocuments) { /* Your callback function... */ });

Je kunt het volgen op:

• https://github.com/Automattic/mongoose/issues/723
• https://github.com/Automattic/mongoose/ blob/1887e72694829b62f4e3547283783cebbe66b46b/lib/model.js#L1774

Antwoord 3, autoriteit 12%

Inderdaad, je kunt de “create”-methode van Mongoose gebruiken, het kan een reeks documenten bevatten, zie dit voorbeeld:

Candy.create({ candy: 'jelly bean' }, { candy: 'snickers' }, function (err, jellybean, snickers) {
});

De callback-functie bevat de ingevoegde documenten.
Je weet niet altijd hoeveel items er moeten worden ingevoegd (vaste argumentlengte zoals hierboven), zodat je er doorheen kunt lopen:

var insertedDocs = [];
for (var i=1; i<arguments.length; ++i) {
    insertedDocs.push(arguments[i]);
}

Update: een betere oplossing

Een betere oplossing zou zijn om Candy.collection.insert()te gebruiken in plaats van Candy.create()– gebruikt in het bovenstaande voorbeeld – omdat het sneller is (create()roept Model.save()aan op elk item, dus het is langzamer).

Zie de Mongo-documentatie voor meer informatie:
http://docs.mongodb.org/manual/reference/method/db.collection.insert /

(met dank aan arcseldonvoor het erop wijzen)

Antwoord 4, autoriteit 3%

Hier zijn beide manieren om gegevens op te slaan met insertMany en opslaan

1) Mongoose slaat reeks documenten op met insertManyin bulk

/* write mongoose schema model and export this */
var Potato = mongoose.model('Potato', PotatoSchema);
/* write this api in routes directory  */
router.post('/addDocuments', function (req, res) {
    const data = [/* array of object which data need to save in db */];
    Potato.insertMany(data)  
    .then((result) => {
            console.log("result ", result);
            res.status(200).json({'success': 'new documents added!', 'data': result});
    })
    .catch(err => {
            console.error("error ", err);
            res.status(400).json({err});
    });
})

2) Mongoose slaat reeks documenten op met .save()

Deze documenten worden parallel opgeslagen.

/* write mongoose schema model and export this */
var Potato = mongoose.model('Potato', PotatoSchema);
/* write this api in routes directory  */
router.post('/addDocuments', function (req, res) {
    const saveData = []
    const data = [/* array of object which data need to save in db */];
    data.map((i) => {
        console.log(i)
        var potato = new Potato(data[i])
        potato.save()
        .then((result) => {
            console.log(result)
            saveData.push(result)
            if (saveData.length === data.length) {
                res.status(200).json({'success': 'new documents added!', 'data': saveData});
            }
        })
        .catch((err) => {
            console.error(err)
            res.status(500).json({err});
        })
    })
})

Antwoord 5, autoriteit 2%

U kunt bulksgewijs invoegen met behulp van mongoDB-shell door de waarden in een array in te voegen.

db.collection.insert([{values},{values},{values},{values}]);

Antwoord 6, autoriteit 2%

U kunt bulkinvoeging uitvoeren met mangoest, als antwoord met de hoogste score.
Maar het voorbeeld kan niet werken, het zou moeten zijn:

/* a humongous amount of potatos */
var potatoBag = [{name:'potato1'}, {name:'potato2'}];
var Potato = mongoose.model('Potato', PotatoSchema);
Potato.collection.insert(potatoBag, onInsert);
function onInsert(err, docs) {
    if (err) {
        // TODO: handle error
    } else {
        console.info('%d potatoes were successfully stored.', docs.length);
    }
}

Gebruik geen schema-instantie voor de bulkinvoeging, u moet een gewoon kaartobject gebruiken.

Antwoord 7, autoriteit 2%

Het lijkt erop dat er bij het gebruik van mangoest een limiet is van meer dan 1000 documenten bij het gebruik van

Potato.collection.insert(potatoBag, onInsert);

U kunt gebruiken:

var bulk = Model.collection.initializeOrderedBulkOp();
async.each(users, function (user, callback) {
    bulk.insert(hash);
}, function (err) {
    var bulkStart = Date.now();
    bulk.execute(function(err, res){
        if (err) console.log (" gameResult.js > err " , err);
        console.log (" gameResult.js > BULK TIME  " , Date.now() - bulkStart );
        console.log (" gameResult.js > BULK INSERT " , res.nInserted)
      });
});

Maar dit is bijna twee keer zo snel bij het testen met 10000 documenten:

function fastInsert(arrOfResults) {
var startTime = Date.now();
    var count = 0;
    var c = Math.round( arrOfResults.length / 990);
    var fakeArr = [];
    fakeArr.length = c;
    var docsSaved = 0
    async.each(fakeArr, function (item, callback) {
            var sliced = arrOfResults.slice(count, count+999);
            sliced.length)
            count = count +999;
            if(sliced.length != 0 ){
                    GameResultModel.collection.insert(sliced, function (err, docs) {
                            docsSaved += docs.ops.length
                            callback();
                    });
            }else {
                    callback()
            }
    }, function (err) {
            console.log (" gameResult.js > BULK INSERT AMOUNT: ", arrOfResults.length, "docsSaved  " , docsSaved, " DIFF TIME:",Date.now() - startTime);
    });
}

Antwoord 8

Delen van werkende en relevante code van ons project:

//documentsArray is the list of sampleCollection objects
sampleCollection.insertMany(documentsArray)  
    .then((res) => {
        console.log("insert sampleCollection result ", res);
    })
    .catch(err => {
        console.log("bulk insert sampleCollection error ", err);
    });