/ /

Tutoriales de Pipeline

Docs Home

/ /

Pipeline de agregación

Tutoriales de Pipeline

Docs Home

Desarrollo

Operaciones de agregación

Pipeline de agregación

Tutoriales de Pipeline

Realizar uniones uno a uno

Este tutorial ilustra cómo construir un pipeline de agregación, realizar la agregación en una colección y mostrar los resultados utilizando el lenguaje que elijas.

Acerca de esta tarea

Este tutorial muestra cómo combinar datos de una colección que describe información de producto con otra que describe pedidos de clientes. Los resultados muestran una lista de todos los pedidos realizados en 2020 e incluyen los detalles de producto asociados a cada pedido.

Esta agregación realiza una unión uno a uno. Una unión uno a uno ocurre cuando un documento de una colección tiene un valor de campo que coincide con un documento de otra colección con el mismo valor de campo. La agregación compara estos documentos según el valor de campo y combina la información de ambas fuentes en un solo resultado.

Nota

Una unión uno a uno no requiere que los documentos tengan una relación uno a uno. Para obtener más información sobre esta relación de datos, consulte la entrada de Wikipedia sobre Uno a uno (modelo de datos).

Antes de comenzar

➤ Usar el menú desplegable Seleccionar lenguaje en la parte superior derecha para establecer el lenguaje de los siguientes ejemplos o seleccionar MongoDB Shell.

Este ejemplo utiliza dos colecciones:

orders: documentos que describen pedidos individuales de productos en una tienda
products: documentos que describen los productos que vende una tienda

Un pedido solo puede contener un producto. La agregación utiliza una unión uno a uno para vincular un documento de pedido con el documento de producto correspondiente. La agregación une las colecciones mediante el campo product_id presente en los documentos de ambas colecciones.

Para crear las colecciones orders y products, utilice el insertMany() :

db.orders.insertMany( [
   {
      customer_id: "elise_smith@myemail.com",
      orderdate: new Date("2020-05-30T08:35:52Z"),
      product_id: "a1b2c3d4",
      value: 431.43
   },
   {
      customer_id: "tj@wheresmyemail.com",
      orderdate: new Date("2019-05-28T19:13:32Z"),
      product_id: "z9y8x7w6",
      value: 5.01
   },
   {
      customer_id: "oranieri@warmmail.com",
      orderdate: new Date("2020-01-01T08:25:37Z"),
      product_id: "ff11gg22hh33",
      value: 63.13
   },
   {
      customer_id: "jjones@tepidmail.com",
      orderdate: new Date("2020-12-26T08:55:46Z"),
      product_id: "a1b2c3d4",
      value: 429.65
   }
] )

db.products.insertMany( [
   {
      p_id: "a1b2c3d4",
      name: "Asus Laptop",
      category: "ELECTRONICS",
      description: "Good value laptop for students"
   },
   {
      p_id: "z9y8x7w6",
      name: "The Day Of The Triffids",
      category: "BOOKS",
      description: "Classic post-apocalyptic novel"
   },
   {
      p_id: "ff11gg22hh33",
      name: "Morphy Richardds Food Mixer",
      category: "KITCHENWARE",
      description: "Luxury mixer turning good cakes into great"
   },
   {
      p_id: "pqr678st",
      name: "Karcher Hose Set",
      category: "GARDEN",
      description: "Hose + nozzles + winder for tidy storage"
   }
] )

Crea la aplicación de plantilla

Antes de comenzar a seguir este tutorial de agregación, debes configurar una nueva aplicación en C. Puedes usar esta aplicación para conectarte a una implementación de MongoDB, insertar datos de muestra en MongoDB y ejecutar el pipeline de agregación.

Tip

Para aprender cómo instalar el controlador y conectarse a MongoDB, consulta la Guía para comenzar con el controlador C.

Para obtener más información sobre cómo realizar agregaciones en el controlador C, consulta la Guía de agregación.

Después de instalar el controlador, crea un archivo llamado agg-tutorial.c. Pega el siguiente código en este archivo para crear una plantilla de aplicación para los tutoriales de agregación.

Importante

En el siguiente código, lee los comentarios del código para encontrar las secciones del código que debes modificar para el tutorial que estás siguiendo.

Si intenta ejecutar el código sin hacer ningún cambio, se encontrará con un error de conexión.

#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, se debe reemplazar el marcador de posición de la cadena de conexión con la cadena de conexión de la implementación.

Tip

Para aprender a localizar la cadena de conexión de la implementación, se debe consultar el paso Crear una cadena de conexión de la guía de introducción a C++.

Por ejemplo, si la cadena de conexión es "mongodb+srv://mongodb-example:27017", la asignación de cadena de conexión se asemeja a lo siguiente:

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

Crear la colección

Este ejemplo utiliza dos colecciones:

orders: documentos que describen pedidos individuales de productos en una tienda
products: documentos que describen los productos que vende una tienda

Para crear las colecciones orders y products e insertar los datos de muestra, agregue el siguiente código a su aplicación:

mongoc_collection_t *orders = mongoc_client_get_collection(client, "agg_tutorials_db", "orders");
mongoc_collection_t *products = mongoc_client_get_collection(client, "agg_tutorials_db", "products");
{
    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);
    }
    if (!mongoc_collection_delete_many(products, filter, NULL, NULL, &error))
    {
        fprintf(stderr, "Delete error: %s\n", error.message);
    }
    bson_destroy(filter);
}
{
    size_t num_docs = 4;
    bson_t *order_docs[num_docs];
    order_docs[0] = BCON_NEW(
        "customer_id", BCON_UTF8("elise_smith@myemail.com"),
        "orderdate", BCON_DATE_TIME(1590822952000UL), // 2020-05-30T08:35:52Z
        "product_id", BCON_UTF8("a1b2c3d4"),
        "value", BCON_DOUBLE(431.43));
    order_docs[1] = BCON_NEW(
        "customer_id", BCON_UTF8("tj@wheresmyemail.com"),
        "orderdate", BCON_DATE_TIME(1559063612000UL), // 2019-05-28T19:13:32Z
        "product_id", BCON_UTF8("z9y8x7w6"),
        "value", BCON_DOUBLE(5.01));
    order_docs[2] = BCON_NEW(
        "customer_id", BCON_UTF8("oranieri@warmmail.com"),
        "orderdate", BCON_DATE_TIME(1577869537000UL), // 2020-01-01T08:25:37Z
        "product_id", BCON_UTF8("ff11gg22hh33"),
        "value", BCON_DOUBLE(63.13));
    order_docs[3] = BCON_NEW(
        "customer_id", BCON_UTF8("jjones@tepidmail.com"),
        "orderdate", BCON_DATE_TIME(1608976546000UL), // 2020-12-26T08:55:46Z
        "product_id", BCON_UTF8("a1b2c3d4"),
        "value", BCON_DOUBLE(429.65));
    bson_error_t error;
    if (!mongoc_collection_insert_many(orders, (const bson_t **)order_docs, num_docs, NULL, NULL, &error))
    {
        fprintf(stderr, "Insert error: %s\n", error.message);
    }
    for (int i = 0; i < num_docs; i++)
    {
        bson_destroy(order_docs[i]);
    }
}
{
    size_t num_docs = 4;
    bson_t *product_docs[num_docs];
    product_docs[0] = BCON_NEW(
        "id", BCON_UTF8("a1b2c3d4"),
        "name", BCON_UTF8("Asus Laptop"),
        "category", BCON_UTF8("ELECTRONICS"),
        "description", BCON_UTF8("Good value laptop for students"));
    product_docs[1] = BCON_NEW(
        "id", BCON_UTF8("z9y8x7w6"),
        "name", BCON_UTF8("The Day Of The Triffids"),
        "category", BCON_UTF8("BOOKS"),
        "description", BCON_UTF8("Classic post-apocalyptic novel"));
    product_docs[2] = BCON_NEW(
        "id", BCON_UTF8("ff11gg22hh33"),
        "name", BCON_UTF8("Morphy Richardds Food Mixer"),
        "category", BCON_UTF8("KITCHENWARE"),
        "description", BCON_UTF8("Luxury mixer turning good cakes into great"));
    product_docs[3] = BCON_NEW(
        "id", BCON_UTF8("pqr678st"),
        "name", BCON_UTF8("Karcher Hose Set"),
        "category", BCON_UTF8("GARDEN"),
        "description", BCON_UTF8("Hose + nozzles + winder for tidy storage"));
    bson_error_t error;
    if (!mongoc_collection_insert_many(products, (const bson_t **)product_docs, num_docs, NULL, NULL, &error))
    {
        fprintf(stderr, "Insert error: %s\n", error.message);
    }
    for (int i = 0; i < num_docs; i++)
    {
        bson_destroy(product_docs[i]);
    }
}

Crea la aplicación de plantilla

Antes de comenzar a seguir un tutorial de agregación, debes configurar una nueva aplicación de C++. Puedes usar esta aplicación para conectarte a una implementación de MongoDB, insertar datos de muestra en MongoDB y ejecutar el pipeline de agregación.

Tip

Para aprender cómo instalar el controlador y conectarte a MongoDB, consulta el tutorial Comienza con C++.

Para aprender más sobre el uso del controlador C++, consulta la documentación de la API.

Para obtener más información sobre cómo realizar agregaciones en el controlador C++, consulta la guía de agregación.

Después de instalar el controlador, crea un archivo llamado agg-tutorial.cpp. Pega el siguiente código en este archivo para crear una plantilla de aplicación para los tutoriales de agregación.

Importante

En el siguiente código, lee los comentarios del código para encontrar las secciones del código que debes modificar para el tutorial que estás siguiendo.

Si intenta ejecutar el código sin hacer ningún cambio, se encontrará con un error de conexión.

#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, se debe reemplazar el marcador de posición de la cadena de conexión con la cadena de conexión de la implementación.

Tip

Para aprender a localizar la cadena de conexión de la implementación, se debe consultar el paso Crear una cadena de conexión del tutorial de introducción a C++.

Por ejemplo, si la cadena de conexión es "mongodb+srv://mongodb-example:27017", la asignación de cadena de conexión se asemeja a lo siguiente:

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

Crear la colección

Este ejemplo utiliza dos colecciones:

orders: documentos que describen pedidos individuales de productos en una tienda
products: documentos que describen los productos que vende una tienda

Para crear las colecciones orders y products e insertar los datos de muestra, agregue el siguiente código a su aplicación:

auto orders = db["orders"];
auto products = db["products"];
std::vector<bsoncxx::document::value> order_docs = {
    bsoncxx::from_json(R"({
        "customer_id": "elise_smith@myemail.com",
        "orderdate": {"$date": 1590821752000},
        "product_id": "a1b2c3d4",
        "value": 431.43
    })"),
    bsoncxx::from_json(R"({
        "customer_id": "tj@wheresmyemail.com",
        "orderdate": {"$date": 1559062412},
        "product_id": "z9y8x7w6",
        "value": 5.01
    })"),
    bsoncxx::from_json(R"({
        "customer_id": "oranieri@warmmail.com",
        "orderdate": {"$date": 1577861137},
        "product_id": "ff11gg22hh33",
        "value": 63.13
    })"),
    bsoncxx::from_json(R"({
        "customer_id": "jjones@tepidmail.com",
        "orderdate": {"$date": 1608972946000},
        "product_id": "a1b2c3d4",
        "value": 429.65
    })")
};
orders.insert_many(order_docs); // Might throw an exception
std::vector<bsoncxx::document::value> product_docs = {
    bsoncxx::from_json(R"({
        "id": "a1b2c3d4",
        "name": "Asus Laptop",
        "category": "ELECTRONICS",
        "description": "Good value laptop for students"
    })"),
    bsoncxx::from_json(R"({
        "id": "z9y8x7w6",
        "name": "The Day Of The Triffids",
        "category": "BOOKS",
        "description": "Classic post-apocalyptic novel"
    })"),
    bsoncxx::from_json(R"({
        "id": "ff11gg22hh33",
        "name": "Morphy Richardds Food Mixer",
        "category": "KITCHENWARE",
        "description": "Luxury mixer turning good cakes into great"
    })"),
    bsoncxx::from_json(R"({
        "id": "pqr678st",
        "name": "Karcher Hose Set",
        "category": "GARDEN",
        "description": "Hose + nozzles + winder for tidy storage"
    })")
};
products.insert_many(product_docs); // Might throw an exception

Crea la aplicación de plantilla

Antes de comenzar a seguir este tutorial de agregación, debes configurar una nueva aplicación de C#/.NET. Puedes usar esta aplicación para conectarte a una implementación de MongoDB, insertar datos de muestra en MongoDB y ejecutar el pipeline de agregación.

Tip

Para aprender cómo instalar el controlador y conectarte a MongoDB, consulta la Guía de inicio rápido del controlador C#/.NET.

Para obtener más información sobre cómo realizar agregaciones en el controlador C#/.NET, consulta la Guía de agregación.

Después de instalar el controlador, pegue el siguiente código en su archivo Program.cs para crear una plantilla de aplicación para los tutoriales de agregación.

Importante

En el siguiente código, lee los comentarios del código para encontrar las secciones del código que debes modificar para el tutorial que estás siguiendo.

Si intenta ejecutar el código sin hacer ningún cambio, se encontrará con un error de conexión.

using MongoDB.Bson;
using MongoDB.Bson.Serialization.Attributes;
using MongoDB.Driver;
// 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, se debe reemplazar el marcador de posición de la cadena de conexión con la cadena de conexión de la implementación.

Tip

Para aprender a localizar la cadena de conexión de la implementación, se debe consultar el paso Configurar un clúster de nivel gratuito en Atlas de la guía de inicio rápido de C#.

Por ejemplo, si la cadena de conexión es "mongodb+srv://mongodb-example:27017", la asignación de cadena de conexión se asemeja a lo siguiente:

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

Crear la colección

Este ejemplo utiliza dos colecciones:

orders: documentos que describen pedidos individuales de productos en una tienda
products: documentos que describen los productos que vende una tienda

Un pedido debe contener un producto. La agregación utiliza una unión uno a uno para emparejar un documento de pedido con el documento del producto correspondiente. La agregación une las colecciones por el campo ProductId que existe en los documentos de ambas colecciones.

Primero, cree clases C# para modelar los datos en las colecciones orders y products:

public class Order
{
    [BsonId]
    public ObjectId Id { get; set; }
    public required string CustomerId { get; set; }
    public DateTime OrderDate { get; set; }
    public required string ProductId { get; set; }
    public double Value { get; set; }
}
public class Product
{
    [BsonId]
    public required string Id { get; set; }
    public string Name { get; set; } = "";
    public string Category { get; set; } = "";
    public string Description { get; set; } = "";
}

Para crear las colecciones orders y products e insertar los datos de muestra, agregue el siguiente código a su aplicación:

var orders = aggDB.GetCollection<Order>("orders");
var products = aggDB.GetCollection<Product>("products");
orders = aggDB.GetCollection<Order>("orders");
products = aggDB.GetCollection<Product>("products");
orders.InsertMany(new List<Order>
{
    new Order()
    {
        CustomerId = "elise_smith@myemail.com",
        OrderDate = DateTime.Parse("2020-05-30T08:35:52Z"),
        ProductId = "a1b2c3d4",
        Value = 431.43
    },
    new Order()
    {
        CustomerId = "tj@wheresmyemail.com",
        OrderDate = DateTime.Parse("2019-05-28T19:13:32Z"),
        ProductId = "z9y8x7w6",
        Value = 5.01
    },
    new Order()
    {
        CustomerId = "oranieri@warmmail.com",
        OrderDate = DateTime.Parse("2020-01-01T08:25:37Z"),
        ProductId = "ff11gg22hh33",
        Value = 63.13
    },
    new Order()
    {
        CustomerId = "jjones@tepidmail.com",
        OrderDate = DateTime.Parse("2020-12-26T08:55:46Z"),
        ProductId = "a1b2c3d4",
        Value = 429.65
    }
});
products.InsertMany(new List<Product>
{
    new Product()
    {
        Id = "a1b2c3d4",
        Name = "Asus Laptop",
        Category = "ELECTRONICS",
        Description = "Good value laptop for students"
    },
    new Product()
    {
        Id = "z9y8x7w6",
        Name = "The Day Of The Triffids",
        Category = "BOOKS",
        Description = "Classic post-apocalyptic novel"
    },
    new Product()
    {
        Id = "ff11gg22hh33",
        Name = "Morphy Richardds Food Mixer",
        Category = "KITCHENWARE",
        Description = "Luxury mixer turning good cakes into great"
    },
    new Product()
    {
        Id = "pqr678st",
        Name = "Karcher Hose Set",
        Category = "GARDEN",
        Description = "Hose + nozzles + winder for tidy storage"
    }
});

Crea la aplicación de plantilla

Antes de comenzar a seguir este tutorial de agregación, debes configurar una nueva aplicación Go. Puedes usar esta aplicación para conectarte a una implementación de MongoDB, insertar datos de muestra en MongoDB y ejecutar el pipeline de agregación.

Tip

Para aprender cómo instalar el controlador y conectarse a MongoDB, consulte la Guía de inicio rápido del controlador Go.

Para obtener más información sobre cómo realizar agregaciones en el controlador de Go, consulta la Guía de agregación.

Después de instalar el controlador, crea un archivo llamado agg_tutorial.go. Pega el siguiente código en este archivo para crear una plantilla de aplicación para los tutoriales de agregación.

Importante

En el siguiente código, lee los comentarios del código para encontrar las secciones del código que debes modificar para el tutorial que estás siguiendo.

Si intenta ejecutar el código sin hacer ningún cambio, se encontrará con un error de conexión.

package main
import (
	"context"
	"fmt"
	"log"
	"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() {
	ctx := context.Background()
	// 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(ctx); 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(cxt, 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(ctx, pipeline)
	if err != nil {
		log.Fatal(err)
	}
	defer func() {
		if err := cursor.Close(ctx); err != nil {
			log.Fatalf("failed to close cursor: %v", err)
		}
	}()
	// Decode the aggregation results.
	var results []bson.D
	if err = cursor.All(ctx, &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, se debe reemplazar el marcador de posición de la cadena de conexión con la cadena de conexión de la implementación.

Tip

Para aprender a localizar la cadena de conexión de la implementación, se debe consultar el paso Crear un clúster de MongoDB de la guía de inicio rápido de Go.

Por ejemplo, si la cadena de conexión es "mongodb+srv://mongodb-example:27017", la asignación de cadena de conexión se asemeja a lo siguiente:

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

Crear la colección

Este ejemplo utiliza dos colecciones:

orders: documentos que describen pedidos individuales de productos en una tienda
products: documentos que describen los productos que vende una tienda

Primero, cree estructuras Go para modelar los datos en las colecciones orders y products:

type Order struct {
	CustomerID string        `bson:"customer_id"`
	OrderDate  bson.DateTime `bson:"orderdate"`
	ProductID  string        `bson:"product_id"`
	Value      float32       `bson:"value"`
}
type Product struct {
	ID          string `bson:"id"`
	Name        string `bson:"name"`
	Category    string `bson:"category"`
	Description string `bson:"description"`
}

Para crear las colecciones orders y products e insertar los datos de muestra, agregue el siguiente código a su aplicación:

orders := aggDB.Collection("orders")
products := aggDB.Collection("products")
_, err = orders.InsertMany(ctx, []interface{}{
	Order{
		CustomerID: "elise_smith@myemail.com",
		OrderDate:  bson.NewDateTimeFromTime(time.Date(2020, 5, 30, 8, 35, 52, 0, time.UTC)),
		ProductID:  "a1b2c3d4",
		Value:      431.43,
	},
	Order{
		CustomerID: "tj@wheresmyemail.com",
		OrderDate:  bson.NewDateTimeFromTime(time.Date(2019, 5, 28, 19, 13, 32, 0, time.UTC)),
		ProductID:  "z9y8x7w6",
		Value:      5.01,
	},
	Order{
		CustomerID: "oranieri@warmmail.com",
		OrderDate:  bson.NewDateTimeFromTime(time.Date(2020, 01, 01, 8, 25, 37, 0, time.UTC)),
		ProductID:  "ff11gg22hh33",
		Value:      63.13,
	},
	Order{
		CustomerID: "jjones@tepidmail.com",
		OrderDate:  bson.NewDateTimeFromTime(time.Date(2020, 12, 26, 8, 55, 46, 0, time.UTC)),
		ProductID:  "a1b2c3d4",
		Value:      429.65,
	},
})
if err != nil {
	log.Fatal(err)
}
_, err = products.InsertMany(ctx, []interface{}{
	Product{
		ID:          "a1b2c3d4",
		Name:        "Asus Laptop",
		Category:    "ELECTRONICS",
		Description: "Good value laptop for students",
	},
	Product{
		ID:          "z9y8x7w6",
		Name:        "The Day Of The Triffids",
		Category:    "BOOKS",
		Description: "Classic post-apocalyptic novel",
	},
	Product{
		ID:          "ff11gg22hh33",
		Name:        "Morphy Richardds Food Mixer",
		Category:    "KITCHENWARE",
		Description: "Luxury mixer turning good cakes into great",
	},
	Product{
		ID:          "pqr678st",
		Name:        "Karcher Hose Set",
		Category:    "GARDEN",
		Description: "Hose + nozzles + winder for tidy storage",
	},
})
if err != nil {
	log.Fatal(err)
}

Crea la aplicación de plantilla

Antes de comenzar a seguir un tutorial de agregación, debes configurar una nueva aplicación de Java. Puedes usar esta aplicación para conectarte a una implementación de MongoDB, insertar datos de muestra en MongoDB y ejecutar el pipeline de agregación.

Tip

Para aprender cómo instalar el controlador y conectarte a MongoDB, consulta la Guía de inicio del controlador de Java.

Para obtener más información sobre cómo realizar agregaciones en el Java Sync Driver, consulta la Guía de agregación.

Después de instalar el controlador, crea un archivo llamado AggTutorial.java. Pega el siguiente código en este archivo para crear una plantilla de aplicación para los tutoriales de agregación.

Importante

En el siguiente código, lee los comentarios del código para encontrar las secciones del código que debes modificar para el tutorial que estás siguiendo.

Si intenta ejecutar el código sin hacer ningún cambio, se encontrará con un error de conexión.

package org.example;
// Modify imports for each tutorial as needed.
import com.mongodb.client.*;
import com.mongodb.client.model.Accumulators;
import com.mongodb.client.model.Aggregates;
import com.mongodb.client.model.Field;
import com.mongodb.client.model.Filters;
import com.mongodb.client.model.Sorts;
import com.mongodb.client.model.Variable;
import org.bson.Document;
import org.bson.conversions.Bson;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
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 = ...
            // 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, se debe reemplazar el marcador de posición de la cadena de conexión con la cadena de conexión de la implementación.

Tip

Para aprender a localizar la cadena de conexión de la implementación, se debe consultar el paso Crear una cadena de conexión de la guía de inicio rápido de Java Sync.

Por ejemplo, si la cadena de conexión es "mongodb+srv://mongodb-example:27017", la asignación de cadena de conexión se asemeja a lo siguiente:

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

Crear la colección

Este ejemplo utiliza dos colecciones:

orders: documentos que describen pedidos individuales de productos en una tienda
products: documentos que describen los productos que vende una tienda

Para crear las colecciones orders y products e insertar los datos de muestra, agregue el siguiente código a su aplicación:

MongoDatabase aggDB = mongoClient.getDatabase("agg_tutorials_db");
MongoCollection<Document> orders = aggDB.getCollection("orders");
MongoCollection<Document> products = aggDB.getCollection("products");
orders.insertMany(
        Arrays.asList(
                new Document("customer_id", "elise_smith@myemail.com")
                        .append("orderdate", LocalDateTime.parse("2020-05-30T08:35:52"))
                        .append("product_id", "a1b2c3d4")
                        .append("value", 431.43),
                new Document("customer_id", "tj@wheresmyemail.com")
                        .append("orderdate", LocalDateTime.parse("2019-05-28T19:13:32"))
                        .append("product_id", "z9y8x7w6")
                        .append("value", 5.01),
                new Document("customer_id", "oranieri@warmmail.com")
                        .append("orderdate", LocalDateTime.parse("2020-01-01T08:25:37"))
                        .append("product_id", "ff11gg22hh33")
                        .append("value", 63.13),
                new Document("customer_id", "jjones@tepidmail.com")
                        .append("orderdate", LocalDateTime.parse("2020-12-26T08:55:46"))
                        .append("product_id", "a1b2c3d4")
                        .append("value", 429.65)
        )
);
products.insertMany(
        Arrays.asList(
                new Document("id", "a1b2c3d4")
                        .append("name", "Asus Laptop")
                        .append("category", "ELECTRONICS")
                        .append("description", "Good value laptop for students"),
                new Document("id", "z9y8x7w6")
                        .append("name", "The Day Of The Triffids")
                        .append("category", "BOOKS")
                        .append("description", "Classic post-apocalyptic novel"),
                new Document("id", "ff11gg22hh33")
                        .append("name", "Morphy Richardds Food Mixer")
                        .append("category", "KITCHENWARE")
                        .append("description", "Luxury mixer turning good cakes into great"),
                new Document("id", "pqr678st")
                        .append("name", "Karcher Hose Set")
                        .append("category", "GARDEN")
                        .append("description", "Hose + nozzles + winder for tidy storage")
        )
);

Crea la aplicación de plantilla

Antes de comenzar a seguir un tutorial de agregación, debes configurar una nueva aplicación de Kotlin. Puedes usar esta aplicación para conectarte a una implementación de MongoDB, insertar datos de muestra en MongoDB y ejecutar el pipeline de agregación.

Tip

Para aprender cómo instalar el controlador y conectarte a MongoDB, consulta la Guía de inicio rápido del controlador Kotlin.

Para obtener más información sobre cómo realizar agregaciones en el controlador de Kotlin, consulta la Guía de agregación.

Además del driver, también se deben añadir las siguientes dependencias al archivo de build.gradle.kts y volver a cargar el proyecto:

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

Después de instalar el controlador, crea un archivo llamado AggTutorial.kt. Pega el siguiente código en este archivo para crear una plantilla de aplicación para los tutoriales de agregación.

Importante

En el siguiente código, lee los comentarios del código para encontrar las secciones del código que debes modificar para el tutorial que estás siguiendo.

Si intenta ejecutar el código sin hacer ningún cambio, se encontrará con un error de conexión.

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, se debe reemplazar el marcador de posición de la cadena de conexión con la cadena de conexión de la implementación.

Tip

Para aprender a localizar la cadena de conexión de la implementación, se debe consultar el paso Conectarte al clúster de la guía de inicio rápido del driver de Kotlin.

Por ejemplo, si la cadena de conexión es "mongodb+srv://mongodb-example:27017", la asignación de cadena de conexión se asemeja a lo siguiente:

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

Crear la colección

Este ejemplo utiliza dos colecciones:

orders: documentos que describen pedidos individuales de productos en una tienda
products: documentos que describen los productos que vende una tienda

Primero, cree clases de datos Kotlin para modelar los datos en las colecciones orders y products:

@Serializable
data class Order(
    val customerID: String,
    @Contextual val orderDate: LocalDateTime,
    val productID: String,
    val value: Double
)
@Serializable
data class Product(
    val ID: String,
    val name: String,
    val category: String,
    val description: String
)

Para crear las colecciones orders y products e insertar los datos de muestra, agregue el siguiente código a su aplicación:

val orders = aggDB.getCollection<Order>("orders")
val products = aggDB.getCollection<Product>("products")
orders.deleteMany(Filters.empty());
products.deleteMany(Filters.empty());
orders.insertMany(
    listOf(
        Order("elise_smith@myemail.com", LocalDateTime.parse("2020-05-30T08:35:52"), "a1b2c3d4", 431.43),
        Order("tj@wheresmyemail.com", LocalDateTime.parse("2019-05-28T19:13:32"), "z9y8x7w6", 5.01),
        Order("oranieri@warmmail.com", LocalDateTime.parse("2020-01-01T08:25:37"), "ff11gg22hh33", 63.13),
        Order("jjones@tepidmail.com", LocalDateTime.parse("2020-12-26T08:55:46"), "a1b2c3d4", 429.65)
    )
)
products.insertMany(
    listOf(
        Product("a1b2c3d4", "Asus Laptop", "ELECTRONICS", "Good value laptop for students"),
        Product("z9y8x7w6", "The Day Of The Triffids", "BOOKS", "Classic post-apocalyptic novel"),
        Product(
            "ff11gg22hh33",
            "Morphy Richardds Food Mixer",
            "KITCHENWARE",
            "Luxury mixer turning good cakes into great"
        ),
        Product("pqr678st", "Karcher Hose Set", "GARDEN", "Hose + nozzles + winder for tidy storage")
    )
)

Crea la aplicación de plantilla

Antes de comenzar a seguir este tutorial de agregación, debes configurar una nueva aplicación de Node.js. Puedes usar esta aplicación para conectarte a una implementación de MongoDB, insertar datos de muestra en MongoDB y ejecutar el pipeline de agregación.

Tip

Para aprender a instalar el controlador y conectarte a MongoDB, consulta la Guía de inicio rápido del controlador de Node.js.

Para obtener más información sobre cómo realizar agregaciones en el controlador de Nodo.js, consulta la Guía de agregación.

Después de instalar el controlador, crea un archivo para ejecutar la plantilla del tutorial. Pega el siguiente código en este archivo para crear una plantilla de aplicación para los tutoriales de agregación.

Importante

En el siguiente código, lee los comentarios del código para encontrar las secciones del código que debes modificar para el tutorial que estás siguiendo.

Si intenta ejecutar el código sin hacer ningún cambio, se encontrará con un error de conexión.

const { MongoClient } = require('mongodb');
// Replace the placeholder with your connection string.
const uri = '<connection-string>';
const client = new MongoClient(uri);
export 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, se debe reemplazar el marcador de posición de la cadena de conexión con la cadena de conexión de la implementación.

Tip

Para aprender a localizar la cadena de conexión de la implementación, se debe consultar el paso Crear una cadena de conexión de la guía de inicio rápido de Nodo.js.

Por ejemplo, si la cadena de conexión es "mongodb+srv://mongodb-example:27017", la asignación de cadena de conexión se asemeja a lo siguiente:

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

Crear la colección

Este ejemplo utiliza dos colecciones:

orders: documentos que describen pedidos individuales de productos en una tienda
products: documentos que describen los productos que vende una tienda

Para crear las colecciones orders y products e insertar los datos de muestra, agregue el siguiente código a su aplicación:

const orders = aggDB.collection('orders');
const products = aggDB.collection('products');
await orders.insertMany([
  {
    customer_id: 'elise_smith@myemail.com',
    orderdate: new Date('2020-05-30T08:35:52Z'),
    product_id: 'a1b2c3d4',
    value: 431.43,
  },
  {
    customer_id: 'tj@wheresmyemail.com',
    orderdate: new Date('2019-05-28T19:13:32Z'),
    product_id: 'z9y8x7w6',
    value: 5.01,
  },
  {
    customer_id: 'oranieri@warmmail.com',
    orderdate: new Date('2020-01-01T08:25:37Z'),
    product_id: 'ff11gg22hh33',
    value: 63.13,
  },
  {
    customer_id: 'jjones@tepidmail.com',
    orderdate: new Date('2020-12-26T08:55:46Z'),
    product_id: 'a1b2c3d4',
    value: 429.65,
  },
]);
await products.insertMany([
  {
    id: 'a1b2c3d4',
    name: 'Asus Laptop',
    category: 'ELECTRONICS',
    description: 'Good value laptop for students',
  },
  {
    id: 'z9y8x7w6',
    name: 'The Day Of The Triffids',
    category: 'BOOKS',
    description: 'Classic post-apocalyptic novel',
  },
  {
    id: 'ff11gg22hh33',
    name: 'Morphy Richardds Food Mixer',
    category: 'KITCHENWARE',
    description: 'Luxury mixer turning good cakes into great',
  },
  {
    id: 'pqr678st',
    name: 'Karcher Hose Set',
    category: 'GARDEN',
    description: 'Hose + nozzles + winder for tidy storage',
  },
]);

Crea la aplicación de plantilla

Antes de comenzar a seguir este tutorial de agregación, debes configurar una nueva aplicación PHP. Puedes usar esta aplicación para conectarte a una implementación de MongoDB, insertar datos de muestra en MongoDB y ejecutar el pipeline de agregación.

Tip

Para aprender cómo instalar la biblioteca PHP y conectarte a MongoDB, consulta el tutorial Comenzar a usar la librería PHP.

Para obtener más información sobre cómo realizar agregaciones en la biblioteca de PHP, consulta la Guía de agregación.

Después de instalar la biblioteca, crea un archivo llamado agg_tutorial.php. Pega el siguiente código en este archivo para crear una plantilla de aplicación para los tutoriales de agregación.

Importante

En el siguiente código, lee los comentarios del código para encontrar las secciones del código que debes modificar para el tutorial que estás siguiendo.

Si intenta ejecutar el código sin hacer ningún cambio, se encontrará con un error de conexión.

<?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, se debe reemplazar el marcador de posición de la cadena de conexión con la cadena de conexión de la implementación.

Tip

Para aprender a localizar la cadena de conexión de la implementación, se debe consultar el paso Crear una cadena de conexión del tutorial Comenzar con la librería PHP.

Por ejemplo, si la cadena de conexión es "mongodb+srv://mongodb-example:27017", la asignación de cadena de conexión se asemeja a lo siguiente:

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

Crear la colección

Este ejemplo utiliza dos colecciones:

orders: documentos que describen pedidos individuales de productos en una tienda
products: documentos que describen los productos que vende una tienda

Para crear las colecciones orders y products e insertar los datos de muestra, agregue el siguiente código a su aplicación:

$orders = $client->agg_tutorials_db->orders;
$products = $client->agg_tutorials_db->products;
$orders->deleteMany([]);
$products->deleteMany([]);
$orders->insertMany(
    [
        [
            'customer_id' => 'elise_smith@myemail.com',
            'orderdate' => new UTCDateTime(new DateTimeImmutable('2020-05-30T08:35:52')),
            'product_id' => 'a1b2c3d4',
            'value' => 431.43
        ],
        [
            'customer_id' => 'tj@wheresmyemail.com',
            'orderdate' => new UTCDateTime(new DateTimeImmutable('2019-05-28T19:13:32')),
            'product_id' => 'z9y8x7w6',
            'value' => 5.01
        ],
        [
            'customer_id' => 'oranieri@warmmail.com',
            'orderdate' => new UTCDateTime(new DateTimeImmutable('2020-01-01T08:25:37')),
            'product_id' => 'ff11gg22hh33',
            'value' => 63.13,
        ],
        [
            'customer_id' => 'jjones@tepidmail.com',
            'orderdate' => new UTCDateTime(new DateTimeImmutable('2020-12-26T08:55:46')),
            'product_id' => 'a1b2c3d4',
            'value' => 429.65
        ],
    ]
);
$products->insertMany(
    [
        [
            'id' => 'a1b2c3d4',
            'name' => 'Asus Laptop',
            'category' => 'ELECTRONICS',
            'description' => 'Good value laptop for students',
        ],
        [
            'id' => 'z9y8x7w6',
            'name' => 'The Day Of The Triffids',
            'category' => 'BOOKS',
            'description' => 'Classic post-apocalyptic novel',
        ],
        [
            'id' => 'ff11gg22hh33',
            'name' => 'Morphy Richardds Food Mixer',
            'category' => 'KITCHENWARE',
            'description' => 'Luxury mixer turning good cakes into great',
        ],
        [
            'id' => 'pqr678st',
            'name' => 'Karcher Hose Set',
            'category' => 'GARDEN',
            'description' => 'Hose + nozzles + winder for tidy storage',
        ],
    ]
);

Crea la aplicación de plantilla

Antes de comenzar a seguir este tutorial de agregación, debe configurar una nueva aplicación de Python. Puedes usar esta aplicación para conectarte a una implementación de MongoDB, insertar datos de muestra en MongoDB y ejecutar el pipeline de agregación.

Tip

Para aprender a instalar PyMongo y conectarte a MongoDB, consulta el tutorial Get Started with PyMongo.

Para obtener más información sobre cómo realizar agregaciones en PyMongo, consulta la Guía de agregación.

Después de instalar la biblioteca, crea un archivo llamado agg_tutorial.py. Pega el siguiente código en este archivo para crear una plantilla de aplicación para los tutoriales de agregación.

Importante

En el siguiente código, lee los comentarios del código para encontrar las secciones del código que debes modificar para el tutorial que estás siguiendo.

Si intenta ejecutar el código sin hacer ningún cambio, se encontrará con un error de conexión.

# 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, se debe reemplazar el marcador de posición de la cadena de conexión con la cadena de conexión de la implementación.

Tip

Para aprender a localizar la cadena de conexión de la implementación, se debe consultar el paso Crear una cadena de conexión del tutorial Comenzar con la librería PHP.

Por ejemplo, si la cadena de conexión es "mongodb+srv://mongodb-example:27017", la asignación de cadena de conexión se asemeja a lo siguiente:

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

Crear la colección

Este ejemplo utiliza dos colecciones:

orders: documentos que describen pedidos individuales de productos en una tienda
products: documentos que describen los productos que vende una tienda

Para crear las colecciones orders y products e insertar los datos de muestra, agregue el siguiente código a su aplicación:

orders_coll = agg_db["orders"]
products_coll = agg_db["products"]
order_data = [
    {
        "customer_id": "elise_smith@myemail.com",
        "orderdate": datetime(2020, 5, 30, 8, 35, 52),
        "product_id": "a1b2c3d4",
        "value": 431.43,
    },
    {
        "customer_id": "tj@wheresmyemail.com",
        "orderdate": datetime(2019, 5, 28, 19, 13, 32),
        "product_id": "z9y8x7w6",
        "value": 5.01,
    },
    {
        "customer_id": "oranieri@warmmail.com",
        "orderdate": datetime(2020, 1, 1, 8, 25, 37),
        "product_id": "ff11gg22hh33",
        "value": 63.13,
    },
    {
        "customer_id": "jjones@tepidmail.com",
        "orderdate": datetime(2020, 12, 26, 8, 55, 46),
        "product_id": "a1b2c3d4",
        "value": 429.65,
    },
]
orders_coll.insert_many(order_data)
product_data = [
    {
        "id": "a1b2c3d4",
        "name": "Asus Laptop",
        "category": "ELECTRONICS",
        "description": "Good value laptop for students",
    },
    {
        "id": "z9y8x7w6",
        "name": "The Day Of The Triffids",
        "category": "BOOKS",
        "description": "Classic post-apocalyptic novel",
    },
    {
        "id": "ff11gg22hh33",
        "name": "Morphy Richardds Food Mixer",
        "category": "KITCHENWARE",
        "description": "Luxury mixer turning good cakes into great",
    },
    {
        "id": "pqr678st",
        "name": "Karcher Hose Set",
        "category": "GARDEN",
        "description": "Hose + nozzles + winder for tidy storage",
    },
]
products_coll.insert_many(product_data)

Crea la aplicación de plantilla

Antes de comenzar a seguir este tutorial de agregación, debes configurar una nueva aplicación de Ruby. Puedes usar esta aplicación para conectarte a una implementación de MongoDB, insertar datos de muestra en MongoDB y ejecutar el pipeline de agregación.

Tip

Para aprender cómo instalar el controlador de Ruby y conectarte a MongoDB, consulta la Guía de introducción al controlador de Ruby.

Para obtener más información sobre cómo realizar agregaciones en el controlador Ruby, consulta la Guía de agregación.

Después de instalar el controlador, crea un archivo llamado agg_tutorial.rb. Pega el siguiente código en este archivo para crear una plantilla de aplicación para los tutoriales de agregación.

Importante

En el siguiente código, lee los comentarios del código para encontrar las secciones del código que debes modificar para el tutorial que estás siguiendo.

Si intenta ejecutar el código sin hacer ningún cambio, se encontrará con un error de conexión.

# 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, se debe reemplazar el marcador de posición de la cadena de conexión con la cadena de conexión de la implementación.

Tip

Para aprender a localizar la cadena de conexión de la implementación, se debe consultar el paso Crear una cadena de conexión de la guía de inicio de Ruby.

Por ejemplo, si la cadena de conexión es "mongodb+srv://mongodb-example:27017", la asignación de cadena de conexión se asemeja a lo siguiente:

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

Crear la colección

Este ejemplo utiliza dos colecciones:

orders: documentos que describen pedidos individuales de productos en una tienda
products: documentos que describen los productos que vende una tienda

Para crear las colecciones orders y products e insertar los datos de muestra, agregue el siguiente código a su aplicación:

orders = agg_db[:orders]
products = agg_db[:products]
orders.delete_many({})
products.delete_many({})
orders.insert_many(
  [
    {
      customer_id: "elise_smith@myemail.com",
      orderdate: DateTime.parse("2020-05-30T08:35:52Z"),
      product_id: "a1b2c3d4",
      value: 431.43,
    },
    {
      customer_id: "tj@wheresmyemail.com",
      orderdate: DateTime.parse("2019-05-28T19:13:32Z"),
      product_id: "z9y8x7w6",
      value: 5.01,
    },
    {
      customer_id: "oranieri@warmmail.com",
      orderdate: DateTime.parse("2020-01-01T08:25:37Z"),
      product_id: "ff11gg22hh33",
      value: 63.13,
    },
    {
      customer_id: "jjones@tepidmail.com",
      orderdate: DateTime.parse("2020-12-26T08:55:46Z"),
      product_id: "a1b2c3d4",
      value: 429.65,
    },
  ]
)
products.insert_many(
  [
    {
      id: "a1b2c3d4",
      name: "Asus Laptop",
      category: "ELECTRONICS",
      description: "Good value laptop for students",
    },
    {
      id: "z9y8x7w6",
      name: "The Day Of The Triffids",
      category: "BOOKS",
      description: "Classic post-apocalyptic novel",
    },
    {
      id: "ff11gg22hh33",
      name: "Morphy Richardds Food Mixer",
      category: "KITCHENWARE",
      description: "Luxury mixer turning good cakes into great",
    },
    {
      id: "pqr678st",
      name: "Karcher Hose Set",
      category: "GARDEN",
      description: "Hose + nozzles + winder for tidy storage",
    },
  ]
)

Crea la aplicación de plantilla

Antes de comenzar a seguir este tutorial de agregación, debes configurar una nueva aplicación de Rust. Puedes usar esta aplicación para conectarte a una implementación de MongoDB, insertar datos de muestra en MongoDB y ejecutar el pipeline de agregación.

Tip

Para aprender cómo instalar el controlador y conectarte a MongoDB, consulta la Guía de inicio rápido del controlador de Rust.

Para obtener más información sobre cómo realizar agregaciones en el controlador de Rust, consulta la Guía de agregación.

Después de instalar el controlador, crea un archivo llamado agg-tutorial.rs. Pega el siguiente código en este archivo para crear una plantilla de aplicación para los tutoriales de agregación.

Importante

En el siguiente código, lee los comentarios del código para encontrar las secciones del código que debes modificar para el tutorial que estás siguiendo.

Si intenta ejecutar el código sin hacer ningún cambio, se encontrará con un error de conexión.

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, se debe reemplazar el marcador de posición de la cadena de conexión con la cadena de conexión de la implementación.

Tip

Para aprender a localizar la cadena de conexión de su implementación, consulte el paso Crear una cadena de conexión de la guía de inicio rápido de Rust.

Por ejemplo, si la cadena de conexión es "mongodb+srv://mongodb-example:27017", la asignación de cadena de conexión se asemeja a lo siguiente:

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

Crear la colección

Este ejemplo utiliza dos colecciones:

orders: documentos que describen pedidos individuales de productos en una tienda
products: documentos que describen los productos que vende una tienda

Primero, crea estructuras en Rust para modelar los datos en las colecciónes orders y products:

#[derive(Debug, Serialize, Deserialize)]
struct Order {
    customer_id: String,
    order_date: DateTime,
    product_id: String,
    value: f32,
}
#[derive(Debug, Serialize, Deserialize)]
struct Product {
    id: String,
    name: String,
    category: String,
    description: String,
}

Para crear las colecciones orders y products e insertar los datos de muestra, agregue el siguiente código a su aplicación:

let orders: Collection<Order> = agg_db.collection("orders");
let products: Collection<Product> = agg_db.collection("products");
orders.delete_many(doc! {}).await?;
products.delete_many(doc! {}).await?;
let order_docs = vec![
    Order {
        customer_id: "elise_smith@myemail.com".to_string(),
        order_date: DateTime::builder().year(2020).month(5).day(30).hour(8).minute(35).second(52).build().unwrap(),
        product_id: "a1b2c3d4".to_string(),
        value: 431.43,
    },
    Order {
        customer_id: "tj@wheresmyemail.com".to_string(),
        order_date: DateTime::builder().year(2019).month(5).day(28).hour(19).minute(13).second(32).build().unwrap(),
        product_id: "z9y8x7w6".to_string(),
        value: 5.01,
    },
    Order {
        customer_id: "oranieri@warmmail.com".to_string(),
        order_date: DateTime::builder().year(2020).month(1).day(1).hour(8).minute(25).second(37).build().unwrap(),
        product_id: "ff11gg22hh33".to_string(),
        value: 63.13,
    },
    Order {
        customer_id: "jjones@tepidmail.com".to_string(),
        order_date: DateTime::builder().year(2020).month(12).day(26).hour(8).minute(55).second(46).build().unwrap(),
        product_id: "a1b2c3d4".to_string(),
        value: 429.65,
    },
];
orders.insert_many(order_docs).await?;
let product_docs = vec![
    Product {
        id: "a1b2c3d4".to_string(),
        name: "Asus Laptop".to_string(),
        category: "ELECTRONICS".to_string(),
        description: "Good value laptop for students".to_string(),
    },
    Product {
        id: "z9y8x7w6".to_string(),
        name: "The Day Of The Triffids".to_string(),
        category: "BOOKS".to_string(),
        description: "Classic post-apocalyptic novel".to_string(),
    },
    Product {
        id: "ff11gg22hh33".to_string(),
        name: "Morphy Richardds Food Mixer".to_string(),
        category: "KITCHENWARE".to_string(),
        description: "Luxury mixer turning good cakes into great".to_string(),
    },
    Product {
        id: "pqr678st".to_string(),
        name: "Karcher Hose Set".to_string(),
        category: "GARDEN".to_string(),
        description: "Hose + nozzles + winder for tidy storage".to_string(),
    },
];
products.insert_many(product_docs).await?;

Crea la aplicación de plantilla

Antes de comenzar a seguir un tutorial de agregación, debe configurar una nueva aplicación de Scala. Puede usar esta aplicación para conectarse a una implementación de MongoDB, insertar datos de muestra en MongoDB y ejecutar la canalización de agregación.

Tip

Para aprender cómo instalar el controlador y conectarte a MongoDB, consulta la Guía para comenzar con el controlador de Scala.

Para obtener más información sobre cómo realizar agregaciones en el Scala Driver, consulta la Guía de agregación.

Después de instalar el controlador, crea un archivo llamado AggTutorial.scala. Pega el siguiente código en este archivo para crear una plantilla de aplicación para los tutoriales de agregación.

Importante

En el siguiente código, lee los comentarios del código para encontrar las secciones del código que debes modificar para el tutorial que estás siguiendo.

Si intenta ejecutar el código sin hacer ningún cambio, se encontrará con un error de conexión.

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, se debe reemplazar el marcador de posición de la cadena de conexión con la cadena de conexión de la implementación.

Tip

Para aprender a localizar la cadena de conexión de la implementación, se debe consultar el paso Crear una cadena de conexión de la guía de inicio del driver de Scala.

Por ejemplo, si la cadena de conexión es "mongodb+srv://mongodb-example:27017", la asignación de cadena de conexión se asemeja a lo siguiente:

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

Crear la colección

Este ejemplo utiliza dos colecciones:

orders: documentos que describen pedidos individuales de productos en una tienda
products: documentos que describen los productos que vende una tienda

Para crear las colecciones orders y products e insertar los datos de muestra, agregue el siguiente código a su aplicación:

val orders = aggDB.getCollection("orders")
val products = aggDB.getCollection("products")
orders.deleteMany(Filters.empty()).subscribe(
  _ => {},
  e => println("Error: " + e.getMessage),
)
products.deleteMany(Filters.empty()).subscribe(
  _ => {},
  e => println("Error: " + e.getMessage),
)
val dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss")
orders.insertMany(
  Seq(
    Document(
      "customer_id" -> "elise_smith@myemail.com",
      "orderdate" -> dateFormat.parse("2020-05-30T08:35:52"),
      "product_id" -> "a1b2c3d4",
      "value" -> 431.43
    ),
    Document(
      "customer_id" -> "tj@wheresmyemail.com",
      "orderdate" -> dateFormat.parse("2019-05-28T19:13:32"),
      "product_id" -> "z9y8x7w6",
      "value" -> 5.01
    ),
    Document(
      "customer_id" -> "oranieri@warmmail.com",
      "orderdate" -> dateFormat.parse("2020-01-01T08:25:37"),
      "product_id" -> "ff11gg22hh33",
      "value" -> 63.13
    ),
    Document(
      "customer_id" -> "jjones@tepidmail.com",
      "orderdate" -> dateFormat.parse("2020-12-26T08:55:46"),
      "product_id" -> "a1b2c3d4",
      "value" -> 429.65
    )
  )
).subscribe(
  _ => {},
  e => println("Error: " + e.getMessage),
)
products.insertMany(
  Seq(
    Document(
      "id" -> "a1b2c3d4",
      "name" -> "Asus Laptop",
      "category" -> "ELECTRONICS",
      "description" -> "Good value laptop for students"
    ),
    Document(
      "id" -> "z9y8x7w6",
      "name" -> "The Day Of The Triffids",
      "category" -> "BOOKS",
      "description" -> "Classic post-apocalyptic novel"
    ),
    Document(
      "id" -> "ff11gg22hh33",
      "name" -> "Morphy Richardds Food Mixer",
      "category" -> "KITCHENWARE",
      "description" -> "Luxury mixer turning good cakes into great"
    ),
    Document(
      "id" -> "pqr678st",
      "name" -> "Karcher Hose Set",
      "category" -> "GARDEN",
      "description" -> "Hose + nozzles + winder for tidy storage"
    )
  )
).subscribe(
  _ => {},
  e => println("Error: " + e.getMessage),
)

Pasos

Los siguientes pasos demuestran cómo crear y ejecutar una canalización de agregación para unir colecciones en un único campo común.

Ejecute la canalización de agregación.

db.orders.aggregate( [
   // Stage 1: Match orders that were placed in 2020
   { $match: {
      orderdate: {
         $gte: new Date("2020-01-01T00:00:00Z"),
         $lt: new Date("2021-01-01T00:00:00Z")
      }
   } },
   // Stage 2: Link the collections
   { $lookup: {
      from: "products",
      localField: "product_id",
      foreignField: "p_id",
      as: "product_mapping"
   } },
   // Stage 3: Create new document fields
   { $set: {
      product_mapping: { $first: "$product_mapping" }
   } },
   { $set: {
      product_name: "$product_mapping.name",
      product_category: "$product_mapping.category"
   } },
   // Stage 4: Remove unneeded fields
   { $unset: ["_id", "product_id", "product_mapping"] }
] )

En este ejemplo, la etapa $lookup siempre genera una matriz product_mapping que contiene un documento. La etapa $set, posterior a la etapa $lookup, utiliza $first para extraer el documento de la matriz product_mapping. Si utiliza esta canalización en un entorno donde la etapa $lookup genera una matriz con más de un documento, considere usar una etapa { $limit: 1 } explícita en la etapa $lookup.

Nota

Si no existe un índice de apoyo en, una foreignField $lookup operación que realice una coincidencia de igualdad con una sola unión probablemente tendrá un rendimiento bajo. Para obtener más información, consulte Consideraciones sobre el rendimiento de las búsquedas y Crear un índice.

Interpretar los resultados de la agregación.

Los resultados agregados contienen tres documentos. Estos documentos representan pedidos de clientes realizados en 2020, con el product_name y el product_category del producto solicitado:

{
   customer_id: 'elise_smith@myemail.com',
   orderdate: ISODate('2020-05-30T08:35:52.000Z'),
   value: 431.43,
   product_name: 'Asus Laptop',
   product_category: 'ELECTRONICS'
}
{
   customer_id: 'oranieri@warmmail.com',
   orderdate: ISODate('2020-01-01T08:25:37.000Z'),
   value: 63.13,
   product_name: 'Morphy Richardds Food Mixer',
   product_category: 'KITCHENWARE'
}
{
   customer_id: 'jjones@tepidmail.com',
   orderdate: ISODate('2020-12-26T08:55:46.000Z'),
   value: 429.65,
   product_name: 'Asus Laptop',
   product_category: 'ELECTRONICS'
}

El resultado consiste en documentos que contienen campos de documentos de la colección orders y la colección products unidos mediante la coincidencia del campo product_id presente en cada documento original.

Añadir una etapa de coincidencia para pedidos en 2020.

Agregue una etapa que $match 2020 coincida con los pedidos realizados en:

"{", "$match", "{",
"orderdate", "{",
"$gte", BCON_DATE_TIME(1577836800000UL),
"$lt", BCON_DATE_TIME(1609459200000UL),
"}",
"}", "}",

Agregue una etapa de búsqueda para vincular las colecciones.

A continuación, agregue una etapa.$lookup La $lookup etapa une el product_id campo de la orders colección con el id campo de la products colección:

"{", "$lookup", "{",
"from", BCON_UTF8("products"),
"localField", BCON_UTF8("product_id"),
"foreignField", BCON_UTF8("id"),
"as", BCON_UTF8("product_mapping"),
"}", "}",

Agregue etapas establecidas para crear nuevos campos de documento.

A continuación, agregue dos etapas al $set pipeline.

La primera etapa $set establece el campo product_mapping en el primer elemento del objeto product_mapping creado en la etapa $lookup anterior.

La segunda etapa $set crea dos campos nuevos, product_name y product_category, a partir de los valores del campo de objeto product_mapping:

"{", "$set", "{", "product_mapping", "{", "$first", BCON_UTF8("$product_mapping"), "}", "}", "}",
"{", "$set", "{",
"product_name", BCON_UTF8("$product_mapping.name"),
"product_category", BCON_UTF8("$product_mapping.category"),
"}", "}",

Tip

Dado que se trata de una unión uno a uno, la $lookup etapa añade solo un elemento de la matriz al documento de entrada. La canalización utiliza el operador para recuperar los datos de este $first elemento.

Añade una etapa de Remoción para remover campos innecesarios

Finalmente, agregue una etapa.$unset La $unset etapa elimina los campos innecesarios del documento:

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

Ejecute la canalización de agregación.

Se debe agregar el siguiente código al final de la aplicación para realizar la agregación en la colección orders:

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

Asegúrese de limpiar los recursos de la colección añadiendo la siguiente línea a sus instrucciones de limpieza:

mongoc_collection_destroy(orders);
mongoc_collection_destroy(products);

Finalmente, se deben ejecutar los siguientes comandos en el shell para generar y ejecutar el ejecutable:

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

Tip

Si encuentras errores de conexión al ejecutar los comandos anteriores en una sola llamada, puedes ejecutarlos por separado.

Interpretar los resultados de la agregación.

El resultado agregado contiene tres documentos. Estos documentos representan pedidos de clientes realizados en 2020, con el product_name y el product_category del producto solicitado:

{ "customer_id" : "elise_smith@myemail.com", "orderdate" : { "$date" : { "$numberLong" : "1590822952000" } }, "value" : { "$numberDouble" : "431.43000000000000682" }, "product_name" : "Asus Laptop", "product_category" : "ELECTRONICS" }
{ "customer_id" : "oranieri@warmmail.com", "orderdate" : { "$date" : { "$numberLong" : "1577869537000" } }, "value" : { "$numberDouble" : "63.130000000000002558" }, "product_name" : "Morphy Richardds Food Mixer", "product_category" : "KITCHENWARE" }
{ "customer_id" : "jjones@tepidmail.com", "orderdate" : { "$date" : { "$numberLong" : "1608976546000" } }, "value" : { "$numberDouble" : "429.64999999999997726" }, "product_name" : "Asus Laptop", "product_category" : "ELECTRONICS" }

El resultado consiste en documentos que contienen campos de documentos de la colección orders y la colección products, unidos por la coincidencia del campo product_id presente en cada documento original.

Añadir una etapa de coincidencia para pedidos en 2020.

Agregue una etapa que $match 2020 coincida con los pedidos realizados en:

pipeline.match(bsoncxx::from_json(R"({
    "orderdate": {
        "$gte": {"$date": 1577836800},
        "$lt": {"$date": 1609459200000}
    }
})"));

Agregue una etapa de búsqueda para vincular las colecciones.

A continuación, agregue una etapa.$lookup La $lookup etapa une el product_id campo de la orders colección con el id campo de la products colección:

pipeline.lookup(bsoncxx::from_json(R"({
    "from": "products",
    "localField": "product_id",
    "foreignField": "id",
    "as": "product_mapping"
})"));

Agregue etapas addFields para crear nuevos campos de documento.

A continuación, agregue dos etapas al $addFields pipeline.

La primera etapa $addFields establece el campo product_mapping en el primer elemento del objeto product_mapping creado en la etapa $lookup anterior.

La segunda etapa $addFields crea dos campos nuevos, product_name y product_category, a partir de los valores del campo de objeto product_mapping:

pipeline.add_fields(bsoncxx::from_json(R"({
    "product_mapping": {"$first": "$product_mapping"}
})"));
pipeline.add_fields(bsoncxx::from_json(R"({
    "product_name": "$product_mapping.name",
    "product_category": "$product_mapping.category"
})"));

Tip

Añade una etapa de Remoción para remover campos innecesarios

Finalmente, agregue una etapa.$unset La $unset etapa elimina los campos innecesarios del documento:

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

Ejecute la canalización de agregación.

Se debe agregar el siguiente código al final de la aplicación para realizar la agregación en la colección orders:

auto cursor = orders.aggregate(pipeline);

Finalmente, ejecute el siguiente comando en su shell para iniciar su aplicación:

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

Interpretar los resultados de la agregación.

El resultado agregado contiene tres documentos. Estos documentos representan pedidos de clientes realizados en 2020, con el product_name y el product_category del producto solicitado:

{ "customer_id" : "elise_smith@myemail.com", "orderdate" : { "$date" : "2020-05-30T06:55:52Z" },
"value" : 431.43000000000000682, "product_name" : "Asus Laptop", "product_category" : "ELECTRONICS" }
{ "customer_id" : "oranieri@warmmail.com", "orderdate" : { "$date" : "1970-01-19T06:17:41.137Z" },
"value" : 63.130000000000002558, "product_name" : "Morphy Richardds Food Mixer", "product_category" : "KITCHENWARE" }
{ "customer_id" : "jjones@tepidmail.com", "orderdate" : { "$date" : "2020-12-26T08:55:46Z" },
"value" : 429.64999999999997726, "product_name" : "Asus Laptop", "product_category" : "ELECTRONICS" }

Añadir una etapa de coincidencia para pedidos en 2020.

Primero, inicie la agregación en la colección orders y encadene una etapa $match que coincida con los pedidos realizados en 2020:

var results = orders.Aggregate()
    .Match(o => o.OrderDate >= DateTime.Parse("2020-01-01T00:00:00Z") &&
                o.OrderDate < DateTime.Parse("2021-01-01T00:00:00Z"))

Agregue una etapa de búsqueda para vincular las colecciones.

A continuación, agregue una etapa.$lookup La $lookup etapa une el ProductId campo de la orders colección con el Id campo de la products colección:

.Lookup<Product, Order>(
    foreignCollectionName: "products",
    localField: "ProductId",
    foreignField: "Id",
    "ProductMapping"
)

Agregue una etapa de proyección para crear nuevos campos de documento y omitir los campos innecesarios.

A continuación, agregue una etapa a la $project canalización.

La etapa $project crea dos campos nuevos, ProductName y ProductCategory, a partir de las primeras entradas de los valores respectivos en el campo de objeto ProductMapping. La etapa también especifica qué campos se incluirán y excluirán de los documentos de salida:

.Project(new BsonDocument
{
    { "ProductName", new BsonDocument("$first", "$ProductMapping.Name") },
    { "ProductCategory", new BsonDocument("$first", "$ProductMapping.Category") },
    { "OrderDate", 1 },
    { "CustomerId", 1 },
    { "Value", 1 },
    { "_id", 0 }
});

Tip

Ejecutar la agregación e interpretar los resultados.

Por último, se debe ejecutar la aplicación en el IDE e inspeccionar los resultados.

El resultado agregado contiene tres documentos. Estos documentos representan pedidos de clientes realizados en 2020, con el ProductName y el ProductCategory del producto solicitado:

{ "CustomerId" : "elise_smith@myemail.com", "OrderDate" : { "$date" : "2020-05-30T08:35:52Z" }, "Value" : 431.43000000000001, "ProductName" : "Asus Laptop", "ProductCategory" : "ELECTRONICS" }
{ "CustomerId" : "oranieri@warmmail.com", "OrderDate" : { "$date" : "2020-01-01T08:25:37Z" }, "Value" : 63.130000000000003, "ProductName" : "Morphy Richardds Food Mixer", "ProductCategory" : "KITCHENWARE" }
{ "CustomerId" : "jjones@tepidmail.com", "OrderDate" : { "$date" : "2020-12-26T08:55:46Z" }, "Value" : 429.64999999999998, "ProductName" : "Asus Laptop", "ProductCategory" : "ELECTRONICS" }

El resultado consiste en documentos que contienen campos de documentos de la colección orders y la colección products, unidos por la coincidencia del campo ProductId presente en cada documento original.

Añadir una etapa de coincidencia para pedidos en 2020.

Agregue una etapa que $match 2020 coincida con los pedidos realizados en:

matchStage := bson.D{{Key: "$match", Value: bson.D{
	{Key: "orderdate", Value: bson.D{
		{Key: "$gte", Value: time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)},
		{Key: "$lt", Value: time.Date(2021, 1, 1, 0, 0, 0, 0, time.UTC)},
	}},
}}}

Agregue una etapa de búsqueda para vincular las colecciones.

A continuación, agregue una etapa.$lookup La $lookup etapa une el product_id campo de la orders colección con el id campo de la products colección:

lookupStage := bson.D{{Key: "$lookup", Value: bson.D{
	{Key: "from", Value: "products"},
	{Key: "localField", Value: "product_id"},
	{Key: "foreignField", Value: "id"},
	{Key: "as", Value: "product_mapping"},
}}}

Agregue etapas establecidas para crear nuevos campos de documento.

A continuación, agregue dos etapas al $set pipeline.

La primera etapa $set establece el campo product_mapping en el primer elemento del objeto product_mapping creado en la etapa $lookup anterior.

La segunda etapa $set crea dos campos nuevos, product_name y product_category, a partir de los valores del campo de objeto product_mapping:

setProductMappingStage := bson.D{{Key: "$set", Value: bson.D{
	{Key: "product_mapping", Value: bson.D{{Key: "$first", Value: "$product_mapping"}}},
}}}
setProductNameCategoryStage := bson.D{{Key: "$set", Value: bson.D{
	{Key: "product_name", Value: "$product_mapping.name"},
	{Key: "product_category", Value: "$product_mapping.category"},
}}}

Tip

Añade una etapa de Remoción para remover campos innecesarios

Finalmente, agregue una etapa.$unset La $unset etapa elimina los campos innecesarios del documento:

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

Ejecute la canalización de agregación.

Se debe agregar el siguiente código al final de la aplicación para realizar la agregación en la colección orders:

pipeline := mongo.Pipeline{
	matchStage,
	lookupStage,
	setProductMappingStage,
	setProductNameCategoryStage,
	unsetStage,
}
cursor, err := orders.Aggregate(ctx, pipeline)

Por último, ejecuta la aplicación e inspecciona los resultados.

Interpretar los resultados de la agregación.

El resultado agregado contiene tres documentos. Estos documentos representan pedidos de clientes realizados en 2020, con el product_name y el product_category del producto solicitado:

{"customer_id":"elise_smith@myemail.com","orderdate":{"$date":"2020-05-30T08:35:52Z"},"value":431.42999267578125,"product_name":"Asus Laptop","product_category":"ELECTRONICS"}
{"customer_id":"oranieri@warmmail.com","orderdate":{"$date":"2020-01-01T08:25:37Z"},"value":63.130001068115234,"product_name":"Morphy Richardds Food Mixer","product_category":"KITCHENWARE"}
{"customer_id":"jjones@tepidmail.com","orderdate":{"$date":"2020-12-26T08:55:46Z"},"value":429.6499938964844,"product_name":"Asus Laptop","product_category":"ELECTRONICS"}

Añadir una etapa de coincidencia para pedidos en 2020.

Agregue una etapa que $match 2020 coincida con los pedidos realizados en:

pipeline.add(Aggregates.match(Filters.and(
        Filters.gte("orderdate", LocalDateTime.parse("2020-01-01T00:00:00")),
        Filters.lt("orderdate", LocalDateTime.parse("2021-01-01T00:00:00"))
)));

Agregue una etapa de búsqueda para vincular las colecciones.

A continuación, agregue una etapa.$lookup La $lookup etapa une el product_id campo de la orders colección con el id campo de la products colección:

pipeline.add(Aggregates.lookup(
        "products",
        "product_id",
        "id",
        "product_mapping"
));

Agregue etapas establecidas para crear nuevos campos de documento.

A continuación, agregue dos etapas al $set pipeline.

La primera etapa $set establece el campo product_mapping en el primer elemento del objeto product_mapping creado en la etapa $lookup anterior.

La segunda etapa $set crea dos campos nuevos, product_name y product_category, a partir de los valores del campo de objeto product_mapping:

pipeline.add(Aggregates.set(
        new Field<>(
                "product_mapping",
                new Document("$first", "$product_mapping")
        )
));
pipeline.add(Aggregates.set(
        new Field<>("product_name", "$product_mapping.name"),
        new Field<>("product_category", "$product_mapping.category")
));

Tip

Añade una etapa de Remoción para remover campos innecesarios

Finalmente, agregue una etapa.$unset La $unset etapa elimina los campos innecesarios del documento:

pipeline.add(Aggregates.unset("_id", "product_id", "product_mapping"));

Ejecute la canalización de agregación.

Se debe agregar el siguiente código al final de la aplicación para realizar la agregación en la colección orders:

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

Finalmente, ejecute la aplicación en su IDE.

Interpretar los resultados de la agregación.

El resultado agregado contiene tres documentos. Estos documentos representan pedidos de clientes realizados en 2020, con el product_name y el product_category del producto solicitado:

{"customer_id": "elise_smith@myemail.com", "orderdate": {"$date": "2020-05-30T08:35:52Z"}, "value": 431.43, "product_name": "Asus Laptop", "product_category": "ELECTRONICS"}
{"customer_id": "oranieri@warmmail.com", "orderdate": {"$date": "2020-01-01T08:25:37Z"}, "value": 63.13, "product_name": "Morphy Richardds Food Mixer", "product_category": "KITCHENWARE"}
{"customer_id": "jjones@tepidmail.com", "orderdate": {"$date": "2020-12-26T08:55:46Z"}, "value": 429.65, "product_name": "Asus Laptop", "product_category": "ELECTRONICS"}

Añadir una etapa de coincidencia para pedidos en 2020.

Agregue una etapa que $match 2020 coincida con los pedidos realizados en:

pipeline.add(
    Aggregates.match(
        Filters.and(
            Filters.gte(
                Order::orderDate.name,
                LocalDateTime.parse("2020-01-01T00:00:00").toJavaLocalDateTime()
            ),
            Filters.lt(Order::orderDate.name, LocalDateTime.parse("2021-01-01T00:00:00").toJavaLocalDateTime())
        )
    )
)

Agregue una etapa de búsqueda para vincular las colecciones.

A continuación, agregue una etapa.$lookup La $lookup etapa une el productID campo de la orders colección con el ID campo de la products colección:

pipeline.add(
    Aggregates.lookup(
        "products",
        Order::productID.name,
        Product::ID.name,
        "product_mapping"
    )
)

Agregue etapas establecidas para crear nuevos campos de documento.

A continuación, agregue dos etapas al $set pipeline.

La primera etapa $set establece el campo product_mapping en el primer elemento del objeto product_mapping creado en la etapa $lookup anterior.

La segunda etapa $set crea dos campos nuevos, product_name y product_category, a partir de los valores del campo de objeto product_mapping:

pipeline.add(
    Aggregates.set(Field("product_mapping", Document("\$first", "\$product_mapping")))
)
pipeline.add(
    Aggregates.set(
        Field("product_name", "\$product_mapping.name"),
        Field("product_category", "\$product_mapping.category")
    )
)

Tip

Añade una etapa de Remoción para remover campos innecesarios

Finalmente, agregue una etapa.$unset La $unset etapa elimina los campos innecesarios del documento:

pipeline.add(Aggregates.unset("_id", Order::productID.name, "product_mapping"))

Ejecute la canalización de agregación.

Se debe agregar el siguiente código al final de la aplicación para realizar la agregación en la colección orders:

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

Finalmente, ejecute la aplicación en su IDE.

Interpretar los resultados de la agregación.

El resultado agregado contiene tres documentos. Estos documentos representan pedidos de clientes realizados en 2020, con el product_name y el product_category del producto solicitado:

Document{{customerID=elise_smith@myemail.com, orderDate=Sat May 30 04:35:52 EDT 2020, value=431.43, product_name=Asus Laptop, product_category=ELECTRONICS}}
Document{{customerID=oranieri@warmmail.com, orderDate=Wed Jan 01 03:25:37 EST 2020, value=63.13, product_name=Morphy Richardds Food Mixer, product_category=KITCHENWARE}}
Document{{customerID=jjones@tepidmail.com, orderDate=Sat Dec 26 03:55:46 EST 2020, value=429.65, product_name=Asus Laptop, product_category=ELECTRONICS}}

Añadir una etapa de coincidencia para pedidos en 2020.

Agregue una etapa que $match 2020 coincida con los pedidos realizados en:

pipeline.push({
  $match: {
    orderdate: {
      $gte: new Date('2020-01-01T00:00:00Z'),
      $lt: new Date('2021-01-01T00:00:00Z'),
    },
  },
});

Agregue una etapa de búsqueda para vincular las colecciones.

A continuación, agregue una etapa.$lookup La $lookup etapa une el product_id campo de la orders colección con el id campo de la products colección:

pipeline.push({
  $lookup: {
    from: 'products',
    localField: 'product_id',
    foreignField: 'id',
    as: 'product_mapping',
  },
});

Agregue etapas establecidas para crear nuevos campos de documento.

A continuación, agregue dos etapas al $set pipeline.

La primera etapa $set establece el campo product_mapping en el primer elemento del objeto product_mapping creado en la etapa $lookup anterior.

La segunda etapa $set crea dos campos nuevos, product_name y product_category, a partir de los valores del campo de objeto product_mapping:

pipeline.push(
  {
    $set: {
      product_mapping: { $first: '$product_mapping' },
    },
  },
  {
    $set: {
      product_name: '$product_mapping.name',
      product_category: '$product_mapping.category',
    },
  }
);

Tip

Añade una etapa de Remoción para remover campos innecesarios

Finalmente, agregue una etapa.$unset La $unset etapa elimina los campos innecesarios del documento:

pipeline.push({ $unset: ['_id', 'product_id', 'product_mapping'] });

Ejecute la canalización de agregación.

Se debe agregar el siguiente código al final de la aplicación para realizar la agregación en la colección orders:

const aggregationResult = await orders.aggregate(pipeline);

Finalmente, ejecute el código en el archivo usando su IDE o la línea de comandos.

Interpretar los resultados de la agregación.

El resultado agregado contiene tres documentos. Estos documentos representan pedidos de clientes realizados en 2020, con el product_name y el product_category del producto solicitado:

{
  customer_id: 'elise_smith@myemail.com',
  orderdate: 2020-05-30T08:35:52.000Z,
  value: 431.43,
  product_name: 'Asus Laptop',
  product_category: 'ELECTRONICS'
}
{
  customer_id: 'oranieri@warmmail.com',
  orderdate: 2020-01-01T08:25:37.000Z,
  value: 63.13,
  product_name: 'Morphy Richardds Food Mixer',
  product_category: 'KITCHENWARE'
}
{
  customer_id: 'jjones@tepidmail.com',
  orderdate: 2020-12-26T08:55:46.000Z,
  value: 429.65,
  product_name: 'Asus Laptop',
  product_category: 'ELECTRONICS'
}

Añadir una etapa de coincidencia para pedidos en 2020.

Agregue una etapa que $match 2020 coincida con los pedidos realizados en:

Stage::match(
    orderdate: [
        Query::gte(new UTCDateTime(new DateTimeImmutable('2020-01-01T00:00:00'))),
        Query::lt(new UTCDateTime(new DateTimeImmutable('2021-01-01T00:00:00'))),
    ]
),

Agregue una etapa de búsqueda para vincular las colecciones.

Fuera de la Pipeline instancia, cree una etapa en una función de fábrica. La etapa ``$lookup`` une $lookup el product_id campo de la orders colección con el id campo de la products colección:

function lookupProductsStage()
{
    return Stage::lookup(
        from: 'products',
        localField: 'product_id',
        foreignField: 'id',
        as: 'product_mapping',
    );
}

Luego, en la instancia de Pipeline, llamar a la función lookupProductsStage():

lookupProductsStage(),

Agregue etapas establecidas para crear nuevos campos de documento.

A continuación, agregue dos etapas al $set pipeline.

La primera etapa $set establece el campo product_mapping en el primer elemento del objeto product_mapping creado en la etapa $lookup anterior.

La segunda etapa $set crea dos campos nuevos, product_name y product_category, a partir de los valores del campo de objeto product_mapping:

Stage::set(
    product_mapping: Expression::first(
        Expression::arrayFieldPath('product_mapping')
    )
),
Stage::set(
    product_name: Expression::stringFieldPath('product_mapping.name'),
    product_category: Expression::stringFieldPath('product_mapping.category')
),

Tip

Añade una etapa de Remoción para remover campos innecesarios

Finalmente, agregue una etapa.$unset La $unset etapa elimina los campos innecesarios del documento:

Stage::unset('_id', 'product_id', 'product_mapping')

Ejecute la canalización de agregación.

Se debe agregar el siguiente código al final de la aplicación para realizar la agregación en la colección orders:

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

Finalmente, ejecute el siguiente comando en su shell para iniciar su aplicación:

php agg_tutorial.php

Interpretar los resultados de la agregación.

El resultado agregado contiene tres documentos. Estos documentos representan pedidos de clientes realizados en 2020, con el product_name y el product_category del producto solicitado:

{
    "customer_id": "elise_smith@myemail.com",
    "orderdate": {
        "$date": {
            "$numberLong": "1590827752000"
        }
    },
    "value": 431.43,
    "product_name": "Asus Laptop",
    "product_category": "ELECTRONICS"
}
{
    "customer_id": "oranieri@warmmail.com",
    "orderdate": {
        "$date": {
            "$numberLong": "1577867137000"
        }
    },
    "value": 63.13,
    "product_name": "Morphy Richardds Food Mixer",
    "product_category": "KITCHENWARE"
}
{
    "customer_id": "jjones@tepidmail.com",
    "orderdate": {
        "$date": {
            "$numberLong": "1608972946000"
        }
    },
    "value": 429.65,
    "product_name": "Asus Laptop",
    "product_category": "ELECTRONICS"
}

Añadir una etapa de coincidencia para pedidos en 2020.

Agregue una etapa que $match 2020 coincida con los pedidos realizados en:

pipeline.append(
    {
        "$match": {
            "orderdate": {
                "$gte": datetime(2020, 1, 1, 0, 0, 0),
                "$lt": datetime(2021, 1, 1, 0, 0, 0),
            }
        }
    }
)

Agregue una etapa de búsqueda para vincular las colecciones.

A continuación, agregue una etapa.$lookup La $lookup etapa une el product_id campo de la orders colección con el id campo de la products colección:

pipeline.append(
    {
        "$lookup": {
            "from": "products",
            "localField": "product_id",
            "foreignField": "id",
            "as": "product_mapping",
        }
    }
)

Agregue etapas establecidas para crear nuevos campos de documento.

A continuación, agregue dos etapas al $set pipeline.

La primera etapa $set establece el campo product_mapping en el primer elemento del objeto product_mapping creado en la etapa $lookup anterior.

La segunda etapa $set crea dos campos nuevos, product_name y product_category, a partir de los valores del campo de objeto product_mapping:

pipeline.extend(
    [
        {"$set": {"product_mapping": {"$first": "$product_mapping"}}},
        {
            "$set": {
                "product_name": "$product_mapping.name",
                "product_category": "$product_mapping.category",
            }
        },
    ]
)

Tip

Añade una etapa de Remoción para remover campos innecesarios

Finalmente, agregue una etapa.$unset La $unset etapa elimina los campos innecesarios del documento:

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

Ejecute la canalización de agregación.

Se debe agregar el siguiente código al final de la aplicación para realizar la agregación en la colección orders:

aggregation_result = orders_coll.aggregate(pipeline)

Finalmente, ejecute el siguiente comando en su shell para iniciar su aplicación:

python3 agg_tutorial.py

Interpretar los resultados de la agregación.

El resultado agregado contiene tres documentos. Estos documentos representan pedidos de clientes realizados en 2020, con el product_name y el product_category del producto solicitado:

{'customer_id': 'elise_smith@myemail.com', 'orderdate': datetime.datetime(2020, 5, 30, 8, 35, 52), 'value': 431.43, 'product_name': 'Asus Laptop', 'product_category': 'ELECTRONICS'}
{'customer_id': 'oranieri@warmmail.com', 'orderdate': datetime.datetime(2020, 1, 1, 8, 25, 37), 'value': 63.13, 'product_name': 'Morphy Richardds Food Mixer', 'product_category': 'KITCHENWARE'}
{'customer_id': 'jjones@tepidmail.com', 'orderdate': datetime.datetime(2020, 12, 26, 8, 55, 46), 'value': 429.65, 'product_name': 'Asus Laptop', 'product_category': 'ELECTRONICS'}

Añadir una etapa de coincidencia para pedidos en 2020.

Agregue una etapa que $match 2020 coincida con los pedidos realizados en:

{
  "$match": {
    orderdate: {
      "$gte": DateTime.parse("2020-01-01T00:00:00Z"),
      "$lt": DateTime.parse("2021-01-01T00:00:00Z"),
    },
  },
},

Agregue una etapa de búsqueda para vincular las colecciones.

A continuación, agregue una etapa.$lookup La $lookup etapa une el product_id campo de la orders colección con el id campo de la products colección:

{
  "$lookup": {
    from: "products",
    localField: "product_id",
    foreignField: "id",
    as: "product_mapping",
  },
},

Agregue etapas establecidas para crear nuevos campos de documento.

A continuación, agregue dos etapas al $set pipeline.

La primera etapa $set establece el campo product_mapping en el primer elemento del objeto product_mapping creado en la etapa $lookup anterior.

La segunda etapa $set crea dos campos nuevos, product_name y product_category, a partir de los valores del campo de objeto product_mapping:

{
  "$set": {
    product_mapping: { "$first": "$product_mapping" },
  },
},
{
  "$set": {
    product_name: "$product_mapping.name",
    product_category: "$product_mapping.category",
  },
},

Tip

Añade una etapa de Remoción para remover campos innecesarios

Finalmente, agregue una etapa.$unset La $unset etapa elimina los campos innecesarios del documento:

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

Ejecute la canalización de agregación.

Se debe agregar el siguiente código al final de la aplicación para realizar la agregación en la colección orders:

aggregation_result = orders.aggregate(pipeline)

Finalmente, ejecute el siguiente comando en su shell para iniciar su aplicación:

ruby agg_tutorial.rb

Interpretar los resultados de la agregación.

El resultado agregado contiene tres documentos. Estos documentos representan pedidos de clientes realizados en 2020, con el product_name y el product_category del producto solicitado:

{"customer_id"=>"elise_smith@myemail.com", "orderdate"=>2020-05-30 08:35:52 UTC, "value"=>431.43, "product_name"=>"Asus Laptop", "product_category"=>"ELECTRONICS"}
{"customer_id"=>"oranieri@warmmail.com", "orderdate"=>2020-01-01 08:25:37 UTC, "value"=>63.13, "product_name"=>"Morphy Richardds Food Mixer", "product_category"=>"KITCHENWARE"}
{"customer_id"=>"jjones@tepidmail.com", "orderdate"=>2020-12-26 08:55:46 UTC, "value"=>429.65, "product_name"=>"Asus Laptop", "product_category"=>"ELECTRONICS"}

Añadir una etapa de coincidencia para pedidos en 2020.

Agregue una etapa que $match 2020 coincida con los pedidos realizados en:

pipeline.push(doc! {
    "$match": {
        "order_date": {
            "$gte": DateTime::builder().year(2020).month(1).day(1).build().unwrap(),
            "$lt": DateTime::builder().year(2021).month(1).day(1).build().unwrap()
        }
    }
});

Agregue una etapa de búsqueda para vincular las colecciones.

A continuación, agregue una etapa.$lookup La $lookup etapa une el product_id campo de la orders colección con el id campo de la products colección:

pipeline.push(doc! {
    "$lookup": {
        "from": "products",
        "localField": "product_id",
        "foreignField": "id",
        "as": "product_mapping"
    }
});

Agregue etapas establecidas para crear nuevos campos de documento.

A continuación, agregue dos etapas al $set pipeline.

La primera etapa $set establece el campo product_mapping en el primer elemento del objeto product_mapping creado en la etapa $lookup anterior.

La segunda etapa $set crea dos campos nuevos, product_name y product_category, a partir de los valores del campo de objeto product_mapping:

pipeline.push(doc! {
    "$set": {
        "product_mapping": { "$first": "$product_mapping" }
    }
});
pipeline.push(doc! {
    "$set": {
        "product_name": "$product_mapping.name",
        "product_category": "$product_mapping.category"
    }
});

Tip

Añade una etapa de Remoción para remover campos innecesarios

Finalmente, agregue una etapa.$unset La $unset etapa elimina los campos innecesarios del documento:

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

Ejecute la canalización de agregación.

Se debe agregar el siguiente código al final de la aplicación para realizar la agregación en la colección orders:

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

Finalmente, ejecute el siguiente comando en su shell para iniciar su aplicación:

cargo run

Interpretar los resultados de la agregación.

El resultado agregado contiene tres documentos. Estos documentos representan pedidos de clientes realizados en 2020, con el product_name y el product_category del producto solicitado:

Document({"customer_id": String("elise_smith@myemail.com"), "order_date": DateTime(2020-05-30 8:35:52.0 +00:00:00),
"value": Double(431.42999267578125), "product_name": String("Asus Laptop"), "product_category": String("ELECTRONICS")})
Document({"customer_id": String("oranieri@warmmail.com"), "order_date": DateTime(2020-01-01 8:25:37.0 +00:00:00),
"value": Double(63.130001068115234), "product_name": String("Morphy Richardds Food Mixer"), "product_category": String("KITCHENWARE")})
Document({"customer_id": String("jjones@tepidmail.com"), "order_date": DateTime(2020-12-26 8:55:46.0 +00:00:00),
"value": Double(429.6499938964844), "product_name": String("Asus Laptop"), "product_category": String("ELECTRONICS")})

Añadir una etapa de coincidencia para pedidos en 2020.

Agregue una etapa que $match 2020 coincida con los pedidos realizados en:

Aggregates.filter(Filters.and(
  Filters.gte("orderdate", dateFormat.parse("2020-01-01T00:00:00")),
  Filters.lt("orderdate", dateFormat.parse("2021-01-01T00:00:00"))
)),

Agregue una etapa de búsqueda para vincular las colecciones.

A continuación, agregue una etapa.$lookup La $lookup etapa une el product_id campo de la orders colección con el id campo de la products colección:

Aggregates.lookup(
  "products",
  "product_id",
  "id",
  "product_mapping"
),

Agregue etapas establecidas para crear nuevos campos de documento.

A continuación, agregue dos etapas al $set pipeline.

La primera etapa $set establece el campo product_mapping en el primer elemento del objeto product_mapping creado en la etapa $lookup anterior.

La segunda etapa $set crea dos campos nuevos, product_name y product_category, a partir de los valores del campo de objeto product_mapping:

Aggregates.set(Field("product_mapping", Document("$first" -> "$product_mapping"))),
Aggregates.set(
  Field("product_name", "$product_mapping.name"),
  Field("product_category", "$product_mapping.category")
),

Tip

Añade una etapa de Remoción para remover campos innecesarios

Finalmente, agregue una etapa.$unset La $unset etapa elimina los campos innecesarios del documento:

Aggregates.unset("_id", "product_id", "product_mapping")

Ejecute la canalización de agregación.

Se debe agregar el siguiente código al final de la aplicación para realizar la agregación en la colección orders:

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

Finalmente, ejecute la aplicación en su IDE.

Interpretar los resultados de la agregación.

El resultado agregado contiene tres documentos. Estos documentos representan pedidos de clientes realizados en 2020, con el product_name y el product_category del producto solicitado:

{"customer_id": "elise_smith@myemail.com", "orderdate": {"$date": "2020-05-30T12:35:52Z"}, "value": 431.43, "product_name": "Asus Laptop", "product_category": "ELECTRONICS"}
{"customer_id": "oranieri@warmmail.com", "orderdate": {"$date": "2020-01-01T13:25:37Z"}, "value": 63.13, "product_name": "Morphy Richardds Food Mixer", "product_category": "KITCHENWARE"}
{"customer_id": "jjones@tepidmail.com", "orderdate": {"$date": "2020-12-26T13:55:46Z"}, "value": 429.65, "product_name": "Asus Laptop", "product_category": "ELECTRONICS"}

Volver

Descomponer arreglos

Unión de varios campos