Count() & Remove() Functions in MongoDB with Example

MongoDB Count() Function

The concept of aggregation is to carry out a computation on the results which are returned in a query. For example, suppose you wanted to know what is the count of documents in a collection as per the query fired, then MongoDB provides the count() function.

Example of MongoDB Count() Function

Let’s look at an example of this.

db.Employee.count()

Code Explanation:

• The above code executes the count function.

If the command is executed successfully, the following Output will be shown

Output:

The output clearly shows that 4 documents are there in the collection.

MongoDB Count with a Query Condition

The count() method is most useful when you pass a query condition, so it counts only the documents that match instead of the entire collection. This is helpful for reports, such as how many employees belong to a department or how many orders are still open.

The following example counts the employees whose Employeeid is greater than 2:

db.Employee.count({Employeeid:{$gt:2}})

Here is what happens:

• The query object {Employeeid:{$gt:2}} acts as a filter, using the $gt (greater than) operator.
• count() returns only the number of documents that satisfy the filter.
• The rest of the collection is ignored in the total.

In current MongoDB versions, countDocuments() is the recommended method for a conditional count, because it always returns an accurate result. The same query works with it:

db.Employee.countDocuments({Employeeid:{$gt:2}})

Both commands return a single number, which you can store in a variable or display directly. Adding a matching index on the queried field keeps conditional counts fast on large collections.

Performing Modifications

The other two classes of operations in MongoDB are the update and remove statements.

The update operations allow one to modify existing data, and the remove operations allow the deletion of data from a collection.

Remove() Function in MongoDB

In MongoDB, the db.collection.remove() method is used to remove documents from a collection. Either all of the documents can be removed from a collection or only those which matches a specific condition.

If you just issue the remove command, all of the documents will be removed from the collection.

Example of MongoDB Remove() Function

The following code example demonstrate how to remove a specific document from the collection.

db.Employee.remove({Employeeid:22})

Code Explanation:

• The above code use the remove function and specifies the criteria which in this case is to remove the documents which have the Employee id as 22.

If the command is executed successfully, the following Output will be shown

Output:

The output will show that 1 document was removed.

Remove All Documents vs a Single Document

The remove() method can delete every matching document or just one, depending on the arguments you pass. Understanding the difference prevents accidental data loss.

To remove every document in a collection, pass an empty condition:

db.Employee.remove({})

This deletes all documents but keeps the collection itself. To remove only documents that match a condition, pass a query object, as shown earlier with {Employeeid:22}. If several documents match and you want to delete only the first one, add the justOne option:

db.Employee.remove({EmployeeName:"Smith"}, {justOne:true})

The key differences are:

• remove({}) deletes all documents in the collection.
• remove({condition}) deletes every document that matches the condition.
• remove({condition}, {justOne:true}) deletes only the first matching document.

Always double-check the condition before running a remove command, because an empty or wrong filter can clear the whole collection. In modern MongoDB, deleteOne() and deleteMany() replace these patterns and make the intent clearer.

Modern Alternatives to count() and remove()

Both count() and remove() are legacy methods. Newer MongoDB drivers mark them as deprecated and provide clearer replacements. The table below maps each old method to its modern equivalent:

For new applications, prefer these modern methods. They separate counting from estimating and deleting one document from deleting many, which makes queries safer and easier to read. The legacy count() and remove() still work for older tutorials and scripts.

FAQs