db.collection.count()¶

On this page

Definition
Behavior
Examples

Definition¶

db.collection.count(query, options)¶

mongo Shell Method

This page documents the mongo shell method, and does not refer to the MongoDB Node.js driver (or any other driver) method. For corresponding MongoDB driver API, refer to your specific MongoDB driver documentation instead.

Note

MongoDB drivers compatible with the 4.0 features deprecate their respective cursor and collection count() APIs in favor of new APIs for countDocuments() and estimatedDocumentCount(). For the specific API names for a given driver, see the driver documentation.

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

Important

Avoid using the db.collection.count() method without a query predicate since without the query predicate, the method returns results based on the collection’s metadata, which may result in an approximate count. In particular,
- On a sharded cluster, the resulting count will not correctly filter out orphaned documents.
- After an unclean shutdown, the count may be incorrect.
For counts based on collection metadata, see also collStats pipeline stage with the count option.

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.
`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 read concern level of `"majority"`, replica sets must use WiredTiger storage engine. You can disable read concern `"majority"` for a deployment with a three-member primary-secondary-arbiter (PSA) architecture; however, this has implications for change streams (in MongoDB 4.0 and earlier only) and transactions on sharded clusters. For more information, see Disable Read Concern Majority. 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.
`collation`	document	Optional. Specifies the collation to use for the operation. Collation allows users to specify language-specific rules for string comparison, such as rules for lettercase and accent marks. The collation option has the following syntax: copy collation: { locale: <string>, caseLevel: <boolean>, caseFirst: <string>, strength: <int>, numericOrdering: <boolean>, alternate: <string>, maxVariable: <string>, backwards: <boolean> } When specifying collation, the `locale` field is mandatory; all other collation fields are optional. For descriptions of the fields, see Collation Document. If the collation is unspecified but the collection has a default collation (see `db.createCollection()`), the operation uses the collation specified for the collection. If no collation is specified for the collection or for the operations, MongoDB uses the simple binary comparison used in prior versions for string comparisons. You cannot specify multiple collations for an operation. For example, you cannot specify different collations per field, or if performing a find with a sort, you cannot use one collation for the find and another for the sort. New in version 3.4.

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

Behavior¶

Count and Transactions¶

You cannot use count and shell helpers count() and db.collection.count() in transactions.

For details, see Transactions and Count Operations.

Sharded Clusters¶

On a sharded cluster, db.collection.count() without a query predicate 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 db.collection.aggregate() method:

You can use the $count stage to count the documents. For example, the following operation counts the documents in a collection:

copy

db.collection.aggregate( [
   { $count: "myCount" }
])

The $count stage is equivalent to the following $group + $project sequence:

copy

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

Index Use¶

Consider a collection with the following index:

copy

{ 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:

copy

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.

copy

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.

Accuracy after Unexpected Shutdown¶

After an unclean shutdown of a mongod using the Wired Tiger storage engine, count statistics reported by count() may be inaccurate.

The amount of drift depends on the number of insert, update, or delete operations performed between the last checkpoint and the unclean shutdown. Checkpoints usually occur every 60 seconds. However, mongod instances running with non-default --syncdelay settings may have more or less frequent checkpoints.

Run validate on each collection on the mongod to restore the correct statistics after an unclean shutdown.

Note

This loss of accuracy only applies to count() operations that do not include a query predicate.

Client Disconnection¶

Starting in MongoDB 4.2, if the client that issued the db.collection.count() disconnects before the operation completes, MongoDB marks the db.collection.count() for termination (i.e. killOp on the operation).

Examples¶

Count all Documents in a Collection¶

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

copy

db.orders.count()

This operation is equivalent to the following:

copy

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'):

copy

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

The query is equivalent to the following:

copy

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

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