Why does .find() show fast MongoDB transaction times & slow node.js transaction times, and .findOne() shows the complete opposite?

user_13686241 0
Viewed 330

I recently stress-tested my express server with the following two queries:

db.collection.find(queryCondition).limit(1).toArray()

// and

db.collection.findOne(queryCondition)

THESE ARE THE NEW RELIC RESULTS

Can someone explain why .find() shows fast transaction times for MongoDB yet slow transaction times for node.js? Then, in complete contrast, .findOne() shows slow MongoDB times but fast node.js times?

For context, my express server is on a t2.micro instance and my database is on another t2.micro instance.

express node.js mongodb
1 Answers

Let's compare the the performance of .find() and .findOne() in nodejs and on the mongodb level.

MongoDb:

Here, find().limit() should emrge as a clear winner as it fetches the cursor to the result, which is a pointer to the result of the query, instead of the data itself, and that is precisely the case as per your observation.

Nodejs:

Here, theoretically, .find().limit() should also emerge faster, however, it seems that in the New Relic results screenshot that you've linked, you're actually doing .find().limit().toArray() which fetches you an array of data as per your query instead of just fetching the cursor, and findOne() just fetches you a document (in the form of a JS object in nodejs).

As per the mongodb driver docs for nodejs, .find() quickly returns a cursor and is, therefore, a synchronous operation that does not require a .then() or await, on the other hand, since .toArray() is a method of Cursor and fetches all the documents matching the query in an array (not unlike fetching the cursor and putting all the documents that .next() can fetch in an array yourself). This can be time-consuming depending on the query, and therefore, it returns a promise.

In your test, what seems to be happening is that with .findOne(), you're fetching just one document (which is time consuming on the MongoDb level and at least as time consuming in nodejs as well) but with find(), you're first fetching the cursor (fast on the mongodb level) then telling the nodejs driver to fetch the data from that cursor (time consuming), which is why .find().limit(1).toArray() is appearing to be perhaps more time consuming than findOne() in nodejs, and in the bottom graph in your link, the space is almost entirely blue, which represents nodejs.

I suggest you try simply doing .find().limit() and checking the result, but then heed that you won't be getting your actual data, just a cursor that's pretty useless until you fetch data from it.

I hope this has been of use.

user_67183530
Related