Exemplos de framework de aggregation

Requisitos

Vamos verificar se tudo está instalado.

Use o seguinte comando para carregar o conjunto de dados zips.json na instância mongod:

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

Vamos usar o shell do MongoDB para verificar se tudo foi importado com sucesso.

$ 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"
}

Agregações usando o conjunto de dados de códigos postais

Cada documento nessa coleção tem o seguinte formato:

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

Nesses documentos:

• O campo _id mantém o código postal como uma string.

• O campo city contém o nome da cidade.

• O campo state contém a abreviação de estado de duas letras.

• O campo pop contém a população.

• O campo loc contém a localização como uma array [latitude, longitude] .

Estados com populações acima de 10 milhões

Para obter todos os estados com uma população superior a 10 milhões, use o seguinte pipeline de agregação:

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

Você deverá ver um resultado como o seguinte:

{ "_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 }

O aggregation pipeline acima é compilado a partir de dois operadores de pipeline: $group e $match.

O operador de pipeline $group exige o campo _id onde especificamos o agrupamento; os campos restantes especificam como gerar valor composto e devem usar uma das funções de agregação de grupo: $addToSet, $first, $last, $max, $min, $avg, $push, $sum. A sintaxe do operador de pipeline $match é a mesma que a sintaxe da query da operação de leitura.

O processo $group lê todos os documentos e para cada estado cria um documento separado, por exemplo:

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

O campo total_pop utiliza a função de agregação $sum para somar os valores de todos os campos pop nos documentos de origem.

Os documentos criados por $group são encaminhados para o operador de pipeline $match . Retorna os documentos com o valor do campo total_pop maior ou igual a 10 milhões.

População média da cidade por estado

Para obter os três primeiros estados com a maior população média por cidade, use a seguinte agregação:

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) "}",
"]");

Esse pipeline agregado produz:

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

O aggregation pipeline acima é compilado a partir de três operadores de pipeline: $group, $sort e $limit.

O primeiro operador $group cria os seguintes documentos:

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

Observe que o operador $group não pode usar documentos aninhados, exceto o campo _id .

O segundo $group utiliza estes documentos para criar os seguintes documentos:

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

Esses documentos são classificados pelo campo avg_city_pop em ordem decrescente. Finalmente, o operador de pipeline $limit retorna os primeiros 3 documentos do conjunto classificado.