Operaciones de agregación

Analogía

Una operación de agregación se asemeja a una fábrica de automóviles. Una fábrica de automóviles tiene una línea de ensamblaje, que contiene estaciones de ensamblaje con herramientas especializadas para realizar tareas específicas, como taladros y soldadores. Las piezas en bruto ingresan a la fábrica y luego la línea de montaje las transforma y ensambla en un producto terminado.

La tubería de agregación es la línea de ensamblaje, las etapas de agregación son las estaciones de ensamblaje y las expresiones del operador son las herramientas especializadas.

Comparar las operaciones de agregación y búsqueda

Se pueden utilizar las operaciones de búsqueda para realizar las siguientes acciones:

• Seleccione qué documentos devolver

• Seleccione qué campos devolver

• Ordenar los resultados

Puedes utilizar operaciones de agregación para realizar las siguientes acciones:

• Ejecutar operaciones de búsqueda

• Cambiar el nombre de los campos

• Calcular campos

• Resumir datos

• Valores del grupo

Limitaciones

Considera las siguientes limitaciones al realizar operaciones de agregación:

• Los documentos devueltos no pueden violar el límite de tamaño de documento BSON de 16 megabytes.

• Las etapas del pipeline tienen un límite de memoria de 100 megabytes por defecto. Puedes superar este límite creando un arreglo de opciones que establezca el allowDiskUse opción a true y pasar el arreglo al método MongoDB\Collection::aggregate().

  Importante

  Excepción $graphLookup

  La etapa $graphLookup tiene un límite de memoria estricto de 100 megabytes e ignora la allowDiskUse opción.

Ejemplo de Filtro y Agrupación

El siguiente ejemplo de código produce un recuento del número de panaderías en cada distrito de Nueva York. Para ello, utiliza una pipeline de agregación que contiene las siguientes etapas:

1. Etapa$match para filtrar los documentos en los que el cuisine campo contiene el valor 'Bakery'

2. $group etapa para agrupar los documentos coincidentes por el campo borough, acumulando un conteo de documentos para cada valor distinto

$pipeline = [
    ['$match' => ['cuisine' => 'Bakery']],
    ['$group' => ['_id' => '$borough', 'count' => ['$sum' => 1]]],
];
$cursor = $collection->aggregate($pipeline);
foreach ($cursor as $doc) {
    echo json_encode($doc), PHP_EOL;
}

{"_id":"Brooklyn","count":173}
{"_id":"Queens","count":204}
{"_id":"Bronx","count":71}
{"_id":"Staten Island","count":20}
{"_id":"Missing","count":2}
{"_id":"Manhattan","count":221}

Explica una agregación

Para ver información sobre cómo MongoDB ejecuta tu operación, puedes instruir al planificador de consultas de MongoDB para que la explique. Cuando MongoDB explica una operación, devuelve planes de ejecución y estadísticas de rendimiento. Un plan de ejecución es una forma potencial en la que MongoDB puede completar una operación. Cuando instruyes a MongoDB para que explique una operación, devuelve tanto el plan que MongoDB ejecutó como cualquier plan de ejecución rechazado.

Para explicar una operación de agregación, construye un objeto MongoDB\Operation\Aggregate y pasa la base de datos, la colección y las etapas del pipeline como parámetros. Luego, pasa el objeto MongoDB\Operation\Aggregate al método MongoDB\Collection::explain().

El siguiente ejemplo le indica a MongoDB que explique la operación de agregación de la sección anterior:

$pipeline = [
    ['$match' => ['cuisine' => 'Bakery']],
    ['$group' => ['_id' => '$borough', 'count' => ['$sum' => 1]]],
];
$aggregate = new MongoDB\Operation\Aggregate(
    $collection->getDatabaseName(),
    $collection->getCollectionName(),
    $pipeline,
);
$result = $collection->explain($aggregate);
echo json_encode($result), PHP_EOL;

{"explainVersion":"2","queryPlanner":{"namespace":"sample_restaurants.restaurants",
"indexFilterSet":false,"parsedQuery":{"cuisine":{"$eq":"Bakery"}},"queryHash":"865F14C3",
"planCacheKey":"D56D6F10","optimizedPipeline":true,"maxIndexedOrSolutionsReached":false,
"maxIndexedAndSolutionsReached":false,"maxScansToExplodeReached":false,"winningPlan":{
... }

Ejemplo de Filtro y Agrupación

Este ejemplo utiliza los datos de muestra proporcionados en la sección Calcular recuento, suma y promedio de la referencia de etapa $group en el manual del servidor.

El siguiente ejemplo de código calcula el monto total de ventas, la cantidad promedio de ventas y el recuento de ventas para cada día del año 2014. Para ello, utiliza una pipeline de agregación que contiene las siguientes etapas:

1. $match etapa para filtrar documentos que tengan un campo date en el que el año sea 2014

2. $group etapa para agrupar los documentos por fecha y calcular el monto total de las ventas, la cantidad media de ventas y el recuento de ventas para cada grupo

3. Etapa $sort para ordenar los resultados por el monto total de venta para cada grupo en orden descendente

$pipeline = new MongoDB\Builder\Pipeline(
    MongoDB\Builder\Stage::match(
        date: [
            MongoDB\Builder\Query::gte(new MongoDB\BSON\UTCDateTime(new DateTimeImmutable('2014-01-01'))),
            MongoDB\Builder\Query::lt(new MongoDB\BSON\UTCDateTime(new DateTimeImmutable('2015-01-01'))),
        ],
    ),
    MongoDB\Builder\Stage::group(
        _id: MongoDB\Builder\Expression::dateToString(MongoDB\Builder\Expression::dateFieldPath('date'), '%Y-%m-%d'),
        totalSaleAmount: MongoDB\Builder\Accumulator::sum(
            MongoDB\Builder\Expression::multiply(
                MongoDB\Builder\Expression::numberFieldPath('price'),
                MongoDB\Builder\Expression::numberFieldPath('quantity'),
            ),
        ),
        averageQuantity: MongoDB\Builder\Accumulator::avg(
            MongoDB\Builder\Expression::numberFieldPath('quantity'),
        ),
        count: MongoDB\Builder\Accumulator::sum(1),
    ),
    MongoDB\Builder\Stage::sort(
        totalSaleAmount: MongoDB\Builder\Type\Sort::Desc,
    ),
);
$cursor = $collection->aggregate($pipeline);
foreach ($cursor as $doc) {
    echo json_encode($doc), PHP_EOL;
}

{"_id":"2014-04-04","totalSaleAmount":{"$numberDecimal":"200"},"averageQuantity":15,"count":2}
{"_id":"2014-03-15","totalSaleAmount":{"$numberDecimal":"50"},"averageQuantity":10,"count":1}
{"_id":"2014-03-01","totalSaleAmount":{"$numberDecimal":"40"},"averageQuantity":1.5,"count":2}

Ejemplo para desanidar arrays embebidos

Este ejemplo utiliza los datos de muestra proporcionados en la sección Unwind Embedded Arrays de la $unwind referencia de la etapa en el manual del servidor.

El siguiente ejemplo de código agrupa los artículos vendidos por sus etiquetas y calcula el importe total de ventas para cada etiqueta. Para ello, utiliza una pipeline de agregación que contiene las siguientes etapas:

1. $unwind etapa para emitir un documento separado para cada elemento en el arreglo items

2. La etapa $unwind para generar un documento independiente para cada elemento en los arreglos items.tags.

3. Etapa de grupo para agrupar los documentos por valor de etiqueta y calcular el monto total de ventas de los artículos que tienen cada etiqueta

$pipeline = new MongoDB\Builder\Pipeline(
    MongoDB\Builder\Stage::unwind(MongoDB\Builder\Expression::arrayFieldPath('items')),
    MongoDB\Builder\Stage::unwind(MongoDB\Builder\Expression::arrayFieldPath('items.tags')),
    MongoDB\Builder\Stage::group(
        _id: MongoDB\Builder\Expression::fieldPath('items.tags'),
        totalSalesAmount: MongoDB\Builder\Accumulator::sum(
            MongoDB\Builder\Expression::multiply(
                MongoDB\Builder\Expression::numberFieldPath('items.price'),
                MongoDB\Builder\Expression::numberFieldPath('items.quantity'),
            ),
        ),
    ),
);
$cursor = $collection->aggregate($pipeline);
foreach ($cursor as $doc) {
    echo json_encode($doc), PHP_EOL;
}

{"_id":"office","totalSalesAmount":{"$numberDecimal":"1019.60"}}
{"_id":"school","totalSalesAmount":{"$numberDecimal":"104.85"}}
{"_id":"stationary","totalSalesAmount":{"$numberDecimal":"264.45"}}
{"_id":"electronics","totalSalesAmount":{"$numberDecimal":"800.00"}}
{"_id":"writing","totalSalesAmount":{"$numberDecimal":"60.00"}}

Ejemplo de unión de igualdad simple

Este ejemplo utiliza los datos de muestra proporcionados en la sección Realizar una unión de igualdad única con $lookup de la referencia de la $lookup etapa en el manual del servidor.

El siguiente ejemplo de código une los documentos de la colección orders con los documentos de la colección inventory usando el campo item de la colección orders y el campo sku de la colección inventory.

Para ello, el ejemplo utiliza una canalización de agregación que contiene una etapa $lookup que especifica la colección de la que se recuperarán los datos y los nombres de los campos locales y externos.

$pipeline = new MongoDB\Builder\Pipeline(
    MongoDB\Builder\Stage::lookup(
        from: 'inventory',
        localField: 'item',
        foreignField: 'sku',
        as: 'inventory_docs',
    ),
);
/* Performs the aggregation on the orders collection */
$cursor = $collection->aggregate($pipeline);
foreach ($cursor as $doc) {
    echo json_encode($doc), PHP_EOL;
}

{"_id":1,"item":"almonds","price":12,"quantity":2,"inventory_docs":[{"_id":1,"sku":"almonds","description":"product 1","instock":120}]}
{"_id":2,"item":"pecans","price":20,"quantity":1,"inventory_docs":[{"_id":4,"sku":"pecans","description":"product 4","instock":70}]}
{"_id":3,"inventory_docs":[{"_id":5,"sku":null,"description":"Incomplete"},{"_id":6}]}

Manual del Servidor de MongoDB

Para obtener más información sobre los temas tratados en esta guía, consulte las siguientes páginas del manual de MongoDB Server:

• Para obtener una lista completa de las etapas de agregación, consulta Etapas de agregación en el manual de MongoDB Server.

• Para aprender sobre cómo armar un pipeline de agregación y para ver ejemplos, consulta pipeline de agregación.

• Para obtener más información sobre cómo crear etapas de canalización, consulte Etapas de agregación.

• Para obtener más información sobre cómo explicar las operaciones de MongoDB, consulte Explicar los planesde salida y consulta.

Búsqueda de MongoDB y búsqueda vectorial

Puedes realizar búsquedas de texto completo utilizando la funcionalidad de búsqueda de MongoDB. Para obtener más información, consulta la guía sobre cómo ejecutar una MongoDB Search query.

Puede realizar búsquedas de similitud en incrustaciones vectoriales mediante la función de búsqueda vectorial de MongoDB. Para obtener más información, consulte la guía "Ejecutar una consulta de búsqueda vectorial de MongoDB".

Documentación de la API

Para obtener más información sobre los métodos analizados en esta guía, consulte la siguiente documentación de API:

• MongoDB\Collection::aggregate()

• MongoDB\Collection::explain()