Ejemplos de marcos de agregación

Requisitos

Verifiquemos si todo está instalado.

Utilice el siguiente comando para cargar el conjunto de datos zips.json en la instancia de mongod:

$ mongoimport --drop -d test -c zipcodes zips.json

Utilicemos el shell MongoDB para verificar que todo se haya importado correctamente.

$ mongo test
connecting to: test
> db.zipcodes.count()
29467
> db.zipcodes.findOne()
{
      "_id" : "35004",
      "city" : "ACMAR",
      "loc" : [
              -86.51557,
              33.584132
      ],
      "pop" : 6055,
      "state" : "AL"
}

Agregaciones utilizando el conjunto de datos de códigos postales

Cada documento de esta colección tiene el siguiente formato:

{
  "_id" : "35004",
  "city" : "Acmar",
  "state" : "AL",
  "pop" : 6055,
  "loc" : [-86.51557, 33.584132]
}

En estos documentos:

• El _id El campo contiene el código postal como una cadena.

• El campo city contiene el nombre de la ciudad.

• El campo state contiene la abreviatura de dos letras del estado.

• El campo pop contiene la población.

• El campo loc contiene la ubicación como una matriz [latitude, longitude].

Estados con poblaciones superiores a 10 millones

Para obtener todos los estados con una población mayor a 10 millones, utilice la siguiente secuencia de agregación:

#include <mongoc/mongoc.h>
#include <stdio.h>
static void
print_pipeline (mongoc_collection_t *collection)
{
   mongoc_cursor_t *cursor;
   bson_error_t error;
   const bson_t *doc;
   bson_t *pipeline;
   char *str;
   pipeline = BCON_NEW ("pipeline",
                        "[",
                        "{",
                        "$group",
                        "{",
                        "_id",
                        "$state",
                        "total_pop",
                        "{",
                        "$sum",
                        "$pop",
                        "}",
                        "}",
                        "}",
                        "{",
                        "$match",
                        "{",
                        "total_pop",
                        "{",
                        "$gte",
                        BCON_INT32 (10000000),
                        "}",
                        "}",
                        "}",
                        "]");
   cursor = mongoc_collection_aggregate (collection, MONGOC_QUERY_NONE, pipeline, NULL, NULL);
   while (mongoc_cursor_next (cursor, &doc)) {
      str = bson_as_canonical_extended_json (doc, NULL);
      printf ("%s\n", str);
      bson_free (str);
   }
   if (mongoc_cursor_error (cursor, &error)) {
      fprintf (stderr, "Cursor Failure: %s\n", error.message);
   }
   mongoc_cursor_destroy (cursor);
   bson_destroy (pipeline);
}
int
main (void)
{
   mongoc_client_t *client;
   mongoc_collection_t *collection;
   const char *uri_string = "mongodb://localhost:27017/?appname=aggregation-example";
   mongoc_uri_t *uri;
   bson_error_t error;
   mongoc_init ();
   uri = mongoc_uri_new_with_error (uri_string, &error);
   if (!uri) {
      fprintf (stderr,
               "failed to parse URI: %s\n"
               "error message:       %s\n",
               uri_string,
               error.message);
      return EXIT_FAILURE;
   }
   client = mongoc_client_new_from_uri (uri);
   if (!client) {
      return EXIT_FAILURE;
   }
   mongoc_client_set_error_api (client, 2);
   collection = mongoc_client_get_collection (client, "test", "zipcodes");
   print_pipeline (collection);
   mongoc_uri_destroy (uri);
   mongoc_collection_destroy (collection);
   mongoc_client_destroy (client);
   mongoc_cleanup ();
   return EXIT_SUCCESS;
}

Debería ver un resultado como el siguiente:

{ "_id" : "PA", "total_pop" : 11881643 }
{ "_id" : "OH", "total_pop" : 10847115 }
{ "_id" : "NY", "total_pop" : 17990455 }
{ "_id" : "FL", "total_pop" : 12937284 }
{ "_id" : "TX", "total_pop" : 16986510 }
{ "_id" : "IL", "total_pop" : 11430472 }
{ "_id" : "CA", "total_pop" : 29760021 }

La canalización de agregación anterior se construye a partir de dos operadores de canalización: $group y $match.

El operador de canalización $group requiere el campo _id, donde se especifica la agrupación. Los campos restantes especifican cómo generar el valor compuesto y deben usar una de las funciones de agregación de grupos: $addToSet, $first, $last, $max, $min, $avg, $push, $sum. La sintaxis del operador de canalización $match es la misma que la de la consulta de lectura.

El proceso $group lee todos los documentos y para cada estado crea un documento separado, por ejemplo:

{ "_id" : "WA", "total_pop" : 4866692 }

El campo total_pop utiliza la función de agregación $sum para sumar los valores de todos los campos pop en los documentos de origen.

Los documentos creados por $group se canalizan al operador de canalización $match. Este devuelve los documentos con un valor del campo total_pop mayor o igual a 10 millones.

Población promedio de la ciudad por estado

Para obtener los tres primeros estados con la mayor población promedio por ciudad, utilice la siguiente agregación:

pipeline = BCON_NEW ("pipeline", "[",
   "{", "$group", "{", "_id", "{", "state", "$state", "city", "$city", "}", "pop", "{", "$sum", "$pop", "}", "}", "}",
   "{", "$group", "{", "_id", "$_id.state", "avg_city_pop", "{", "$avg", "$pop", "}", "}", "}",
   "{", "$sort", "{", "avg_city_pop", BCON_INT32 (-1), "}", "}",
   "{", "$limit", BCON_INT32 (3) "}",
"]");

Esta tubería agregada produce:

{ "_id" : "DC", "avg_city_pop" : 303450.0 }
{ "_id" : "FL", "avg_city_pop" : 27942.29805615551 }
{ "_id" : "CA", "avg_city_pop" : 27735.341099720412 }

La canalización de agregación anterior se construye a partir de tres operadores de canalización: $group, $sort y $limit.

El primer operador $group crea los siguientes documentos:

{ "_id" : { "state" : "WY", "city" : "Smoot" }, "pop" : 414 }

Tenga en cuenta que el operador $group no puede utilizar documentos anidados excepto el campo _id.

El segundo $group utiliza estos documentos para crear los siguientes documentos:

{ "_id" : "FL", "avg_city_pop" : 27942.29805615551 }

Estos documentos se ordenan por el campo avg_city_pop en orden descendente. Finalmente, el operador de canalización $limit devuelve los primeros 3 documentos del conjunto ordenado.