Delete Documents

# delete_one() — remove the first matching document

from pymongo import MongoClient

client = MongoClient("mongodb://localhost:27017/")
db     = client["dataplexa"]

# First check what we are about to delete
target = db.reviews.find_one({"_id": "r008"})
print("About to delete:", target)

# Delete the review
result = db.reviews.delete_one({"_id": "r008"})
print("Deleted count:", result.deleted_count)

# Confirm it is gone
gone = db.reviews.find_one({"_id": "r008"})
print("After delete:", gone)

# delete_one() with no match — returns 0, no error raised
result = db.reviews.delete_one({"_id": "r999"})
print("No match deleted_count:", result.deleted_count)

# delete_many() — remove all matching documents

from pymongo import MongoClient
from datetime import datetime, timezone

client = MongoClient("mongodb://localhost:27017/")
db     = client["dataplexa"]

# First — see what we are about to remove
cancelled = list(db.orders.find({"status": "cancelled"}, {"_id": 1, "status": 1}))
print("Cancelled orders to delete:", [o["_id"] for o in cancelled])

# Delete all cancelled orders
result = db.orders.delete_many({"status": "cancelled"})
print(f"Deleted {result.deleted_count} cancelled order(s)")

# Confirm the remaining orders
remaining = db.orders.count_documents({})
print("Remaining orders:", remaining)

# Delete products with zero stock
result = db.products.delete_many({"stock": {"$lte": 0}})
print(f"\nOut-of-stock products deleted: {result.deleted_count}")

# Remove all documents from a collection — pass empty filter
# CAUTION: this deletes everything — use drop() if you want to remove the collection too
result = db.user_sessions.delete_many({})
print(f"User sessions cleared: {result.deleted_count}")

# Safe delete pattern — verify before deleting

from pymongo import MongoClient

client = MongoClient("mongodb://localhost:27017/")
db     = client["dataplexa"]

def safe_delete_user(user_id: str) -> dict:
    """
    Delete a user only after confirming they exist.
    Returns a result dict with status and details.
    """
    # Step 1 — verify the target exists
    user = db.users.find_one({"_id": user_id})
    if not user:
        return {"status": "not_found", "deleted": False}

    # Step 2 — log what we are deleting (audit trail)
    print(f"Deleting user: {user['name']} ({user['email']})")

    # Step 3 — perform the delete
    result = db.users.delete_one({"_id": user_id})

    # Step 4 — confirm
    if result.deleted_count == 1:
        return {"status": "deleted", "deleted": True, "user": user["name"]}
    else:
        return {"status": "error", "deleted": False}

# Test the function
print(safe_delete_user("u006"))    # inserted in Lesson 11 — should succeed
print(safe_delete_user("u999"))    # does not exist

# find_one_and_delete() — atomic fetch then delete

from pymongo import MongoClient, ASCENDING

client = MongoClient("mongodb://localhost:27017/")
db     = client["dataplexa"]

# Simulate a job queue — pop the next pending order for processing
# In a real queue, multiple workers call this simultaneously — atomicity prevents double-processing

def pop_next_order(status="processing"):
    """
    Atomically fetch and remove the next order with the given status.
    Returns the order document or None if the queue is empty.
    """
    order = db.orders.find_one_and_delete(
        {"status": status},
        sort=[("date", ASCENDING)]        # process oldest first
    )
    return order

# Pop the next processing order
order = pop_next_order("processing")
if order:
    print(f"Processing order: {order['_id']}  user: {order['user_id']}  total: ${order['total']}")
else:
    print("No processing orders in queue")

# Confirm it was removed
count_after = db.orders.count_documents({"status": "processing"})
print(f"Remaining processing orders: {count_after}")

# Soft delete pattern — mark as deleted rather than remove

from pymongo import MongoClient
from datetime import datetime, timezone

client = MongoClient("mongodb://localhost:27017/")
db     = client["dataplexa"]

def soft_delete_review(review_id: str, deleted_by: str):
    """Mark a review as deleted without removing it from the database."""
    result = db.reviews.update_one(
        {"_id": review_id, "deleted": {"$exists": False}},  # not already deleted
        {"$set": {
            "deleted":    True,
            "deleted_at": datetime.now(timezone.utc),
            "deleted_by": deleted_by
        }}
    )
    return result.modified_count == 1

# Soft delete review r007
success = soft_delete_review("r007", deleted_by="admin")
print("Soft deleted:", success)

# Normal query — exclude soft-deleted documents
active_reviews = db.reviews.find(
    {"deleted": {"$exists": False}},    # only non-deleted reviews
    {"_id": 1, "product_id": 1, "rating": 1}
)
print("\nActive reviews:")
for r in active_reviews:
    print(f"  {r['_id']}  product: {r['product_id']}  rating: {r['rating']}")

# Admin query — include soft-deleted documents to see full history
all_reviews = db.reviews.find({}, {"_id": 1, "deleted": 1})
print("\nAll reviews including soft-deleted:")
for r in all_reviews:
    status = "deleted" if r.get("deleted") else "active"
    print(f"  {r['_id']} — {status}")

# drop() vs delete_many({}) — knowing when to use each

from pymongo import MongoClient

client = MongoClient("mongodb://localhost:27017/")
db     = client["dataplexa"]

comparison = {
    "delete_many({})": {
        "removes_documents": True,
        "removes_indexes":   False,     # indexes are preserved
        "removes_collection": False,
        "speed":             "Slower — deletes document by document",
        "use_when":          "You want to clear data but keep the collection structure and indexes"
    },
    "collection.drop()": {
        "removes_documents":  True,
        "removes_indexes":    True,     # indexes are removed
        "removes_collection": True,
        "speed":              "Instant — removes all data files in one step",
        "use_when":           "You want to completely destroy and recreate the collection"
    }
}

for method, details in comparison.items():
    print(f"\n{method}:")
    for k, v in details.items():
        print(f"  {k:25} {v}")

# Example: drop and recreate for test data reset
# db.test_collection.drop()
# All documents and indexes removed instantly