Question

我连接到该集合，然后开始对集合进行查询以查找具有此查询的所有文档。但是当我记录结果时，我得到一个Readable对象，我假设它是一个流。我在它上面使用了一些流方法，但它只返回一个文档。我不确定为什么它不会返回json。

const path = require('path'),
      User = require(path.join(__dirname, '../models/user.js')),
      Card = require(path.join(__dirname, '../models/card.js')),
      mongoose = require('mongoose');

module.exports = {

  get: (req, res) => {
    const foo = mongoose.connection.db.collection('foo');

      Card.find({ _id: {$in: req.user.cards } },
            { name: 1,
              bank: 1 }).exec(function(err, cards) {

        if (err) throw err;


        // Problem: does not return documents or error
        foo.find({ bank: 'chase'}, { name: 1, bank: 1, value: 1 }, function(err, bonus) {
          if (err) throw err;

          console.log(bonus);
        });


      });

  }

}

这是输出。我不认为我的查询正在执行，但我不知道从哪里开始。

Readable {
  pool: null,
  server: null,
  disconnectHandler: 
   { s: { storedOps: [], storeOptions: [Object], topology: [Object] },
     length: [Getter] },
  bson: {},
  ns: 'kard_development.kard_bonus',
  cmd: 
   { find: 'kard_development.kard_bonus',
     limit: 0,
     skip: 0,
     query: { bank: 'Chase' },
     slaveOk: false },
  options: 
   { skip: 0,
     limit: 0,
     raw: undefined,
     hint: null,
     timeout: undefined,
     slaveOk: false,
     db: 
      EventEmitter {
        domain: null,
        _events: [Object],
        _eventsCount: 6,
        _maxListeners: undefined,
        s: [Object],
        serverConfig: [Getter],
        bufferMaxEntries: [Getter],
        databaseName: [Getter],
        _listening: true },
     promiseLibrary: [Function: Promise],
     disconnectHandler: { s: [Object], length: [Getter] } },
  topology: 
   EventEmitter {
     domain: null,
     _events: 
      { reconnect: [Function],
        timeout: [Object],
        error: [Object],
        close: [Function],
        destroy: [Object],
        serverDescriptionChanged: [Function],
        serverHeartbeatStarted: [Function],
        serverHeartbeatSucceeded: [Function],
        serverHearbeatFailed: [Function],
        serverOpening: [Function],
        serverClosed: [Function],
        topologyOpening: [Function],
        topologyClosed: [Function],
        topologyDescriptionChanged: [Function] },
     _eventsCount: 14,
     _maxListeners: undefined,
     s: 
      { options: [Object],
        callbacks: [Object],
        logger: [Object],
        state: 'connected',
        reconnect: true,
        reconnectTries: 30,
        reconnectInterval: 1000,
        emitError: true,
        currentReconnectRetry: 30,
        ismaster: [Object],
        readPreferenceStrategies: undefined,
        authProviders: [Object],
        id: 0,
        topologyId: -1,
        tag: undefined,
        disconnectHandler: [Object],
        monitoring: false,
        haInterval: 10000,
        wireProtocolHandler: [Object],
        Cursor: [Object],
        bsonInstance: {},
        inquireServerStateTimeout: null,
        bson: {},
        pool: [Object],
        isMasterLatencyMS: 8,
        inTopology: false,
        serverDetails: [Object],
        serverDescription: null,
        topologyDescription: null },
     hashedName: '1309e35791f04f1f4fc35d5e683e81d350dd04f4',
     name: [Getter],
     bson: [Getter],
     wireProtocolHandler: [Getter],
     id: [Getter] },
  cursorState: 
   { cursorId: null,
     cmd: 
      { find: 'kard_development.kard_bonus',
        limit: 0,
        skip: 0,
        query: [Object],
        slaveOk: false },
     documents: [],
     cursorIndex: 0,
     dead: false,
     killed: false,
     init: false,
     notified: false,
     limit: 0,
     skip: 0,
     batchSize: 1000,
     currentLimit: 0,
     transforms: undefined },
  callbacks: null,
  logger: { className: 'Cursor' },
  _readableState: 
   ReadableState {
     objectMode: true,
     highWaterMark: 16,
     buffer: [],
     length: 0,
     pipes: null,
     pipesCount: 0,
     flowing: null,
     ended: false,
     endEmitted: false,
     reading: false,
     sync: true,
     needReadable: false,
     emittedReadable: false,
     readableListening: false,
     resumeScheduled: false,
     defaultEncoding: 'utf8',
     ranOut: false,
     awaitDrain: 0,
     readingMore: false,
     decoder: null,
     encoding: null },
  readable: true,
  domain: 
   Domain {
     domain: null,
     _events: { error: [Function] },
     _eventsCount: 1,
     _maxListeners: undefined,
     members: [] },
  _events: {},
  _eventsCount: 0,
  _maxListeners: undefined,
  s: 
   { numberOfRetries: 5,
     tailableRetryInterval: 500,
     currentNumberOfRetries: 5,
     state: 0,
     streamOptions: {},
     bson: {},
     ns: 'kard_development.kard_bonus',
     cmd: 
      { find: 'kard_development.kard_bonus',
        limit: 0,
        skip: 0,
        query: [Object],
        slaveOk: false },
     options: 
      { skip: 0,
        limit: 0,
        raw: undefined,
        hint: null,
        timeout: undefined,
        slaveOk: false,
        db: [Object],
        promiseLibrary: [Function: Promise],
        disconnectHandler: [Object] },
     topology: 
      EventEmitter {
        domain: null,
        _events: [Object],
        _eventsCount: 14,
        _maxListeners: undefined,
        s: [Object],
        hashedName: '1309e35791f04f1f4fc35d5e683e81d350dd04f4',
        name: [Getter],
        bson: [Getter],
        wireProtocolHandler: [Getter],
        id: [Getter] },
     topologyOptions: 
      { socketOptions: {},
        auto_reconnect: true,
        host: 'localhost',
        port: 27017,
        cursorFactory: [Object],
        reconnect: true,
        emitError: true,
        size: 5,
        disconnectHandler: [Object],
        bson: {},
        messageHandler: [Function],
        wireProtocolHandler: [Object] },
     promiseLibrary: [Function: Promise],
     currentDoc: null },
  sortValue: undefined }

Answer 1

如果您正在使用Mongoose，它被称为MongoDB的ODM，如果您使用的是模型/模式，这很好，但对于集合上的简单查询有点奇怪。如果您查看Mongoose API http://mongoosejs.com/docs/api.html，则查找方法仅适用于模型和查询，这就是您的第一个查找有效的原因，您使用的是卡片模型。

但是，如果您想对您的收藏集进行查询，就像您在此行中一样：

var formatted = AmCharts.formatNumber(number, 
{
     precision: chart.precision,
     decimalSeparator: chart.decimalSeparator,
     thousandsSeparator: chart.thousandsSeparator
}, 2);

它不会很好用，因为mongoose连接对象没有.find（）方法。你可以做的一件事就是使用Node的原生MongoDB驱动程序，排除@dvlsg在评论中提到的内容，你可能会得到你想要的东西。

Mongoose不使用.find（）方法查询我的集合

1 个答案: