我是node和mongoDB的新手.我正在使用nodeJS,express和mongoDB开发一个应用程序.我想从文件输入字段读取csv / xlsx文件,并使用mongoose将其存储在mongoDB中.我遇到了困难.我在前端使用 angularjs.谁能给我建议我应该通过什么程序？具体代码将是很有帮助的.

我使用busboy模块将文件存储在特定文件夹中.这是我的代码

在路线：

router.post('/fileupload',function (req,res) {
    var fstream;
    req.pipe(req.busboy);
    console.log(req.pipe);
    console.log(req.busboy);
    req.busboy.on('file',function (fieldname,file,filename) {
        console.log("Uploading: " + filename);
        fstream = fs.createWriteStream('./files/' + filename);
        file.pipe(fstream);
        fstream.on('close',function () {
            res.redirect('back');
        });
    });
});

和我的前端：

<form method="post" action="/fileupload" enctype="multipart/form-data">
    <input type="file" id="file" name="file">
    <button type="submit">Submit</button>
</form>

到目前为止没有错误.现在我只想将这些文件存储在数据库中.
接下来我该怎么办？

您可能需要了解在mongo中存储文件的基础.为什么文件存储在mongo中以及如何存储？

根据您的工作,您现在需要一个mongoose插件,将您上传的文件存储到mongo GridFS中. GridFS在这里： – http://docs.mongodb.org/manual/core/gridfs/.您可以使用任何兼容的驱动程序访问网格 – mongoose和mongoose插件gridfs-stream就是一个例子 – 见这里：https://www.npmjs.org/package/gridfs-stream

我用下面的文件将文件保存到gridfs中.

var express = require('express');
var formidable = require('formidable');
var mongoose = require('mongoose');
var grid = require('gridfs-stream');
var fs = require('fs');
var util = require('util');
var app = express();

app.post('/fileupload',res) {
    var form = new formidable.IncomingForm();
    form.uploadDir = __dirname + "/data";
    form.keepExtensions = true;
    form.parse(req,function(err,fields,files) {
        if (!err) {
          console.log('File uploaded : ' + files.file.path);
          grid.mongo = mongoose.mongo;
          var conn = mongoose.createConnection('..mongo connection string..');
          conn.once('open',function () {
          var gfs = grid(conn.db);
          var writestream = gfs.createWriteStream({
              filename: files.file.name
          });
          fs.createReadStream(files.file.path).pipe(writestream);
       });
     }        
   });
   form.on('end',function() {        
       res.send('Completed ..... go and check fs.files & fs.chunks in  mongodb');
   });

});

app.get('/',function(request,response){
    response.send(
        '<form method="post" action="/fileupload" enctype="multipart/form-data">'
        + '<input type="file" id="file" name="file">'
        + '<input type="submit" value="submit">'
        + '</form>'
        );    
});

app.listen(40000,function() {
    console.log('Express is listening on port 40000');
});

以上是关于如何在上传文件后继续进行的指南,它不是生产就绪的概念证明.请注意,我将busboy替换为强大的个人偏好.

继续前进是否有助于您？

SO1

是否有任何选项可以使用猫鼬执行批量提花？所以基本上有一个数组，并插入每个元素，如果它不存在或更新它，如果它存在？ (我正在使用海关_ids)

当我使用.insert MongoDB返回错误E11000的重复键(应该更新)。插入多个新文档工作正常：

var Users = self.db.collection('Users');

Users.insert(data,function(err){
            if (err) {
                callback(err);
            }
            else {
                callback(null);
            }
        });

使用.save返回错误，该参数必须是单个文档：

Users.save(data,function(err){
   ...
}

This answer建议没有这样的选项，但是它是具体的C#，也已经3年了。所以我想知道是否有任何选择使用猫鼬做这个？

谢谢！

不是在特定的“猫头鹰”，或至少尚未写作。 2.6版本中的MongoDB shell实际上使用了所有的一般帮助方法中的 “Bulk operations API”“引擎盖”。在实现中，它首先尝试这样做，如果检测到较旧版本的服务器，那么对旧版本的实现会有一个“后备”。

所有的“目前”的黑客方法都使用“遗留”实现或写入关注响应和基本的传统方法。但是，来自任何给定的mongoose模型的.collection访问器基本上可以从本身实现自己实现mongoose的底层“节点本机驱动程序”访问“收集对象”

var mongoose = require('mongoose'),Schema = mongoose.Schema;

 mongoose.connect('mongodb://localhost/test');

 var sampleSchema  = new Schema({},{ "strict": false });

 var Sample = mongoose.model( "Sample",sampleSchema,"sample" );

 mongoose.connection.on("open",function(err,conn) { 

    var bulk = Sample.collection.initializeOrderedBulkOp();
    var counter = 0;

    // representing a long loop
    for ( var x = 0; x < 100000; x++ ) {

        bulk.find(/* some search */).upsert().updateOne(
            /* update conditions */
        });
        counter++;

        if ( counter % 1000 == 0 )
            bulk.execute(function(err,result) {             
                bulk = Sample.collection.initializeOrderedBulkOp();
            });
    }

    if ( counter % 1000 != 0 )
        bulk.execute(function(err,result) {
           // maybe do something with result
        });

 });

主要捕获的是“mongoose方法”实际上意识到，连接可能实际上不会被创建，并且“排队”直到完成。您正在“挖掘”的本地驱动程序不会使这个区别。

所以你真的必须意识到连接是以某种方式或形式建立的。但是，只要你注意到你在做什么，你可以使用本机驱动程序。

我使用以下代码将数据插入 mongodb

router.post('/NewStory',function (req,res) {
var currentObject = { user: userId,story : story,_id:new ObjectID().toHexString() };
        req.db.get('clnTemple').findAndModify({
            query: { _id: req.body.postId },update: { $addToSet: { Stories: currentObject } },upsert: true
        });
});

如果我删除_id：new ObjectID().toHexString(),此代码工作正常

我想在这里实现的是,对于每个新故事,我都希望将一个独特的_id对象附加到它上面

我究竟做错了什么？

{
    "_id": {
        "$oid": "55ae24016fb73f6ac7c2d640"
    },"Name": "some name",...... some other details
    "Stories": [
        {
            "userId": "105304831528398207103","story": "some story"
        },{
            "userId": "105304831528398207103","story": "some story"
        }
    ]
}

这是文档模型,我试图创建的_id是故事

您不应该在此处调用.toHexString(),因为您将获得“字符串”而不是ObjectID.字符串占用的空间比ObjectId的字节多.

var async = require('async'),mongo = require('mongodb'),db = require('monk')('localhost/test'),ObjectID = mongo.ObjectID;


var coll = db.get('junk');

var obj = { "_id": new ObjectID(),"name": "Bill" };

coll.findAndModify(
  { "_id": new ObjectID() },{ "$addToSet": { "stories": obj } },{
    "upsert": true,"new": true
  },function(err,doc) {
    if (err) throw err;
    console.log(doc);
  }
)

这对我来说非常适合.注意那里的“新”选项,以便返回修改后的文档,而不是默认文档的原始形式.

{ _id: 55c04b5b52d0ec940694f819,stories: [ { _id: 55c04b5b52d0ec940694f818,name: 'Bill' } ] }

然而,这里有一个问题,那就是如果你使用$addToSet并为每个项目生成一个新的ObjectId,那么新的ObjectId会使一切都“独一无二”.所以你会继续在“集合”中添加内容.如果你想做的话,这也可能是$push.

因此,如果userId和故事组合已经使这个“独特”,那么这样做：

coll.findAndModify(
  { 
      "_id": docId,"stories": {
          "$not": { "$elemmatch": { "userId": userId,"story": story } }
      }
  },{ "$push": { 
     "stories": {
         "userId": userId,"story": story,"_id": new ObjectID()
     }
  }},{
    "new": true
  },doc) {
    if (err) throw err;
    console.log(doc);
  }
)

因此,测试数组中是否存在唯一元素,以及它们不存在的位置,然后将它们附加到数组中.还注意到,在与“upserts”混合时,你不能对数组元素进行“不等式匹配”.您对“upsert”文档的测试应该只在主要的“_id”值上.管理数组条目和文档“upserts”需要处于单独的更新操作中.不要尝试混合两者,否则你最终会在你不打算创建新文档时.

我有2个集合(data,MetaData)

数据模式是

{
_id: ......,name: ......,//not unique
mobile: ......,// unique or null
email: ......,// unique or null
uniqueId: ......,// unique or null
}

插入需要至少一个唯一数据

元数据架构是

{
_id: ......,dataId: ......,//refrence from _id of data collection
key: ......,value: ......
}

JSON数组来自客户端

[{
  name: "abc",mobile: 9999999999,mData: {
    c1: 123,c2: "xyz"
  }
},{
  name: "qwerty",email: 'qwerty@mail.com',c2: "zxc"
  }
}
......
]

我正在迭代数组并将它们中的每一个插入到MongoDB中.

let Bulk = Data.collection.initializeUnorderedBulkOp();
dataArr.forEach(function(item) {
  let data = service.generateData(item);
  // data.query: {mobile: ...,email: ...,uniqueId: ...}
  // if value exists then keys is also exists for mobile,email,uniqueId in query
  Bulk.find(data.query).upsert().updateOne(data.doc);
});
Bulk.execute((e,d) => {
  let MetaBulk = MetaData.collection.initializeOrderedBulkOp();
  let length = dataArr.length;
  dataArr.forEach(function(data) {
    Data.findOne(data.query).exec(function(err,data) {
      length--;      
      for(let key in data["mData"]) {
        let value = data["mData"][key] || "";
        let mData = service.generateMdata(key,value,data._id);
        MetaBulk.find(mData.query).upsert().updateOne(mData.doc);
      }
      if(length == 0) {
        MetaBulk.execute();
      }
    });
  });
});

我的解决方案现在工作正常但是它花了很多时间来迭代数据收集以查找MetaData集合的ID.

我需要一种将数据批量插入MongoDB而无需查询数据ID的方法.是否有任何选项可以在单个查询中使用mongoose对多个集合执行批量upsert.

您的方案的单个命令中没有多个集合更新.在您的情况下,如果您可以在父集合中包含元数据数组,则可以使用updateMany()使用单个命令插入数据. MongoDB还支持通过 db.collection.insertMany()批量插入.

db.data.insertMany( [{ name: "abc",mData: { c1: 123,c2: "xyz"} },{name: "qwerty",c2: "zxc" }}]);

你也可以使用db.collection.bulkWrite().