Agregação

Campos de comando

O comando aggregate usa os seguintes campos como argumentos:

collation: {
   locale: <string>,
   caseLevel: <boolean>,
   caseFirst: <string>,
   strength: <int>,
   numericOrdering: <boolean>,
   alternate: <string>,
   maxVariable: <string>,
   backwards: <boolean>
}

{
  <variable_name_1>: <expression_1>,
  ...,
  <variable_name_n>: <expression_n>
}

O MongoDB remove o uso do comando aggregate sem a opção cursor a menos que o comando inclua a opção explain. A menos que você inclua a opção explain, especifique a opção cursor.

• Para indicar um cursor com o tamanho de lote padrão, especifique cursor: {}.

• Para indicar um cursor com um tamanho de lote não padrão, use cursor: { batchSize: <num> }.

Para obter mais informações sobre o pipeline de agregação, consulte:

• Pipeline de agregação

• Referência de agregação

• Limites de Pipeline de Agregação

Tempo-limite de inatividade da sessão

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 estiver 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 maxTimeMS() com mais de 30 minutos.

Para operações que retornam um cursor, se o cursor puder ficar ocioso por mais de 30 minutos, emita a operação em uma sessão explícita usando Mongo.startSession() e atualize periodicamente a sessão usando o comando refreshSessions. Consulte Tempo limite de inatividade da sessão para obter mais informações.

Desconexão do cliente

Para aggregate a operação que não inclua os estágios $out ou $merge:

A partir do MongoDB 4.2, se o cliente que emitiu aggregate se desconectar antes da conclusão da operação, o MongoDB marcará aggregate para encerramento usando killOp.

Agregar Dados com Pipeline Multi-Estágio

Uma collection articles contém documentos como os seguintes:

{
   _id: ObjectId("52769ea0f3dc6ead47c9a1b2"),
   author: "abc123",
   title: "zzz",
   tags: [ "programming", "database", "mongodb" ]
}

O exemplo a seguir executa uma operação aggregate na coleção articles para calcular a contagem de cada elemento distinto na array tags que aparece na coleção.

db.runCommand( {
   aggregate: "articles",
   pipeline: [
      { $project: { tags: 1 } },
      { $unwind: "$tags" },
      { $group: { _id: "$tags", count: { $sum : 1 } } }
   ],
   cursor: { }
} )

Em mongosh, essa operação pode usar o auxiliar db.collection.aggregate(), como a seguir:

db.articles.aggregate( [
   { $project: { tags: 1 } },
   { $unwind: "$tags" },
   { $group: { _id: "$tags", count: { $sum : 1 } } }
] )

Use $currentOp em um Banco de Dados Administrativo

O exemplo a seguir executa um pipeline com dois estágios no banco de dados admin. O primeiro estágio executa a operação$currentOp e o segundo estágio filtra os resultados dessa operação.

db.adminCommand( {
   aggregate : 1,
   pipeline : [ {
      $currentOp : { allUsers : true, idleConnections : true } }, {
      $match : { shard : "shard01" }
      }
   ],
   cursor : { }
} )

Informações de Retorno sobre a Operação de Agregação

A seguinte operação de aggregation define o campo opcional explain para true para retornar informações sobre a operação de aggregation.

db.orders.aggregate([
      { $match: { status: "A" } },
      { $group: { _id: "$cust_id", total: { $sum: "$amount" } } },
      { $sort: { total: -1 } }
   ],
   { explain: true }
)

Interação com allowDiskUseByDefault

A partir do MongoDB 6.0, os estágios do pipeline que exigem mais de 100 megabytes de memória para execução gravam arquivos temporários no disco por padrão. Esses arquivos temporários duram durante a execução do pipeline e podem influenciar o espaço de armazenamento na sua instância. Em versões anteriores do MongoDB, você deve passar { allowDiskUse: true } para find individuais e comandos aggregate para habilitar esse comportamento.

Somente find e aggregate comandos podem substituir o parâmetro allowDiskUseByDefault por um ou outro:

• Usando { allowDiskUse: true } para permitir a gravação de arquivos temporários no disco quando allowDiskUseByDefault estiver definido como false

• Usando { allowDiskUse: false } para proibir a gravação de arquivos temporários no disco quando allowDiskUseByDefault estiver definido como true

As mensagens de registro do criador de perfil e as mensagens de registro de diagnóstico incluem um indicador usedDisk se algum estágio de agregação gravou dados em arquivos temporários devido a restrições de memória.

Dados Agregados Especificando o Tamanho do Lote

Para especificar um tamanho de lote inicial, especifique o batchSize no campo cursor, como no seguinte exemplo:

db.orders.aggregate( [
      { $match: { status: "A" } },
      { $group: { _id: "$cust_id", total: { $sum: "$amount" } } },
      { $sort: { total: -1 } },
      { $limit: 2 }
   ],
   { cursor: { batchSize: 0 } }
)

O documento do { cursor: { batchSize: 0 } }, que especifica o tamanho do tamanho do lote inicial, indica um primeiro lote vazio. Esse tamanho de lote é útil para retornar rapidamente um cursor ou uma mensagem de falha sem realizar um trabalho significativo no lado do servidor.

Para especificar o tamanho do lote para operações subsequentes do getMore (após o lote inicial), utilize o campo batchSize ao executar o comando getMore.

Especificar um agrupamento

A colocação permite que os usuários especifiquem regras específicas do idioma para comparação de strings, como regras para letras maiúsculas e marcas de acento.

Uma coleção myColl possui os seguintes documentos:

{ _id: 1, category: "café", status: "A" }
{ _id: 2, category: "cafe", status: "a" }
{ _id: 3, category: "cafE", status: "a" }

A seguinte operação de aggregation inclui a opção Agrupamento:

db.myColl.aggregate(
   [ { $match: { status: "A" } }, { $group: { _id: "$category", count: { $sum: 1 } } } ],
   { collation: { locale: "fr", strength: 1 } }
);

Para obter descrições sobre os campos de agrupamento, consulte Documento de agrupamento.

Sugerir um Índice

Crie uma collection foodColl com os seguintes documentos:

db.foodColl.insertMany( [
   { _id: 1, category: "cake", type: "chocolate", qty: 10 },
   { _id: 2, category: "cake", type: "ice cream", qty: 25 },
   { _id: 3, category: "pie", type: "boston cream", qty: 20 },
   { _id: 4, category: "pie", type: "blueberry", qty: 15 }
] )

Crie os seguintes índices:

db.foodColl.createIndex( { qty: 1, type: 1 } );
db.foodColl.createIndex( { qty: 1, category: 1 } );

A seguinte operação de aggregation inclui a opção hint para forçar o uso do índice especificado:

db.foodColl.aggregate(
   [ { $sort: { qty: 1 }}, { $match: { category: "cake", qty: 10  } }, { $sort: { type: -1 } } ],
   { hint: { qty: 1, category: 1 } }
)

Substituir o Padrão Atenção com a Leitura

Para substituir o nível de preocupação de leitura padrão, utilize a opção readConcern. O comando getMore usa o nível readConcern especificado no comando aggregate de origem.

Não é possível usar o stage $out ou $merge em conjunto com a read concern "linearizable". Ou seja, se você especificar "linearizable" read concern para db.collection.aggregate(), não poderá incluir nenhum dos estágios no pipeline.

A operação a seguir em um conjunto de réplicas especifica uma read concern de "majority" para ler a cópia mais recente dos dados confirmados como tendo sido gravados na maioria dos nós.

db.restaurants.aggregate(
   [ { $match: { rating: { $lt: 5 } } } ],
   { readConcern: { level: "majority" } }
)

Para garantir que um único thread possa ler suas próprias gravações, use "majority" read concern e "majority" write concern em relação ao primário do conjunto de réplicas.

Usar variáveis em let

Para definir variáveis que você pode acessar em outro lugar no comando, use a opção let .

Crie uma collection cakeSales contendo vendas para sabores de bolo:

db.cakeSales.insertMany( [
   { _id: 1, flavor: "chocolate", salesTotal: 1580 },
   { _id: 2, flavor: "strawberry", salesTotal: 4350 },
   { _id: 3, flavor: "cherry", salesTotal: 2150 }
] )

O seguinte exemplo:

• recupera o bolo que tem um salesTotal maior que 3000, que é o bolo com um _id de 2

• define uma variável targetTotal em let, que é referenciada em $gt como $$targetTotal

db.runCommand( {
   aggregate: db.cakeSales.getName(),
   pipeline: [
      { $match: {
           $expr: { $gt: [ "$salesTotal", "$$targetTotal" ] }
      } },
    ],
    cursor: {},
    let: { targetTotal: 3000 }
} )