O Mongoose v3.6 + suporta inserções em lote agora? Procurei por alguns minutos, mas qualquer coisa que corresponda a essa consulta tem alguns anos e a resposta foi um não inequívoco.

Editar:

Para referência futura, a resposta é usar Model.create(). create()aceita um array como seu primeiro argumento, então você pode passar seus documentos a serem inseridos como um array.

Veja a documentação de Model.create ()

Model.create () vs Model.collection.insert (): uma abordagem mais rápida

Model.create()é uma maneira ruim de fazer inserções se você estiver lidando com um volume muito grande. Vai ser muito lento . Nesse caso, você deve usar Model.collection.insert, que tem um desempenho muito melhor . Dependendo do tamanho do bulk, Model.create()vai até travar! Tentei com um milhão de documentos, sem sorte. Usá- Model.collection.insertlo demorou apenas alguns segundos.

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

• docs é a matriz de documentos a serem inseridos;
• optionsé um objeto de configuração opcional - veja a documentação
• callback(err, docs)será chamado depois que todos os documentos forem salvos ou ocorrer um erro. Em caso de sucesso, docs é a matriz de documentos persistentes.

Como o autor do Mongoose aponta aqui , este método irá ignorar qualquer procedimento de validação e acessar o driver Mongo diretamente. É uma troca que você tem que fazer, já que está lidando com uma grande quantidade de dados, caso contrário, você não seria capaz de inseri-los em seu banco de dados (lembre-se de que estamos falando de centenas de milhares de documentos aqui).

Um exemplo simples

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

Atualização 22/06/2019 : embora insert()ainda possa ser usado sem problemas, ele foi substituído por insertMany(). Os parâmetros são exatamente os mesmos, então você pode apenas usá-lo como um substituto drop-in e tudo deve funcionar bem (bem, o valor de retorno é um pouco diferente, mas provavelmente você não o está usando de qualquer maneira).

Referência

• Documentação Mongo
• Aaron Heckman nos Grupos do Google, discutindo inserções em massa

Mongoose 4.4.0 agora suporta inserção em massa

O Mongoose 4.4.0 apresenta a inserção --true-- bulk com o método model .insertMany(). É muito mais rápido do que fazer um loop .create()ou fornecer um array.

Uso:

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

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

Ou

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

Você pode rastreá-lo em:

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

Na verdade, você pode usar o método "criar" do Mongoose, ele pode conter uma série de documentos, veja este exemplo:

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

A função de retorno de chamada contém os documentos inseridos. Você nem sempre sabe quantos itens devem ser inseridos (comprimento de argumento fixo como acima) para que possa percorrê-los:

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

Atualização: uma solução melhor

Uma solução melhor seria usar em Candy.collection.insert()vez de Candy.create()- usado no exemplo acima - porque é mais rápido ( create()chama Model.save()cada item, então é mais lento).

Consulte a documentação do Mongo para obter mais informações: http://docs.mongodb.org/manual/reference/method/db.collection.insert/

(obrigado a arcseldon por apontar isso)

Você pode realizar a inserção em massa usando o shell mongoDB, inserindo os valores em uma matriz.

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

Você pode realizar a inserção em massa usando o mangusto, como a resposta de maior pontuação. Mas o exemplo não pode funcionar, deveria 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);
    }
}

Não use uma instância de esquema para a inserção em massa, você deve usar um objeto de mapa simples.

Aqui estão as duas maneiras de salvar dados com insertMany e salvar

1) Mongoose salvar matriz de documentos com insertManyem massa

/* 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 salvar matriz de documentos com .save()

Esses documentos serão salvos paralelamente.

/* 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 usando o mangusto há um limite de mais de 1000 documentos, ao usar

Potato.collection.insert(potatoBag, onInsert);

Você pode 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)
      });
});

Mas isso é quase duas vezes mais rápido ao testar com 10.000 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);
    });
}

Compartilhando código funcional e relevante de nosso projeto:

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