Aggregation com o conjunto de dados de CEP

Modelo de dados

Cada documento na coleção zipcodes tem o seguinte formato:

{
  "_id": "10280",
  "city": "NEW YORK",
  "state": "NY",
  "pop": 5574,
  "loc": [
    -74.016323,
    40.710537
  ]
}

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

• O campo city contém o nome da cidade. Uma cidade pode ter mais de um CEP associado a ela, pois diferentes seções da cidade podem ter um CEP diferente.

• 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 um par de latitude e longitude.

aggregate() Método

Todos os exemplos a seguir usam o auxiliar aggregate() no mongosh.

O método aggregate() utiliza o pipeline de agregação para processar documentos em resultados agregados. Um pipeline de agregação consiste em stages, cada estágio processando os documentos à medida que eles passam pelo pipeline. Os documentos passam pelas etapas em sequência.

O método aggregate() em mongosh fornece um encapsulador para o comando de banco de dados aggregate. Consulte a documentação de seu driver para obter uma interface mais idiomática para operações de agregação de dados.

Retornar estados com populações acima de 10 milhões

A seguinte operação de aggregation retorna todos os estados com população total superior a 10 milhões:

db.zipcodes.aggregate( [
   { $group: { _id: "$state", totalPop: { $sum: "$pop" } } },
   { $match: { totalPop: { $gte: 10*1000*1000 } } }
] )

Neste exemplo, o pipeline de agregação consiste no estágio $group seguido pelo estágio $match:

• O estágio $group agrupa os documentos da coleção zipcode pelo campo state, calcula o campo totalPop para cada estado e gera um documento para cada estado exclusivo.

  Os novos documentos por estado têm dois campos: o campo _id e o campo totalPop. O campo _id contém o valor de state, ou seja, o grupo por campo. O campo totalPop é um campo calculado que contém a população total de cada estado. Para calcular o valor, $group utiliza o operador $sum para adicionar o campo de população (pop) para cada estado.

  Após a etapa $group, os documentos no pipeline se assemelham ao seguinte:

  {
    "_id" : "AK",
    "totalPop" : 550043
  }

• O estágio $match filtra esses documentos agrupados para produzir apenas os documentos cujo valor totalPop é maior ou igual a 10 milhões. O estágio $match não altera os documentos correspondentes, mas produz os documentos correspondentes sem modificações.

O SQL equivalente para esta operação de agregação é:

SELECT state, SUM(pop) AS totalPop
FROM zipcodes
GROUP BY state
HAVING totalPop >= (10*1000*1000)

Retornar a população média da cidade por estado

A seguinte operação de aggregation retorna as populações médias para as cidades em cada estado:

db.zipcodes.aggregate( [
   { $group: { _id: { state: "$state", city: "$city" }, pop: { $sum: "$pop" } } },
   { $group: { _id: "$_id.state", avgCityPop: { $avg: "$pop" } } }
] )

Neste exemplo, o pipeline de agregação consiste no estágio $group seguido por outro estágio $group:

• A primeira etapa $group agrupa os documentos pela combinação de city e state, utiliza a expressão $sum para calcular a população para cada combinação e gera um documento para cada combinação city e state. [1]

  Após esse estágio no pipeline, os documentos se parecem com o seguinte:

  {
    "_id" : {
      "state" : "CO",
      "city" : "EDGEWATER"
    },
    "pop" : 13154
  }

• Um segundo estágio $group agrupa os documentos no pipeline pelo campo _id.state (ou seja, o campo state dentro do documento _id), usa a expressão $avg para calcular a população média da cidade (avgCityPop) para cada estado e gera um documento para cada estado.

Os documentos resultantes desta operação de aggregation se parecem com o seguinte:

{
  "_id" : "MN",
  "avgCityPop" : 5335
}

Retornar as maiores e menores cidades por estado

A seguinte operação de aggregation retorna as menores e maiores cidades por população para cada estado:

db.zipcodes.aggregate( [
   { $group:
      {
        _id: { state: "$state", city: "$city" },
        pop: { $sum: "$pop" }
      }
   },
   { $sort: { pop: 1 } },
   { $group:
      {
        _id : "$_id.state",
        biggestCity:  { $last: "$_id.city" },
        biggestPop:   { $last: "$pop" },
        smallestCity: { $first: "$_id.city" },
        smallestPop:  { $first: "$pop" }
      }
   },
  // the following $project is optional, and
  // modifies the output format.
  { $project:
    { _id: 0,
      state: "$_id",
      biggestCity:  { name: "$biggestCity",  pop: "$biggestPop" },
      smallestCity: { name: "$smallestCity", pop: "$smallestPop" }
    }
  }
] )

Neste exemplo, o pipeline de agregação consiste em um estágio $group, um estágio $sort, outro estágio $group e um estágio $project:

• O primeiro stage $group grupos os documents pela combination de city e state, calculates o sum dos pop valores para cada combination e outputs um document para cada city e state combination.

  Nesse estágio no pipeline, os documentos se parecem com o seguinte:

  {
    "_id" : {
      "state" : "CO",
      "city" : "EDGEWATER"
    },
    "pop" : 13154
  }

• O estágio $sort ordena os documentos no pipeline pelo valor de campo pop, do menor para o maior, ou seja, pelo aumento do pedido. Essa operação não altera os documentos.

• O próximo estágio $group agrupa os documentos agora classificados pelo campo _id.state (ou seja, o campo state dentro do documento _id) e gera um documento para cada estado.

  O estágio também calcula os quatro campos seguintes para cada estado. Utilizando a expressão $last, o operador $group cria os campos biggestCity e biggestPop que armazenam a cidade com a maior população e essa população. Utilizando a expressão $first, o operador $group cria os campos smallestCity e smallestPop que armazenam a cidade com a população mais pequena e essa população.

  Os documentos, nesta etapa do pipeline, se assemelham ao seguinte:

  {
    "_id" : "WA",
    "biggestCity" : "SEATTLE",
    "biggestPop" : 520096,
    "smallestCity" : "BENGE",
    "smallestPop" : 2
  }

• O estágio final $project renomeia o campo _id para state e move os documentos incorporados biggestCity, biggestPop, smallestCity e smallestPop para biggestCity e smallestCity.

Os documentos de saída desta operação de agregação se assemelham ao seguinte:

{
  "state" : "RI",
  "biggestCity" : {
    "name" : "CRANSTON",
    "pop" : 176404
  },
  "smallestCity" : {
    "name" : "CLAYVILLE",
    "pop" : 45
  }
}