Menu Docs
Página inicial do Docs
/
Idiomas
/
JavaScript
/
Controlador Node.js
/
Tutoriais de agregação

Descompactar arrays e grupo

Nesta página

  • Introdução
  • Resumo da tarefa de agregação
  • Antes de começar
  • Tutorial
  • Adicione um estágio de desenrolamento para desempacotar a array de pedidos de produtos
  • Adicione um estágio de correspondência para produtos que custam mais de US$ 15
  • Adicione um estágio de grupo para agrupar por tipo de produto
  • Adicione um estágio de definição para exibir o ID do produto
  • Adicione um estágio não definido para remover campos desnecessários
  • Executar o pipeline de agregação
  • Interpretar resultados

Introdução

Neste tutorial, você pode aprender a usar o driver Node.js para criar um pipeline de agregação, realizar a agregação em uma coleção e imprimir os resultados concluindo e executando um aplicativo de amostra. Esta agregação executa as seguintes operações:

  • Desencadeia um campo de array em documentos separados

  • Corresponde a um subconjunto de documentos pelo valor de um campo

  • Agrupa documentos por valores de campo comuns

  • Adiciona campos calculados a cada documento de resultado

Resumo da tarefa de agregação

Este tutorial demonstra como criar insights a partir de dados de pedido de cliente. Os resultados mostram a lista de produtos pedidos que custam mais de US$ 15, e cada documento contém o número de unidades vendidas e o valor total de venda de cada produto.

Este exemplo utiliza uma coleção, orders , que contém documentos que descrevem pedidos de produtos. Como cada pedido contém vários produtos, a primeira etapa da agregação é descompactar a array products em documentos de pedido de produto individual.

Antes de começar

Antes de iniciar este tutorial, conclua as instruções do Aggregation Template App para configurar um aplicação Node.js de trabalho.

Depois de configurar o aplicativo, acesse a coleção orders adicionando o seguinte código ao aplicativo:

const ordersColl = aggDB.collection("orders");

Exclua quaisquer dados existentes e insira dados de amostra na coleção orders como mostrado no seguinte código:

await ordersColl.deleteMany({});
const orderData = [
  {
    order_id: 6363763262239,
    products: [
      {
        prod_id: "abc12345",
        name: "Asus Laptop",
        price: 431,
      },
      {
        prod_id: "def45678",
        name: "Karcher Hose Set",
        price: 22,
      },
    ],
  },
  {
    order_id: 1197372932325,
    products: [
      {
        prod_id: "abc12345",
        name: "Asus Laptop",
        price: 429,
      },
    ],
  },
  {
    order_id: 9812343774839,
    products: [
      {
        prod_id: "pqr88223",
        name: "Morphy Richards Food Mixer",
        price: 431,
      },
      {
        prod_id: "def45678",
        name: "Karcher Hose Set",
        price: 21,
      },
    ],
  },
  {
    order_id: 4433997244387,
    products: [
      {
        prod_id: "def45678",
        name: "Karcher Hose Set",
        price: 23,
      },
      {
        prod_id: "jkl77336",
        name: "Picky Pencil Sharpener",
        price: 1,
      },
      {
        prod_id: "xyz11228",
        name: "Russell Hobbs Chrome Kettle",
        price: 16,
      },
    ],
  },
];
await ordersColl.insertMany(orderData);

Tutorial

1

Adicione um estágio de desenrolamento para desempacotar a array de pedidos de produtos

Primeiro, adicione um estágio $unwind para separar as entradas na array products em documentos individuais:

pipeline.push({
  $unwind: {
    path: "$products",
  },
});
2

Adicione um estágio de correspondência para produtos que custam mais de US$ 15

Em seguida, adicione um estágio $match que corresponda a produtos com um valor de products.price maior que 15:

pipeline.push({
  $match: {
    "products.price": {
      $gt: 15,
    },
  },
});
3

Adicione um estágio de grupo para agrupar por tipo de produto

Adicione um estágio $group para agrupar pedidos pelo valor do campo prod_id . Nesta etapa, adicione operações de agregação que criam os seguintes campos nos documentos de resultado:

  • product: o nome do produto

  • total_value: o valor total de todas as vendas do produto

  • quantity: o número de pedidos do produto

pipeline.push({
  $group: {
    _id: "$products.prod_id",
    product: { $first: "$products.name" },
    total_value: { $sum: "$products.price" },
    quantity: { $sum: 1 },
  },
});
4

Adicione um estágio de definição para exibir o ID do produto

Adicione um estágio $set para recriar o campo product_id a partir dos valores no campo _id que foram definidos durante o estágio $group :

pipeline.push({
  $set: {
    product_id: "$_id",
  },
});
5

Adicione um estágio não definido para remover campos desnecessários

Finalmente, adicione um estágio $unset . O estágio $unset remove o campo _id dos documentos de resultado:

pipeline.push({ $unset: ["_id"] });
6

Executar o pipeline de agregação

Adicione o seguinte código ao final do seu aplicativo para executar a aggregation na collection orders :

const aggregationResult = await ordersColl.aggregate(pipeline);

Por fim, execute o seguinte comando em seu shell para iniciar seu aplicativo:

node agg_tutorial.js
7

Interpretar resultados

A agregação retorna o seguinte resumo dos pedidos dos clientes de 2020:

{
  product: 'Asus Laptop',
  total_value: 860,
  quantity: 2,
  product_id: 'abc12345'
}
{
  product: 'Morphy Richards Food Mixer',
  total_value: 431,
  quantity: 1,
  product_id: 'pqr88223'
}
{
  product: 'Russell Hobbs Chrome Kettle',
  total_value: 16,
  quantity: 1,
  product_id: 'xyz11228'
}
{
  product: 'Karcher Hose Set',
  total_value: 66,
  quantity: 3,
  product_id: 'def45678'
}

Os documentos de resultado contêm detalhes sobre o valor total e a quantidade de pedidos de produtos que custam mais de US$ 15.

Para visualizar o código completo deste tutorial, consulte o Aplicativo de Descompactação de Arrays Concluído no Github Github.

Voltar

Grupo e total

Próximo

Junção um para um