Expirar dados de coleções definindo TTL

Expirar documentos na interface do usuário do Atlas MongoDB

Para expirar dados na IU do Atlas, siga estas etapas:

Expirar documentos após um número especificado de segundos

Você pode expirar os dados após um número específico de segundos no terminal. Para expirar os dados depois que um número especificado de segundos tiver passado desde o campo indexado, crie um índice TTL em um campo que contenha valores do tipo data BSON ou uma array de objetos do tipo data BSON e especifique um valor positivo diferente de zero no campo expireAfterSeconds. Um documento expirará quando o número de segundos no campo expireAfterSeconds tiver passado desde o tempo especificado em seu campo indexado. [1]

O valor expireAfterSeconds do índice TTL deve estar dentro de 0 e 2147483647 inclusive.

Por exemplo, a seguinte operação cria um índice no campo log_events da collection createdAt e especifica o valor expireAfterSeconds de 10 para definir o tempo de expiração para dez segundos após o tempo especificado por createdAt.

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

Ao adicionar documentos à coleção log_events, defina o campo createdAt para o horário atual:

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

O MongoDB excluirá automaticamente os documentos da coleção log_events quando o valor createdAt do documento [1] for maior que o número de segundos especificado em expireAfterSeconds.

Expirar documentos com condições de filtro

Para expirar documentos com expressões de filtro específicas, você pode criar um índice que seja tanto um índice parcial quanto um índice TTL.

Criar um índice TTL parcial:

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

Insira dois documentos, um dos quais corresponde à expressão de filtro { D : 1 } do partialFilterExpression:

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

Aguarde dez segundos e faça a query da collection foo:

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

O documento que corresponde a partialFilterExpression de { D : 1 } foi excluído (expirado). Como resultado, apenas um documento permanece na coleção foo:

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

Expirar documentos em um horário específico

Você pode expirar os dados em um tempo de relógio especificado no terminal. Para expirar documentos em um horário de relógio específico, comece criando um índice TTL em um campo que contenha valores do tipo de data BSON ou uma matriz de objetos do tipo data BSON e especifique um valor expireAfterSeconds de 0. Para cada documento na coleção, defina o campo de data indexada como um valor correspondente à hora em que o documento deve expirar. Se o campo de data indexada contiver uma data no passado, MongoDB considera o documento expirado.

Por exemplo, a seguinte operação cria um índice no campo log_events da coleção expireAt e especifica o valor expireAfterSeconds de 0:

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

Para cada documento, defina o valor de expireAt para corresponder à hora em que o documento deve expirar. Por exemplo, a operação insertOne() a seguir adiciona um documento que expira em July 22, 2013 14:00:00.

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

O MongoDB excluirá automaticamente os documentos da collection log_events quando o valor expireAt dos documentos for mais antigo do que o número de segundos especificado em expireAfterSeconds, ou seja, 0 segundos mais antigo neste caso. Dessa forma, os dados expiram no valor expireAt especificado.

Índices configurados usando NaN

Não defina expireAfterSeconds como NaN na configuração do índice TTL.

Antes do MongoDB 5.0, quando um índice TTL tem expireAfterSeconds definido como NaN, o MongoDB registra um erro e não remove nenhum registro.

Do MongoDB 5.0.0 - 5.0.13 (e 6.0.0 - 6.0.1), NaN é tratado como 0. Se um índice TTL for configurado com expireAfterSeconds definido como NaN, todos os documentos indexados em TTL expirarão imediatamente.

Iniciando no MongoDB 5.0.14 (e 6.0.2), o servidor não utilizará índices TTL que tenham expireAfterSeconds definido como NaN.

No entanto, ainda há algumas situações que podem resultar em comportamento inesperado. Os documentos podem expirar:

• Durante uma sincronização inicial com uma versão anterior do MongoDB 5.0.0 - 5.0.13 (ou 6.0.0 - 6.0.1).

• Ao atualizar de uma versão anterior para MongoDB 5.0.0 - 5.0.13.

• Ao restaurar uma coleção de um pré-5.0 mongodump em um MongoDB 5.0.0 - 5.0.13 (ou 6.0.0 - 6.0.1) instância.

Para evitar problemas, deixe cair ou corrija quaisquer índices de TTL configurados incorretamente.

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();