What is a Cursor in MongoDB?
I am by no mean a mongodb expert but I just want to add some observations from working in a medium sized mongo system for the last year. Also thanks to @xameeramir for the excellent walkthough about how cursors work in general.
The causes of a "cursor lost" exception may be several. One that I have noticed is explained in this answer.
The cursor lives server side. It is not distributed over a replica set but exists on the instance that is primary at the time of creation. This means that if another instance takes over as primary the cursor will be lost to the client. If the old primary is still up and around it may still be there but for no use. I guess it is garbaged collected away after a while. So if your mongo replica set is unstable or you have a shaky network in front of it you are out of luck when doing any long running queries.
If the full content of what the cursor wants to return does not fit in memory on the server the query may be very slow. RAM on your servers needs to be larger than the largest query you run.
All this can partly be avoided by designing better. For a use case with large long running queries you may be better of with several smaller database collections instead of a big one.
The collection's find
method returns a cursor - this points to the set of documents (called as result set) that are matched to the query filter. The result set is the actual documents that are returned by the query, but this is on the database server.
To the client program, for example the mongo
shell, you get a cursor. You can think the cursor is like an API or a program to work with the result set. The cursor has many methods which can be run to perform some actions on the result set. Some of the methods affect the result set data and some provide the status or info about the result set.
As the cursor maintains information about the result set, some information can change as you use the result set data by applying other cursor methods. You use these methods and information to suit your application, i.e., how and what you want to do with the queried data.
Working on the result set using the cursor and some of its commonly used methods and features from mongo
shell:
The count()
method returns the count of the number of documents in the result set, initially - as the result of the query. It is always constant at any point in the life of the cursor. This is information. This information remains same even after the cursor is closed or exhausted.
As you read documents from the result set, the result set gets exhausted. Once completely exhausted you cannot read any more. The hasNext()
tells if there are any documents available to be read - returns a boolean true or false. The next()
returns a document if available (you first check with hasNext
, and then do a next
). These two methods are commonly used to iterate over the result set data. Another iteration method is the forEach()
.
The data is retrieved from the server in batches - which has a default size. With the first batch you read the documents and when all it's documents are read, the following next()
method retrieves the next batch of documents, etc., until all documents are read from the result set. This batch size can be configured and you can also get its status.
If you apply the toArray()
method on the cursor, then all the remaining documents in the result set are loaded into the memory of your client computer and are available as a JavaScript array. And, the result set data is exhausted. The following hasNext
method will return false
, and the next
will throw an error (once you exhaust the cursor, you cannot read data from it). This method loads all the result set data into your client's memory (the array). This can be memory consuming in case of large result sets.
The itcount()
returns the count of remaining documents in the result set and exhausts the cursor.
There are cursor methods like isClosed()
, isExhausted()
, size()
which give status information about the cursor and its underlying result set as you work with your data.
Those are the basic features of cursor and result set. There are many cursor methods, and you can try and see how they work and get a better understanding.
Reference:
- mongo shell's cursor methods
- Cursor behavior with Aggregate
method
(the collection's
aggregate
method also returns a cursor)
Example usage in mongo
shell:
Assume the test
collection has 200 documents (run the commands in the same sequence).
var cur = db.test.find( { } ).limit(25)
creates a result set with 25 documents only.- But,
cur.count()
will show 200, which is the actual count of documents by the query's filter. hasNext()
will returntrue
.next()
will return a document.itcount()
will return 24 (and exhausts the cursor).itcount()
again will return 0.cur.count()
will still show 200.
Here's a comparison between toArray()
and cursors after a find()
in the Node.js MongoDB driver. Common code:
var MongoClient = require('mongodb').MongoClient,
assert = require('assert');
MongoClient.connect('mongodb://localhost:27017/crunchbase', function (err, db) {
assert.equal(err, null);
console.log('Successfully connected to MongoDB.');
const query = { category_code: "biotech" };
// toArray() vs. cursor code goes here
});
Here's the toArray()
code that goes in the section above.
db.collection('companies').find(query).toArray(function (err, docs) {
assert.equal(err, null);
assert.notEqual(docs.length, 0);
docs.forEach(doc => {
console.log(`${doc.name} is a ${doc.category_code} company.`);
});
db.close();
});
Per the documentation,
The caller is responsible for making sure that there is enough memory to store the results.
Here's the cursor-based approach, using the cursor.forEach()
method:
const cursor = db.collection('companies').find(query);
cursor.forEach(
function (doc) {
console.log(`${doc.name} is a ${doc.category_code} company.`);
},
function (err) {
assert.equal(err, null);
return db.close();
}
);
});
With the forEach()
approach, instead of fetching all data in memory, we're streaming the data to our application. find()
creates a cursor immediately because it doesn't actually make a request to the database until we try to use some of the documents it will provide. The point of cursor
is to describe our query. The second parameter to cursor.forEach
shows what to do when an error occurs.
In the initial version of the above code, it was toArray()
which forced the database call. It meant we needed ALL the documents and wanted them to be in an array
.
Note that MongoDB
returns data in batches. The image below shows requests from cursors (from application) to MongoDB
:
forEach
scales better than toArray
because we can process documents as they come in until we reach the end. Contrast it with toArray
- where we wait for ALL the documents to be retrieved and the entire array is built. This means we're not getting any advantage from the fact that the driver and the database system are working together to batch results to your application. Batching is meant to provide efficiency in terms of memory overhead and the execution time. Take advantage of it in your application, if you can.