Desenrole arrays e agrupe dados

Este tutorial ilustra como construir um pipeline de agregação , executar a agregação em uma coleção e exibir os resultados usando a linguagem de sua escolha.

Sobre esta tarefa

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

O agregação pipeline 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

Antes de começar

➤ Use o menu suspenso Selecione seu idioma no canto superior direito para definir o idioma dos exemplos a seguir ou selecione MongoDB Shell.

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

Para criar a orders coleção, use o insertMany() método:

db.orders.deleteMany({})
db.orders.insertMany( [
   {
      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
         }
      ]
   }
] )

Criar o Aplicativo Modelo

Antes de começar a seguir este tutorial de agregação , você deve configurar um novo aplicativo C. Você pode usar esse aplicativo para se conectar a um sistema do MongoDB , inserir dados de amostra no MongoDB e executar o pipeline de agregação .

Dica

Para saber como instalar o driver e se conectar ao MongoDB, consulte o guia Introdução ao driver C.

Para saber mais sobre como realizar agregações no C Driver, consulte o Guia de agregação.

Depois de instalar o driver, crie um arquivo chamado agg-tutorial.c. Cole o código abaixo neste arquivo para criar um modelo de aplicativo para os tutoriais de agregação .

Importante

No código a seguir, leia os comentários do código para localizar as seções do código que você deve modificar para o tutorial que está seguindo.

Se você tentar executar o código sem fazer alterações, encontrará um erro de conexão.

#include <stdio.h>
#include <bson/bson.h>
#include <mongoc/mongoc.h>
int main(void)
{
    mongoc_init();
    // Replace the placeholder with your connection string.
    char *uri = "<connection string>";
    mongoc_client_t* client = mongoc_client_new(uri);
    // Get a reference to relevant collections.
    // ... mongoc_collection_t *some_coll = mongoc_client_get_collection(client, "agg_tutorials_db", "some_coll");
    // ... mongoc_collection_t *another_coll = mongoc_client_get_collection(client, "agg_tutorials_db", "another_coll");
    // Delete any existing documents in collections if needed.
    // ... {
    // ...     bson_t *filter = bson_new();
    // ...     bson_error_t error;
    // ...     if (!mongoc_collection_delete_many(some_coll, filter, NULL, NULL, &error))
    // ...     {
    // ...         fprintf(stderr, "Delete error: %s\n", error.message);
    // ...     }
    // ...     bson_destroy(filter);
    // ... }
    // Insert sample data into the collection or collections.
    // ... {
    // ...     size_t num_docs = ...;
    // ...     bson_t *docs[num_docs];
    // ...
    // ...     docs[0] = ...;
    // ...
    // ...     bson_error_t error;
    // ...     if (!mongoc_collection_insert_many(some_coll, (const bson_t **)docs, num_docs, NULL, NULL, &error))
    // ...     {
    // ...         fprintf(stderr, "Insert error: %s\n", error.message);
    // ...     }
    // ...
    // ...     for (int i = 0; i < num_docs; i++)
    // ...     {
    // ...         bson_destroy(docs[i]);
    // ...     }
    // ... }
    {
        const bson_t *doc;
        // Add code to create pipeline stages.
        bson_t *pipeline = BCON_NEW("pipeline", "[",
        // ... Add pipeline stages here.
        "]");
        // Run the aggregation.
        // ... mongoc_cursor_t *results = mongoc_collection_aggregate(some_coll, MONGOC_QUERY_NONE, pipeline, NULL, NULL);
        bson_destroy(pipeline);
        // Print the aggregation results.
        while (mongoc_cursor_next(results, &doc))
        {
            char *str = bson_as_canonical_extended_json(doc, NULL);
            printf("%s\n", str);
            bson_free(str);
        }
        bson_error_t error;
        if (mongoc_cursor_error(results, &error))
        {
            fprintf(stderr, "Aggregation error: %s\n", error.message);
        }
        mongoc_cursor_destroy(results);
    }
    // Clean up resources.
    // ... mongoc_collection_destroy(some_coll);
    mongoc_client_destroy(client);
    mongoc_cleanup();
    return EXIT_SUCCESS;
}

Para cada tutorial, você deve substituir o placeholder da string de conexão pela string de conexão da sua implantação.

Dica

Para saber como localizar a string de conexão do seu sistema, consulte a etapa Criar uma cadeia de conexão do guia de Introdução C.

Por exemplo, se sua string de conexão for "mongodb+srv://mongodb-example:27017", sua atribuição de string de conexão será semelhante à seguinte:

char *uri = "mongodb+srv://mongodb-example:27017";

Criar a coleção

Para criar a coleção orders e inserir os dados de amostra, adicione o seguinte código ao seu aplicação:

mongoc_collection_t *orders = mongoc_client_get_collection(client, "agg_tutorials_db", "orders");
{
    bson_t *filter = bson_new();
    bson_error_t error;
    if (!mongoc_collection_delete_many(orders, filter, NULL, NULL, &error))
    {
        fprintf(stderr, "Delete error: %s\n", error.message);
    }
    bson_destroy(filter);
}
{
    size_t num_docs = 4;
    bson_t *docs[num_docs];
    docs[0] = BCON_NEW(
        "order_id", BCON_INT64(6363763262239),
        "products", "[",
        "{",
        "prod_id", BCON_UTF8("abc12345"),
        "name", BCON_UTF8("Asus Laptop"),
        "price", BCON_INT32(431),
        "}",
        "{",
        "prod_id", BCON_UTF8("def45678"),
        "name", BCON_UTF8("Karcher Hose Set"),
        "price", BCON_INT32(22),
        "}",
        "]");
    docs[1] = BCON_NEW(
        "order_id", BCON_INT64(1197372932325),
        "products", "[",
        "{",
        "prod_id", BCON_UTF8("abc12345"),
        "name", BCON_UTF8("Asus Laptop"),
        "price", BCON_INT32(429),
        "}",
        "]");
    docs[2] = BCON_NEW(
        "order_id", BCON_INT64(9812343774839),
        "products", "[",
        "{",
        "prod_id", BCON_UTF8("pqr88223"),
        "name", BCON_UTF8("Morphy Richards Food Mixer"),
        "price", BCON_INT32(431),
        "}",
        "{",
        "prod_id", BCON_UTF8("def45678"),
        "name", BCON_UTF8("Karcher Hose Set"),
        "price", BCON_INT32(21),
        "}",
        "]");
    docs[3] = BCON_NEW(
        "order_id", BCON_INT64(4433997244387),
        "products", "[",
        "{",
        "prod_id", BCON_UTF8("def45678"),
        "name", BCON_UTF8("Karcher Hose Set"),
        "price", BCON_INT32(23),
        "}",
        "{",
        "prod_id", BCON_UTF8("jkl77336"),
        "name", BCON_UTF8("Picky Pencil Sharpener"),
        "price", BCON_INT32(1),
        "}",
        "{",
        "prod_id", BCON_UTF8("xyz11228"),
        "name", BCON_UTF8("Russell Hobbs Chrome Kettle"),
        "price", BCON_INT32(16),
        "}",
        "]");
    bson_error_t error;
    if (!mongoc_collection_insert_many(orders, (const bson_t **)docs, num_docs, NULL, NULL, &error))
    {
        fprintf(stderr, "Insert error: %s\n", error.message);
    }
    for (int i = 0; i < num_docs; i++)
    {
        bson_destroy(docs[i]);
    }
}

Criar o Aplicativo Modelo

Antes de começar a seguir um tutorial de agregação , você deve configurar um novo aplicativo C++ . Você pode usar esse aplicativo para se conectar a um sistema do MongoDB , inserir dados de amostra no MongoDB e executar o pipeline de agregação .

Dica

Para saber como instalar o driver e se conectar ao MongoDB, consulte o tutorial Introdução ao C++ .

Para saber mais sobre como usar o driver C++ , consulte a documentação da API.

Para saber mais sobre como executar agregações no driver C++ , consulte o guia Agregação.

Depois de instalar o driver, crie um arquivo chamado agg-tutorial.cpp. Cole o código abaixo neste arquivo para criar um modelo de aplicativo para os tutoriais de agregação .

Importante

No código a seguir, leia os comentários do código para localizar as seções do código que você deve modificar para o tutorial que está seguindo.

Se você tentar executar o código sem fazer alterações, encontrará um erro de conexão.

#include <iostream>
#include <bsoncxx/builder/basic/document.hpp>
#include <bsoncxx/builder/basic/kvp.hpp>
#include <bsoncxx/json.hpp>
#include <mongocxx/client.hpp>
#include <mongocxx/instance.hpp>
#include <mongocxx/pipeline.hpp>
#include <mongocxx/uri.hpp>
#include <chrono>
using bsoncxx::builder::basic::kvp;
using bsoncxx::builder::basic::make_document;
using bsoncxx::builder::basic::make_array;
int main() {
   mongocxx::instance instance;
   // Replace the placeholder with your connection string.
   mongocxx::uri uri("<connection string>");
   mongocxx::client client(uri);
   auto db = client["agg_tutorials_db"];
   // Delete existing data in the database, if necessary.
   db.drop();
   // Get a reference to relevant collections.
   // ... auto some_coll = db["..."];
   // ... auto another_coll = db["..."];
   // Insert sample data into the collection or collections.
   // ... some_coll.insert_many(docs);
   // Create an empty pipelne.
   mongocxx::pipeline pipeline;
   // Add code to create pipeline stages.
   // pipeline.match(make_document(...));
   // Run the aggregation and print the results.
   auto cursor = orders.aggregate(pipeline);
   for (auto&& doc : cursor) {
      std::cout << bsoncxx::to_json(doc, bsoncxx::ExtendedJsonMode::k_relaxed) << std::endl;
   }
}

Para cada tutorial, você deve substituir o placeholder da string de conexão pela string de conexão da sua implantação.

Dica

Para saber como localizar a string de conexão do seu sistema, consulte a etapa Criar uma cadeia de conexão do tutorial de Introdução do C++ .

Por exemplo, se sua string de conexão for "mongodb+srv://mongodb-example:27017", sua atribuição de string de conexão será semelhante à seguinte:

mongocxx::uri uri{"mongodb+srv://mongodb-example:27017"};

Criar a coleção

Para criar a coleção orders e inserir os dados de amostra, adicione o seguinte código ao seu aplicação:

auto orders = db["orders"];
std::vector<bsoncxx::document::value> order_docs = {
    bsoncxx::from_json(R"({
        "order_id": 6363763262239,
        "products": [
            {
                "prod_id": "abc12345",
                "name": "Asus Laptop",
                "price": 431
            },
            {
                "prod_id": "def45678",
                "name": "Karcher Hose Set",
                "price": 22
            }
        ]
    })"),
    bsoncxx::from_json(R"({
        "order_id": 1197372932325,
        "products": [
            {
                "prod_id": "abc12345",
                "name": "Asus Laptop",
                "price": 429
            }
        ]
    })"),
    bsoncxx::from_json(R"({
        "order_id": 9812343774839,
        "products": [
            {
                "prod_id": "pqr88223",
                "name": "Morphy Richards Food Mixer",
                "price": 431
            },
            {
                "prod_id": "def45678",
                "name": "Karcher Hose Set",
                "price": 21
            }
        ]
    })"),
    bsoncxx::from_json(R"({
        "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
            }
        ]
    })")
};
orders.insert_many(order_docs); // Might throw an exception

Criar o Aplicativo Modelo

Antes de começar a seguir este tutorial de agregação , você deve configurar um novo aplicativo C#/ .NET . Você pode usar esse aplicativo para se conectar a um sistema do MongoDB , inserir dados de amostra no MongoDB e executar o pipeline de agregação .

Dica

Para saber como instalar o driver e se conectar ao MongoDB, consulte o guia de início rápido do driver C#/ .NET .

Para saber mais sobre como executar agregações no driver C#/ .NET , consulte o guia Agregação.

Depois de instalar o driver, cole o seguinte código no seu arquivo Program.cs para criar um modelo de aplicativo para os tutoriais de agregação .

Importante

No código a seguir, leia os comentários do código para localizar as seções do código que você deve modificar para o tutorial que está seguindo.

Se você tentar executar o código sem fazer alterações, encontrará um erro de conexão.

using MongoDB.Driver;
using MongoDB.Bson;
using MongoDB.Bson.Serialization.Attributes;
// Define data model classes.
// ... public class MyClass { ... }
// Replace the placeholder with your connection string.
var uri = "<connection string>";
var client = new MongoClient(uri);
var aggDB = client.GetDatabase("agg_tutorials_db");
// Get a reference to relevant collections.
// ... var someColl = aggDB.GetCollection<MyClass>("someColl");
// ... var anotherColl = aggDB.GetCollection<MyClass>("anotherColl");
// Delete any existing documents in collections if needed.
// ... someColl.DeleteMany(Builders<MyClass>.Filter.Empty);
// Insert sample data into the collection or collections.
// ... someColl.InsertMany(new List<MyClass> { ... });
// Add code to chain pipeline stages to the Aggregate() method.
// ... var results = someColl.Aggregate().Match(...);
// Print the aggregation results.
foreach (var result in results.ToList())
{
  Console.WriteLine(result);
}

Para cada tutorial, você deve substituir o placeholder da string de conexão pela string de conexão da sua implantação.

Dica

Para saber como localizar a string de conexão do seu sistema, consulte a etapa Configurar um cluster de camada grátis no Atlas do guia de Início Rápido de C#.

Por exemplo, se sua string de conexão for "mongodb+srv://mongodb-example:27017", sua atribuição de string de conexão será semelhante à seguinte:

var uri = "mongodb+srv://mongodb-example:27017";

Criar a coleção

Primeiro, crie classes C# para modelar os dados na collection orders:

public class Order
{
  [BsonId]
  public ObjectId Id { get; set; }
  public long OrderId { get; set; }
  public List<Product> Products { get; set; }
}
public class OrderUnwound
{
  public long OrderId { get; set; }
  public Product Products { get; set; }
}
public class Product
{
  public string ProductId { get; set; }
  public string Name { get; set; }
  public int Price { get; set; }
}

Para criar a coleção orders e inserir os dados de amostra, adicione o seguinte código ao seu aplicação:

var orders = aggDB.GetCollection<Order>("orders");
orders.DeleteMany(Builders<Order>.Filter.Empty);
orders.InsertMany(new List<Order>
    {
        new Order
        {
            OrderId = 6363763262239L,
            Products = new List<Product>
            {
                new Product
                {
                    ProductId = "abc12345",
                    Name = "Asus Laptop",
                    Price = 431
                },
                new Product
                {
                    ProductId = "def45678",
                    Name = "Karcher Hose Set",
                    Price = 22
                }
            }
        },
        new Order
        {
            OrderId = 1197372932325L,
            Products = new List<Product>
            {
                new Product
                {
                    ProductId = "abc12345",
                    Name = "Asus Laptop",
                    Price = 429
                }
            }
        },
        new Order
        {
            OrderId = 9812343774839L,
            Products = new List<Product>
            {
                new Product
                {
                    ProductId = "pqr88223",
                    Name = "Morphy Richards Food Mixer",
                    Price = 431
                },
                new Product
                {
                    ProductId = "def45678",
                    Name = "Karcher Hose Set",
                    Price = 21
                }
            }
        },
        new Order
        {
            OrderId = 4433997244387L,
            Products = new List<Product>
            {
                new Product
                {
                    ProductId = "def45678",
                    Name = "Karcher Hose Set",
                    Price = 23
                },
                new Product
                {
                    ProductId = "jkl77336",
                    Name = "Picky Pencil Sharpener",
                    Price = 1
                },
                new Product
                {
                    ProductId = "xyz11228",
                    Name = "Russell Hobbs Chrome Kettle",
                    Price = 16
                }
            }
        }
    });

Criar o Aplicativo Modelo

Antes de começar a seguir este tutorial de agregação , você deve configurar um novo aplicativo Go. Você pode usar esse aplicativo para se conectar a um sistema do MongoDB , inserir dados de amostra no MongoDB e executar o pipeline de agregação .

Dica

Para saber como instalar o driver e se conectar ao MongoDB, consulte o guia Início Rápido do Driver Go.

Para saber mais sobre como executar agregações no Go Driver, consulte o guia Agregação.

Depois de instalar o driver, crie um arquivo chamado agg_tutorial.go. Cole o código abaixo neste arquivo para criar um modelo de aplicativo para os tutoriais de agregação .

Importante

No código a seguir, leia os comentários do código para localizar as seções do código que você deve modificar para o tutorial que está seguindo.

Se você tentar executar o código sem fazer alterações, encontrará um erro de conexão.

package main
import (
    "context"
    "fmt"
    "log"
    "time"
    "go.mongodb.org/mongo-driver/v2/bson"
    "go.mongodb.org/mongo-driver/v2/mongo"
    "go.mongodb.org/mongo-driver/v2/mongo/options"
)
// Define structs.
// type MyStruct struct { ... }
func main() {
    // Replace the placeholder with your connection string.
    const uri = "<connection string>"
    client, err := mongo.Connect(options.Client().ApplyURI(uri))
    if err != nil {
        log.Fatal(err)
    }
    defer func() {
        if err = client.Disconnect(context.TODO()); err != nil {
            log.Fatal(err)
        }
    }()
    aggDB := client.Database("agg_tutorials_db")
    // Get a reference to relevant collections.
    // ... someColl := aggDB.Collection("...")
    // ... anotherColl := aggDB.Collection("...")
    // Delete any existing documents in collections if needed.
    // ... someColl.DeleteMany(context.TODO(), bson.D{})
    // Insert sample data into the collection or collections.
    // ... _, err = someColl.InsertMany(...)
    // Add code to create pipeline stages.
    // ... myStage := bson.D{{...}}
    // Create a pipeline that includes the stages.
    // ... pipeline := mongo.Pipeline{...}
    // Run the aggregation.
    // ... cursor, err := someColl.Aggregate(context.TODO(), pipeline)
    if err != nil {
        log.Fatal(err)
    }
    defer func() {
        if err := cursor.Close(context.TODO()); err != nil {
            log.Fatalf("failed to close cursor: %v", err)
        }
    }()
    // Decode the aggregation results.
    var results []bson.D
    if err = cursor.All(context.TODO(), &results); err != nil {
        log.Fatalf("failed to decode results: %v", err)
    }
    // Print the aggregation results.
    for _, result := range results {
        res, _ := bson.MarshalExtJSON(result, false, false)
        fmt.Println(string(res))
    }
}

Para cada tutorial, você deve substituir o placeholder da string de conexão pela string de conexão da sua implantação.

Dica

Para saber como localizar a string de conexão do seu sistema, consulte a etapa Criar um cluster MongoDB do guia Go Quick Start.

Por exemplo, se sua string de conexão for "mongodb+srv://mongodb-example:27017", sua atribuição de string de conexão será semelhante à seguinte:

const uri = "mongodb+srv://mongodb-example:27017";

Criar a coleção

Primeiro, crie estruturas Go para modelar os dados na collection orders:

type Order struct {
	OrderID  int       `bson:"order_id"`
	Products []Product `bson:"products"`
}
type Product struct {
	ProductID string `bson:"prod_id"`
	Name      string `bson:"name"`
	Price     int    `bson:"price"`
}

Para criar a coleção orders e inserir os dados de amostra, adicione o seguinte código ao seu aplicação:

orders := aggDB.Collection("orders")
orders.DeleteMany(context.TODO(), bson.D{})
_, err = orders.InsertMany(context.TODO(), []interface{}{
	Order{
		OrderID: 6363763262239,
		Products: []Product{
			{ProductID: "abc12345", Name: "Asus Laptop", Price: 431},
			{ProductID: "def45678", Name: "Karcher Hose Set", Price: 22},
		},
	},
	Order{
		OrderID: 1197372932325,
		Products: []Product{
			{ProductID: "abc12345", Name: "Asus Laptop", Price: 429},
		},
	},
	Order{
		OrderID: 9812343774839,
		Products: []Product{
			{ProductID: "pqr88223", Name: "Morphy Richards Food Mixer", Price: 431},
			{ProductID: "def45678", Name: "Karcher Hose Set", Price: 21},
		},
	},
	Order{
		OrderID: 4433997244387,
		Products: []Product{
			{ProductID: "def45678", Name: "Karcher Hose Set", Price: 23},
			{ProductID: "jkl77336", Name: "Picky Pencil Sharpene", Price: 1},
			{ProductID: "xyz11228", Name: "Russell Hobbs Chrome Kettle", Price: 16},
		},
	},
})
if err != nil {
	log.Fatal(err)
}

Criar o Aplicativo Modelo

Antes de começar a seguir um tutorial de agregação , você deve configurar um novo aplicativo Java . Você pode usar esse aplicativo para se conectar a um sistema do MongoDB , inserir dados de amostra no MongoDB e executar o pipeline de agregação .

Dica

Para saber como instalar o driver e se conectar ao MongoDB, consulte o guia Introdução ao driver Java .

Para saber mais sobre como realizar agregações no Driver Java Sync, consulte o guia Agregação.

Depois de instalar o driver, crie um arquivo chamado AggTutorial.java. Cole o código abaixo neste arquivo para criar um modelo de aplicativo para os tutoriais de agregação .

Importante

No código a seguir, leia os comentários do código para localizar as seções do código que você deve modificar para o tutorial que está seguindo.

Se você tentar executar o código sem fazer alterações, encontrará um erro de conexão.

package org.example;
// Modify imports for each tutorial as needed.
import com.mongodb.client.*;
import com.mongodb.client.model.Aggregates;
import com.mongodb.client.model.Filters;
import com.mongodb.client.model.Sorts;
import org.bson.Document;
import org.bson.conversions.Bson;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class AggTutorial {
    public static void main( String[] args ) {
        // Replace the placeholder with your connection string.
        String uri = "<connection string>";
        try (MongoClient mongoClient = MongoClients.create(uri)) {
            MongoDatabase aggDB = mongoClient.getDatabase("agg_tutorials_db");
            // Get a reference to relevant collections.
            // ... MongoCollection<Document> someColl = ...
            // ... MongoCollection<Document> anotherColl = ...
            // Delete any existing documents in collections if needed.
            // ... someColl.deleteMany(Filters.empty());
            // Insert sample data into the collection or collections.
            // ... someColl.insertMany(...);
            // Create an empty pipeline array.
            List<Bson> pipeline = new ArrayList<>();
            // Add code to create pipeline stages.
            // ... pipeline.add(...);
            // Run the aggregation.
            // ... AggregateIterable<Document> aggregationResult = someColl.aggregate(pipeline);
            // Print the aggregation results.
            for (Document document : aggregationResult) {
                System.out.println(document.toJson());
            }
        }
    }
}

Para cada tutorial, você deve substituir o placeholder da string de conexão pela string de conexão da sua implantação.

Dica

Para saber como localizar a string de conexão do seu sistema, consulte a etapa Criar uma connection string do guia Início Rápido do Java Sync.

Por exemplo, se sua string de conexão for "mongodb+srv://mongodb-example:27017", sua atribuição de string de conexão será semelhante à seguinte:

String uri = "mongodb+srv://mongodb-example:27017";

Criar a coleção

Para criar a coleção orders e inserir os dados de amostra, adicione o seguinte código ao seu aplicação:

MongoCollection<Document> orders = aggDB.getCollection("orders");
orders.deleteMany(Filters.empty());
orders.insertMany(
        Arrays.asList(
                new Document("order_id", 6363763262239f)
                        .append("products", Arrays.asList(
                                new Document("prod_id", "abc12345")
                                        .append("name", "Asus Laptop")
                                        .append("price", 431),
                                new Document("prod_id", "def45678")
                                        .append("name", "Karcher Hose Set")
                                        .append("price", 22)
                        )),
                new Document("order_id", 1197372932325f)
                        .append("products", Collections.singletonList(
                                new Document("prod_id", "abc12345")
                                        .append("name", "Asus Laptop")
                                        .append("price", 429)
                        )),
                new Document("order_id", 9812343774839f)
                        .append("products", Arrays.asList(
                                new Document("prod_id", "pqr88223")
                                        .append("name", "Morphy Richards Food Mixer")
                                        .append("price", 431),
                                new Document("prod_id", "def45678")
                                        .append("name", "Karcher Hose Set")
                                        .append("price", 21)
                                )),
                new Document("order_id", 4433997244387f)
                        .append("products", Arrays.asList(
                                new Document("prod_id", "def45678")
                                        .append("name", "Karcher Hose Set")
                                        .append("price", 23),
                                new Document("prod_id", "jkl77336")
                                        .append("name", "Picky Pencil Sharpener")
                                        .append("price", 1),
                                new Document("prod_id", "xyz11228")
                                        .append("name", "Russell Hobbs Chrome Kettle")
                                        .append("price", 16)
                                ))
        )
);

Criar o Aplicativo Modelo

Antes de começar a seguir um tutorial de agregação , você deve configurar um novo aplicativo Kotlin . Você pode usar esse aplicativo para se conectar a um sistema do MongoDB , inserir dados de amostra no MongoDB e executar o pipeline de agregação .

Dica

Para saber como instalar o driver e se conectar ao MongoDB, consulte o guia Início rápido do driver Kotlin .

Para saber mais sobre como executar agregações no Driver Kotlin , consulte o guia Agregação.

Além do driver, você também deve adicionar as seguintes dependências ao seu arquivo build.gradle.kts e recarregar seu projeto:

dependencies {
    // Implements Kotlin serialization
    implementation("org.jetbrains.kotlinx:kotlinx-serialization-core:1.5.1")
    // Implements Kotlin date and time handling
    implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.6.1")
}

Depois de instalar o driver, crie um arquivo chamado AggTutorial.kt. Cole o código abaixo neste arquivo para criar um modelo de aplicativo para os tutoriais de agregação .

Importante

No código a seguir, leia os comentários do código para localizar as seções do código que você deve modificar para o tutorial que está seguindo.

Se você tentar executar o código sem fazer alterações, encontrará um erro de conexão.

package org.example
// Modify imports for each tutorial as needed.
import com.mongodb.client.model.*
import com.mongodb.kotlin.client.coroutine.MongoClient
import kotlinx.coroutines.runBlocking
import kotlinx.datetime.LocalDateTime
import kotlinx.datetime.toJavaLocalDateTime
import kotlinx.serialization.Contextual
import kotlinx.serialization.Serializable
import org.bson.Document
import org.bson.conversions.Bson
// Define data classes.
@Serializable
data class MyClass(
    ...
)
suspend fun main() {
    // Replace the placeholder with your connection string.
    val uri = "<connection string>"
    MongoClient.create(uri).use { mongoClient ->
        val aggDB = mongoClient.getDatabase("agg_tutorials_db")
        // Get a reference to relevant collections.
        // ... val someColl = ...
        // Delete any existing documents in collections if needed.
        // ... someColl.deleteMany(empty())
        // Insert sample data into the collection or collections.
        // ... someColl.insertMany( ... )
        // Create an empty pipeline.
        val pipeline = mutableListOf<Bson>()
        // Add code to create pipeline stages.
        // ... pipeline.add(...)
        // Run the aggregation.
        // ... val aggregationResult = someColl.aggregate<Document>(pipeline)
        // Print the aggregation results.
        aggregationResult.collect { println(it) }
    }
}

Para cada tutorial, você deve substituir o placeholder da string de conexão pela string de conexão da sua implantação.

Dica

Para saber como localizar a string de conexão do seu sistema, consulte a etapa Conectar-se ao cluster do guia de início rápido do driver Kotlin .

Por exemplo, se sua string de conexão for "mongodb+srv://mongodb-example:27017", sua atribuição de string de conexão será semelhante à seguinte:

val uri = "mongodb+srv://mongodb-example:27017"

Criar a coleção

Primeiro, crie classes de dados Kotlin para modelar os dados na coleção orders:

@Serializable
data class Order(
    val orderID: Float,
    val products: List<Product>
)
@Serializable
data class Product(
    val prodID: String,
    val name: String,
    val price: Int
)

Para criar a coleção orders e inserir os dados de amostra, adicione o seguinte código ao seu aplicação:

val orders = aggDB.getCollection<Order>("orders")
orders.deleteMany(Filters.empty())
orders.insertMany(
    listOf(
        Order(
            6363763262239f, listOf(
                Product("abc12345", "Asus Laptop", 431),
                Product("def45678", "Karcher Hose Set", 22)
            )
        ),
        Order(
            1197372932325f, listOf(
                Product("abc12345", "Asus Laptop", 429)
            )
        ),
        Order(
            9812343774839f, listOf(
                Product("pqr88223", "Morphy Richards Food Mixer", 431),
                Product("def45678", "Karcher Hose Set", 21)
            )
        ),
        Order(
            4433997244387f, listOf(
                Product("def45678", "Karcher Hose Set", 23),
                Product("jkl77336", "Picky Pencil Sharpener", 1),
                Product("xyz11228", "Russell Hobbs Chrome Kettle", 16)
            )
        )
    )
)

Criar o Aplicativo Modelo

Antes de começar a seguir este tutorial de agregação , você deve configurar um novo aplicativo Node.js Você pode usar esse aplicativo para se conectar a um sistema do MongoDB , inserir dados de amostra no MongoDB e executar o pipeline de agregação .

Dica

Para saber como instalar o driver e se conectar ao MongoDB, consulte o guia de início rápido do driver do Node.js

Para saber mais sobre como realizar agregações no Driver Node.js , consulte o Guia de agregação.

Depois de instalar o driver, crie um arquivo chamado agg_tutorial.js. Cole o código abaixo neste arquivo para criar um modelo de aplicativo para os tutoriais de agregação .

Importante

No código a seguir, leia os comentários do código para localizar as seções do código que você deve modificar para o tutorial que está seguindo.

Se você tentar executar o código sem fazer alterações, encontrará um erro de conexão.

const { MongoClient } = require("mongodb");
// Replace the placeholder with your connection string.
const uri = "<connection string>";
const client = new MongoClient(uri);
async function run() {
  try {
    const aggDB = client.db("agg_tutorials_db");
    // Get a reference to relevant collections.
    // ... const someColl =
    // ... const anotherColl =
    // Delete any existing documents in collections.
    // ... await someColl.deleteMany({});
    // Insert sample data into the collection or collections.
    // ... const someData = [ ... ];
    // ... await someColl.insertMany(someData);
    // Create an empty pipeline array.
    const pipeline = [];
    // Add code to create pipeline stages.
    // ... pipeline.push({ ... })
    // Run the aggregation.
    // ... const aggregationResult = ...
    // Print the aggregation results.
    for await (const document of aggregationResult) {
      console.log(document);
    }
  } finally {
    await client.close();
  }
}
run().catch(console.dir);

Para cada tutorial, você deve substituir o placeholder da string de conexão pela string de conexão da sua implantação.

Dica

Para saber como localizar a string de conexão do seu sistema, consulte a etapa Criar uma connection string do guia de Início Rápido do Node.js

Por exemplo, se sua string de conexão for "mongodb+srv://mongodb-example:27017", sua atribuição de string de conexão será semelhante à seguinte:

const uri = "mongodb+srv://mongodb-example:27017";

Criar a coleção

Para criar a coleção orders e inserir os dados de amostra, adicione o seguinte código ao seu aplicação:

const orders = aggDB.collection("orders");
await orders.deleteMany({});
await orders.insertMany([
  {
    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,
      },
    ],
  },
]);

Criar o Aplicativo Modelo

Antes de começar a seguir este tutorial de agregação , você deve configurar um novo aplicativo PHP. Você pode usar esse aplicativo para se conectar a um sistema do MongoDB , inserir dados de amostra no MongoDB e executar o pipeline de agregação .

Dica

Para saber como instalar a biblioteca PHP e se conectar ao MongoDB, consulte o tutorial Introdução à biblioteca PHP.

Para saber mais sobre como realizar agregações na biblioteca PHP, consulte o Guia de agregação.

Depois de instalar a biblioteca, crie um arquivo chamado agg_tutorial.php. Cole o código abaixo neste arquivo para criar um modelo de aplicativo para os tutoriais de agregação .

Importante

No código a seguir, leia os comentários do código para localizar as seções do código que você deve modificar para o tutorial que está seguindo.

Se você tentar executar o código sem fazer alterações, encontrará um erro de conexão.

<?php
require 'vendor/autoload.php';
// Modify imports for each tutorial as needed.
use MongoDB\Client;
use MongoDB\BSON\UTCDateTime;
use MongoDB\Builder\Pipeline;
use MongoDB\Builder\Stage;
use MongoDB\Builder\Type\Sort;
use MongoDB\Builder\Query;
use MongoDB\Builder\Expression;
use MongoDB\Builder\Accumulator;
use function MongoDB\object;
// Replace the placeholder with your connection string.
$uri = '<connection string>';
$client = new Client($uri);
// Get a reference to relevant collections.
// ... $someColl = $client->agg_tutorials_db->someColl;
// ... $anotherColl = $client->agg_tutorials_db->anotherColl;
// Delete any existing documents in collections if needed.
// ... $someColl->deleteMany([]);
// Insert sample data into the collection or collections.
// ... $someColl->insertMany(...);
// Add code to create pipeline stages within the Pipeline instance.
// ... $pipeline = new Pipeline(...);
// Run the aggregation.
// ... $cursor = $someColl->aggregate($pipeline);
// Print the aggregation results.
foreach ($cursor as $doc) {
    echo json_encode($doc, JSON_PRETTY_PRINT), PHP_EOL;
}

Para cada tutorial, você deve substituir o placeholder da string de conexão pela string de conexão da sua implantação.

Dica

Para saber como localizar a string de conexão do seu sistema, consulte a etapa Criar uma connection string do tutorial de Introdução à biblioteca PHP.

Por exemplo, se sua string de conexão for "mongodb+srv://mongodb-example:27017", sua atribuição de string de conexão será semelhante à seguinte:

$uri = 'mongodb+srv://mongodb-example:27017';

Criar a coleção

Para criar a coleção orders e inserir os dados de amostra, adicione o seguinte código ao seu aplicação:

$orders = $client->agg_tutorials_db->orders;
$orders->deleteMany([]);
$orders->insertMany(
    [
        [
            '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,
                ],
            ],
        ]
    ]
);

Criar o Aplicativo Modelo

Antes de começar a seguir este tutorial de agregação , você deve configurar um novo aplicativo Python. Você pode usar esse aplicativo para se conectar a um sistema do MongoDB , inserir dados de amostra no MongoDB e executar o pipeline de agregação .

Dica

Para saber como instalar o PyMongo e se conectar ao MongoDB, consulte o tutorial Introdução ao PyMongo.

Para saber mais sobre como realizar agregações no PyMongo, consulte o Guia de agregação.

Depois de instalar a biblioteca, crie um arquivo chamado agg_tutorial.py. Cole o código abaixo neste arquivo para criar um modelo de aplicativo para os tutoriais de agregação .

Importante

No código a seguir, leia os comentários do código para localizar as seções do código que você deve modificar para o tutorial que está seguindo.

Se você tentar executar o código sem fazer alterações, encontrará um erro de conexão.

# Modify imports for each tutorial as needed.
from pymongo import MongoClient
# Replace the placeholder with your connection string.
uri = "<connection string>"
client = MongoClient(uri)
try:
    agg_db = client["agg_tutorials_db"]
    # Get a reference to relevant collections.
    # ... some_coll = agg_db["some_coll"]
    # ... another_coll = agg_db["another_coll"]
    # Delete any existing documents in collections if needed.
    # ... some_coll.delete_many({})
    # Insert sample data into the collection or collections.
    # ... some_coll.insert_many(...)
    # Create an empty pipeline array.
    pipeline = []
    # Add code to create pipeline stages.
    # ... pipeline.append({...})
    # Run the aggregation.
    # ... aggregation_result = ...
    # Print the aggregation results.
    for document in aggregation_result:
        print(document)
finally:
    client.close()

Para cada tutorial, você deve substituir o placeholder da string de conexão pela string de conexão da sua implantação.

Dica

Para saber como localizar a string de conexão do seu sistema, consulte a etapa Criar uma connection string do tutorial de Introdução à biblioteca PHP.

Por exemplo, se sua string de conexão for "mongodb+srv://mongodb-example:27017", sua atribuição de string de conexão será semelhante à seguinte:

uri = "mongodb+srv://mongodb-example:27017"

Criar a coleção

Para criar a coleção orders e inserir os dados de amostra, adicione o seguinte código ao seu aplicação:

orders_coll = agg_db["orders"]
orders_coll.delete_many({})
order_data = [
    {
        "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,
            },
        ],
    },
]
orders_coll.insert_many(order_data)

Criar o Aplicativo Modelo

Antes de começar a seguir este tutorial de agregação , você deve configurar um novo aplicativo Ruby. Você pode usar esse aplicativo para se conectar a um sistema do MongoDB , inserir dados de amostra no MongoDB e executar o pipeline de agregação .

Dica

Para saber como instalar o Ruby Driver e se conectar ao MongoDB, consulte o guia Introdução ao Ruby Driver.

Para saber mais sobre como realizar agregações no Driver Ruby, consulte o guia Agregação.

Depois de instalar o driver, crie um arquivo chamado agg_tutorial.rb. Cole o código abaixo neste arquivo para criar um modelo de aplicativo para os tutoriais de agregação .

Importante

No código a seguir, leia os comentários do código para localizar as seções do código que você deve modificar para o tutorial que está seguindo.

Se você tentar executar o código sem fazer alterações, encontrará um erro de conexão.

# typed: strict
require 'mongo'
require 'bson'
# Replace the placeholder with your connection string.
uri = "<connection string>"
Mongo::Client.new(uri) do |client|
  agg_db = client.use('agg_tutorials_db')
  # Get a reference to relevant collections.
  # ... some_coll = agg_db[:some_coll]
  # Delete any existing documents in collections if needed.
  # ... some_coll.delete_many({})
  # Insert sample data into the collection or collections.
  # ... some_coll.insert_many( ... )
  # Add code to create pipeline stages within the array.
  # ... pipeline = [ ... ]
  # Run the aggregation.
  # ... aggregation_result = some_coll.aggregate(pipeline)
  # Print the aggregation results.
  aggregation_result.each do |doc|
    puts doc
  end
end

Para cada tutorial, você deve substituir o placeholder da string de conexão pela string de conexão da sua implantação.

Dica

Para saber como localizar a string de conexão do seu sistema, consulte a etapa Criar uma connection string do guia de Introdução ao Ruby.

Por exemplo, se sua string de conexão for "mongodb+srv://mongodb-example:27017", sua atribuição de string de conexão será semelhante à seguinte:

uri = "mongodb+srv://mongodb-example:27017"

Criar a coleção

Para criar a coleção orders e inserir os dados de amostra, adicione o seguinte código ao seu aplicação:

orders = agg_db[:orders]
orders.delete_many({})
orders.insert_many(
  [
    {
      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,
        },
      ],
    },
  ]
)

Criar o Aplicativo Modelo

Antes de começar a seguir este tutorial de agregação , você deve configurar um novo aplicativo Rust. Você pode usar esse aplicativo para se conectar a um sistema do MongoDB , inserir dados de amostra no MongoDB e executar o pipeline de agregação .

Dica

Para saber como instalar o driver e se conectar ao MongoDB, consulte o guia Início Rápido do Driver Rust.

Para saber mais sobre como realizar agregações no Driver Rust, consulte o guia Agregação.

Depois de instalar o driver, crie um arquivo chamado agg-tutorial.rs. Cole o código abaixo neste arquivo para criar um modelo de aplicativo para os tutoriais de agregação .

Importante

No código a seguir, leia os comentários do código para localizar as seções do código que você deve modificar para o tutorial que está seguindo.

Se você tentar executar o código sem fazer alterações, encontrará um erro de conexão.

use mongodb::{
    bson::{doc, Document},
    options::ClientOptions,
    Client,
};
use futures::stream::TryStreamExt;
use std::error::Error;
// Define structs.
// #[derive(Debug, Serialize, Deserialize)]
// struct MyStruct { ... }
#[tokio::main]
async fn main() mongodb::error::Result<()> {
    // Replace the placeholder with your connection string.
    let uri = "<connection string>";
    let client = Client::with_uri_str(uri).await?;
    let agg_db = client.database("agg_tutorials_db");
    // Get a reference to relevant collections.
    // ... let some_coll: Collection<T> = agg_db.collection("...");
    // ... let another_coll: Collection<T> = agg_db.collection("...");
    // Delete any existing documents in collections if needed.
    // ... some_coll.delete_many(doc! {}).await?;
    // Insert sample data into the collection or collections.
    // ... some_coll.insert_many(vec![...]).await?;
    // Create an empty pipeline.
    let mut pipeline = Vec::new();
    // Add code to create pipeline stages.
    // pipeline.push(doc! { ... });
    // Run the aggregation and print the results.
    let mut results = some_coll.aggregate(pipeline).await?;
    while let Some(result) = results.try_next().await? {
       println!("{:?}\n", result);
    }
    Ok(())
}

Para cada tutorial, você deve substituir o placeholder da string de conexão pela string de conexão da sua implantação.

Dica

Para saber como localizar a string de conexão do seu sistema, consulte a etapa Criar uma connection string do guia Rust Quick Start.

Por exemplo, se sua string de conexão for "mongodb+srv://mongodb-example:27017", sua atribuição de string de conexão será semelhante à seguinte:

let uri = "mongodb+srv://mongodb-example:27017";

Criar a coleção

Primeiro, crie estruturas Rust para modelar os dados na collection orders:

#[derive(Debug, Serialize, Deserialize)]
struct Product {
    prod_id: String,
    name: String,
    price: i32,
}
#[derive(Debug, Serialize, Deserialize)]
struct Order {
    order_id: i64,
    products: Vec<Product>,
}

Para criar a coleção orders e inserir os dados de amostra, adicione o seguinte código ao seu aplicação:

let orders_coll: Collection<Order> = agg_db.collection("orders");
orders.delete_many(doc! {}).await?;
let orders = vec![
    Order {
        order_id: 6363763262239,
        products: vec![
            Product {
                prod_id: "abc12345".to_string(),
                name: "Asus Laptop".to_string(),
                price: 431,
            },
            Product {
                prod_id: "def45678".to_string(),
                name: "Karcher Hose Set".to_string(),
                price: 22,
            },
        ],
    },
    Order {
        order_id: 1197372932325,
        products: vec![Product {
            prod_id: "abc12345".to_string(),
            name: "Asus Laptop".to_string(),
            price: 429,
        }],
    },
    Order {
        order_id: 9812343774839,
        products: vec![
            Product {
                prod_id: "pqr88223".to_string(),
                name: "Morphy Richards Food Mixer".to_string(),
                price: 431,
            },
            Product {
                prod_id: "def45678".to_string(),
                name: "Karcher Hose Set".to_string(),
                price: 21,
            },
        ],
    },
    Order {
        order_id: 4433997244387,
        products: vec![
            Product {
                prod_id: "def45678".to_string(),
                name: "Karcher Hose Set".to_string(),
                price: 23,
            },
            Product {
                prod_id: "jkl77336".to_string(),
                name: "Picky Pencil Sharpene".to_string(),
                price: 1,
            },
            Product {
                prod_id: "xyz11228".to_string(),
                name: "Russell Hobbs Chrome Kettle".to_string(),
                price: 16,
            },
        ],
    },
];
orders_coll.insert_many(orders).await?;

Criar o Aplicativo Modelo

Antes de começar a seguir um tutorial de agregação , você deve configurar um novo aplicativo Scala. Você pode usar esse aplicativo para se conectar a um sistema do MongoDB , inserir dados de amostra no MongoDB e executar o pipeline de agregação .

Dica

Para saber como instalar o driver e se conectar ao MongoDB, consulte o guia Introdução ao driver Scala.

Para saber mais sobre como executar agregações no Driver Scala, consulte o Guia de agregação.

Depois de instalar o driver, crie um arquivo chamado AggTutorial.scala. Cole o código abaixo neste arquivo para criar um modelo de aplicativo para os tutoriais de agregação .

Importante

No código a seguir, leia os comentários do código para localizar as seções do código que você deve modificar para o tutorial que está seguindo.

Se você tentar executar o código sem fazer alterações, encontrará um erro de conexão.

package org.example;
// Modify imports for each tutorial as needed.
import org.mongodb.scala.MongoClient
import org.mongodb.scala.bson.Document
import org.mongodb.scala.model.{Accumulators, Aggregates, Field, Filters, Variable}
import java.text.SimpleDateFormat
object FilteredSubset {
  def main(args: Array[String]): Unit = {
    // Replace the placeholder with your connection string.
    val uri = "<connection string>"
    val mongoClient = MongoClient(uri)
    Thread.sleep(1000)
    val aggDB = mongoClient.getDatabase("agg_tutorials_db")
    // Get a reference to relevant collections.
    // ... val someColl = aggDB.getCollection("someColl")
    // ... val anotherColl = aggDB.getCollection("anotherColl")
    // Delete any existing documents in collections if needed.
    // ... someColl.deleteMany(Filters.empty()).subscribe(...)
    // If needed, create the date format template.
    val dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss")
    // Insert sample data into the collection or collections.
    // ... someColl.insertMany(...).subscribe(...)
    Thread.sleep(1000)
    // Add code to create pipeline stages within the Seq.
    // ... val pipeline = Seq(...)
    // Run the aggregation and print the results.
    // ... someColl.aggregate(pipeline).subscribe(...)
    Thread.sleep(1000)
    mongoClient.close()
  }
}

Para cada tutorial, você deve substituir o placeholder da string de conexão pela string de conexão da sua implantação.

Dica

Para saber como localizar a string de conexão do seu sistema, consulte a etapa Criar uma connection string do guia de Introdução do driver Scala.

Por exemplo, se sua string de conexão for "mongodb+srv://mongodb-example:27017", sua atribuição de string de conexão será semelhante à seguinte:

val uri = "mongodb+srv://mongodb-example:27017"

Criar a coleção

Para criar a coleção orders e inserir os dados de amostra, adicione o seguinte código ao seu aplicação:

val orders = aggDB.getCollection("orders")
orders.deleteMany(Filters.empty()).subscribe(
  _ => {},
  e => println("Error: " + e.getMessage),
)
orders.insertMany(Seq(
  Document(
    "order_id" -> 6363763262239L,
    "products" -> Seq(
      Document(
        "prod_id" -> "abc12345",
        "name" -> "Asus Laptop",
        "price" -> 431
      ),
      Document(
        "prod_id" -> "def45678",
        "name" -> "Karcher Hose Set",
        "price" -> 22
      )
    )
  ),
  Document(
    "order_id" -> 1197372932325L,
    "products" -> Seq(
      Document(
        "prod_id" -> "abc12345",
        "name" -> "Asus Laptop",
        "price" -> 429
      )
    )
  ),
  Document(
    "order_id" -> 9812343774839L,
    "products" -> Seq(
      Document(
        "prod_id" -> "pqr88223",
        "name" -> "Morphy Richards Food Mixer",
        "price" -> 431
      ),
      Document(
        "prod_id" -> "def45678",
        "name" -> "Karcher Hose Set",
        "price" -> 21
      )
    )
  ),
  Document(
    "order_id" -> 4433997244387L,
    "products" -> Seq(
      Document(
        "prod_id" -> "def45678",
        "name" -> "Karcher Hose Set",
        "price" -> 23
      ),
      Document(
        "prod_id" -> "jkl77336",
        "name" -> "Picky Pencil Sharpener",
        "price" -> 1
      ),
      Document(
        "prod_id" -> "xyz11228",
        "name" -> "Russell Hobbs Chrome Kettle",
        "price" -> 16
      )
    )
  )
)).subscribe(
  _ => {},
  e => println("Error: " + e.getMessage),
)

Passos

As etapas a seguir demonstram como criar e executar um pipeline de agregação para descompactar campos de array em documentos separados e calcular novos valores com base em grupos de valores comuns.

Execute o agregação pipeline.

db.orders.aggregate( [
   // Stage 1: Unwind the array of product orders
   { $unwind: { path: "$products" } },
   // Stage 2: Match products that cost more than $15
   { $match: { "products.price": { $gt: 15 } } },
   // Stage 3: Group products by product type
   { $group:
      {
         _id: "$products.prod_id",
         product: { $first: "$products.name"  },
         total_value: { $sum: "$products.price" },
         quantity: { $sum: 1 }
      }
   },
   // Stage 4: Display the product ID
   { $set: { product_id: "$_id" } },
   // Stage 5: Remove unneeded fields
   { $unset: [ "_id"] }
] )

Interprete os resultados da agregação .

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

Observação

Se você executar este exemplo, a ordem dos documentos em seus resultados poderá ser diferente da ordem dos documentos nesta página porque o pipeline de agregação não contém um estágio de classificação.

Adicione um estágio de desenrolamento para descompactar a matriz de pedidos de produtos.

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

"{", "$unwind", "{", "path", BCON_UTF8("$products"), "}", "}",

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

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

"{", "$match", "{", "products.price", "{", "$gt", BCON_INT32(15), "}", "}", "}",

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

Adicione um estágio para coletar documentos de pedido pelo valor $group do prod_id campo . 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

"{", "$group", "{",
"_id", BCON_UTF8("$products.prod_id"),
"product", "{", "$first", BCON_UTF8("$products.name"), "}",
"total_value", "{", "$sum", BCON_UTF8("$products.price"), "}",
"quantity", "{", "$sum", BCON_INT32(1), "}",
"}", "}",

Adicione um estágio definido para exibir o ID do produto.

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

"{", "$set", "{", "product_id", BCON_UTF8("$_id"), "}", "}",

Adicione um estágio de desconfiguração para remover campos desnecessários.

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

"{", "$unset", "[", BCON_UTF8("_id"), "]", "}",

Execute o agregação pipeline.

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

mongoc_cursor_t *results =
    mongoc_collection_aggregate(orders, MONGOC_QUERY_NONE, pipeline, NULL, NULL);
bson_destroy(pipeline);

Certifique-se de limpar os recursos de coleta adicionando a seguinte linha às declarações de limpeza:

mongoc_collection_destroy(orders);

Por fim, execute os seguintes comandos em seu shell para gerar e executar o executável:

gcc -o aggc agg-tutorial.c $(pkg-config --libs --cflags libmongoc-1.0)
./aggc

Dica

Se você encontrar erros de conexão ao executar os comandos anteriores em uma chamada, poderá executá-los separadamente.

Interprete os resultados da agregação .

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

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

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

Adicione um estágio de desenrolamento para descompactar a matriz de pedidos de produtos.

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

pipeline.unwind("$products");

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

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

pipeline.match(bsoncxx::from_json(R"({
    "products.price": { "$gt": 15 }
})"));

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

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.group(bsoncxx::from_json(R"({
    "_id": "$products.prod_id",
    "product": { "$first": "$products.name" },
    "total_value": { "$sum": "$products.price" },
    "quantity": { "$sum": 1 }
})"));

Adicione um estágio addFields para exibir o ID do produto.

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

pipeline.add_fields(bsoncxx::from_json(R"({
    "product_id": "$_id"
})"));

Adicione um estágio de desconfiguração para remover campos desnecessários.

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

pipeline.append_stage(bsoncxx::from_json(R"({
    "$unset": ["_id"]
})"));

Execute o agregação pipeline.

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

auto cursor = orders.aggregate(pipeline);

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

c++ --std=c++17 agg-tutorial.cpp $(pkg-config --cflags --libs libmongocxx) -o ./app.out
./app.out

Interprete os resultados da agregação .

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

{ "product" : "Karcher Hose Set", "total_value" : 66, "quantity" : 3, "product_id" : "def45678" }
{ "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" }

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

Adicione um estágio de desenrolamento para descompactar a matriz de pedidos de produtos.

Primeiro, inicie a agregação na orders coleção e encadeie um estágio para separar as entradas $unwind na Products array em documentos individuais:

var results = orders.Aggregate()
    .Unwind<Order, OrderUnwound>(o => o.Products)

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

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

.Match(o => o.Products.Price > 15)

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

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

ProductId: o ID do produto (a chave de agrupamento)
Product: o nome do produto
TotalValue: o valor total de todas as vendas do produto
Quantity: o número de pedidos do produto

.Group(
    id: o => o.Products.ProductId,
    group: g => new
    {
      ProductId = g.Key,
      Product = g.First().Products.Name,
      TotalValue = g.Sum(o => o.Products.Price),
      Quantity = g.Count(),
    }
);

Execute a agregação e interprete os resultados.

Por fim, execute o aplicação em seu IDE e inspecione os resultados.

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

{ ProductId = pqr88223, Product = Morphy Richards Food Mixer, TotalValue = 431, Quantity = 1 }
{ ProductId = xyz11228, Product = Russell Hobbs Chrome Kettle, TotalValue = 16, Quantity = 1 }
{ ProductId = abc12345, Product = Asus Laptop, TotalValue = 860, Quantity = 2 }
{ ProductId = def45678, Product = Karcher Hose Set, TotalValue = 66, Quantity = 3 }

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

Adicione um estágio de desenrolamento para descompactar a matriz de pedidos de produtos.

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

unwindStage := bson.D{{Key: "$unwind", Value: bson.D{
	{Key: "path", Value: "$products"},
}}}

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

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

matchStage := bson.D{{Key: "$match", Value: bson.D{
	{Key: "products.price", Value: bson.D{{Key: "$gt", Value: 15}}},
}}}

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

product: o nome do produto
total_value: o valor total de todas as vendas do produto
quantity: o número de pedidos do produto

groupStage := bson.D{{Key: "$group", Value: bson.D{
	{Key: "_id", Value: "$products.prod_id"},
	{Key: "product", Value: bson.D{{Key: "$first", Value: "$products.name"}}},
	{Key: "total_value", Value: bson.D{{Key: "$sum", Value: "$products.price"}}},
	{Key: "quantity", Value: bson.D{{Key: "$sum", Value: 1}}},
}}}

Adicione um estágio definido para exibir o ID do produto.

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

setStage := bson.D{{Key: "$set", Value: bson.D{
	{Key: "product_id", Value: "$_id"},
}}}

Adicione um estágio de desconfiguração para remover campos desnecessários.

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

unsetStage := bson.D{{Key: "$unset", Value: bson.A{"_id"}}}

Execute o agregação pipeline.

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

pipeline := mongo.Pipeline{unwindStage, matchStage, groupStage, setStage, unsetStage}
cursor, err := orders.Aggregate(context.TODO(), pipeline)

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

go run agg_tutorial.go

Interprete os resultados da agregação .

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

{"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"}
{"product":"Asus Laptop","total_value":860,"quantity":2,"product_id":"abc12345"}

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

Adicione um estágio de desenrolamento para descompactar a matriz de pedidos de produtos.

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

pipeline.add(Aggregates.unwind("$products"));

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

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

pipeline.add(Aggregates.match(
        Filters.gt("products.price", 15)
));

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

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.add(Aggregates.group(
        "$products.prod_id",
        Accumulators.first("product", "$products.name"),
        Accumulators.sum("total_value", "$products.price"),
        Accumulators.sum("quantity", 1)
));

Adicione um estágio definido para exibir o ID do produto.

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

pipeline.add(Aggregates.set(new Field<>("product_id", "$_id")));

Adicione um estágio de desconfiguração para remover campos desnecessários.

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

pipeline.add(Aggregates.unset("_id"));

Execute o agregação pipeline.

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

AggregateIterable<Document> aggregationResult = orders.aggregate(pipeline);

Por fim, execute o aplicação em seu IDE.

Interprete os resultados da agregação .

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": "Russell Hobbs Chrome Kettle", "total_value": 16, "quantity": 1, "product_id": "xyz11228"}
{"product": "Karcher Hose Set", "total_value": 66, "quantity": 3, "product_id": "def45678"}
{"product": "Morphy Richards Food Mixer", "total_value": 431, "quantity": 1, "product_id": "pqr88223"}

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

Adicione um estágio de desenrolamento para descompactar a matriz de pedidos de produtos.

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

pipeline.add(
    Aggregates.unwind("\$${Order::products.name}")
)

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

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

pipeline.add(
    Aggregates.match(
        Filters.gt("${Order::products.name}.${Product::price.name}", 15)
    )
)

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

Adicione um estágio para coletar documentos de pedido pelo valor $group do prodID campo . 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.add(
    Aggregates.group(
        "\$${Order::products.name}.${Product::prodID.name}",
        Accumulators.first("product", "\$${Order::products.name}.${Product::name.name}"),
        Accumulators.sum("total_value", "\$${Order::products.name}.${Product::price.name}"),
        Accumulators.sum("quantity", 1)
    )
)

Adicione um estágio definido para exibir o ID do produto.

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

pipeline.add(Aggregates.set(Field("product_id", "\$_id")))

Adicione um estágio de desconfiguração para remover campos desnecessários.

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

pipeline.add(Aggregates.unset("_id"))

Execute o agregação pipeline.

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

val aggregationResult = orders.aggregate<Document>(pipeline)

Por fim, execute o aplicação em seu IDE.

Interprete os resultados da agregação .

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

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

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

Adicione um estágio de desenrolamento para descompactar a matriz de pedidos de produtos.

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

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

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

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

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

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

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

Adicione um estágio definido para exibir o ID do produto.

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

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

Adicione um estágio de desconfiguração para remover campos desnecessários.

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

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

Execute o agregação pipeline.

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

const aggregationResult = await orders.aggregate(pipeline);

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

node agg_tutorial.js

Interprete os resultados da agregação .

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.

Adicione um estágio de desenrolamento para descompactar a matriz de pedidos de produtos.

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

Stage::unwind(
    path: Expression::arrayFieldPath('products')
),

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

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

Stage::match(
    ['products.price' => Query::gt(15)]
),

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

Fora de sua Pipeline instância, crie um estágio em uma função de fábrica para coletar documentos de pedido pelo valor $group do prod_id campo. 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

function groupByProductStage()
{
    return Stage::group(
        _id: Expression::stringFieldPath('products.prod_id'),
        product: Accumulator::first(
            Expression::stringFieldPath('products.name')
        ),
        total_value: Accumulator::sum(
            Expression::numberFieldPath('products.price'),
        ),
        quantity: Accumulator::sum(1)
    );
}

Em seguida, na sua instância do Pipeline, chame a função groupByProductStage():

groupByProductStage(),

Adicione um estágio definido para exibir o ID do produto.

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

Stage::set(product_id: Expression::stringFieldPath('_id')),

Adicione um estágio de desconfiguração para remover campos desnecessários.

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

Stage::unset('_id')

Execute o agregação pipeline.

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

$cursor = $orders->aggregate($pipeline);

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

php agg_tutorial.php

Interprete os resultados da agregação .

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

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

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

Adicione um estágio de desenrolamento para descompactar a matriz de pedidos de produtos.

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

pipeline.append({"$unwind": {"path": "$products"}})

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

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

pipeline.append({"$match": {"products.price": {"$gt": 15}}})

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

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.append(
    {
        "$group": {
            "_id": "$products.prod_id",
            "product": {"$first": "$products.name"},
            "total_value": {"$sum": "$products.price"},
            "quantity": {"$sum": 1},
        }
    }
)

Adicione um estágio definido para exibir o ID do produto.

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

pipeline.append({"$set": {"product_id": "$_id"}})

Adicione um estágio de desconfiguração para remover campos desnecessários.

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

pipeline.append({"$unset": ["_id"]})

Execute o agregação pipeline.

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

aggregation_result = orders_coll.aggregate(pipeline)

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

python3 agg_tutorial.py

Interprete os resultados da agregação .

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

{'product': 'Morphy Richards Food Mixer', 'total_value': 431, 'quantity': 1, 'product_id': 'pqr88223'}
{'product': 'Asus Laptop', 'total_value': 860, 'quantity': 2, 'product_id': 'abc12345'}
{'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.

Adicione um estágio de desenrolamento para descompactar a matriz de pedidos de produtos.

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

{
  "$unwind": {
    path: "$products",
  },
},

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

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

{
  "$match": {
    "products.price": {
      "$gt": 15,
    },
  },
},

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

product: o nome do produto
total_value: o valor total de todas as vendas do produto
quantity: o número de pedidos do produto

{
  "$group": {
    _id: "$products.prod_id",
    product: { "$first": "$products.name" },
    total_value: { "$sum": "$products.price" },
    quantity: { "$sum": 1 },
  },
},

Adicione um estágio definido para exibir o ID do produto.

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

{
  "$set": {
    product_id: "$_id",
  },
},

Adicione um estágio de desconfiguração para remover campos desnecessários.

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

{ "$unset": ["_id"] },

Execute o agregação pipeline.

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

aggregation_result = orders.aggregate(pipeline)

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

ruby agg_tutorial.rb

Interprete os resultados da agregação .

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"=>"Russell Hobbs Chrome Kettle", "total_value"=>16, "quantity"=>1, "product_id"=>"xyz11228"}
{"product"=>"Karcher Hose Set", "total_value"=>66, "quantity"=>3, "product_id"=>"def45678"}
{"product"=>"Morphy Richards Food Mixer", "total_value"=>431, "quantity"=>1, "product_id"=>"pqr88223"}

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

Adicione um estágio de desenrolamento para descompactar a matriz de pedidos de produtos.

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

pipeline.push(doc! {
    "$unwind": {
        "path": "$products"
    }
});

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

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

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

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

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(doc! {
    "$group": {
        "_id": "$products.prod_id",
        "product": { "$first": "$products.name" },
        "total_value": { "$sum": "$products.price" },
        "quantity": { "$sum": 1 }
    }
});

Adicione um estágio definido para exibir o ID do produto.

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

pipeline.push(doc! {
    "$set": {
        "prod_id": "$_id"
    }
});

Adicione um estágio de desconfiguração para remover campos desnecessários.

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

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

Execute o agregação pipeline.

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

let mut cursor = orders_coll.aggregate(pipeline).await?;

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

cargo run

Interprete os resultados da agregação .

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

Document({"product": String("Russell Hobbs Chrome Kettle"), "total_value": Int32(16), "quantity": Int32(1),
"prod_id": String("xyz11228")})
Document({"product": String("Morphy Richards Food Mixer"), "total_value": Int32(431), "quantity": Int32(1),
"prod_id": String("pqr88223")})
Document({"product": String("Karcher Hose Set"), "total_value": Int32(66), "quantity": Int32(3),
"prod_id": String("def45678")})
Document({"product": String("Asus Laptop"), "total_value": Int32(860), "quantity": Int32(2),
"prod_id": String("abc12345")})

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

Adicione um estágio de desenrolamento para descompactar a matriz de pedidos de produtos.

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

Aggregates.unwind("$products"),

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

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

Aggregates.filter(Filters.gt("products.price", 15)),

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

product: o nome do produto
total_value: o valor total de todas as vendas do produto
quantity: o número de pedidos do produto

Aggregates.group(
  "$products.prod_id",
  Accumulators.first("product", "$products.name"),
  Accumulators.sum("total_value", "$products.price"),
  Accumulators.sum("quantity", 1)
),

Adicione um estágio definido para exibir o ID do produto.

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

Aggregates.set(Field("product_id", "$_id")),

Adicione um estágio de desconfiguração para remover campos desnecessários.

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

Aggregates.unset("_id")

Execute o agregação pipeline.

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

orders.aggregate(pipeline)
  .subscribe((doc: Document) => println(doc.toJson()),
    (e: Throwable) => println(s"Error: $e"))

Por fim, execute o aplicação em seu IDE.

Interprete os resultados da agregação .

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

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

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

Voltar

Grupo e total

Junção um para um