Agregação

Campos de comando

O comando aggregate utiliza 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> }

MongoDB 3.6 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 mais informações sobre o aggregation pipeline, aggregation pipeline, Referência de aggregation e Limites de aggregation pipeline.

Tempo-limite de inatividade da sessão

Os drivers e mongosh do MongoDB associam todas as operações a uma sessão de servidor, com exceção de operações de gravação não reconhecidas. Para operações não explicitamente associadas a uma sessão (ou seja, uso Mongo.startSession()), os drivers do 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 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 collection articles para calcular a contagem de cada elemento distinto na array tags que aparece na collection.

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, estágios de pipeline que exigem mais de 100 megabytes de memória para executar arquivos temporários de gravação em disco por padrão. 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

A partir do MongoDB 4.2, 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 aggregation 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 read concern padrão, use a opção readConcern . O comando getMore usa o nível readConcern especificado no comando aggregate 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 }
} )