¿ Mongoose v3.6 + admite inserciones por lotes ahora? He buscado durante unos minutos, pero cualquier cosa que coincida con esta consulta tiene un par de años y la respuesta fue un rotundo no.

Editar:

Para referencia futura, la respuesta es usar Model.create(). create()acepta una matriz como primer argumento, por lo que puede pasar sus documentos para que se inserten como una matriz.

Consulte la documentación de Model.create ()

Model.create () vs Model.collection.insert (): un enfoque más rápido

Model.create()es una mala forma de hacer inserciones si se trata de un volumen muy grande. Será muy lento . En ese caso debería utilizar Model.collection.insert, que funciona mucho mejor . Dependiendo del tamaño del bulto, ¡ Model.create()incluso se estrellará! Intenté con un millón de documentos, sin suerte. Usarlo Model.collection.inserttomó solo unos segundos.

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

• docs es el conjunto de documentos que se insertarán;
• optionses un objeto de configuración opcional; consulte los documentos
• callback(err, docs)se llamará después de que se guarden todos los documentos o se produzca un error. En caso de éxito, docs es el conjunto de documentos persistentes.

Como señala aquí el autor de Mongoose , este método evitará cualquier procedimiento de validación y accederá directamente al controlador de Mongo. Es una compensación que debe hacer ya que está manejando una gran cantidad de datos; de lo contrario, no podría insertarlos en su base de datos (recuerde que estamos hablando de cientos de miles de documentos aquí).

Un simple ejemplo

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

Actualización 2019-06-22 : aunque insert()todavía se puede usar sin problemas, ha quedado obsoleto en favor de insertMany(). Los parámetros son exactamente los mismos, por lo que puede usarlo como un reemplazo directo y todo debería funcionar bien (bueno, el valor de retorno es un poco diferente, pero probablemente no lo esté usando de todos modos).

Referencia

• Documentación de Mongo
• Aaron Heckman en Grupos de Google discutiendo inserciones masivas

Mongoose 4.4.0 ahora admite inserción a granel

Mongoose 4.4.0 introduce --verdadero-- inserto a granel con el método modelo .insertMany(). Es mucho más rápido que realizar un bucle .create()o proporcionarle una matriz.

Uso:

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

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

O

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

Puedes rastrearlo en:

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

De hecho, puede usar el método "crear" de Mongoose, puede contener una variedad de documentos, vea este ejemplo:

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

La función de devolución de llamada contiene los documentos insertados. No siempre sabe cuántos elementos deben insertarse (longitud de argumento fija como el anterior) para que pueda recorrerlos:

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

Actualización: una mejor solución

Una mejor solución sería usar en Candy.collection.insert()lugar de Candy.create()usar en el ejemplo anterior, porque es más rápido ( create()está llamando Model.save()a cada elemento, por lo que es más lento).

Consulte la documentación de Mongo para obtener más información: http://docs.mongodb.org/manual/reference/method/db.collection.insert/

(gracias a arcseldon por señalar esto)

Puede realizar una inserción masiva usando mongoDB shell usando la inserción de los valores en una matriz.

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

Puede realizar una inserción masiva utilizando mangosta, como la respuesta de mayor puntuación. Pero el ejemplo no puede funcionar, debería ser:

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

No use una instancia de esquema para la inserción masiva, debe usar un objeto de mapa simple.

Aquí están las dos formas de guardar datos con insertMany y save

1) Mongoose guarda una variedad de documentos a insertManygranel

/* 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 guardar una serie de documentos con .save()

Estos documentos se guardarán en paralelo.

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

Parece que al usar mangosta hay un límite de más de 1000 documentos, cuando se usa

Potato.collection.insert(potatoBag, onInsert);

Puedes usar:

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

Pero esto es casi el doble de rápido cuando se prueba con 10000 documentos:

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

Compartiendo código de trabajo y relevante de nuestro proyecto:

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