Menu Docs
Página inicial do Docs
/
Manual do MongoDB
/
Referência
/
Métodos de mongosh
/
Cursors

cursor.maxTimeMS()

Nesta página

  • Definição
  • Compatibilidade
  • Comportamentos
  • Exemplos

Definição

cursor.maxTimeMS(<time limit>)

Importante

Método mongosh

Esta página documenta um método mongosh. Esta não é a documentação de um driver de idioma específico, como Node.js.

Para drivers de API do MongoDB, consulte a documentação do driver do MongoDB específica da linguagem.

Especifica um limite de tempo cumulativo em milissegundos para operações de processamento em um cursor.

O método maxTimeMS() tem a seguinte forma de protótipo:

db.collection.find(
   { <query> },
   { <projection> }
).maxTimeMS( <milliseconds> )

O método maxTimeMS() tem o seguinte parâmetro:

Parâmetro
Tipo
Descrição

milliseconds

inteiro

Especifica um limite de tempo cumulativo em milésimos de segundo para operações de processamento no cursor.

Importante

maxTimeMS() não está relacionado ao sinalizador de query NoCursorTimeout. maxTimeMS() diz respeito ao tempo de processamento, enquanto NoCursorTimeout faz referência a tempo ocioso. O tempo ocioso de um cursor não contribui para seu tempo de processamento.

O maxAwaitTimeMS() método define um limite para o tempo que um cursor persistente espera pela próxima resposta. Não define um limite no tempo total de processamento.

Compatibilidade

Esse método está disponível em implantações hospedadas nos seguintes ambientes:

  • MongoDB Atlas: o serviço totalmente gerenciado para implantações do MongoDB na nuvem

Observação

Este comando é aceito em todos os clusters do MongoDB Atlas. Para obter informações sobre o suporte do Atlas a todos os comandos, consulte Comandos não suportados.

  • MongoDB Enterprise: a versão autogerenciada e baseada em assinatura do MongoDB

  • MongoDB Community: uma versão com código disponível, de uso gratuito e autogerenciada do MongoDB

Comportamentos

O MongoDB direciona as operações para encerramento se o cursor associado exceder seu limite de tempo alocado. O MongoDB encerra as operações que excedem o limite de tempo alocado usando o mesmo mecanismo de db.killOp(). O MongoDB só encerra uma operação em um de seus pontos designados.

O MongoDB não conta a latência de rede entre o cliente e o servidor para o limite de tempo de um cursor. Para um cluster fragmentado, no entanto, o MongoDB inclui a latência entre as instâncias mongos e mongod para esse limite de tempo.

As queries que geram vários lotes de resultados continuam a retornar lotes até que o cursor exceda o limite de tempo alocado.

Substituições de tempo limite de inatividade da sessão maxTimeMS

Os drivers MongoDB e mongosh associam todas as operações a uma sessão do servidor, com exceção das operações de gravação não reconhecidas. No caso das operações não associadas explicitamente a uma sessão (ou seja, usando Mongo.startSession()), os drivers MongoDB e mongosh criam uma sessão implícita e a associam à operação.

Se uma sessão ficar ociosa por mais de 30 minutos, o servidor MongoDB marcará essa sessão como expirada e poderá fechá-la a qualquer momento. Quando o servidor MongoDB fecha a sessão, ele também elimina todas as operações em andamento e abre os cursores associados à sessão. Isso inclui cursores configurados com noCursorTimeout() ou um maxTimeMS() maior que 30 minutos.

Por exemplo, considere uma operação do find() com o maxTimeMS() configurado para um tempo limite de 31 minutos. O servidor retorna um cursor junto com um lote de documentos definido pelo cursor.batchSize() do find(). A sessão é atualizada toda vez que o aplicativo solicita um novo lote de documentos do servidor. No entanto, se o aplicativo demorar mais de 30 minutos para processar o lote atual de documentos, a sessão será marcada como expirada e encerrada. Quando o servidor fecha a sessão, ele também elimina o cursor apesar de o cursor estar configurado com maxTimeMS() maior que 30 minutos. Quando o aplicativo solicita o próximo lote de documentos, o servidor retorna um erro.

Para operações que retornam um cursor, se o cursor ficar inativo por mais de 30 minutos, execute a operação em uma sessão explícita usando e atualize periodicamente Mongo.startSession() refreshSessions a sessão usando o comando. Por exemplo:

var session = db.getMongo().startSession()
var sessionId = session
sessionId  // show the sessionId
var cursor = session.getDatabase("examples").getCollection("data").find().noCursorTimeout()
var refreshTimestamp = new Date() // take note of time at operation start
while (cursor.hasNext()) {
  // Check if more than 5 minutes have passed since the last refresh
  if ( (new Date()-refreshTimestamp)/1000 > 300 ) {
    print("refreshing session")
    db.adminCommand({"refreshSessions" : [sessionId]})
    refreshTimestamp = new Date()
  }
  // process cursor normally
}

Na operação de exemplo, o método db.collection.find() está associado com uma sessão explícita. O cursor é configurado com cursor.maxTimeMS() para manter o cursor aberto por pelo menos 31 minutos. O loop while inclui um bloco que utiliza refreshSessions para atualizar a sessão a cada 5 minutos. Como a sessão nunca excederá o tempo limite de inatividade de 30 minutos, o cursor pode permanecer aberto até omaxTimeMS() configurado.

Para drivers MongoDB, consulte a documentação do driver para obter instruções e sintaxe para criar sessões.

Dica

Veja também:

Tempo-limite de inatividade da sessão

Tempo limite padrão para todas as operações

A partir do MongoDB 8.0, você pode usar o parâmetro de cluster defaultMaxTimeMS para especificar um limite de tempo padrão para a conclusão de operações de leitura individuais. Se uma consulta especificar uma opção maxTimeMS(), esse valor substituirá o valor defaultMaxTimeMS.

Exemplos

Exemplo

A seguinte query especifica um limite de tempo de 50 milésimos de segundo:

db.collection.find({description: /August [0-9]+, 1969/}).maxTimeMS(50)

Voltar

cursor.maxAwaitTimeMS

Próximo

cursor.min