QueryCursor

Query.prototype.Symbol.asyncIterator()

Returns an asyncIterator for use with for/await/of loops. You do not need to call this function explicitly, the JavaScript runtime will call it for you.

Example

  1. // Works without using `cursor()`
  2. for await (const doc of Model.find([{ $sort: { name: 1 } }])) {
  3.   console.log(doc.name);
  4. }
  6. // Can also use `cursor()`
  7. for await (const doc of Model.find([{ $sort: { name: 1 } }]).cursor()) {
  8.   console.log(doc.name);
  9. }

Node.js 10.x supports async iterators natively without any flags. You can enable async iterators in Node.js 8.x using the --harmony_async_iteration flag.

Note: This function is not if Symbol.asyncIterator is undefined. If Symbol.asyncIterator is undefined, that means your Node.js version does not support async iterators.

QueryCursor()

Parameters
  • query «Query»
  • options «Object» query options passed to .find()
Inherits:
  • «Readable»

A QueryCursor is a concurrency primitive for processing query results one document at a time. A QueryCursor fulfills the Node.js streams3 API, in addition to several other mechanisms for loading documents from MongoDB one at a time.

QueryCursors execute the model’s pre find hooks before loading any documents from MongoDB, and the model’s post find hooks after loading each document.

Unless you’re an advanced user, do not instantiate this class directly. Use Query#cursor() instead.

QueryCursor.prototype.addCursorFlag()

Parameters
  • flag «String»
  • value «Boolean»
Returns:
  • «AggregationCursor» this

Adds a cursor flag. Useful for setting the noCursorTimeout and tailable flags.

QueryCursor.prototype.close()

Parameters
  • callback «Function»
Returns:
  • «Promise»

Marks this cursor as closed. Will stop streaming and subsequent calls to next() will error.

QueryCursor.prototype.eachAsync()

Parameters
  • fn «Function»

  • [options] «Object»

  • [options.parallel] «Number» the number of promises to execute in parallel. Defaults to 1.

  • [callback] «Function» executed when all docs have been processed

Returns:
  • «Promise»

Execute fn for every document in the cursor. If fn returns a promise, will wait for the promise to resolve before iterating on to the next one. Returns a promise that resolves when done.

Example

  1. // Iterate over documents asynchronously
  2. Thing.
  3.   find({ name: /^hello/ }).
  4.   cursor().
  5.   eachAsync(async function (doc, i) {
  6.     doc.foo = doc.bar + i;
  7.     await doc.save();
  8.   })

QueryCursor.prototype.map()

Parameters
  • fn «Function»
Returns:
  • «QueryCursor»

Registers a transform function which subsequently maps documents retrieved via the streams interface or .next()

Example

  1. // Map documents returned by `data` events
  2. Thing.
  3.   find({ name: /^hello/ }).
  4.   cursor().
  5.   map(function (doc) {
  6.    doc.foo = "bar";
  7.    return doc;
  8.   })
  9.   on('data', function(doc) { console.log(doc.foo); });
  11. // Or map documents returned by `.next()`
  12. const cursor = Thing.find({ name: /^hello/ }).
  13.   cursor().
  14.   map(function (doc) {
  15.     doc.foo = "bar";
  16.     return doc;
  17.   });
  18. cursor.next(function(error, doc) {
  19.   console.log(doc.foo);
  20. });

QueryCursor.prototype.next()

Parameters
  • callback «Function»
Returns:
  • «Promise»

Get the next document from this cursor. Will return null when there are no documents left.

function Object() { [native code] }.prototype.options

Type:
  • «property»

The options passed in to the QueryCursor constructor.