MongoDB中Change Stream与可尾游标（Tailable Cursor）的区别是什么？

Great question! Let's break down the key differences between MongoDB Change Streams and Tailable Cursors so you can pick the right tool for your use case:

Core Purpose & Ideal Use Cases #

• Change Streams: Built specifically to track every data modification (inserts, updates, deletes, replacements) across a collection, database, or entire cluster. They’re perfect for real-time data pipelines, event-driven architectures, or syncing data between systems where you need to react to any change in your dataset.
• Tailable Cursors: Designed to "tail" a capped collection (a fixed-size, circular-buffer-style collection) and pull in new documents as they’re added. This makes them ideal for log streaming, real-time feeds, or any scenario where you only care about new inserts—not updates or deletions.

What Triggers Them? #

• Change Streams: Fire in response to any write operation that alters your data. Instead of returning the full document, they capture a change event that details exactly what was modified (e.g., which fields were updated, the old vs new document state).
• Tailable Cursors: Only trigger when new documents are inserted into a capped collection. They don’t detect updates or deletions, and each trigger returns the full new document.

Key Feature Comparison #

• Change Streams:
  • Built-in resumability using a resume token—so if your connection drops, you can pick up right where you left off without missing events.
  • Supports filtering, transforming, and aggregating change events using MongoDB’s aggregation pipeline.
  • Works with replica sets and sharded clusters (requires MongoDB 3.6+).
  • No requirement for the collection to be capped.
• Tailable Cursors:
  • No native resumability—if the cursor closes, you’ll need to manually track the last processed document to restart tailing.
  • Limited filtering (only uses standard find() queries; no aggregation during the tailing process).
  • Only works with capped collections.
  • Has been around since MongoDB 1.8, so it’s compatible with older versions.

Example Code Snippets #

Change Streams #

const changeStream = collection.watch();
changeStream.next(function(err, next) {
  expect(err).to.equal(null);
  // 'next' contains the full change event (e.g., operation type, modified fields)
  client.close();
  done();
});

Tailable Cursors #

// Set up a tailable cursor on a capped collection
const cursor = coll.find(self.query || query)
  .addCursorFlag('tailable', true)
  .addCursorFlag('awaitData', true); // Waits for new data instead of returning immediately

// Iterate to get new documents as they're added
cursor.forEach(doc => {
  console.log('New document added to capped collection:', doc);
});

Quick Summary #

Use Change Streams if you need to track all data changes and want robust features like resumability and aggregation. Use Tailable Cursors if you only need to stream new inserts from a log-like capped collection and prefer a lighter, simpler tool.

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