使用Mongoose模式导入CSV

Question

当前，我需要将一个大型CSV文件推送到mongo数据库中，并且值的顺序需要确定数据库条目的键：

CSV文件示例：

9,1557,358,286,Mutantville,4368,2358026,,M,0,0,0,1,0
9,1557,359,147,Wroogny,4853,2356061,,D,0,0,0,1,0

将其解析为数组的代码：

var fs = require("fs");

var csv = require("fast-csv");

fs.createReadStream("rank.txt")
    .pipe(csv())
    .on("data", function(data){
        console.log(data);
    })
    .on("end", function(data){
        console.log("Read Finished");
    });

代码输出：

[ '9',
  '1557',
  '358',
  '286',
  'Mutantville',
  '4368',
  '2358026',
  '',
  'M',
  '0',
  '0',
  '0',
  '1',
  '0' ]
[ '9',
  '1557',
  '359',
  '147',
  'Wroogny',
  '4853',
  '2356061',
  '',
  'D',
  '0',
  '0',
  '0',
  '1',
  '0' ]

如何将数组插入到Mongoose模式中以进入Mongo DB？

架构：

var mongoose = require("mongoose");


var rankSchema = new mongoose.Schema({
   serverid: Number,
   resetid: Number,
   rank: Number,
   number: Number,
   name: String,
   land: Number,
   networth: Number,
   tag: String,
   gov: String,
   gdi: Number,
   protection: Number,
   vacation: Number,
   alive: Number,
   deleted: Number
});

module.exports = mongoose.model("Rank", rankSchema);

数组的顺序需要与架构的顺序匹配，例如在数组中，第一个数字9始终需要保存，因为它们键为“ serverid”，依此类推。 我正在使用Node.JS

Answer 1

您可以使用fast-csv来实现，方法是从架构定义中获取headers ，该headers会将解析后的行作为“对象”返回。 您实际上有一些不匹配，因此我已将它们标记为更正：

const fs = require('mz/fs');
const csv = require('fast-csv');

const { Schema } = mongoose = require('mongoose');

const uri = 'mongodb://localhost/test';

mongoose.Promise = global.Promise;
mongoose.set('debug', true);

const rankSchema = new Schema({
  serverid: Number,
  resetid: Number,
  rank: Number,
  name: String,
  land: String,         // <-- You have this as Number but it's a string
  networth: Number,
  tag: String,
  stuff: String,        // the empty field in the csv
  gov: String,
  gdi: Number,
  protection: Number,
  vacation: Number,
  alive: Number,
  deleted: Number
});

const Rank = mongoose.model('Rank', rankSchema);

const log = data => console.log(JSON.stringify(data, undefined, 2));

(async function() {

  try {
    const conn = await mongoose.connect(uri);

    await Promise.all(Object.entries(conn.models).map(([k,m]) => m.remove()));

    let headers = Object.keys(Rank.schema.paths)
      .filter(k => ['_id','__v'].indexOf(k) === -1);

    console.log(headers);

    await new Promise((resolve,reject) => {

      let buffer = [],
          counter = 0;

      let stream = fs.createReadStream('input.csv')
        .pipe(csv({ headers }))
        .on("error", reject)
        .on("data", async doc => {
          stream.pause();
          buffer.push(doc);
          counter++;
          log(doc);
          try {
            if ( counter > 10000 ) {
              await Rank.insertMany(buffer);
              buffer = [];
              counter = 0;
            }
          } catch(e) {
            stream.destroy(e);
          }

          stream.resume();

        })
        .on("end", async () => {
          try {
            if ( counter > 0 ) {
              await Rank.insertMany(buffer);
              buffer = [];
              counter = 0;
              resolve();
            }
          } catch(e) {
            stream.destroy(e);
          }
        });

    });


  } catch(e) {
    console.error(e)
  } finally {
    process.exit()
  }


})()

只要该模式实际上与提供的CSV对齐，就可以了。 这些是我可以看到的更正，但是如果您需要将实际字段名称进行不同的对齐，则需要进行调整。 但是基本上在一个String的位置上有一个Number ，本质上是一个额外的字段，我想这是CSV中的空白字段。

一般的事情是从架构中获取字段名称数组，并在制作csv解析器实例时将其传递到选项中：

let headers = Object.keys(Rank.schema.paths)
  .filter(k => ['_id','__v'].indexOf(k) === -1);

let stream = fs.createReadStream('input.csv')
  .pipe(csv({ headers }))

实际执行此操作后，您将获得“对象”而不是数组：

{
  "serverid": "9",
  "resetid": "1557",
  "rank": "358",
  "name": "286",
  "land": "Mutantville",
  "networth": "4368",
  "tag": "2358026",
  "stuff": "",
  "gov": "M",
  "gdi": "0",
  "protection": "0",
  "vacation": "0",
  "alive": "1",
  "deleted": "0"
}

不要担心“类型”，因为Mongoose会根据模式强制转换值。

其余的发生在data事件的处理程序中。 为了获得最大效率，我们使用insertMany()每10,000行仅写入数据库一次。 它实际如何到达服务器和进程取决于MongoDB版本，但根据内存使用情况的“权衡”并编写一个单据，您将为单个集合导入的平均字段数应该是10,000，这是相当合理的。合理的网络请求。 如有必要，减小数字。

重要的部分是将这些调用标记为async函数，并在继续之前await insertMany()的结果。 另外，我们还需要在每个项目上分别pause() stream）和resume() ，否则冒着在实际发送文档之前覆盖要插入的文档buffer的风险。 必须使用pause()和resume()来在管道上施加“背压”，否则项目将保持“冒出来”并触发data事件。

自然地，对于10,000个条目的控件要求我们在每次迭代和流完成时都进行检查，以清空缓冲区并将所有剩余文档发送到服务器。

那确实是您要执行的操作，因为您当然不希望在通过data事件的“每次”迭代中触发发送到服务器的异步请求，或者根本不等待每个请求完成。 您无需检查“非常小的文件”就可以摆脱困境，但是对于任何实际负载，由于“正在进行中”的异步调用尚未完成，因此您肯定会超出调用堆栈。

---

仅供参考-使用的package.json 。 mz是可选的，因为它只是现代化的，支持Promise的标准节点“内置”库，我只是习惯使用它。 该代码当然可以与fs模块完全互换。

{
  "description": "",
  "main": "index.js",
  "dependencies": {
    "fast-csv": "^2.4.1",
    "mongoose": "^5.1.1",
    "mz": "^2.7.0"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
}

---

实际上，使用Node v8.9.x及更高版本，我们甚至可以通过stream-to-iterator模块使用AsyncIterator的实现来AsyncIterator过程。 它仍然处于Iterator<Promise<T>>模式，但是应该在Node v10.x变得稳定LTS之前起作用：

const fs = require('mz/fs');
const csv = require('fast-csv');
const streamToIterator = require('stream-to-iterator');

const { Schema } = mongoose = require('mongoose');

const uri = 'mongodb://localhost/test';

mongoose.Promise = global.Promise;
mongoose.set('debug', true);

const rankSchema = new Schema({
  serverid: Number,
  resetid: Number,
  rank: Number,
  name: String,
  land: String,
  networth: Number,
  tag: String,
  stuff: String,        // the empty field
  gov: String,
  gdi: Number,
  protection: Number,
  vacation: Number,
  alive: Number,
  deleted: Number
});

const Rank = mongoose.model('Rank', rankSchema);

const log = data => console.log(JSON.stringify(data, undefined, 2));

(async function() {

  try {
    const conn = await mongoose.connect(uri);

    await Promise.all(Object.entries(conn.models).map(([k,m]) => m.remove()));

    let headers = Object.keys(Rank.schema.paths)
      .filter(k => ['_id','__v'].indexOf(k) === -1);

    //console.log(headers);

    let stream = fs.createReadStream('input.csv')
      .pipe(csv({ headers }));

    const iterator = await streamToIterator(stream).init();

    let buffer = [],
        counter = 0;

    for ( let docPromise of iterator ) {
      let doc = await docPromise;
      buffer.push(doc);
      counter++;

      if ( counter > 10000 ) {
        await Rank.insertMany(buffer);
        buffer = [];
        counter = 0;
      }
    }

    if ( counter > 0 ) {
      await Rank.insertMany(buffer);
      buffer = [];
      counter = 0;
    }

  } catch(e) {
    console.error(e)
  } finally {
    process.exit()
  }

})()

基本上，所有流“事件”的处理，暂停和恢复都将替换为简单的for循环：

const iterator = await streamToIterator(stream).init();

for ( let docPromise of iterator ) {
  let doc = await docPromise;
  // ... The things in the loop
}

简单！ 当它变得更稳定时，将在for..await..of后面的节点实现中for..await..of进行清理。 但以上在指定版本及更高版本上运行良好。

Answer 2

通过说@Neil Lunn需要CSV本身内的标题行 。

使用csvtojson模块的示例。

const csv = require('csvtojson');

const csvArray = [];
  csv()
    .fromFile(file-path)
    .on('json', (jsonObj) => {
      csvArray.push({ name: jsonObj.name, id: jsonObj.id });
    })
    .on('done', (error) => {
      if (error) {
        return res.status(500).json({ error});
      }
          Model.create(csvArray)
      .then((result) => {
         return res.status(200).json({result});
      }).catch((err) => {
          return res.status(500).json({ error});
      });
      });
    });