Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/mongodb/mongodb-count-method-db-collection-count/ below:

MongoDB Count() Method - db.Collection.count()

Last Updated : 23 Jul, 2025

MongoDB's count() method is a powerful tool for retrieving the number of documents in a collection that match a specified query. It offers flexibility in filtering and is useful for obtaining quick counts based on various criteria.

In this article, We will explain the MongoDB count() method in detail, including its syntax, parameters, examples, and best practices. By the end of this article, we will have a deep understanding of how to use the count() method effectively for different use cases.

The count() method in MongoDB is a simple and effective way to count the number of documents that match a given query in a collection. It can take an optional query parameter to filter the documents before counting. It is functionally equivalent to db.collection.find().count() and is available in both db.collection and cursor objects.

• Counts documents based on a query condition (or all documents if no filter is applied).
• Can include optional parameters like limit, skip, and hint for more refined querie
• We cannot use this method in transactions.
• In sharded clusters, results may be inaccurate due to ongoing migrations. Use aggregate() instead for accurate results.
• To avoid this issue, it's recommended to use db.collection.aggregate() method instead.

The count() method can be used in two ways:

1. Count all documents in a collection:

db.Collection_Name.count()

2. Count documents that match a filter condition:

db.Collection_Name.count(
Selection_criteria,
{
    limit: <integer>,
    skip: <integer>,
    hint: <string or document>,
    maxTimeMS : <integer>,
    readConcern: <string>,
    collation: <document>  
})

Or if we want to count the number of documents in the collection

db.Collection_name.count()

• The first parameter is a document specifying the query condition to filter documents before counting.
• If omitted, count() will count all documents in the collection.

The second parameter is an optional document that allows fine-tuning of the counting process.

The count() method returns an integer representing the number of documents that match the selection criteria.

To demonstrate the count() method, we will use a sample MongoDB database named gfg with a collection called student. The collection contains multiple documents, each representing a student with name and age fields. Below is a sample dataset used for the examples:

• Database: gfg
• Collections: student
• Document: Four documents contains name and age of the students

This example demonstrates how to count the total number of documents present in the student collection.

Query:

db.student.count()

Output:

The above query retrieves the total number of documents stored in the student collection. Since no filter condition is applied, it counts all documents in the collection and returns the result as an integer.

This example demonstrates how to count documents in the student collection that meet a specific condition, such as age greater than 18.

Query:

db.student.count({age:{$gt:18}})

Output:

Explanation:

• $gt stands for "greater than" and is used to filter documents where the age field is greater than 18.
• The query first filters the students matching the condition and then counts the number of resulting documents.
• The output returns the total count of students satisfying the condition.

This example demonstrates how to limit the number of documents counted while skipping a specified number of documents in the student collection.

Query:

db.student.count({}, { skip: 1, limit: 2 })

Explanation:

• skip: 1 → Skips the first document in the collection.
• limit: 2 → Counts only the next two documents after skipping.
• This is useful when working with pagination or when counting a specific range of documents in large datasets.

• The count() method cannot be used within transactions in MongoDB.
• For reliable counting in transactional contexts, use the aggregate() method instead

• The count() method is deprecated in MongoDB 4.0+.
• It is recommended to use countDocuments(), which provides more accurate results in sharded clusters and distributed environments.

• Using the hint parameter allows MongoDB to leverage an index for faster count queries.
• This optimization reduces query execution time by directing MongoDB to use the most efficient index for filtering.

Example:

db.student.count({ age: { $gt: 18 } }, { hint: { age: 1 } })

• Here, MongoDB uses the index on the age field ({ age: 1 }) to perform an optimized count operation.
• This improves performance, especially on large datasets.

The count() method in MongoDB is a useful tool for quickly determining the number of documents that meet certain criteria. It can be used with various options to fine-tune the counting process, such as limiting the number of documents counted or specifying a maximum time for the operation to complete. However, with its deprecation in MongoDB 4.0+, it is best practice to use countDocuments() for more accurate and efficient results.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4