Menu Docs
Página inicial do Docs
/ / /
Driver C
/ /

Exemplos de framework de aggregation

Nesta página

  • Requisitos
  • Agregações usando o conjunto de dados de códigos postais
  • Estados com populações acima de 10 milhões
  • População média da cidade por estado

Este documento fornece uma série de exemplos práticos que exibem os recursos da estrutura de agregação .

Os exemplos de aggregations usando o conjunto de dados de códigos postais usam um conjunto de dados disponível publicamente de todos os códigos postais e populações nos Estados Unidos. Esses dados estão disponíveis em: zips.json.

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

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] .

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

aggregation1.c
#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.

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.

Voltar

Operações de gravação em massa