向mongodb里插入10万条记录的代码怎么写？

居然把这坟贴给挖出来，mongodb2.4.0之后，batchInsert这个Api就废弃了，现在直接用insert就能实现批量插入！

mark

@district10 你这个测试不准确的，要把timeend放在回调函数里

@tulayang @xadillax @chemdemo @alsotang
当时测试的时候肯定知道插1次和插1万次的区别，但是insertmany方法和insert方法都会报错，而一条条插入是不会报错的，所以就写了这个示例代码

综上，batchinsert是正确的解决方案，insertmany等其他都不行~

@haozxuan batchinsert是正解，insertmany，insert数组都会报错

bulk.execute();
console.timeEnd('insert,10w');
process.exit(1);

@district10 这三步都是异步的吧！估计数据没保存好，就打印时间和退出了吧！

insert,10w: 5746ms(one by one) v.s. insert,10w: 961ms(bulk insert)

var MongoClient = require('mongodb').MongoClient;
var url = 'mongodb://127.0.0.1:27017/testdb';
console.time('insert,10w');
MongoClient.connect(url, {
    server: {
        poolSize: 50
    }
}, function(err, db) {
    var col = db.collection('test2');
    var bulk = col.initializeUnorderedBulkOp();
    for(var i = 0; i < 100000; i++){
        bulk.insert({
            count: i
        });
    }
    bulk.execute();
    console.timeEnd('insert,10w');
    process.exit(1);
});

@alsotang 想错了...失误失误...囧

@luoyjx 呃。。。又不是说包个函数函数立即调用就是异步了。。

偶然在nodeclub里看到的通过循环查询评论的作者信息的for循环，这应该算是异步的？@alsotang，这样插入10W条记录，虽然不能保证顺序，但是会不会稍微快点？

for (var j = 0; j < 100000; j++) {
      (function () {
        //do someting
      })();
    }

知道总共有10W条了竟然还一条条插入。。

网络传输一次和网络传输 10w 次能比的？

我居然看完了

ｐｙｔｈｏｎ使用了一次插入１０Ｗ行数据，ｎｏｄｅｊｓ使用了１０ｗ次插入一行数据，能不慢吗？？？他俩在数据库操作上，都是要直达系统调用，不可能存在性能差距。

@wmzy 我也在找，目前还没有找到相应的解决方案，你可以尝试用下mongodb的1.X驱动，他仅仅限制16M，没有限制条数。

@haozxuan 请教insertMany为什么限制只允许同时批量插入1000条？这个限制可以修改吗？

@DoubleSpout

var MongoClient = require('mongodb').MongoClient;
var url = 'mongodb://127.0.0.1:27017/testdb';
var dataList = []
var globalCount = 0
console.time('insert,10w');
MongoClient.connect(url, {
  server: {
    poolSize: 50
  }
},function(err, db) {
  if(err) throw(err)

  var listData = []
  for(var i=0; i<100000; i++){
    listData.push({
      count:i
    })
  }
  db.collection('test1').insert(listData,function(err,results){
    if(err){
      console.log(err)
    }else{
      console.log(results)
    }
  });
  console.timeEnd('insert,10w');
});

我这边还要快，但是

{ [MongoError: exceeded maximum write batch size of 1000]
  name: 'MongoError',
  message: 'exceeded maximum write batch size of 1000' }
insert,10w: 413ms

报错了 貌似插不进去吧

这贴也能精华？？？这是把nodejs黑出翔了啊。看代码，不解释

@DoubleSpout 其实你还可以把循环push这个操作踢出去，因为这个也是耗的。 总结就是对于mongodb的写入，8000条插一个和插入8000是两个完全不同的概念，而且常规情况下也是前者，不可能会一条条插8000次的。 by the way：mongodb的2.X驱动对于insertMany做了条数限制，只允许同时批量插入1000条。http://mongodb.github.io/node-mongodb-native/2.0/meta/changes-from-1.0/

@struCoder 不放回调函数的插入操作不是safe操作，不会等待成功插入反馈，所以速度更快一点

@DoubleSpout
interesting
内部好像掉的bulkWrite, 他的第一个参数就是Array ：)

@DoubleSpout 刚刚稍微看了一下文档 现在我插入10W耗时1s
这个和上面我写的go的批处理一样，只不过比go逊色一点 ：)

var MongoClient = require('mongodb').MongoClient;
var url = 'mongodb://127.0.0.1:27017/testdb';
MongoClient.connect(url, function(err, db) {
  if (err) throw (err)

  var col = db.collection("test1");
  var batch = col.initializeUnorderedBulkOp({
    useLegacyOps: true
  });
  console.time('insert,10w');
  for (var i = 0; i < 100000; i++) {
    batch.insert({
      count: i
    });
  }
  batch.execute(function(err) {
    if (err) {
      console.log(err)
    }
    console.timeEnd('insert,10w');
  })
});

@struCoder 确实是这样的，我刚才也试了下python，差距很大，不过Node.js要怎么写代码？

@DoubleSpout 这个不清楚，我刚刚用go分别测了一下 单位(毫秒) 第一个就是直接的insert. 第二个采用批处理 测试结果:

第一种

第二种

package main

import "fmt"
import "time"
import "gopkg.in/mgo.v2"

type Count struct {
  I int
}

func main() {
  session, err := mgo.Dial("127.0.0.1:27017")
  if err != nil {
  	fmt.Print(err)
  }
  defer session.Close()

  b := session.DB("testdb").C("test1").Bulk() // 第二种
  // c := session.DB("testdb").C("test1") //第一种
  start := time.Now()
  for i := 0; i < 100000; i++ {
  	b.Insert(&Count{i}) //第二种
  	//c.Insert(&Count{i}) //第一种
  }
  b.Run()// 第二种
  duration := time.Since(start)
  fmt.Printf("insert 10w: %v", duration.Seconds()*1e6/float64(1000))
}

差距还是很大的， 都不是一个级别的，对于数据量大的插入也应该有相应的处理，python那个mongo包估计就 做了处理，而node中可能也有。具体的API我没看，这里依据go中的API进行仅仅的猜测。

@DoubleSpout 那就有可能是代码本身的效率问题，尤其在C与javascript交互的那个界面上，是效率热点。

我现在越来越怀疑node.js的设计哲学有问题了，callback被滥用，也用烂了。

@coordcn 都是插入本地的数据库，网络通讯的时间可以忽略了~机器配置不同测试结果是有差异的

@wuxiaoqian88 异步事件的回调是在当前代码运行结束后

@wuxiaoqian88 不是的，都是循环插入，我之前也跟你一样的想法，后来我看了pymongo的源码，发现也是把list循环起来插入的，和Node.js操作一样，另外Node.js还支持一个insertMany，是支持批量插入，几千条数据少没问题，一旦到几万就报错了。

pymongo 源码，其中docs就是用户插入的list

...
if manipulate:
        def gen():
            db = self.__database
            for doc in docs:
                # Apply user-configured SON manipulators. This order of
                # operations is required for backwards compatibility,
                # see PYTHON-709.
                doc = db._apply_incoming_manipulators(doc, self)
                if '_id' not in doc:
                    doc['_id'] = ObjectId()

                doc = db._apply_incoming_copying_manipulators(doc, self)
                ids.append(doc['_id'])
                yield doc
...

不过刚才试了下，python每次循环操作插入和一次性插入，差距还是挺大的，估计是pymongo底层库做掉了这部分事情，要研究下源码了

@struCoder 同样是插入本地数据库，同样的机器，python竟然比Node.js快几倍，我也是醉了，难道是链接库的问题？

我也用Meteor试了一下，结果不忍直视：

if (Meteor.isServer) {
  Meteor.startup(function() {
    // code to run on server at startup

  });
  Meteor.methods({
    'insert': function() {
      console.time('insert 10w');
      for (var i = 0; i < 100000; i++) {
        Test.insert({
          count: i
        });
      }
      console.timeEnd('insert 10w');
      process.exit(1);
    }
  });
}

@struCoder 你代码是同步的，这样的时间不准确了。

估计是循环部分的batch优化问题造成的差异，毕竟网络通讯还要时间的，我是猜测的，没代码支撑，胡乱讲的。

你这两个 ， nodejs插入10W次； python只插入了一次， 这能比？

我也测了一下，我这平均在4400左右.

确实很吓人：

var MongoClient = require('mongodb').MongoClient;
var url = 'mongodb://127.0.0.1:27017/testdb';
MongoClient.connect(url, function(err, db) {
  console.time('insert,10w');
  if (err) throw (err)
    var _collection = db.collection('test1');
  for (var i = 0; i < 100000; i++) {
    _collection.insert({
      count: i
    });
  }
  console.timeEnd('insert,10w');
  process.exit(1);
});