db.collection.count()¶

On this page

Definition
Behavior
Examples

Definition¶

db.collection.count(query, options)¶

Returns the count of documents that would match a find() query. The db.collection.count() method does not perform the find() operation but instead counts and returns the number of results that match a query.

Parameter	Type	Description
`query`	document	The query selection criteria.
`options`	document	Optional. Extra options for modifying the count.

The options document contains the following fields:

Field	Type	Description
`limit`	integer	Optional. The maximum number of documents to count.
`skip`	integer	Optional. The number of documents to skip before counting.
`hint`	string or document	Optional. An index name hint or specification for the query. New in version 2.6.
`maxTimeMS`	integer	Optional. The maximum amount of time to allow the query to run.
`readConcern`	string	Optional. Specifies the read concern. The default level is `"local"`. To use a read concern level of `"majority"`, you must use the WiredTiger storage engine and start the `mongod` instances with the --enableMajorityReadConcern command line option (or the `replication.enableMajorityReadConcern` setting if using a configuration file). Only replica sets using `protocol version 1` support `"majority"` read concern. Replica sets running protocol version 0 do not support `"majority"` read concern. To ensure that a single thread can read its own writes, use `"majority"` read concern and `"majority"` write concern against the primary of the replica set. To use a read concern level of `"majority"`, you must specify a nonempty `query` condition. New in version 3.2.

count() is equivalent to the db.collection.find(query).count() construct.

Behavior¶

Sharded Clusters¶

On a sharded cluster, db.collection.count() can result in an inaccurate count if orphaned documents exist or if a chunk migration is in progress.

To avoid these situations, on a sharded cluster, use the $group stage of the db.collection.aggregate() method to $sum the documents. For example, the following operation counts the documents in a collection:

db.collection.aggregate(
   [
      { $group: { _id: null, count: { $sum: 1 } } }
   ]
)

To get a count of documents that match a query condition, include the $match stage as well:

db.collection.aggregate(
   [
      { $match: <query condition> },
      { $group: { _id: null, count: { $sum: 1 } } }
   ]
)

See Perform a Count for an example.

Index Use¶

Consider a collection with the following index:

{ a: 1, b: 1 }

When performing a count, MongoDB can return the count using only the index if:

the query can use an index,
the query only contains conditions on the keys of the index, and
the query predicates access a single contiguous range of index keys.

For example, the following operations can return the count using only the index:

db.collection.find( { a: 5, b: 5 } ).count()
db.collection.find( { a: { $gt: 5 } } ).count()
db.collection.find( { a: 5, b: { $gt: 10 } } ).count()

If, however, the query can use an index but the query predicates do not access a single contiguous range of index keys or the query also contains conditions on fields outside the index, then in addition to using the index, MongoDB must also read the documents to return the count.

db.collection.find( { a: 5, b: { $in: [ 1, 2, 3 ] } } ).count()
db.collection.find( { a: { $gt: 5 }, b: 5 } ).count()
db.collection.find( { a: 5, b: 5, c: 5 } ).count()

In such cases, during the initial read of the documents, MongoDB pages the documents into memory such that subsequent calls of the same count operation will have better performance.

Unexpected Shutdown and Count¶

For MongoDB instances using the WiredTiger storage engine, after an unclean shutdown, statistics on size and count may off by up to 1000 documents as reported by collStats, dbStats, count. To restore the correct statistics for the collection, run validate on the collection.

Examples¶

Count all Documents in a Collection¶

To count the number of all documents in the orders collection, use the following operation:

db.orders.count()

This operation is equivalent to the following:

db.orders.find().count()

Count all Documents that Match a Query¶

Count the number of the documents in the orders collection with the field ord_dt greater than new Date('01/01/2012'):

db.orders.count( { ord_dt: { $gt: new Date('01/01/2012') } } )

The query is equivalent to the following:

db.orders.find( { ord_dt: { $gt: new Date('01/01/2012') } } ).count()

← db.collection.bulkWrite() db.collection.copyTo() →