39

I am working on a project and I am unsure if there is a difference between the way the find cursor works and the way the findOne cursor works. Is findOne just a wrapper for find().limit(1)? I was looking around for it and maybe someone knows if mongodb has a special method for it or not. I am working with the PHP API for mongodb if that makes a difference.

Nick Chammas
  • 14,670
  • 17
  • 75
  • 121
WojonsTech
  • 652
  • 1
  • 5
  • 11

4 Answers4

37

Based on my own benchmarks, find().limit(1) is orders of magnitude faster than findOne().

There is either an error in the MongoDB documentation or a bug in findOne(). findOne() performs more like find().limit(N) where N is the number of documents the query would return. I figured this out while trying to figure out why my simple queries were so slow!

update: response from a 10gen (MongoDB) engineer:

The two queries you are executing are very different. A find query returns a cursor, this is essentially a no-operation scenario, as no actual data is returned (only the cursor information). If you call findOne, then you are actually returning the data and closing the cursor. The docs should definitely be clearer :-)

Update: Indeed, if the find().limit(1) document is retrieved, the orders of magnitude speed difference seems to disappear. Also, I could not reproduce the major speed difference with the MongoDB JavaScript driver. I originally benchmarked using the MongoDB Java driver.

Leftium
  • 769
  • 1
  • 7
  • 13
  • 1
    Great find. Important question, though: Do your benchmarks account for the extra operations you'd have to do with find().limit(1) in the course of normal programming (like actually retrieving the data and closing the cursor) that findOne() automatically does for you anyway? – Nick Chammas Nov 04 '11 at 06:07
  • @Nick: I think extra operations were covered. I was finding a random document (http://cookbook.mongodb.org/patterns/random-attribute/), getting the document with .next() and removing it from the collection. I didn't manually close any cursors... – Leftium Nov 04 '11 at 06:41
  • @Leftium then i must ask is it faster to do a find.limit(1) and then get the cursur value or is it faster to do a findone() – WojonsTech Nov 06 '11 at 09:30
  • 2
    @WojonsTech: a quick benchmark in JS shows findOne() is actually faster. Results may vary by driver/platform, though. For example, I could not reproduce the orders of magnitude speed difference in JS that I originally observed with the Java driver. – Leftium Nov 07 '11 at 05:24
  • 3
    Leftium, I would edit your answer to stress that when you actually retrieve the document (which you normally would), the two functions are actually identical, just as the documentation states. Right now someone will likely read the bolded line at the beginning of your answer and conclude that if they want to retrieve one document, findOne() is worse than find().limit(1), which is incorrect. – Nick Chammas Apr 18 '12 at 15:57
  • Is the information in this answer still relevant? – Austin Gayler Nov 23 '15 at 23:15
  • Also curious if this is still a performance tip still applicable today in 2017. Also - does this apply to Mongoose models? (ie: Model.find(q).limit(1) VS Model.findOne(q)) – chamberlainpi Aug 25 '17 at 12:42
  • 1
    @bigp This is not a valid performance tip, the two methods are identical when actually retrieving the document. – JohnnyHK Jan 15 '19 at 13:44
10

findOne() is indeed syntactic sugar for find().limit(1), given that you are actually retrieving the document (as opposed to just returning the cursor with find()).

See Leftium's answer and updates for more detail.

Community
  • 1
Nick Chammas
  • 14,670
  • 17
  • 75
  • 121
  • okay thank you i dont like using synimus functions in my programming would rather put limit one myself just so all my code is easy to track down. – WojonsTech Nov 03 '11 at 17:51
  • 1
    Actually in benchmarks findOne() a bit faster than find().limit(1). – Vladimir Apr 25 '12 at 09:21
  • @DairT'arg - If you have sources or data to back up this claim, by all means post an answer with the details! From what I've gathered so far, they should be identical as long as you are retrieving the document in both cases. – Nick Chammas Apr 25 '12 at 15:50
3

The source code may helps a lot.

It's java but I guess it can help, too.

The findOne(),

DBObject findOne(DBObject o, DBObject fields, DBObject orderBy, ReadPreference readPref,
                 long maxTime, TimeUnit maxTimeUnit) {

    QueryOpBuilder queryOpBuilder = new QueryOpBuilder().addQuery(o).addOrderBy(orderBy)
                                                        .addMaxTimeMS(MILLISECONDS.convert(maxTime, maxTimeUnit));

    if (getDB().getMongo().isMongosConnection()) {
        queryOpBuilder.addReadPreference(readPref);
    }

    Iterator<DBObject> i = find(queryOpBuilder.get(), fields, 0, -1, 0, getOptions(), readPref, getDecoder());

    DBObject obj = (i.hasNext() ? i.next() : null);
    if ( obj != null && ( fields != null && fields.keySet().size() > 0 ) ){
        obj.markAsPartialObject();
    }
    return obj;
}

And here is find()

public DBCursor find( DBObject ref ){
    return new DBCursor( this, ref, null, getReadPreference());
}

As we can see that findOne() calls find() in it self, gets all the DBOject in i and then return the first.

shellbye
  • 3,934
  • 1
  • 12
  • 6
-1

You must check this link ...

http://mongoosejs.com/docs/2.7.x/docs/finding-documents.html

  1. find - option return array []
  2. findOne - option return document {}
saturngalaxy
  • 1