db.collection.aggregate() (método mongosh)

Parámetros

El método aggregate() toma los siguientes parámetros:

El documento options puede contener los siguientes campos y valores:

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>
}

Error Handling

Si se produce un error, el asistente de aggregate() lanza una excepción.

Comportamiento del cursor

mongoshEn, si el cursor devuelto por no está asignado a una variable mediante db.collection.aggregate() la var palabra clave, lo itera automáticamente mongosh hasta 20 veces. Consulte Iterar un cursor mongosh en para gestionar cursores mongosh en.

Los cursores devueltos por la agregación solo brindan soporte a métodos de cursor que operan en cursores evaluados (es decir, cursores cuya primera agrupación se recuperó), como los siguientes métodos:

Para obtener más información, consulte:

• Pipeline de agregación

• Referencia de agregación

• Límites de la canalización de agregación

• aggregate

Sesiones

Para los cursores creados dentro de una sesión, no puedes llamar a getMore fuera de la sesión.

De manera similar, para los cursores creados fuera de una sesión, no puedes llamar a getMore dentro de una sesión.

Transacciones

db.collection.aggregate() puede usarse dentro de transacciones distribuidas.

Sin embargo, las siguientes etapas no están permitidas dentro de las transacciones:

• $collStats

• $currentOp

• $indexStats

• $listLocalSessions

• $listSessions

• $out

• $merge

• $planCacheStats

Tampoco puede especificar la opción explain.

• Para los cursores creados fuera de una transacción, no puedes llamar a getMore dentro de la transacción.

• Para los cursores creados en una transacción, no puedes llamar a getMore fuera de la transacción.

Desconexión del cliente

Para la operación db.collection.aggregate() que no incluye las etapas $out o $merge:

Si el cliente que emitió db.collection.aggregate() se desconecta antes de que la operación se complete, MongoDB marca db.collection.aggregate() para su terminación usando killOp.

Agrupar y calcular una suma

La siguiente operación de agregación selecciona documentos con estado igual a "A", agrupa los documentos coincidentes por el campo cust_id y calcula el total para cada campo cust_id a partir de la suma del campo amount, y ordena los resultados por el campo total en orden descendente:

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

La operación devuelve un cursor con los siguientes documentos:

[
   { _id: "xyz1", total: 100 },
   { _id: "abc1", total: 75 }
]

mongosh itera automáticamente el cursor devuelto para imprimir los resultados. Consulta Iterar un cursor en mongosh para manejar los cursores de forma manual en mongosh.

Información sobre la operación de pipeline de agregación

El siguiente ejemplo utiliza db.collection.explain() para ver información detallada sobre el plan de ejecución de la canalización de agregación.

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

La operación devuelve un documento que detalla el procesamiento de la canalización de agregación. Por ejemplo, el documento puede mostrar, entre otros detalles, qué índice, si lo hay, se utilizó en la operación. []1 Si la orders colección está fragmentada, el documento también mostrará la división del trabajo entre los fragmentos y la operación de fusión, y, para las consultas dirigidas, los fragmentos de destino.

Puedes ver una salida de explicación más detallada si pasa las modas de explicación executionStats o allPlansExecution al método db.collection.explain().

Interacción con allowDiskUseByDefault

A partir de MongoDB 6.0, las etapas de la canalización que requieren más de 100 megabytes de memoria para ejecutarse escriben archivos temporales en el disco de forma predeterminada. Estos archivos temporales duran mientras se ejecuta la canalización y pueden afectar el espacio de almacenamiento de la instancia. En versiones anteriores de MongoDB, se debía pasar { allowDiskUse: true } a los comandos find y aggregate para habilitar este comportamiento.

Los comandos individuales find y aggregate pueden anular el parámetro allowDiskUseByDefault de las siguientes maneras:

• Se utiliza { allowDiskUse: true } para permitir la escritura de archivos temporales en el disco cuando allowDiskUseByDefault se establece en false

• Se utiliza { allowDiskUse: false } para prohibir la escritura de archivos temporales en el disco cuando allowDiskUseByDefault esté configurado en true

Los mensajes de registro del perfilador y los mensajes de registro de diagnóstico incluyen un indicador usedDisk si alguna etapa de agregación escribió datos en archivos temporales debido a restricciones de memoria.

Para obtener más información, consulte Límites de la pipeline de agregación.

Especifica un tamaño de lote inicial

Para especificar un tamaño de lote inicial para el cursor, utiliza la siguiente sintaxis para la opción cursor:

cursor: { batchSize: <int> }

Por ejemplo, la siguiente operación de agregación especifica el tamaño inicial de la agrupación de 0 para el cursor:

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

El documento { cursor: { batchSize: 0 } }, que especifica el tamaño del agrupación inicial, indica una primera agrupación vacía. Este tamaño de agrupación es útil para devolver rápidamente un cursor o un mensaje de error sin realizar un trabajo significativo en el servidor.

Para especificar el tamaño de agrupación para las operaciones getMore posteriores (después de la agrupación inicial), use el campo batchSize al ejecutar el comando getMore.

mongosh itera automáticamente el cursor devuelto para imprimir los resultados. Consulta Iterar un cursor en mongosh para manejar los cursores de forma manual en mongosh.

Especifica una intercalación

La intercalación permite a los usuarios especificar reglas propias del lenguaje para la comparación de strings, como reglas para el uso de mayúsculas y minúsculas y marcas de acento.

Una colección restaurants tiene los siguientes documentos:

db.restaurants.insertMany( [
   { _id: 1, category: "café", status: "Open" },
   { _id: 2, category: "cafe", status: "open" },
   { _id: 3, category: "cafE", status: "open" }
] )

La siguiente operación de agregación incluye la opción de intercalación:

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

[ { _id: 'café', count: 3 } ]

La agregación especifica una intercalación con strength: 1, lo que significa que la intercalación ignora las diferencias entre mayúsculas y minúsculas y variantes de letras. Como resultado:

• El filtro $match coincide con todos los documentos de la colección y pasa esos documentos a la fase $group.

• La etapa $group ignora las diferencias en las variantes de letras en el campo category y coloca todos los documentos en un solo grupo.

Para obtener descripciones sobre los campos de intercalación, consulta el Documento de intercalación.

Sugerencia de índice

Cree una colección food con los siguientes documentos:

db.food.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 }
] )

Cree los siguientes índices:

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

La siguiente operación de agregación incluye la opción hint para forzar el uso del índice especificado:

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

Sobrescribir readConcern

Utiliza la opción readConcern para especificar el nivel de consistencia de lectura de la operación.

No puedes utilizar la etapa $out o la etapa $merge junto con el nivel de consistencia de lectura "linearizable". Es decir, si especificas el nivel de consistencia de lectura "linearizable" para db.collection.aggregate(), no podrá incluir ninguna de las dos etapas en la pipeline.

La siguiente operación en un set de réplicas especifica un nivel de consistencia de lectura de "majority" para leer la copia más reciente de los datos confirmados como están escritos en la mayoría de los nodos.

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

Especifique un comentario

Una colección llamada movies contiene documentos con el siguiente formato:

db.movies.insertOne(
   {
      _id: ObjectId("599b3b54b8ffff5d1cd323d8"),
      title: "Jaws",
      year: 1975,
      imdb: "tt0073195"
   }
)

La siguiente operación de agregación encuentra películas creadas en 1995 e incluye la opción comment para proporcionar información de seguimiento en logs, la colección db.system.profile, y db.currentOp.

db.movies.aggregate( [ { $match: { year : 1995 } } ], { comment : "match_all_movies_from_1995" } ).pretty()

En un sistema con perfilado activado, puedes consultar la colección system.profile para ver todas las agregaciones similares recientes, como se muestra a continuación:

db.system.profile.find( { "command.aggregate": "movies", "command.comment" : "match_all_movies_from_1995" } ).sort( { ts : -1 } ).pretty()

Esto devolverá un conjunto de resultados del perfilador en el siguiente formato:

{
  "op" : "command",
  "ns" : "video.movies",
  "command" : {
    "aggregate" : "movies",
    "pipeline" : [
      {
        "$match" : {
          "year" : 1995
        }
      }
    ],
    "comment" : "match_all_movies_from_1995",
    "cursor" : {
    },
    "$db" : "video"
  },
  ...
}

Una aplicación puede codificar cualquier información arbitraria en el comentario para rastrear o identificar más fácilmente operaciones específicas a través del sistema. Por ejemplo, una aplicación podría adjuntar un comentario de string que incorpore su ID de proceso, ID de hilo, nombre de host del cliente y el usuario que emitió el comando.

Usar variables en let

Para definir variables a las que puedes acceder en otros lugares del comando, utiliza la opción let.

Cree una colección cakeSales que contenga ventas de sabores de pastel:

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

El siguiente ejemplo:

• recupera el pastel que tiene un salesTotal mayor que 3000, que es el pastel con un _id de 2

• define una variable targetTotal en let, la cual se referencia en $gt como $$targetTotal

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