Question

我希望使用NodeJS Driver使用MongoDB通过各种集合循环查询。对于此测试，我使用sample code from the 'findOne' docs在各种集合中插入了一堆文档：

  collection.insertMany([{a:1, b:1}, {a:2, b:2}, {a:3, b:3}], {w:1}, function(err, result) {
    test.equal(null, err);

同时创建各种集合（每个集合至少有一个先前插入的文档实例）：

测试
TEST1
TEST2
TEST3
TEST4
TEST6
test10

我想要的是收集我在数据库中的集合列表（在我的情况下为'test'）：

var MongoClient = require("mongodb").MongoClient,
  test = require("assert");
MongoClient.connect("mongodb://localhost:27017/test", function(err, db) {
  db.listCollections().toArray(function(err, items) {
    test.ok(items.length >= 1);
    console.log(items);
    db.close();
  });
});

然后会弹出前面提到的集合列表。到目前为止，一切都是正确的！我甚至可以遍历数组来获取集合的名称：

var MongoClient = require("mongodb").MongoClient,
  test = require("assert");
MongoClient.connect("mongodb://localhost:27017/test", function(err, db) {
  db.listCollections().toArray(function(err, items) {
    test.ok(items.length >= 1);
    items.forEach(c => {
      console.log(c.name);
    });
    db.close();
  });
});

那里再没有问题！但是当我在循环中尝试查询时：

var MongoClient = require("mongodb").MongoClient,
  test = require("assert");
MongoClient.connect("mongodb://localhost:27017/test", function(err, db) {
  db.listCollections().toArray(function(err, items) {
    test.ok(items.length >= 1);
    items.forEach(c => {
      var collection = db.collection(c.name);
      collection.findOne({ a: 2 }, { fields: { b: 1 } }, function(err, doc) {
        console.log(doc);
      });
    });
  });
  db.close();
});

我明白了：

null
null
null
null
null
null
null

尽管循环来获取集合似乎工作得很好：

var MongoClient = require("mongodb").MongoClient,
  test = require("assert");
MongoClient.connect("mongodb://localhost:27017/test", function(err, db) {
  db.listCollections().toArray(function(err, items) {
    test.ok(items.length >= 1);
    items.forEach(c => {
      var collection = db.collection(c.name);
      console.log(collection);
      });
    });
  db.close();
});

示例输出：

Collection {
  s: 
   { pkFactory: 
      { [Function: ObjectID]
        index: 10866728,
        createPk: [Function: createPk],
        createFromTime: [Function: createFromTime],
        createFromHexString: [Function: createFromHexString],
        isValid: [Function: isValid],
        ObjectID: [Circular],
        ObjectId: [Circular] },
     db: 
      Db {
        domain: null,
        _events: {},
        _eventsCount: 0,
        _maxListeners: undefined,
        s: [Object],
        serverConfig: [Getter],
        bufferMaxEntries: [Getter],
        databaseName: [Getter] },
     topology: 
      Server {
        domain: null,
        _events: [Object],
        _eventsCount: 8,
        _maxListeners: undefined,
        clientInfo: [Object],
        s: [Object] },
     dbName: 'test',
     options: 
      { promiseLibrary: [Function: Promise],
        readConcern: undefined,
        readPreference: [Object] },
     namespace: 'test.test2',
     readPreference: 
      ReadPreference {
        _type: 'ReadPreference',
        mode: 'primary',
        tags: undefined,
        options: undefined },
     slaveOk: true,
     serializeFunctions: undefined,
     raw: undefined,
     promoteLongs: undefined,
     promoteValues: undefined,
     promoteBuffers: undefined,
     internalHint: null,
     collectionHint: null,
     name: 'test2',
     promiseLibrary: [Function: Promise],
     readConcern: undefined } }

我猜测Collection结构是我的循环问题，但我不确定究竟发生了什么...... 这是每个集合的预期输出的示例：

{ _id: 5a13de85a55e615235f71528, b: 2 }

任何帮助将不胜感激！提前致谢！

Answer 1

javaScript中的ForEach循环是同步的，直到它不包含任何异步调用。在这种情况下，你不能在for循环中调用任何数据库调用。

相反，你可以使用一个名为async的库，它带有一些很棒的函数来处理这个问题，如下所示

var MongoClient = require("mongodb").MongoClient,
    test = require("assert"),
    async = require('async');
MongoClient.connect("mongodb://localhost:27017/test", function (err, db) {
db.listCollections().toArray(function (err, items) {
    test.ok(items.length >= 1);

    async.map(items, (each, callback) => {
        let collection = db.collection(each.name);
        collection.findOne({a: 2}, {fields: {b: 1}}, function (err, doc) {
            console.log(doc);
            callback();
        });
    }, (err) => {
        console.log("done");
    });
  });
  db.close();
});

Answer 2

虽然不是最好的语法，除了记录输出之外没用，但这对我有用：

var mongodb = require('mongodb');


mongodb.connect('mongodb://localhost:27017/test', function (err, db) {
    if (err) {
        throw err;
    }

    db.listCollections().toArray(function (err, cols) {
        if (err) {
            throw err;
        }

        cols.forEach(function (col) {
            db.collection(col.name).find({}, {}, 0, 1, function (err, docs) {
                if(err){
                    throw err;
                }
                console.log(col);
                docs.forEach(console.log);
            });
        });
    })
})

那么，也许查询条件与任何内容都不匹配？

此外，Promise更好：

const mongodb = require('mongodb');
const Promise = require('bluebird');

function getDb() {
    return Promise.resolve(mongodb.connect('mongodb://localhost:27017/test'));
}

function getCollections(db) {
    return Promise.resolve(db.listCollections().toArray());
}

function getDocs(db, col) {
    return Promise.resolve(db.collection(col.name).find({},{},0,1).toArray());
}

const data = {};
getDb()
.then((db) => {
    data.db = db;
    return getCollections(db);
}).then((cols) => {
    data.cols = cols;
    return Promise.map(cols, (col) => getDocs(data.db,col));
}).then((docs) => {
    console.log(docs);
})

NodeJS / Mongo：通过各种集合循环查询

2 个答案: