Suppression MongoDB

PyMongo fournit deux méthodes pour supprimer des documents d'une collection : delete_one() supprime le premier document correspondant, et delete_many() supprime tous les documents correspondants. Les deux sont des opérations précises, pilotées par des filtres — vous indiquez exactement quels documents cibler en utilisant la même syntaxe de requête que find().

Ce chapitre couvre :

• delete_one() — supprimer un seul document
• delete_many() — supprimer plusieurs documents (y compris tous les documents)
• Lecture de l'objet DeleteResult
• Les opérateurs de filtre qui rendent les suppressions précises
• La gestion des erreurs et les bonnes pratiques de sécurité
• Quand supprimer des documents plutôt que de supprimer toute la collection

Prérequis : Python 3.8+, PyMongo installé (pip install pymongo) et un serveur MongoDB en cours d'exécution. Consultez MongoDB Get Started pour la configuration, et MongoDB Insert pour comprendre comment les documents sont insérés dans une collection.

Connexion et sélection d'une collection

Chaque opération de suppression nécessite un MongoClient, une base de données et une collection :

import pymongo

client = pymongo.MongoClient("mongodb://localhost:27017/")
db = client["mydatabase"]
col = db["customers"]

Tous les exemples ci-dessous supposent que col est défini de cette façon.

Suppression d'un document avec delete_one()

delete_one(filter) trouve le premier document correspondant au filtre et le supprime. Si plusieurs documents correspondent, un seul est supprimé (l'ordre naturel de MongoDB détermine lequel).

result = col.delete_one({"name": "Alice"})
print(result.deleted_count)  # 1 if a match was found, 0 if not

delete_one() ne lève jamais d'erreur lorsqu'aucun document ne correspond — elle renvoie un DeleteResult avec deleted_count = 0.

Correspondance sur une valeur de champ spécifique

# Delete the customer whose name is "Bob"
result = col.delete_one({"name": "Bob"})

if result.deleted_count == 1:
    print("Document deleted.")
else:
    print("No matching document found.")

Correspondance sur un champ imbriqué

Utilisez la notation pointée pour cibler des champs dans des documents imbriqués :

# Delete the first customer whose city is "London"
result = col.delete_one({"address.city": "London"})
print(result.deleted_count)  # 1 or 0

Suppression de plusieurs documents avec delete_many()

delete_many(filter) supprime tous les documents correspondant au filtre. Utilisez-la lorsque vous devez nettoyer un ensemble d'enregistrements en un seul appel.

# Delete all customers whose address starts with "S"
result = col.delete_many({"address": {"$regex": "^S"}})
print(result.deleted_count, "documents deleted")

Suppression de tous les documents d'une collection

Passez un filtre vide {} pour supprimer tous les documents. La collection elle-même et ses index restent — seuls les documents sont supprimés :

result = col.delete_many({})
print(result.deleted_count, "documents deleted")

Avertissement : delete_many({}) sur une collection de production est irréversible. Vérifiez toujours votre filtre et effectuez une sauvegarde avant d'exécuter des suppressions en masse. Si vous souhaitez supprimer entièrement la collection (documents et index), utilisez col.drop() — consultez MongoDB Drop Collection.

L'objet DeleteResult

Les deux méthodes retournent un DeleteResult. Les deux propriétés que vous utiliserez le plus souvent sont :

result = col.delete_many({"status": "inactive"})
print(f"Deleted: {result.deleted_count}")
print(f"Acknowledged: {result.acknowledged}")

Opérateurs de filtre pour des suppressions précises

Les mêmes opérateurs de requête utilisés dans find() fonctionnent dans les filtres de suppression.

Suppression par comparaison

# Delete all orders with a quantity less than 10
col.delete_many({"qty": {"$lt": 10}})

# Delete all orders with a quantity greater than or equal to 100
col.delete_many({"qty": {"$gte": 100}})

Suppression par expression régulière

# Delete all customers whose name starts with "A" (case-sensitive)
col.delete_many({"name": {"$regex": "^A"}})

Suppression par existence d'un champ

# Delete all documents that have no "email" field
col.delete_many({"email": {"$exists": False}})

Suppression par valeur dans une liste

# Delete all documents whose status is either "cancelled" or "expired"
col.delete_many({"status": {"$in": ["cancelled", "expired"]}})

Gestion des erreurs

Enveloppez les opérations de suppression dans un bloc try/except pour gérer les deux modes d'échec les plus courants :

• pymongo.errors.OperationFailure — le serveur a rejeté l'opération (par exemple, l'utilisateur connecté ne dispose pas des privilèges remove sur la collection).
• pymongo.errors.ConnectionFailure — la connexion réseau à MongoDB a été perdue.

import pymongo

client = pymongo.MongoClient("mongodb://localhost:27017/")
col = client["mydatabase"]["customers"]

try:
    result = col.delete_many({"status": "inactive"})
    print(f"{result.deleted_count} documents deleted.")
except pymongo.errors.OperationFailure as e:
    print(f"Server error: {e}")
except pymongo.errors.ConnectionFailure as e:
    print(f"Connection error: {e}")

Exemple pratique : flux complet

Cet exemple alimente une collection, exécute des suppressions ciblées et vérifie le résultat :

import pymongo

client = pymongo.MongoClient("mongodb://localhost:27017/")
col = client["mydatabase"]["customers"]

# 1. Start clean
col.drop()

# 2. Insert sample documents
col.insert_many([
    {"name": "Alice", "city": "Oslo",   "active": True},
    {"name": "Bob",   "city": "Sydney", "active": False},
    {"name": "Carol", "city": "Seattle","active": False},
    {"name": "Dave",  "city": "Sofia",  "active": True},
])
print("Inserted:", col.count_documents({}))  # 4

# 3. Delete the one inactive customer named "Bob"
r1 = col.delete_one({"name": "Bob", "active": False})
print("delete_one:", r1.deleted_count)  # 1

# 4. Delete all customers in cities that start with "S"
r2 = col.delete_many({"city": {"$regex": "^S"}})
print("delete_many (city ^S):", r2.deleted_count)  # 2 (Carol/Seattle, Dave/Sofia)

# 5. Check what remains
remaining = list(col.find({}, {"_id": 0}))
print("Remaining:", remaining)  # [{'name': 'Alice', 'city': 'Oslo', 'active': True}]

Résultat attendu :

Inserted: 4
delete_one: 1
delete_many (city ^S): 2
Remaining: [{'name': 'Alice', 'city': 'Oslo', 'active': True}]

Supprimer des documents vs. supprimer une collection

Ces deux opérations sont souvent confondues :

Choisissez delete_many({}) lorsque vous devez vider une collection mais conserver ses index et ses validateurs de schéma. Choisissez col.drop() lorsque vous souhaitez repartir de zéro — par exemple, entre des exécutions de tests ou lors d'une migration de schéma. Consultez MongoDB Drop Collection pour les détails sur drop().

Résumé

• delete_one(filter) supprime le premier document correspondant ; delete_many(filter) supprime tous les documents correspondants.
• Les deux retournent un DeleteResult — vérifiez deleted_count pour confirmer ce qui a été supprimé.
• Un filtre vide {} dans delete_many() supprime tous les documents de la collection.
• Utilisez les opérateurs de requête MongoDB ($regex, $lt, $in, $exists, …) pour construire des filtres précis.
• Enveloppez les opérations dans try/except pour gérer OperationFailure et ConnectionFailure.
• Pour supprimer la collection elle-même, utilisez col.drop() à la place.

Chapitres connexes :

• MongoDB Insert — insertion de documents avec insert_one() et insert_many()
• MongoDB Update — modification de documents existants avec update_one() et update_many()
• MongoDB Drop Collection — suppression d'une collection entière incluant ses index
• MongoDB Query — construction de filtres avec des opérateurs de requête
• MongoDB Get Started — installation de PyMongo et connexion à MongoDB