咨询：如何用Mongoid Ruby批量删除MongoDB中600万条旧文档

Absolutely, Mongoid supports efficient bulk deletion—perfect for your use case of removing 6 million+ old documents. Let’s break down the two main approaches, including one that mirrors the bulk_insert workflow you already use:

1. The Simplest (and Most Efficient) Method: delete_all #

For straightforward bulk deletes where you don’t need to trigger model callbacks or load documents into memory, use Mongoid’s delete_all method. This translates directly to MongoDB’s deleteMany command under the hood—just like your bulk insert, it sends a single command to the database, making it lightning fast even for millions of records.

Here’s how to implement it for your scenario:

# Assuming your model is named MyModel
yesterday_start = Time.current.yesterday.beginning_of_day
MyModel.where(created_at: { "$lt" => yesterday_start }).delete_all

Key Notes: #

• Avoid destroy_all at all costs: Unlike delete_all, destroy_all loads every matching document into memory and runs callbacks (like before_destroy). For 6 million records, this would cause massive memory bloat and take hours to complete.
• Verify your filter first: Run a count query to confirm you’re targeting the right documents before deleting:

  MyModel.where(created_at: { "$lt" => yesterday_start }).count
  

• Index matters: Make sure you have an index on created_at—this will drastically speed up the filter check and deletion process.

2. Manual Bulk Operations (Mirroring bulk_insert) #

If you need more control (e.g., combining deletes with other bulk operations like updates), you can use the underlying MongoDB Ruby Driver’s bulk_write API—just like how you use collection.insert for bulk inserts.

Here’s how to structure a bulk delete with this method:

# Get the raw collection object (same as your bulk_insert approach)
collection = MyModel.collection

# Define your bulk delete operation
bulk_operations = [
  {
    delete_many: {
      filter: { created_at: { "$lt" => Time.current.yesterday.beginning_of_day } }
    }
  }
]

# Execute the bulk operation
collection.bulk_write(bulk_operations, ordered: false)

What ordered: false does: #

This tells MongoDB to process operations in parallel (instead of sequentially). For a single delete operation, it won’t make a huge difference, but it’s useful if you’re adding multiple bulk actions later.

Final Tips for Large Deletes #

• If you’re worried about locking up your collection during the delete, you can split the operation into smaller batches (e.g., delete documents week by week instead of all at once).
• Ensure your MongoDB server has enough resources (CPU, RAM) to handle the operation—though deleteMany is optimized to be resource-efficient.

内容的提问来源于stack exchange，提问作者abhishek