MongoDB Delete

PyMongo stellt zwei Methoden zum Entfernen von Dokumenten aus einer Collection bereit: delete_one() entfernt das erste passende Dokument, und delete_many() entfernt alle passenden Dokumente. Beide sind präzise, filtergesteuerte Operationen — Sie geben genau an, welche Dokumente Sie mit derselben Abfragesyntax wie bei find() ansprechen möchten.

Dieses Kapitel behandelt:

• delete_one() — ein einzelnes Dokument entfernen
• delete_many() — mehrere Dokumente entfernen (einschließlich aller Dokumente)
• Das DeleteResult-Objekt auslesen
• Filteroperatoren für präzise Löschvorgänge
• Fehlerbehandlung und sichere Vorgehensweisen
• Wann Dokumente gelöscht werden sollten gegenüber dem Löschen der gesamten Collection

Voraussetzungen: Python 3.8+, PyMongo installiert (pip install pymongo) und ein laufender MongoDB-Server. Siehe MongoDB Get Started für die Einrichtung und MongoDB Insert, um zu verstehen, wie Dokumente überhaupt in eine Collection gelangen.

Verbinden und eine Collection auswählen

Jede Löschoperation benötigt einen MongoClient, eine Datenbank und eine Collection:

import pymongo

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

Alle folgenden Beispiele gehen davon aus, dass col auf diese Weise definiert ist.

Ein Dokument mit delete_one() löschen

delete_one(filter) sucht das erste Dokument, das dem Filter entspricht, und löscht es. Wenn mehrere Dokumente übereinstimmen, wird nur eines entfernt (die natürliche Reihenfolge von MongoDB bestimmt, welches).

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

delete_one() löst keinen Fehler aus, wenn kein Dokument übereinstimmt — es gibt ein DeleteResult mit deleted_count = 0 zurück.

Übereinstimmung bei einem bestimmten Feldwert

# 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.")

Übereinstimmung bei einem verschachtelten Feld

Verwenden Sie Punktnotation, um Felder in eingebetteten Dokumenten anzusprechen:

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

Mehrere Dokumente mit delete_many() löschen

delete_many(filter) entfernt jedes Dokument, das dem Filter entspricht. Verwenden Sie diese Methode, wenn Sie eine Menge von Datensätzen in einem Aufruf bereinigen möchten.

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

Alle Dokumente einer Collection löschen

Übergeben Sie einen leeren Filter {}, um alle Dokumente zu entfernen. Die Collection selbst und ihre Indizes bleiben erhalten — nur die Dokumente werden entfernt:

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

Warnung: delete_many({}) auf einer Produktions-Collection ist unwiderruflich. Überprüfen Sie Ihren Filter immer sorgfältig und erstellen Sie ein Backup, bevor Sie Massenl öschungen durchführen. Wenn Sie die Collection vollständig entfernen möchten (Dokumente und Indizes), verwenden Sie col.drop() — siehe MongoDB Drop Collection.

Das DeleteResult-Objekt

Beide Methoden geben ein DeleteResult zurück. Die zwei Eigenschaften, die Sie am häufigsten verwenden werden, sind:

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

Filteroperatoren für präzise Löschvorgänge

Dieselben Abfrageoperatoren, die in find() verwendet werden, funktionieren auch in Löschfiltern.

Nach Vergleich löschen

# 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}})

Nach regulärem Ausdruck löschen

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

Nach Vorhandensein eines Feldes löschen

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

Nach Wert in einer Liste löschen

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

Fehlerbehandlung

Umschließen Sie Löschoperationen mit einem try/except-Block, um die zwei häufigsten Fehlerfälle zu behandeln:

• pymongo.errors.OperationFailure — der Server hat die Operation abgelehnt (z. B. fehlen dem verbundenen Benutzer remove-Rechte für die Collection).
• pymongo.errors.ConnectionFailure — die Netzwerkverbindung zu MongoDB wurde unterbrochen.

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}")

Praktisches Beispiel: Vollständiger Workflow

Dieses Beispiel befüllt eine Collection, führt gezielte Löschvorgänge durch und überprüft das Ergebnis:

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}]

Erwartete Ausgabe:

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

Dokumente löschen vs. Collection droppen

Diese beiden Operationen werden häufig verwechselt:

Wählen Sie delete_many({}), wenn Sie eine Collection leeren, aber ihre Indizes und Schema-Validatoren beibehalten möchten. Wählen Sie col.drop(), wenn Sie einen vollständig sauberen Ausgangszustand benötigen — beispielsweise zwischen Testläufen oder bei einer Schema-Migration. Siehe MongoDB Drop Collection für Details zu drop().

Zusammenfassung

• delete_one(filter) entfernt das erste passende Dokument; delete_many(filter) entfernt alle passenden Dokumente.
• Beide geben ein DeleteResult zurück — überprüfen Sie deleted_count, um zu bestätigen, was entfernt wurde.
• Ein leerer Filter {} in delete_many() entfernt alle Dokumente aus der Collection.
• Verwenden Sie MongoDB-Abfrageoperatoren ($regex, $lt, $in, $exists, …), um präzise Filter zu erstellen.
• Umschließen Sie Operationen mit try/except, um OperationFailure und ConnectionFailure zu behandeln.
• Um die Collection selbst zu entfernen, verwenden Sie stattdessen col.drop().

Verwandte Kapitel:

• MongoDB Insert — Dokumente einfügen mit insert_one() und insert_many()
• MongoDB Update — vorhandene Dokumente ändern mit update_one() und update_many()
• MongoDB Drop Collection — eine gesamte Collection einschließlich ihrer Indizes entfernen
• MongoDB Query — Filter mit Abfrageoperatoren erstellen
• MongoDB Get Started — PyMongo installieren und eine Verbindung zu MongoDB herstellen