Does Mongoose v3.6 + unterstützt Batch - Einsätze jetzt? Ich habe ein paar Minuten gesucht, aber alles, was zu dieser Abfrage passt, ist ein paar Jahre alt und die Antwort war ein eindeutiges Nein.

Bearbeiten:

Zum späteren Nachschlagen ist die Antwort zu verwenden Model.create(). create()Akzeptiert ein Array als erstes Argument, sodass Sie Ihre Dokumente zum Einfügen als Array übergeben können.

Siehe Dokumentation zu Model.create ()

Model.create () vs Model.collection.insert (): ein schnellerer Ansatz

Model.create()ist ein schlechter Weg, um Einfügungen zu machen, wenn Sie mit einer sehr großen Masse zu tun haben. Es wird sehr langsam sein . In diesem Fall sollten Sie verwenden Model.collection.insert, was viel besser funktioniert . Abhängig von der Größe der Masse Model.create()wird sogar abstürzen! Versucht mit einer Million Dokumenten, kein Glück. Die Benutzung Model.collection.insertdauerte nur wenige Sekunden.

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

• docs ist das Array der einzufügenden Dokumente;
• optionsist ein optionales Konfigurationsobjekt - siehe Dokumentation
• callback(err, docs)wird aufgerufen, nachdem alle Dokumente gespeichert wurden oder ein Fehler auftritt. Bei Erfolg ist docs das Array von persistierten Dokumenten.

Wie der Autor von Mongoose hier betont, umgeht diese Methode alle Validierungsverfahren und greift direkt auf den Mongo-Treiber zu. Es ist ein Kompromiss, den Sie eingehen müssen, da Sie eine große Datenmenge verarbeiten, da Sie sie sonst überhaupt nicht in Ihre Datenbank einfügen könnten (denken Sie daran, dass es sich hier um Hunderttausende von Dokumenten handelt).

Ein einfaches Beispiel

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 2019-06-22 : Obwohl es insert()immer noch einwandfrei verwendet werden kann, wurde es zugunsten von abgelehnt insertMany(). Die Parameter sind genau gleich, Sie können sie also einfach als Ersatz verwenden und alles sollte einwandfrei funktionieren (der Rückgabewert ist etwas anders, aber Sie verwenden ihn wahrscheinlich trotzdem nicht).

Referenz

• Mongo-Dokumentation
• Aaron Heckman über Google Groups diskutiert Bulk-Inserts

Mongoose 4.4.0 unterstützt jetzt Bulk Insert

Mongoose 4.4.0 führt --true-- Bulk Insert mit der Modellmethode ein .insertMany(). Es ist viel schneller als eine Schleife .create()oder ein Array.

Verwendung:

var rawDocuments = [/* ... */];

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

Oder

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

Sie können es verfolgen auf:

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

In der Tat können Sie die "create" -Methode von Mongoose verwenden. Sie kann eine Reihe von Dokumenten enthalten. Siehe dieses Beispiel:

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

Die Rückruffunktion enthält die eingefügten Dokumente. Sie wissen nicht immer, wie viele Elemente eingefügt werden müssen (feste Argumentlänge wie oben), damit Sie sie durchlaufen können:

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

Update: Eine bessere Lösung

Eine bessere Lösung wäre, Candy.collection.insert()anstatt Candy.create()- wie im obigen Beispiel verwendet - zu verwenden, weil es schneller ist ( create()ruft Model.save()jedes Element auf, damit es langsamer ist).

Weitere Informationen finden Sie in der Mongo-Dokumentation: http://docs.mongodb.org/manual/reference/method/db.collection.insert/

(danke an arcseldon für den Hinweis)

Sie können eine Masseneinfügung mithilfe der mongoDB-Shell durchführen, indem Sie die Werte in ein Array einfügen.

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

Sie können Masseneinfügungen mit Mungo als Antwort mit der höchsten Punktzahl durchführen. Aber das Beispiel kann nicht funktionieren, es sollte sein:

/* 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);
    }
}

Verwenden Sie keine Schemainstanz für die Masseneinfügung, sondern verwenden Sie ein einfaches Kartenobjekt.

Hier sind beide Möglichkeiten zum Speichern von Daten mit insertMany und zum Speichern

1) Mungo speichert eine Reihe von Dokumenten insertManyin großen Mengen

/* 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) Mungo speichern Array von Dokumenten mit .save()

Diese Dokumente werden parallel gespeichert.

/* 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});
        })
    })
})

Es scheint, dass bei der Verwendung von Mungo die Verwendung von mehr als 1000 Dokumenten begrenzt ist

Potato.collection.insert(potatoBag, onInsert);

Sie können verwenden:

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)
      });
});

Beim Testen mit 10000 Dokumenten ist dies jedoch fast doppelt so schnell:

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);
    });
}

Teilen von funktionierendem und relevantem Code aus unserem Projekt:

//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);
    });