MongoDB集合近2天CURD操作计数查询及无时间字段解决方案

Hey there! Let's tackle how to count INSERT, UPDATE, and DELETE operations in a MongoDB collection over the last 2 days—we'll cover both scenarios where you have timestamp fields set up, and where you don't.

Scenario 1: Your Collection Has creationDate/updationDate/deletionDate Fields #

This is the ideal case since timestamp fields make tracking operations straightforward.

INSERT Operations (Count Newly Added Documents) #

To count documents inserted in the last 2 days, use the creationDate field (assuming it's set to the document's insertion time):

// Calculate the timestamp for 2 days ago
const twoDaysAgo = new Date(Date.now() - 2 * 24 * 60 * 60 * 1000);

// Count documents with creationDate >= twoDaysAgo
const insertCount = db.yourCollection.countDocuments({
  creationDate: { $gte: twoDaysAgo }
});
print(`Total INSERTs in last 2 days: ${insertCount}`);

Pro tip: Add an index on creationDate to speed up this query for large collections:

db.yourCollection.createIndex({ creationDate: 1 });

UPDATE Operations (Count Updated Documents) #

For updates, use the updationDate field (ensure this is updated every time the document is modified, e.g., using $currentDate in update queries):

const twoDaysAgo = new Date(Date.now() - 2 * 24 * 60 * 60 * 1000);

const updateCount = db.yourCollection.countDocuments({
  updationDate: { $gte: twoDaysAgo }
});
print(`Total UPDATEs in last 2 days: ${updateCount}`);

Note: If some documents are updated multiple times in the 2-day window, this counts each unique document once (not each update operation). If you need to count individual update operations instead of unique documents, you'll need to use the oplog (see Scenario 2).

DELETE Operations #

There are two common approaches here:

• Soft Delete: If you mark documents as deleted (e.g., with an isDeleted: true flag) and track deletionDate:

  const twoDaysAgo = new Date(Date.now() - 2 * 24 * 60 * 60 * 1000);
  
  const deleteCount = db.yourCollection.countDocuments({
    isDeleted: true,
    deletionDate: { $gte: twoDaysAgo }
  });
  print(`Total DELETEs in last 2 days: ${deleteCount}`);
  

• Hard Delete: If documents are permanently removed, you can't count them directly from the collection. Instead, use the oplog (see Scenario 2's DELETE section).

Scenario 2: No creationDate/updationDate/deletionDate Fields #

If you don't have these timestamp fields, we'll use MongoDB's built-in features to work around this.

INSERT Operations (Using _id ObjectId) #

MongoDB's default _id field (an ObjectId) includes a timestamp of when the document was inserted. We can use this to filter for documents added in the last 2 days:

const twoDaysAgo = new Date(Date.now() - 2 * 24 * 60 * 60 * 1000);
// Convert the date to an ObjectId with the same timestamp
const minObjectId = ObjectId.fromDate(twoDaysAgo);

const insertCount = db.yourCollection.countDocuments({
  _id: { $gte: minObjectId }
});
print(`Total INSERTs in last 2 days: ${insertCount}`);

Caveat: This only works if you're using MongoDB's auto-generated ObjectIds. If you manually set custom _id values, this method won't work.

UPDATE & DELETE Operations (Using the Oplog) #

To track updates and deletions without timestamp fields, you need to use MongoDB's oplog—this requires your deployment to be a replica set or sharded cluster (single-node deployments don't have an oplog). The oplog records all write operations to the database.

First, connect to the local database and query the oplog collection (named oplog.rs for replica sets, oplog.$main for sharded clusters):

Count UPDATE Operations

// Convert 2 days ago to a Unix timestamp (seconds since epoch)
const twoDaysAgoSec = Math.floor(Date.now() / 1000) - 2 * 24 * 60 * 60;

const updateCount = db.getSiblingDB('local').oplog.rs.countDocuments({
  op: 'u', // 'u' = update operation
  ns: 'yourDatabase.yourCollection', // Target namespace (db.collection)
  ts: { $gte: Timestamp(twoDaysAgoSec, 1) } // Oplog timestamp filter
});
print(`Total UPDATE operations in last 2 days: ${updateCount}`);

Count DELETE Operations

const twoDaysAgoSec = Math.floor(Date.now() / 1000) - 2 * 24 * 60 * 60;

const deleteCount = db.getSiblingDB('local').oplog.rs.countDocuments({
  op: 'd', // 'd' = delete operation
  ns: 'yourDatabase.yourCollection',
  ts: { $gte: Timestamp(twoDaysAgoSec, 1) }
});
print(`Total DELETE operations in last 2 days: ${deleteCount}`);

Important Notes:

• You'll need administrative privileges to query the local database and oplog.
• The oplog has a fixed size—if your 2-day window exceeds the oplog's retention capacity, you won't get complete results. For long-term tracking, it's better to add timestamp fields to your collection.
• Unlike the collection-based count, oplog queries count every individual operation (e.g., if a document is updated 3 times, it counts as 3 updates).

Final Recommendations #

• Always add creationDate, updationDate, and use soft deletes with deletionDate if possible—this makes tracking operations simple and efficient.
• For large collections, create indexes on your timestamp fields to avoid slow count queries.
• If you're on a single-node deployment and need to track updates/deletes without timestamp fields, consider converting to a replica set to enable oplog functionality.

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