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

Parámetros

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

Error Handling

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

Comportamiento del cursor

En mongosh, si el cursor devuelto por db.collection.aggregate() no se asigna a una variable utilizando la palabra clave var, entonces mongosh itera automáticamente el cursor hasta 20 veces. Consulta Iterar un cursor en mongosh para gestionar los cursores en mongosh.

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.

Configuración de query

Puedes utilizar la configuración de query para establecer sugerencias de índice, fijar filtros de rechazo de operación y otros campos. Los ajustes se aplican a la forma de la query en todo el clúster. El clúster retiene la configuración después del apagado.

El optimizador de query utiliza la configuración del query como entrada adicional durante la planificación del query, lo que afecta al plan seleccionado para ejecutar el query. También puedes usar la configuración del query para bloquear una forma del query.

Para añadir configuraciones de query y explorar ejemplos, consulte setQuerySettings.

Puedes añadir configuraciones de query para los comandos find, distinct, y aggregate.

La configuración de query tiene más funcionalidades y se prefiere sobre los filtros de índice en desuso.

Para remover la configuración del query, utilice removeQuerySettings. Para obtener la configuración del query, utilice una etapa de $querySettings en una canalización de agregación.

Agrupar y calcular una suma

La siguiente operación de agregación:

• Selecciona películas con una calificación IMDB superior a 8.5.

• Agrupa las películas coincidentes por el campo year.

• Calcula el averageRating para cada year a partir del promedio del campo imdb.rating.

• Ordena los resultados por el campo averageRating en orden descendente.

db.movies.aggregate(
    [
       { $match: { "imdb.rating": { $gt: 8.5 } } },
       { $group: { _id: "$year", averageRating: { $avg: "$imdb.rating" } } },
       { $sort: { averageRating: -1 } },
       { $limit: 3 }
    ] 
)

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

[
  { _id: 1972, averageRating: 9.2 },
  { _id: 1990, averageRating: 9.166666666666666 },
  { _id: 1974, averageRating: 9.1 }
]

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.movies.explain().aggregate( 
    [
       { $match: { "imdb.rating": { $gt: 8.5 } } },
       { $group: { _id: "$year", averageRating: { $avg: "$imdb.rating" } } },
       { $sort: { averageRating: -1 } }
    ] 
)

La operación devuelve un documento que detalla el procesamiento de la pipeline de agregación. Por ejemplo, el documento puede mostrar, entre otros detalles, qué índice utilizó la operación, si lo hay. [1] Si la colección movies es una colección particionada, el documento también muestra la división del trabajo entre las particiones y la operación de fusión, y para los queries dirigidos, las particiones dirigidas.

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

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 permanecen durante la ejecución de la canalización y pueden afectar el espacio de almacenamiento en su instancia.

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.theaters.aggregate( 
    [
       { $match: { "location.address.state": "NY" } },
       { $group: { _id: "$location.address.city", theaterCount: { $sum: 1 } } },
       { $sort: { theaterCount: -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.

La siguiente operación de agregación devuelve los títulos de todas las películas francesas en la colección movies de la base de datos sample_mflix y especifica la intercalación fr:

db.movies.aggregate(
    [ 
       { $match: {"countries": "France", "languages": "French"} }, 
       { $project: { "title": 1, "_id": 0 } }
    ],
    { collation: { locale: "fr", strength: 1 } }
)

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

Sugerencia de índice

La colección movies en la base de datos sample_mflix contiene documentos similares a estos:

{
   title: "The Shawshank Redemption",
   year: 1994, rated: "R",
   imdb: { rating: 9.3, votes: 1513145, id: 111161 }
},
{
   title: "The Godfather",
   year: 1972,
   rated: "R",
   imdb: { rating: 9.2, votes: 1038358, id: 68646 }
},
{
   title: "The Dark Knight",
   year: 2008, rated: "PG-13",
   imdb: { rating: 9, votes: 1495351, id: 468569 }
},
{
   title: "Forrest Gump",
   year: 1994,
   rated: "PG-13",
   imdb: { rating: 8.8, votes: 1087227, id: 109830 }
}

Supongamos que existen los siguientes índices en la colección movies:

db.movies.createIndex( { "imdb.rating": 1, year: 1 } )

db.movies.createIndex( { "imdb.rating": 1, rated: 1 } )

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

db.movies.aggregate(
    [
        { $sort: { "imdb.rating": 1 } }, 
        { $match: { rated: "R", "imdb.rating": { $gte: 9.0 } } }, 
        { $sort: { year: -1 } } 
    ],
    { hint: { "imdb.rating": 1, rated: 1 } }
)

Sobrescribir readConcern

Para anular el nivel de consistencia de lectura por defecto, se debe utilizar la opción readConcern. El comando getMore utiliza el nivel readConcern especificado en el comando aggregate de origen.

La siguiente operación en la movies colección de la sample_mflix base de datos especifica una preocupación de lectura de para leer la copia más reciente de los datos confirmados como escritos en la mayoría de los nodos."majority"

db.movies.aggregate(
    [ 
       { $match: { "imdb.rating": { $gte: 8.0 } } },
       { $group: { _id: "$rated", avgRating: { $avg: "$imdb.rating" }, count: { $sum: 1 } } },
       { $sort: { avgRating: -1 } }
    ],
    { readConcern: { level: "majority" } }
)

Para asegurarte de que un solo hilo pueda leer sus propias escrituras, utiliza el nivel de consistencia de lectura "majority" y el nivel de confirmación de escritura "majority" contra el primario del set de réplicas.

Especifique un comentario

La colección movies del conjunto de datos de muestra sample_mflix contiene documentos similares a este:

{
   title: 'Forrest Gump',
   year: 1994,
   genres: [ 'Drama', 'Romance' ],
   runtime: 142,
   imdb: { rating: 8.8, votes: 1087227, id: 109830 },
   directors: [ 'Robert Zemeckis' ],
   cast: [ 'Tom Hanks', 'Rebecca Williams', 'Sally Field', 'Michael Conner Humphreys' ],
}

La siguiente operación de agregación encuentra películas creadas en 1994 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 : 1994 } },
        { $limit: 3 }
    ], 
    { comment: "match_three_movies_from_1994" } 
)

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_three_movies_from_1994" } ).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" : 1994
        }
      },
      { "$limit": 3 }
    ],
    "comment" : "match_three_movies_from_1994",
    "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 pueda acceder en otros lugares del comando, utilice la opción let.

El siguiente ejemplo:

• Coincide con documentos de la colección sample_mflix.movies donde el campo imdb.rating es mayor que 8.5, limitado a tres resultados.

• Define una variable minRating en let, a la que se hace referencia en $gt como $$minRating.

db.movies.aggregate(
    [
       { $match: {
          $expr: { $gt: [ "$imdb.rating", "$$minRating" ] }
       } },
       { $limit: 3 }
    ],
    { let: { minRating: 8.5 } }
)