How do we delete documents in a collection?

Question

Accepted Answer

The **`deleteOne()`** method removes the first document that matches a specified filter. This is ideal when you know you want to delete a specific document, perhaps identified by a unique field like `_id`. If multiple documents match the filter, `deleteOne()` will only delete the first match based on natural order, which is why it's best used with queries that target unique fields. ```javascript
// Delete a specific product by its unique ID
db.products.deleteOne(
  { _id: ObjectId("507f1f77bcf86cd799439011") }
)

// Delete the first document where inventory is zero
// (deletes only the first match, not all zero-inventory items)
db.products.deleteOne(
  { inventory: 0 }
)

// The method returns a result object with deletion statistics
const result = db.products.deleteOne({ sku: "ABC123" })
print(`Deleted ${result.deletedCount} document(s)`)
```

`deleteOne()` returns a document containing the operation status and the count of documents deleted (which will be either 0 or 1). The **`deleteMany()`** method removes all documents that match a specified filter. This is useful for bulk operations like cleaning up old records, removing all documents belonging to a specific category, or implementing data retention policies. You can also pass an empty filter `{}` to delete all documents in a collection while preserving the collection itself and its indexes. ```javascript
// Delete all products with zero inventory
db.products.deleteMany(
  { inventory: 0 }
)

// Delete all user sessions older than 30 days
db.sessions.deleteMany(
  { lastActive: { $lt: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000) } }
)

// Delete all documents in the logs collection (but keep the collection)
db.logs.deleteMany({})

// Delete all products in a specific category
db.products.deleteMany(
  { category: "discontinued" }
)

// Check deletion count
const result = db.products.deleteMany({ status: "expired" })
print(`Removed ${result.deletedCount} expired products`)
``` The **`drop()`** method removes an entire collection, including all its documents, indexes, and metadata. This is a more drastic operation than `deleteMany({})` because it completely eliminates the collection structure itself. You would typically use this when you no longer need the collection or want to recreate it with different configuration options. ```javascript
// Completely remove the temporary_logs collection and all its data
db.temporary_logs.drop()

// The method returns true if the collection was dropped successfully
if (db.temporary_logs.drop()) {
  print("Collection successfully dropped")
} else {
  print("Collection did not exist or could not be dropped")
}
```

Unlike `deleteMany({})`, which only removes documents, `drop()` eliminates the entire collection structure and would require recreating it with indexes if needed again. Before executing a delete operation, especially a large one, it's often wise to preview which documents will be affected. You can use the same filter with `find()` to verify your criteria before running the actual deletion. ```javascript
// First, preview which documents will be deleted
const documentsToDelete = db.products.find({ inventory: 0 })
console.log(`Found ${documentsToDelete.count()} products with zero inventory`)

// After verification, perform the deletion
db.products.deleteMany({ inventory: 0 })
```

This two-step approach helps prevent accidental data loss by letting you verify the filter logic first. **Irreversible operations:** Delete operations are permanent and cannot be undone. Always ensure you have proper backups before performing large deletions, especially in production environments. **Performance impact:** Deleting many documents can affect database performance. For large-scale deletions, consider batch operations or scheduled maintenance windows. **Index overhead:** Deleting documents removes them from indexes, which can temporarily impact query performance until indexes are rebalanced. **Write concerns:** For critical data, consider using write concern options to ensure deletions are acknowledged by replica sets. **Transactions:** For operations requiring atomicity across multiple documents or collections, use transactions to ensure all deletions succeed or fail together. **Validation:** Always test your delete filters in a staging environment before running them in production.

How do we delete documents in a collection?

MongoDB provides three primary methods for deleting documents: deleteOne() to remove a single document, deleteMany() to remove multiple documents matching a filter, and drop() to remove an entire collection

How do we delete documents in a collection?

MongoDB provides three primary methods for deleting documents: deleteOne() to remove a single document, deleteMany() to remove multiple documents matching a filter, and drop() to remove an entire collection

Scenario Questions

Follow-up Questions