Para agentes de IA: hay un índice de documentación disponible en https://www.mongodb.com/es/docs/llms.txt — versiones en markdown de todas las páginas están disponibles agregando .md a cualquier ruta URL.
Docs Menu
Docs Home
/ /
Etapas de agregación
Docs Home
/
Desarrollo
/
languaje del query
/
Etapas de agregación
Docs Home
/
Desarrollo
/
languaje del query
/
Etapas de agregación

$group (etapa de agregación)

Definición

$group

La etapa $group combina múltiples documentos que tienen el mismo campo, campos, o expresión en un solo documento de acuerdo con una clave de agrupación. El resultado es un documento por cada clave de grupo única.

Una clave de grupo suele ser un campo o un conjunto de campos. La clave de grupo también puede ser el resultado de una expresión. Utiliza el campo _id en la etapa del pipeline $group para establecer la clave de grupo. Consulta a continuación ejemplos de uso.

En la salida de la etapa $group, el campo _id se establece en la clave de grupo para ese documento.

Los documentos de salida también pueden incluir campos adicionales que se configuran mediante expresiones de acumulador.

Nota

$group no ordena sus documentos de salida.

Compatibilidad

Puedes usar $group para implementaciones alojadas en los siguientes entornos:

  • MongoDB Atlas: El servicio totalmente gestionado para implementaciones de MongoDB en la nube

  • MongoDB Enterprise: La versión basada en suscripción y autogestionada de MongoDB

  • MongoDB Community: La versión de MongoDB con código fuente disponible, de uso gratuito y autogestionada.

Sintaxis

La etapa tiene la siguiente forma $group prototipo:

{
 $group:
   {
     _id: <expression>, // Group key
     <field1>: { <accumulator1> : <expression1> },
     ...
   }
 }
Campo
Descripción

_id

Obligatorio. La _id expresión especifica la clave de grupo. Si especifica un _id valor nulo o cualquier otro valor constante, la $group etapa devuelve un único documento que agrega los valores de todos los documentos de entrada. Consulte el ejemplo Agrupar por nulo.

field

Opcional. Calculado utilizando los operadores de acumulación.

_id Los operadores y acumulador pueden aceptar cualquier expression válido. Para obtener más información sobre expresiones, consulte la sección Expresiones.

Considerations

Rendimiento

$group es una etapa de bloqueo, que hace que el pipeline espere a que se recuperen todos los datos de entrada para la etapa de bloqueo antes del procesamiento de los datos. Una etapa de bloqueo puede reducir el rendimiento porque disminuye el procesamiento paralelo en un pipeline con múltiples etapas. Una etapa de bloqueo también puede utilizar cantidades sustanciales de memoria para grandes conjuntos de datos.

Operador de acumulación

El operador <accumulator> debe ser uno de los siguientes operadores de acumulación:

Nombre
Descripción

$accumulator

Devuelve el resultado de una función de acumulador definida por el usuario.

$addToSet

Devuelve un arreglo de valores de expresión únicos para cada grupo. El orden de los elementos del arreglo es indefinido.

Modificado en la versión 5.0:

Disponible en la etapa $setWindowFields.

$avg

Devuelve un promedio de valores numéricos. Ignora los valores no numéricos.

Modificado en la versión 5.0:

Disponible en la etapa $setWindowFields.

$bottom

Devuelve el elemento más bajo dentro de un grupo según el orden de acomodo especificado.

Nuevo en la versión 5.2.

Disponible en las etapas $group $setWindowFields y.

$bottomN

Devuelve una agregación de los campos n inferiores dentro de un grupo, según el orden de clasificación especificado.

Nuevo en la versión 5.2.

Disponible en las etapas $group $setWindowFields y.

$concatArrays

Devuelve un único arreglo que combina los elementos de dos o más arreglos.

Nuevo en la versión 8.1.

$count

Devuelve la cantidad de documentos en un grupo.

Distinto de la etapa de canalización de $count.

Novedades en la versión 5.0:

Disponible en las etapas $group $setWindowFields y.

$first

Devuelve el resultado de una expresión para el primer documento de un grupo.

Modificado en la versión 5.0:

Disponible en la etapa $setWindowFields.

$firstN

Devuelve una agregación de los primeros elementos den dentro de un grupo. Solo es significativo cuando los documentos están en un orden definido. Distinto del operador de arreglo $firstN.

Novedades en la versión 5.2:

Disponible en las etapas,$group expresión $setWindowFields y.

$last

Devuelve el resultado de una expresión para el último documento de un grupo.

Modificado en la versión 5.0:

Disponible en la etapa $setWindowFields.

$lastN

Devuelve una agregación de los últimos elementos n dentro de un grupo. Solo es significativo cuando los documentos están en un orden definido. Distinto del operador de arreglo $lastN.

Novedades en la versión 5.2:

Disponible en las etapas,$group expresión $setWindowFields y.

$max

Devuelve el valor de la expresión más alto para cada grupo.

Modificado en la versión 5.0:

Disponible en la etapa $setWindowFields.

$maxN

Devuelve una agregación de los elementos n con el valor máximo en un grupo. Distinto del operador de arreglo $maxN.

Nuevo en la versión 5.2.

Disponible $group en, y$setWindowFields como expresión.

$median

Devuelve una aproximación de la mediana, el percentil 50, como un valor escalar.

Nuevo en la versión 7.0.

Este operador está disponible como acumulador en estas etapas:

También está disponible como una expresión de agregación.

$mergeObjects

Devuelve un documento creado al combinar los documentos de entrada para cada grupo.

$min

Devuelve el valor de la expresión más bajo para cada grupo.

Modificado en la versión 5.0:

Disponible en la etapa $setWindowFields.

$minN

Devuelve una agregación de los n elementos de menor valor en un grupo. Distinto del operador de arreglo $minN.

Nuevo en la versión 5.2.

Disponible $group en, y$setWindowFields como expresión.

$percentile

Devuelve un arreglo de valores escalares que corresponden a los valores de percentil especificados.

Nuevo en la versión 7.0.

Este operador está disponible como acumulador en estas etapas:

También está disponible como una expresión de agregación.

$push

Devuelve un arreglo de valores de expresión para los documentos en cada grupo.

Modificado en la versión 5.0:

Disponible en la etapa $setWindowFields.

$setUnion

Toma dos o más arreglos y devuelve un arreglo que contiene los elementos que aparecen en cualquier arreglo de entrada.

Nuevo en la versión 8.1.

$stdDevPop

Devuelve la desviación estándar poblacional de los valores de entrada.

Modificado en la versión 5.0:

Disponible en la etapa $setWindowFields.

$stdDevSamp

Devuelve la desviación estándar muestral de los valores de entrada.

Modificado en la versión 5.0:

Disponible en la etapa $setWindowFields.

$sum

Devuelve la suma de valores numéricos. Ignora los valores no numéricos.

Modificado en la versión 5.0:

Disponible en la etapa $setWindowFields.

$top

Devuelve el elemento principal dentro de un grupo según el orden de acomodo especificado.

Nuevo en la versión 5.2.

Disponible en las etapas $group $setWindowFields y.

$topN

Devuelve una agregación de los campos n principales dentro de un grupo, según el orden de clasificación especificado.

Nuevo en la versión 5.2.

Disponible en las etapas $group $setWindowFields y.

$group y restricciones de memoria

Si la etapa supera $group los 100 megabytes de RAM, MongoDB escribe los datos en archivos temporales. Sin embargo, si la opción allowDiskUse está configurada false en, $group devuelve un error. Para obtener más información, consulte los límites de la canalización de agregación.

$group Optimizaciones de rendimiento

Esta sección describe las optimizaciones para mejorar el rendimiento de. Hay optimizaciones que puedes realizar manualmente y optimizaciones que MongoDB realiza $group internamente.

Optimización para devolver el primer o el último documento de cada grupo

Si una canalización sorts y utilizan el mismo campo y groups la $group etapa solo usa el operador acumulador $first o, considere agregar $last un índice al campo agrupado que coincida con el orden de clasificación. En algunos casos, la $group etapa puede usar el índice para encontrar rápidamente el primer o el último documento de cada grupo.

Ejemplo

Si la colección movies contiene un índice { year: 1, title: 1 }, el siguiente pipeline puede utilizar ese índice para encontrar el primer document de cada grupo:

db.movies.aggregate([
   {
      $sort: { year: 1, title: 1 }
   },
   {
      $group: {
         _id: { year: "$year" },
         title: { $first: "$title" }
      }
   }
])

Motor de ejecución de query basado en ranuras

A partir de la 5.2 versión, MongoDB utiliza el motor de consultas de ejecución basado en ranuras para ejecutar $group etapas si se cumple alguna de las siguientes condiciones:

  • $group es la primera etapa en el pipeline.

  • Todas las etapas anteriores en la pipeline también pueden ejecutarse mediante el motor de ejecución basado en ranuras.

Para obtener más información, consulta $groupOptimización.

Ejemplos

Contabiliza el número de documentos en una colección

Los ejemplos de esta página utilizan datos del conjunto de datos de muestra sample_mflix. Para obtener más información sobre cómo cargar este conjunto de datos en la implementación autogestionada de MongoDB, consultar Cargar el conjunto de datos de muestra. Si se realizó alguna modificación en las bases de datos de muestra, es posible que se deban descartar y volver a crear las bases de datos para ejecutar los ejemplos de esta página.

La siguiente operación de agregación utiliza la etapa para contar el número de documentos en $group la movies colección:

db.movies.aggregate([
   {
      $group: {
         _id: null,
         count: { $count: {} }
      }
   }
])
[
  {
    _id: null,
    count: 21349
  }
]

Esta operación de agregación es equivalente a la siguiente instrucción SQL:

SELECT COUNT(*) AS count FROM movies

Tip

Retrieve Distinct Values

La siguiente operación de agregación utiliza la etapa para recuperar $group los rated valores distintos de la movies colección:

db.movies.aggregate( [ { $group : { _id : "$rated" } } ] )
[
  {
    _id: 'TV-PG'
  },
  {
    _id: 'PG'
  },
  {
    _id: 'TV-14'
  },
  {
    _id: 'OPEN'
  },
  {
    _id: 'Not Rated'
  },
  {
    _id: 'GP'
  },
  {
    _id: 'TV-Y7'
  },
  {
    _id: 'G'
  },
  {
    _id: 'PG-13'
  },
  {
    _id: null
  },
  {
    _id: 'M'
  },
  {
    _id: 'R'
  },
  {
    _id: 'TV-MA'
  },
  {
    _id: 'APPROVED'
  },
  {
    _id: 'PASSED'
  },
  {
    _id: 'Approved'
  },
  {
    _id: 'AO'
  },
  {
    _id: 'TV-G'
  }
]

Nota

Por ejemplo, las operaciones $group del siguiente formulario pueden resultar en un DISTINCT_SCAN:

{ $group : { _id : "$<field>" } }

Para obtener más información sobre el comportamiento al recuperar valores distintos, consulte el comportamiento del comando distinct.

Para ver si la operación resulta en un DISTINCT_SCAN, se deben consultar los resultados de la explicación de la operación.

Agrupar por clasificación

La siguiente operación de agregación agrupa documentos por el campo rated, calcula el tiempo de ejecución total por calificación y solo devuelve las calificaciones con un tiempo de ejecución total mayor o igual a 100000:

db.movies.aggregate(
   [
      // First Stage
      {
         $group: {
            _id: "$rated",
            totalRuntime: { $sum: "$runtime" }
         }
      },
      // Second Stage
      {
         $match: { "totalRuntime": { $gte: 100000 } }
      }
   ]
)
[
  {
    _id: 'PG-13',
    totalRuntime: 250843
  },
  {
    _id: 'R',
    totalRuntime: 582318
  },
  {
    _id: null,
    totalRuntime: 967127
  },
  {
    _id: 'PG',
    totalRuntime: 191204
  }
]
Primera etapa:
La etapa agrupa los documentos $group por rated para recuperar los valores de calificación distintos. Esta etapa devuelve el totalRuntime para cada grupo de calificación.
Segunda etapa:
La etapa de $match filtra los documentos resultantes para devolver solo calificaciones con una totalRuntime igual o superior a 100000.

Esta operación de agregación es equivalente a la siguiente instrucción SQL:

SELECT rated,
   Sum(runtime) AS totalRuntime
FROM   movies
GROUP  BY rated
HAVING totalRuntime >= 100000

Tip

$match

Calcular el recuento, la suma y el promedio

Agrupar por año

El siguiente pipeline calcula el tiempo total de ejecución, el tiempo de ejecución promedio y el recuento de películas para cada año antes de 1910:

db.movies.aggregate([
   { $match: { "year": { $lt: 1910 } } },
   {
      $group: {
         _id: "$year",
         totalRuntime: { $sum: "$runtime" },
         averageRuntime: { $avg: "$runtime" },
         count: { $sum: 1 }
      }
   },
   { $sort: { totalRuntime: -1 } }
])
[
  { _id: 1909, totalRuntime: 14, averageRuntime: 14, count: 1 },
  { _id: 1903, totalRuntime: 11, averageRuntime: 11, count: 1 },
  { _id: 1896, totalRuntime: 2, averageRuntime: 1, count: 2 }
]
Primera etapa:
La etapa $match filtra los document para que solo las películas estrenadas antes de 1910 pasen a la siguiente etapa.
Segunda etapa:
La etapa agrupa los documentos por año y calcula el tiempo total de ejecución, el tiempo promedio de ejecución y el recuento total de documentos en cada $group grupo.
Tercera etapa:
La etapa $sort clasifica los resultados según el tiempo total de ejecución de cada grupo en orden descendente.

Esta operación de agregación es equivalente a la siguiente instrucción SQL:

SELECT year,
       Sum(runtime) AS totalRuntime,
       Avg(runtime) AS averageRuntime,
       Count(*)     AS count
FROM   movies
WHERE  year < 1910
GROUP  BY year
ORDER  BY totalRuntime DESC

Tip

Agrupar por null

La siguiente operación de agregación especifica un grupo _id de null, calculando el tiempo de ejecución total, el tiempo de ejecución promedio y el recuento de todos los document en la colección.

db.movies.aggregate([
   {
      $group: {
         _id: null,
         totalRuntime: { $sum: "$runtime" },
         averageRuntime: { $avg: "$runtime" },
         count: { $sum: 1 }
      }
   }
])
[
  {
    _id: null,
    totalRuntime: 2167458,
    averageRuntime: 103.65652797704448,
    count: 21349
  }
]

Esta operación de agregación es equivalente a la siguiente instrucción SQL:

SELECT Sum(runtime) AS totalRuntime,
       Avg(runtime) AS averageRuntime,
       Count(*)     AS count
FROM   movies

Tip

Pivot Data

Agrupa títulos por año

La siguiente operación de agregación pivota los datos en la colección movies para agrupar los títulos por año:

db.movies.aggregate([
   { $match: { year: { $lt: 1910 } } },
   { $group: { _id: "$year", titles: { $push: "$title" } } },
   { $sort: { _id: 1 } }
])
[
  { _id: 1896, titles: [ 'The Kiss', 'The Kiss' ] },
  { _id: 1903, titles: [ 'The Great Train Robbery' ] },
  { _id: 1909, titles: [ 'A Corner in Wheat' ] }
]

Agrupar document por año

La siguiente operación de agregación agrupa los document por año:

db.movies.aggregate([
   { $match: { year: { $lt: 1910 } } },
   { $group: { _id: "$year", movies: { $push: "$$ROOT" } } },
   {
      $addFields: {
         totalRuntime: { $sum: "$movies.runtime" }
      }
   },
   { $sort: { _id: 1 } }
])
[
  { _id: 1896, movies: '...', totalRuntime: 2 },
  { _id: 1903, movies: '...', totalRuntime: 11 },
  { _id: 1909, movies: '...', totalRuntime: 14 }
]
Primera etapa:
$match filtra los document para pasar a la siguiente etapa únicamente aquellas películas estrenadas antes de 1910.
Segunda etapa:
$group utiliza la variable de sistema para agrupar todos los documentos por $$ROOT año.
Tercera etapa:

$addFields agrega un campo a la salida que contiene el tiempo de ejecución total de las películas para cada año.

Nota

Los documentos resultantes no deben exceder el límite de tamaño de documento BSON de 16 mebibytes.

Cuarta etapa:
$sort ordena los documentos resultantes por _id en orden ascendente.

Los ejemplos de C# en esta página utilizan la base de datos sample_mflix de los conjuntos de datos de muestra de Atlas. Para aprender a crear un clúster gratuito de MongoDB Atlas y cargar los conjuntos de datos de muestra, consulta Primeros pasos en la documentación del controlador de MongoDB .NET/C#.

La siguiente clase Movie modela los documentos en la colección sample_mflix.movies:

[BsonIgnoreExtraElements]
public class Movie
{
    [BsonId]
    public ObjectId Id { get; set; }
    [BsonElement("title")]
    public string Title { get; set; } = null!;
    [BsonElement("year")]
    public int? Year { get; set; }
    [BsonElement("runtime")]
    public int? Runtime { get; set; }
    [BsonElement("rated")]
    public string? Rated { get; set; }
    [BsonElement("metacritic")]
    public int Metacritic { get; set; }
    [BsonElement("plot")]
    public string? Plot { get; set; }
    [BsonElement("type")]
    public string? Type { get; set; }
    [BsonElement("cast")]
    public string[]? Cast { get; set; }
    [BsonElement("directors")]
    public string[]? Directors { get; set; }
    [BsonElement("writers")]
    public string[]? Writers { get; set; }
    [BsonElement("imdb")]
    public ImdbData? Imdb { get; set; }
}

Para usar el controlador MongoDB.NET/C# para agregar una $group etapa a una canalización de agregación, llame al método UnionWith() en un PipelineDefinition objeto.

El siguiente ejemplo crea una etapa de pipeline que agrupa los documentos por el valor de su campo Rated. La calificación de cada grupo se muestra en un campo llamado Rating en cada documento de salida. Cada documento de salida también contiene campos llamados TotalRuntime, MedianRuntime y NinetiethPercentileRuntime, que almacenan los valores del tiempo de ejecución total, mediano y percentil 90para las películas de cada grupo.

var pipeline = new EmptyPipelineDefinition<Movie>()
    .Group(
        id: m => m.Rated,
        group: g => new
        {
            Rating = g.Key,
            TotalRuntime = g.Sum(m => m.Runtime),
            MedianRuntime = g.Select(m => m.Runtime).Median(),
            NinetiethPercentileRuntime =
                g.Select(m => m.Runtime).Percentile(new[] { 0.9 })
        }
    );
{ "Rating" : null, "TotalRuntime" : 967127, "MedianRuntime" : 98.0, "NinetiethPercentileRuntime" : [131.0] }
{ "Rating" : "AO", "TotalRuntime" : 274, "MedianRuntime" : 85.0, "NinetiethPercentileRuntime" : [108.0] }
{ "Rating" : "APPROVED", "TotalRuntime" : 74571, "MedianRuntime" : 103.0, "NinetiethPercentileRuntime" : [134.0] }
{ "Rating" : "Approved", "TotalRuntime" : 472, "MedianRuntime" : 93.0, "NinetiethPercentileRuntime" : [109.0] }
{ "Rating" : "G", "TotalRuntime" : 43044, "MedianRuntime" : 89.0, "NinetiethPercentileRuntime" : [125.0] }
{ "Rating" : "GP", "TotalRuntime" : 4864, "MedianRuntime" : 103.0, "NinetiethPercentileRuntime" : [135.0] }
{ "Rating" : "M", "TotalRuntime" : 4107, "MedianRuntime" : 107.0, "NinetiethPercentileRuntime" : [142.0] }
{ "Rating" : "Not Rated", "TotalRuntime" : 116, "MedianRuntime" : 116.0, "NinetiethPercentileRuntime" : [116.0] }
{ "Rating" : "OPEN", "TotalRuntime" : 85, "MedianRuntime" : 85.0, "NinetiethPercentileRuntime" : [85.0] }
{ "Rating" : "PASSED", "TotalRuntime" : 17778, "MedianRuntime" : 98.0, "NinetiethPercentileRuntime" : [123.0] }
{ "Rating" : "PG", "TotalRuntime" : 191204, "MedianRuntime" : 100.0, "NinetiethPercentileRuntime" : [124.0] }
{ "Rating" : "PG-13", "TotalRuntime" : 250843, "MedianRuntime" : 105.0, "NinetiethPercentileRuntime" : [131.0] }
{ "Rating" : "R", "TotalRuntime" : 582318, "MedianRuntime" : 102.0, "NinetiethPercentileRuntime" : [127.0] }
{ "Rating" : "TV-14", "TotalRuntime" : 10527, "MedianRuntime" : 98.0, "NinetiethPercentileRuntime" : [197.0] }
{ "Rating" : "TV-G", "TotalRuntime" : 4653, "MedianRuntime" : 88.0, "NinetiethPercentileRuntime" : [100.0] }
{ "Rating" : "TV-MA", "TotalRuntime" : 7048, "MedianRuntime" : 96.0, "NinetiethPercentileRuntime" : [223.0] }
{ "Rating" : "TV-PG", "TotalRuntime" : 8183, "MedianRuntime" : 90.0, "NinetiethPercentileRuntime" : [169.0] }
{ "Rating" : "TV-Y7", "TotalRuntime" : 244, "MedianRuntime" : 74.0, "NinetiethPercentileRuntime" : [96.0] }

Los ejemplos de Node.js en esta página utilizan la base de datos sample_mflix de los conjuntos de datos de muestra de Atlas. Para aprender a crear un clúster gratuito de MongoDB Atlas y cargar los conjuntos de datos de muestra, consulte Primeros pasos en la documentación del controlador de MongoDB Node.js.

Para utilizar el controlador de MongoDB Node.js para agregar una etapa de $group a una canalización de agregación, utilice el Operador $group en un objeto de canalización.

En el siguiente ejemplo, se crea una etapa de pipeline que agrupa los documentos por el valor de su campo rated. Cada documento de salida tiene un campo rating que almacena la calificación de los grupos. Cada documento de salida también tiene un campo llamado totalRuntime que almacena la duración total de todas las películas del grupo. En el siguiente ejemplo, se ejecuta la pipeline de agregación:

const pipeline = [
  {
    $group: {
      _id: "$rated",
      rating: { $first: "$rated" },
      totalRuntime: { $sum: "$runtime" }
    }
  }
];
const cursor = collection.aggregate(pipeline);
return cursor;

Obtén más información

El tutorial "Agrupar y datos totales" proporciona un ejemplo extenso del $group operador en un caso de uso común.

Para aprender más sobre las etapas relacionadas del pipeline, consulta la guía $addFields.

Volver
$graphLookup
Next
$indexStats
Obtén una insignia de habilidad

Domina los “Fundamentos de la transformación de datos” de forma gratuita.

Más información
Califique esta página

En esta página