Expire Data from Collections by Setting TTL (2024)

Expire Documents in the MongoDB Atlas UI

To expire data in the Atlas UI, followthese steps:

Expire Documents after a Specified Number of Seconds

You can expire data after a specified number of seconds in the terminal.To expire data after a specified number of seconds has passed since theindexed field, create a TTL index on a field that holds values of BSONdate type or an array of BSON date-typed objects and specify apositive non-zero value in the expireAfterSeconds field. A documentwill expire when the number of seconds in the expireAfterSecondsfield has passed since the time specified in its indexed field.[1]

The TTL index expireAfterSeconds value must be within 0 and2147483647 inclusive.

For example, the following operation creates an index on thelog_events collection's createdAt field and specifies theexpireAfterSeconds value of 10 to set the expiration time tobe ten seconds after the time specified by createdAt.

db.log_events.createIndex( { "createdAt": 1 }, { expireAfterSeconds: 10 } )

When adding documents to the log_events collection, set thecreatedAt field to the current time:

db.log_events.insertOne( {
 "createdAt": new Date(),
 "logEvent": 2,
 "logMessage": "Success!"
} )

MongoDB will automatically delete documents from the log_eventscollection when the document's createdAt value[1] is older than the number of secondsspecified in expireAfterSeconds.

Expire Documents with Filter Conditions

To expire documents with specific filter expressions, you can createan index that is both a partialand a TTL index.

Create a partial TTL index:

db.foo.createIndex(
 { F: 1 },
 {
 name: "Partial-TTL-Index",
 partialFilterExpression: { D : 1 },
 expireAfterSeconds: 10
 }
)

Insert two documents, one of which matches the filter expression{ D : 1 } of the partialFilterExpression:

db.foo.insertMany( [
 { "F" : ISODate("2019-03-07T20:59:18.428Z"), "D" : 3},
 { "F" : ISODate("2019-03-07T20:59:18.428Z"), "D" : 1}
] )

Wait for ten seconds then query the foo collection:

db.foo.find({}, {_id: 0, F: 1, D: 1})

The document that matches the partialFilterExpressionof { D : 1 } is deleted (expired). As a result, onlyone document remains in the foo collection:

{ "F" : ISODate("2019-03-07T20:59:18.428Z"), "D" : 3}

Expire Documents at a Specific Clock Time

You can expire data at a specified clock time in the terminal. Toexpire documents at a specific clock time, begin by creating a TTLindex on a field that holds values of BSON date type or an array ofBSON date-typed objects and specify an expireAfterSeconds valueof 0. For each document in the collection, set the indexed datefield to a value corresponding to the time the document should expire.If the indexed date field contains a date in the past, MongoDBconsiders the document expired.

For example, the following operation creates an index on thelog_events collection's expireAt field and specifies theexpireAfterSeconds value of 0:

db.log_events.createIndex( { "expireAt": 1 }, { expireAfterSeconds: 0 } )

For each document, set the value of expireAt to correspond to thetime the document should expire. For example, the followinginsertOne() operation adds a document thatexpires at July 22, 2013 14:00:00.

db.log_events.insertOne( {
 "expireAt": new Date('July 22, 2013 14:00:00'),
 "logEvent": 2,
 "logMessage": "Success!"
} )

MongoDB will automatically delete documents from the log_eventscollection when the documents' expireAt value is older than thenumber of seconds specified in expireAfterSeconds, i.e. 0seconds older in this case. As such, the data expires at the specifiedexpireAt value.

Indexes Configured Using NaN

Do not set expireAfterSeconds to NaN in your TTL indexconfiguration.

Prior to MongoDB 5.0, when a TTL index has expireAfterSeconds set toNaN, MongoDB logs an error and does not remove any records.

From MongoDB 5.0.0 - 5.0.13 (and 6.0.0 - 6.0.1), NaN is treated as0. If a TTL index is configured with expireAfterSeconds set toNaN, all TTL-indexed documents expire immediately.

Starting in MongoDB 5.0.14 (and 6.0.2), the server will not use TTLindexes that have expireAfterSeconds set to NaN.

However, there are still some situations which may result in unexpectedbehavior. Documents may expire:

• During an initial sync to an earlier version from MongoDB 5.0.0 -5.0.13 (or 6.0.0 - 6.0.1).

• When upgrading from an earlier version to MongoDB 5.0.0 - 5.0.13.

• When restoring a collection from a pre-5.0 mongodumpinto a MongoDB 5.0.0 - 5.0.13 (or 6.0.0 - 6.0.1) instance.

To avoid problems, either drop or correct any misconfigured TTL indexes.

function getNaNIndexes() {
 const nan_index = [];
 const dbs = db.adminCommand({ listDatabases: 1 }).databases;
 dbs.forEach((d) => {
 if (d.name != 'local') {
 const listCollCursor = db
 .getSiblingDB(d.name)
 .runCommand({ listCollections: 1 }).cursor;
 const collDetails = {
 db: listCollCursor.ns.split(".$cmd")[0],
 colls: listCollCursor.firstBatch.map((c) => c.name),
 };
 collDetails.colls.forEach((c) =>
 db
 .getSiblingDB(collDetails.db)
 .getCollection(c)
 .getIndexes()
 .forEach((entry) => {
 if (Object.is(entry.expireAfterSeconds, NaN)) {
 nan_index.push({ ns: `${collDetails.db}.${c}`, index: entry });
 }
 })
 );
 }
 });
 return nan_index;
};
getNaNIndexes();