/ /

$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 grupo 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 para 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 $group tiene la siguiente forma de prototipo:

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

Campo	Descripción
`_id`	Requerido. La expresión `_id` especifica la clave del grupo. Si especifica un valor `_id` de null o cualquier otro valor constante, la etapa `$group` devuelve un único documento que agrega los valores de todos los documentos de entrada. Consulte el ejemplo de Group by Null.
`field`	Opcional. Calculado utilizando los operadores de acumulación.

El _id y los operadores de acumulación pueden aceptar cualquier expression válida. Para obtener más información sobre las expresiones, consulta 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. Se cambió 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. Se cambió 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` y `$setWindowFields`.
`$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` y `$setWindowFields`.
`$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 `$group` y `$setWindowFields` etapas.
`$first`	Devuelve el resultado de una expresión para el primer documento de un grupo. Se cambió en la versión 5.0: disponible en la etapa `$setWindowFields`.
`$firstN`	Devuelve una agregación de los primeros elementos de`n` dentro de un grupo. Solo es significativo cuando los documentos están en un orden definido. Distinto del operador de arreglo `$firstN`. Novedad en la versión 5.2: disponible en el `$group`, expresión y etapas `$setWindowFields`.
`$last`	Devuelve el resultado de una expresión para el último documento de un grupo. Se cambió 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`. Novedad en la versión 5.2: disponible en el `$group`, expresión y etapas `$setWindowFields`.
`$max`	Devuelve el valor de la expresión más alto para cada grupo. Se cambió 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 en `$group`, `$setWindowFields` y como una 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: `$group` `$setWindowFields` 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. Se cambió 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 en `$group`, `$setWindowFields` y como una 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: `$group` `$setWindowFields` 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. Se cambió 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. Se cambió en la versión 5.0: disponible en la etapa `$setWindowFields`.
`$stdDevSamp`	Devuelve la desviación estándar muestral de los valores de entrada. Se cambió 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. Se cambió 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` y `$setWindowFields`.
`$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` y `$setWindowFields`.

`$group` y restricciones de memoria

Si la etapa $group supera los 100 megabytes de RAM, MongoDB guarda datos en archivos temporales. Sin embargo, si la opción allowDiskUse se establece en false, $group devuelve un error. Para obtener más información, consulta Límites de pipeline de agregación.

`$group` Optimizaciones de rendimiento

En esta sección, se describen optimizaciones para mejorar el rendimiento de $group. Existen optimizaciones que puedes realizar manualmente y optimizaciones que MongoDB realiza de forma interna.

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

Si un pipeline sorts y groups por el mismo campo y la etapa $group solo utiliza el operador de acumulación $first o $last, considera añadir un índice al campo agrupado que coincida con el orden de clasificación. En algunos casos, la etapa de $group puede utilizar 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 versión 5.2, MongoDB utiliza el motor de query de ejecución basado en ranuras para ejecutar etapas $group si se cumple cualquiera 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 $group para contar el número de documentos en la colección movies:

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 $group para recuperar los valores distintos de rated de la colección movies:

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 $group agrupa los documents por rated para recuperar los valores de calificación distintos. Esta etapa devuelve el totalRuntime para cada grupo de valoració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 $group agrupa los document por año y calcula la duración total, la duración promedio y el recuento total de los document en cada 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

$match
$sort
db.collection.countDocuments() que envuelve la etapa de agregación $group con una expresión $sum.

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

$count
db.collection.countDocuments() que envuelve la etapa de agregación $group con una expresión $sum.

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 $$ROOT variable de sistema para agrupar todos los document por 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:

public class Movie
{
    public ObjectId Id { get; set; }
    public int Runtime { get; set; }
    
    public string Title { get; set; }
    public string Rated { get; set; }
    public List<string> Genres { get; set; }
    public string Plot { get; set; }
    
    public ImdbData Imdb { get; set; }
    public int Year { get; set; }
    public int Index { get; set; }
    
    public string[] Comments { get; set; }
   
    [BsonElement("lastupdated")]
    public DateTime LastUpdated { get; set; }
}

Nota

ConventionPack para Pascal Case

Las clases de C# en esta página utilizan Pascal case para los nombres de sus propiedades, pero los nombres de los campos en la colección de MongoDB utilizan camel case. Para tener en cuenta esta diferencia, se puede usar el siguiente código para registrar un ConventionPack cuando la aplicación se inicie:

var camelCaseConvention = new ConventionPack { new CamelCaseElementNameConvention() };
ConventionRegistry.Register("CamelCase", camelCaseConvention, type => true);

Para utilizar el driver MongoDB .NET/C# con el fin de añadir una etapa $group a un pipeline de agregación, ejecuta Group() método en un objeto PipelineDefinition.

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

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 Totalizar Datos proporciona un extenso ejemplo del operador $group en un caso de uso común.

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

Volver

$graphLookup

$indexStats

Definición

Nota

Compatibilidad

Sintaxis

Considerations

Rendimiento

Operador de acumulación

$group y restricciones de memoria

$group Optimizaciones de rendimiento

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

Ejemplo

Motor de ejecución de query basado en ranuras

Ejemplos

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

Tip

Retrieve Distinct Values

Nota

Agrupar por clasificación

Tip

Calcular el recuento, la suma y el promedio

Agrupar por año

Tip

Agrupar por null

Tip

Pivot Data

Agrupa títulos por año

Agrupar document por año

Nota

Nota

ConventionPack para Pascal Case

Obtén más información

Obtén una insignia de habilidad

`$group` y restricciones de memoria

`$group` Optimizaciones de rendimiento

Agrupar por `null`