/ /

Pipeline de agregación

Ejemplos completos de tuberías

Docs Home

Manual de base de datos

Operaciones de agregación

Pipeline de agregación

Ejemplos completos de tuberías

Datos de grupo y totales

Esta versión de la documentación está archivada y ya no recibe soporte. Para actualizar su implementación 6.0, consulte Procedimientos de actualización de MongoDB.7.0

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 demuestra cómo agrupar y analizar los datos de pedidos de clientes. Los resultados muestran la lista de clientes que compraron artículos en 2020 e incluyen el historial de pedidos de cada cliente para 2020.

La canalización de agregación realiza las siguientes operaciones:

Coincide un subconjunto de documentos por un valor de campo
Agrupa los documentos por valores comunes de campo
Añadir campos calculados a cada documento de resultado

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 un orders Colección que contiene documentos que describen pedidos de productos individuales. Dado que cada pedido corresponde a un solo cliente, la agregación agrupa los documentos de pedido según el campo customer_id, que contiene las direcciones de correo electrónico de los clientes.

Para crear la colección orders, utilice el insertMany() :

db.orders.deleteMany({})
db.orders.insertMany( [
   {
      customer_id: "elise_smith@myemail.com",
      orderdate: new Date("2020-05-30T08:35:52Z"),
      value: 231,
   },
   {
      customer_id: "elise_smith@myemail.com",
      orderdate: new Date("2020-01-13T09:32:07Z"),
      value: 99,
   },
   {
      customer_id: "oranieri@warmmail.com",
      orderdate: new Date("2020-01-01T08:25:37Z"),
      value: 63,
   },
   {
      customer_id: "tj@wheresmyemail.com",
      orderdate: new Date("2019-05-28T19:13:32Z"),
      value: 2,
   },
   {
      customer_id: "tj@wheresmyemail.com",
      orderdate: new Date("2020-11-23T22:56:53Z"),
      value: 187,
   },
   {
      customer_id: "tj@wheresmyemail.com",
      orderdate: new Date("2020-08-18T23:04:48Z"),
      value: 4,
   },
   {
      customer_id: "elise_smith@myemail.com",
      orderdate: new Date("2020-12-26T08:55:46Z"),
      value: 4,
   },
   {
      customer_id: "tj@wheresmyemail.com",
      orderdate: new Date("2021-02-29T07:49:32Z"),
      value: 1024,
   },
   {
      customer_id: "elise_smith@myemail.com",
      orderdate: new Date("2020-10-03T13:49:44Z"),
      value: 102,
   }
] )

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 una colección orders, que contiene documentos que describen órdenes de productos individuales. Dado que cada pedido corresponde a un solo cliente, la agregación agrupa los documentos de pedido por el campo customer_id, que contiene las direcciones de correo electrónico de los clientes.

Para crear la colección orders e insertar los datos de muestra, se debe añadir el siguiente código a la aplicación:

mongoc_collection_t *orders = mongoc_client_get_collection(client, "agg_tutorials_db", "orders");
{
    bson_t *filter = bson_new();
    bson_error_t error;
    if (!mongoc_collection_delete_many(orders, filter, NULL, NULL, &error))
    {
        fprintf(stderr, "Delete error: %s\n", error.message);
    }
    bson_destroy(filter);
}
{
    size_t num_docs = 9;
    bson_t *docs[num_docs];
    docs[0] = BCON_NEW(
        "customer_id", BCON_UTF8("elise_smith@myemail.com"),
        "orderdate", BCON_DATE_TIME(1590825352000UL), // 2020-05-30T08:35:52Z
        "value", BCON_INT32(231));
    docs[1] = BCON_NEW(
        "customer_id", BCON_UTF8("elise_smith@myemail.com"),
        "orderdate", BCON_DATE_TIME(1578904327000UL), // 2020-01-13T09:32:07Z
        "value", BCON_INT32(99));
    docs[2] = BCON_NEW(
        "customer_id", BCON_UTF8("oranieri@warmmail.com"),
        "orderdate", BCON_DATE_TIME(1577865937000UL), // 2020-01-01T08:25:37Z
        "value", BCON_INT32(63));
    docs[3] = BCON_NEW(
        "customer_id", BCON_UTF8("tj@wheresmyemail.com"),
        "orderdate", BCON_DATE_TIME(1559061212000UL), // 2019-05-28T19:13:32Z
        "value", BCON_INT32(2));
    docs[4] = BCON_NEW(
        "customer_id", BCON_UTF8("tj@wheresmyemail.com"),
        "orderdate", BCON_DATE_TIME(1606171013000UL), // 2020-11-23T22:56:53Z
        "value", BCON_INT32(187));
    docs[5] = BCON_NEW(
        "customer_id", BCON_UTF8("tj@wheresmyemail.com"),
        "orderdate", BCON_DATE_TIME(1597793088000UL), // 2020-08-18T23:04:48Z
        "value", BCON_INT32(4));
    docs[6] = BCON_NEW(
        "customer_id", BCON_UTF8("elise_smith@myemail.com"),
        "orderdate", BCON_DATE_TIME(1608963346000UL), // 2020-12-26T08:55:46Z
        "value", BCON_INT32(4));
    docs[7] = BCON_NEW(
        "customer_id", BCON_UTF8("tj@wheresmyemail.com"),
        "orderdate", BCON_DATE_TIME(1614496172000UL), // 2021-02-28T07:49:32Z
        "value", BCON_INT32(1024));
    docs[8] = BCON_NEW(
        "customer_id", BCON_UTF8("elise_smith@myemail.com"),
        "orderdate", BCON_DATE_TIME(1601722184000UL), // 2020-10-03T13:49:44Z
        "value", BCON_INT32(102));
    bson_error_t error;
    if (!mongoc_collection_insert_many(orders, (const bson_t **)docs, num_docs, NULL, NULL, &error))
    {
        fprintf(stderr, "Insert error: %s\n", error.message);
    }
    for (int i = 0; i < num_docs; i++)
    {
        bson_destroy(docs[i]);
    }
}

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 obtener más información sobre el uso del controlador C++, consulte 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

Para crear la colección orders e insertar los datos de muestra, se debe añadir el siguiente código a la aplicación:

auto orders = db["orders"];
std::vector<bsoncxx::document::value> docs = {
    bsoncxx::from_json(R"({
        "customer_id": "elise_smith@myemail.com",
        "orderdate": {"$date": 1590821752000},
        "value": 231
    })"),
    bsoncxx::from_json(R"({
        "customer_id": "elise_smith@myemail.com",
        "orderdate": {"$date": 1578901927},
        "value": 99
    })"),
    bsoncxx::from_json(R"({
        "customer_id": "oranieri@warmmail.com",
        "orderdate": {"$date": 1577861137},
        "value": 63
    })"),
    bsoncxx::from_json(R"({
        "customer_id": "tj@wheresmyemail.com",
        "orderdate": {"$date": 1559076812},
        "value": 2
    })"),
    bsoncxx::from_json(R"({
        "customer_id": "tj@wheresmyemail.com",
        "orderdate": {"$date": 1606172213},
        "value": 187
    })"),
    bsoncxx::from_json(R"({
        "customer_id": "tj@wheresmyemail.com",
        "orderdate": {"$date": 1597794288},
        "value": 4
    })"),
    bsoncxx::from_json(R"({
        "customer_id": "elise_smith@myemail.com",
        "orderdate": {"$date": 1608972946000},
        "value": 4
    })"),
    bsoncxx::from_json(R"({
        "customer_id": "tj@wheresmyemail.com",
        "orderdate": {"$date": 1614570572},
        "value": 1024
    })"),
    bsoncxx::from_json(R"({
        "customer_id": "elise_smith@myemail.com",
        "orderdate": {"$date": 1601722184000},
        "value": 102
    })")
};
auto result = orders.insert_many(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.Driver;
using MongoDB.Bson;
using MongoDB.Bson.Serialization.Attributes;
// Define data model classes.
// ... public class MyClass { ... }
// Replace the placeholder with your connection string.
var uri = "<connection string>";
var client = new MongoClient(uri);
var aggDB = client.GetDatabase("agg_tutorials_db");
// Get a reference to relevant collections.
// ... var someColl = aggDB.GetCollection<MyClass>("someColl");
// ... var anotherColl = aggDB.GetCollection<MyClass>("anotherColl");
// Delete any existing documents in collections if needed.
// ... someColl.DeleteMany(Builders<MyClass>.Filter.Empty);
// Insert sample data into the collection or collections.
// ... someColl.InsertMany(new List<MyClass> { ... });
// Add code to chain pipeline stages to the Aggregate() method.
// ... var results = someColl.Aggregate().Match(...);
// Print the aggregation results.
foreach (var result in results.ToList())
{
  Console.WriteLine(result);
}

Para cada tutorial, 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 una colección orders, que contiene documentos que describen órdenes de productos individuales. Dado que cada pedido corresponde a un solo cliente, la agregación agrupa los documentos de pedido por el campo CustomerId, que contiene las direcciones de correo electrónico de los clientes.

Primero, cree una clase en C# para modelar los datos en la colección orders:

public class Order
{
  [BsonId]
  public ObjectId Id { get; set; }
  public string CustomerId { get; set; }
  public DateTime OrderDate { get; set; }
  public int Value { get; set; }
}

Para crear la colección orders e insertar los datos de muestra, se debe añadir el siguiente código a la aplicación:

var orders = aggDB.GetCollection<Order>("orders");
orders.DeleteMany(Builders<Order>.Filter.Empty);
orders.InsertMany(new List<Order>
    {
        new Order
        {
            CustomerId = "elise_smith@myemail.com",
            OrderDate = DateTime.Parse("2020-05-30T08:35:52Z"),
            Value = 231
        },
        new Order
        {
            CustomerId = "elise_smith@myemail.com",
            OrderDate = DateTime.Parse("2020-01-13T09:32:07Z"),
            Value = 99
        },
        new Order
        {
            CustomerId = "oranieri@warmmail.com",
            OrderDate = DateTime.Parse("2020-01-01T08:25:37Z"),
            Value = 63
        },
        new Order
        {
            CustomerId = "tj@wheresmyemail.com",
            OrderDate = DateTime.Parse("2019-05-28T19:13:32Z"),
            Value = 2
        },
        new Order
        {
            CustomerId = "tj@wheresmyemail.com",
            OrderDate = DateTime.Parse("2020-11-23T22:56:53Z"),
            Value = 187
        },
        new Order
        {
            CustomerId = "tj@wheresmyemail.com",
            OrderDate = DateTime.Parse("2020-08-18T23:04:48Z"),
            Value = 4
        },
        new Order
        {
            CustomerId = "elise_smith@myemail.com",
            OrderDate = DateTime.Parse("2020-12-26T08:55:46Z"),
            Value = 4
        },
        new Order
        {
            CustomerId = "tj@wheresmyemail.com",
            OrderDate = DateTime.Parse("2021-02-28T07:49:32Z"),
            Value = 1024
        },
        new Order
        {
            CustomerId = "elise_smith@myemail.com",
            OrderDate = DateTime.Parse("2020-10-03T13:49:44Z"),
            Value = 102
        }
    });

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

Para cada tutorial, 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

Primero, cree una estructura de Go para modelar los datos en la colección orders:

type Order struct {
	CustomerID string        `bson:"customer_id,omitempty"`
	OrderDate  bson.DateTime `bson:"orderdate"`
	Value      int           `bson:"value"`
}

Para crear la colección orders e insertar los datos de muestra, se debe añadir el siguiente código a la aplicación:

orders := aggDB.Collection("orders")
orders.DeleteMany(context.TODO(), bson.D{})
_, err = orders.InsertMany(context.TODO(), []interface{}{
	Order{
		CustomerID: "elise_smith@myemail.com",
		OrderDate:  bson.NewDateTimeFromTime(time.Date(2020, 5, 30, 8, 35, 53, 0, time.UTC)),
		Value:      231,
	},
	Order{
		CustomerID: "elise_smith@myemail.com",
		OrderDate:  bson.NewDateTimeFromTime(time.Date(2020, 1, 13, 9, 32, 7, 0, time.UTC)),
		Value:      99,
	},
	Order{
		CustomerID: "oranieri@warmmail.com",
		OrderDate:  bson.NewDateTimeFromTime(time.Date(2020, 1, 01, 8, 25, 37, 0, time.UTC)),
		Value:      63,
	},
	Order{
		CustomerID: "tj@wheresmyemail.com",
		OrderDate:  bson.NewDateTimeFromTime(time.Date(2019, 5, 28, 19, 13, 32, 0, time.UTC)),
		Value:      2,
	},
	Order{
		CustomerID: "tj@wheresmyemail.com",
		OrderDate:  bson.NewDateTimeFromTime(time.Date(2020, 11, 23, 22, 56, 53, 0, time.UTC)),
		Value:      187,
	},
	Order{
		CustomerID: "tj@wheresmyemail.com",
		OrderDate:  bson.NewDateTimeFromTime(time.Date(2020, 8, 18, 23, 4, 48, 0, time.UTC)),
		Value:      4,
	},
	Order{
		CustomerID: "elise_smith@myemail.com",
		OrderDate:  bson.NewDateTimeFromTime(time.Date(2020, 12, 26, 8, 55, 46, 0, time.UTC)),
		Value:      4,
	},
	Order{
		CustomerID: "tj@wheresmyemail.com",
		OrderDate:  bson.NewDateTimeFromTime(time.Date(2021, 2, 29, 7, 49, 32, 0, time.UTC)),
		Value:      1024,
	},
	Order{
		CustomerID: "elise_smith@myemail.com",
		OrderDate:  bson.NewDateTimeFromTime(time.Date(2020, 10, 3, 13, 49, 44, 0, time.UTC)),
		Value:      102,
	},
})
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.Aggregates;
import com.mongodb.client.model.Filters;
import com.mongodb.client.model.Sorts;
import org.bson.Document;
import org.bson.conversions.Bson;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class AggTutorial {
    public static void main( String[] args ) {
        // Replace the placeholder with your connection string.
        String uri = "<connection string>";
        try (MongoClient mongoClient = MongoClients.create(uri)) {
            MongoDatabase aggDB = mongoClient.getDatabase("agg_tutorials_db");
            // Get a reference to relevant collections.
            // ... MongoCollection<Document> someColl = ...
            // ... MongoCollection<Document> anotherColl = ...
            // Delete any existing documents in collections if needed.
            // ... someColl.deleteMany(Filters.empty());
            // Insert sample data into the collection or collections.
            // ... someColl.insertMany(...);
            // Create an empty pipeline array.
            List<Bson> pipeline = new ArrayList<>();
            // Add code to create pipeline stages.
            // ... pipeline.add(...);
            // Run the aggregation.
            // ... AggregateIterable<Document> aggregationResult = someColl.aggregate(pipeline);
            // Print the aggregation results.
            for (Document document : aggregationResult) {
                System.out.println(document.toJson());
            }
        }
    }
}

Para cada tutorial, 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

Para crear la colección orders e insertar los datos de muestra, se debe añadir el siguiente código a la aplicación:

MongoCollection<Document> orders = aggDB.getCollection("orders");
orders.deleteMany(Filters.empty());
orders.insertMany(
        Arrays.asList(
                new Document("customer_id", "elise_smith@myemail.com")
                        .append("orderdate", LocalDateTime.parse("2020-05-30T08:35:52"))
                        .append("value", 231),
                new Document("customer_id", "elise_smith@myemail.com")
                        .append("orderdate", LocalDateTime.parse("2020-01-13T09:32:07"))
                        .append("value", 99),
                new Document("customer_id", "oranieri@warmmail.com")
                        .append("orderdate", LocalDateTime.parse("2020-01-01T08:25:37"))
                        .append("value", 63),
                new Document("customer_id", "tj@wheresmyemail.com")
                        .append("orderdate", LocalDateTime.parse("2019-05-28T19:13:32"))
                        .append("value", 2),
                new Document("customer_id", "tj@wheresmyemail.com")
                        .append("orderdate", LocalDateTime.parse("2020-11-23T22:56:53"))
                        .append("value", 187),
                new Document("customer_id", "tj@wheresmyemail.com")
                        .append("orderdate", LocalDateTime.parse("2020-08-18T23:04:48"))
                        .append("value", 4),
                new Document("customer_id", "elise_smith@myemail.com")
                        .append("orderdate", LocalDateTime.parse("2020-12-26T08:55:46"))
                        .append("value", 4),
                new Document("customer_id", "tj@wheresmyemail.com")
                        .append("orderdate", LocalDateTime.parse("2021-02-28T07:49:32"))
                        .append("value", 1024),
                new Document("customer_id", "elise_smith@myemail.com")
                        .append("orderdate", LocalDateTime.parse("2020-10-03T13:49:44"))
                        .append("value", 102)
        )
);

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

Primero, cree una clase de datos de Kotlin para modelar los datos en la colección orders:

@Serializable
data class Order(
    val customerID: String,
    @Contextual val orderDate: LocalDateTime,
    val value: Int
)

Para crear la colección orders e insertar los datos de muestra, se debe añadir el siguiente código a la aplicación:

val orders = aggDB.getCollection<Order>("orders")
orders.deleteMany(Filters.empty())
orders.insertMany(
    listOf(
        Order("elise_smith@myemail.com", LocalDateTime.parse("2020-05-30T08:35:52"), 231),
        Order("elise_smith@myemail.com", LocalDateTime.parse("2020-01-13T09:32:07"), 99),
        Order("oranieri@warmmail.com", LocalDateTime.parse("2020-01-01T08:25:37"), 63),
        Order("tj@wheresmyemail.com", LocalDateTime.parse("2019-05-28T19:13:32"), 2),
        Order("tj@wheresmyemail.com", LocalDateTime.parse("2020-11-23T22:56:53"), 187),
        Order("tj@wheresmyemail.com", LocalDateTime.parse("2020-08-18T23:04:48"), 4),
        Order("elise_smith@myemail.com", LocalDateTime.parse("2020-12-26T08:55:46"), 4),
        Order("tj@wheresmyemail.com", LocalDateTime.parse("2021-02-28T07:49:32"), 1024),
        Order("elise_smith@myemail.com", LocalDateTime.parse("2020-10-03T13:49:44"), 102)
    )
)

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 llamado agg_tutorial.js. 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);
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

Para crear la colección orders e insertar los datos de muestra, se debe añadir el siguiente código a la aplicación:

const orders = aggDB.collection("orders");
await orders.deleteMany({});
await orders.insertMany([
  {
    customer_id: "elise_smith@myemail.com",
    orderdate: new Date("2020-05-30T08:35:52Z"),
    value: 231,
  },
  {
    customer_id: "elise_smith@myemail.com",
    orderdate: new Date("2020-01-13T09:32:07Z"),
    value: 99,
  },
  {
    customer_id: "oranieri@warmmail.com",
    orderdate: new Date("2020-01-01T08:25:37Z"),
    value: 63,
  },
  {
    customer_id: "tj@wheresmyemail.com",
    orderdate: new Date("2019-05-28T19:13:32Z"),
    value: 2,
  },
  {
    customer_id: "tj@wheresmyemail.com",
    orderdate: new Date("2020-11-23T22:56:53Z"),
    value: 187,
  },
  {
    customer_id: "tj@wheresmyemail.com",
    orderdate: new Date("2020-08-18T23:04:48Z"),
    value: 4,
  },
  {
    customer_id: "elise_smith@myemail.com",
    orderdate: new Date("2020-12-26T08:55:46Z"),
    value: 4,
  },
  {
    customer_id: "tj@wheresmyemail.com",
    orderdate: new Date("2021-02-29T07:49:32Z"),
    value: 1024,
  },
  {
    customer_id: "elise_smith@myemail.com",
    orderdate: new Date("2020-10-03T13:49:44Z"),
    value: 102,
  },
]);

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

Para crear la colección orders e insertar los datos de muestra, se debe añadir el siguiente código a la aplicación:

$orders = $client->agg_tutorials_db->orders;
$orders->deleteMany([]);
$orders->insertMany(
    [
        [
            'customer_id' => 'elise_smith@myemail.com',
            'orderdate' => new UTCDateTime(new DateTimeImmutable('2020-05-30T08:35:52')),
            'value' => 231
        ],
        [
            'customer_id' => 'elise_smith@myemail.com',
            'orderdate' => new UTCDateTime(new DateTimeImmutable('2020-01-13T09:32:07')),
            'value' => 99
        ],
        [
            'customer_id' => 'oranieri@warmmail.com',
            'orderdate' => new UTCDateTime(new DateTimeImmutable('2020-01-01T08:25:37')),
            'value' => 63
        ],
        [
            'customer_id' => 'tj@wheresmyemail.com',
            'orderdate' => new UTCDateTime(new DateTimeImmutable('2019-05-28T19:13:32')),
            'value' => 2
        ],
        [
            'customer_id' => 'tj@wheresmyemail.com',
            'orderdate' => new UTCDateTime(new DateTimeImmutable('2020-11-23T22:56:53')),
            'value' => 187
        ],
        [
            'customer_id' => 'tj@wheresmyemail.com',
            'orderdate' => new UTCDateTime(new DateTimeImmutable('2020-08-18T23:04:48')),
            'value' => 4
        ],
        [
            'customer_id' => 'elise_smith@myemail.com',
            'orderdate' => new UTCDateTime(new DateTimeImmutable('2020-12-26T08:55:46')),
            'value' => 4
        ],
        [
            'customer_id' => 'tj@wheresmyemail.com',
            'orderdate' => new UTCDateTime(new DateTimeImmutable('2021-02-28T07:49:32')),
            'value' => 1024
        ],
        [
            'customer_id' => 'elise_smith@myemail.com',
            'orderdate' => new UTCDateTime(new DateTimeImmutable('2020-10-03T13:49:44')),
            'value' => 102
        ]
    ]
);

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

Para crear la colección orders e insertar los datos de muestra, se debe añadir el siguiente código a la aplicación:

orders_coll = agg_db["orders"]
orders_coll.delete_many({})
order_data = [
    {
        "customer_id": "elise_smith@myemail.com",
        "orderdate": datetime(2020, 5, 30, 8, 35, 52),
        "value": 231,
    },
    {
        "customer_id": "elise_smith@myemail.com",
        "orderdate": datetime(2020, 1, 13, 9, 32, 7),
        "value": 99,
    },
    {
        "customer_id": "oranieri@warmmail.com",
        "orderdate": datetime(2020, 1, 1, 8, 25, 37),
        "value": 63,
    },
    {
        "customer_id": "tj@wheresmyemail.com",
        "orderdate": datetime(2019, 5, 28, 19, 13, 32),
        "value": 2,
    },
    {
        "customer_id": "tj@wheresmyemail.com",
        "orderdate": datetime(2020, 11, 23, 22, 56, 53),
        "value": 187,
    },
    {
        "customer_id": "tj@wheresmyemail.com",
        "orderdate": datetime(2020, 8, 18, 23, 4, 48),
        "value": 4,
    },
    {
        "customer_id": "elise_smith@myemail.com",
        "orderdate": datetime(2020, 12, 26, 8, 55, 46),
        "value": 4,
    },
    {
        "customer_id": "tj@wheresmyemail.com",
        "orderdate": datetime(2021, 2, 28, 7, 49, 32),
        "value": 1024,
    },
    {
        "customer_id": "elise_smith@myemail.com",
        "orderdate": datetime(2020, 10, 3, 13, 49, 44),
        "value": 102,
    },
]
orders_coll.insert_many(order_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

Para crear la colección orders e insertar los datos de muestra, se debe añadir el siguiente código a la aplicación:

orders = agg_db[:orders]
orders.delete_many({})
orders.insert_many(
  [
    {
      customer_id: "elise_smith@myemail.com",
      orderdate: DateTime.parse("2020-05-30T08:35:52Z"),
      value: 231,
    },
    {
      customer_id: "elise_smith@myemail.com",
      orderdate: DateTime.parse("2020-01-13T09:32:07Z"),
      value: 99,
    },
    {
      customer_id: "oranieri@warmmail.com",
      orderdate: DateTime.parse("2020-01-01T08:25:37Z"),
      value: 63,
    },
    {
      customer_id: "tj@wheresmyemail.com",
      orderdate: DateTime.parse("2019-05-28T19:13:32Z"),
      value: 2,
    },
    {
      customer_id: "tj@wheresmyemail.com",
      orderdate: DateTime.parse("2020-11-23T22:56:53Z"),
      value: 187,
    },
    {
      customer_id: "tj@wheresmyemail.com",
      orderdate: DateTime.parse("2020-08-18T23:04:48Z"),
      value: 4,
    },
    {
      customer_id: "elise_smith@myemail.com",
      orderdate: DateTime.parse("2020-12-26T08:55:46Z"),
      value: 4,
    },
    {
      customer_id: "tj@wheresmyemail.com",
      orderdate: DateTime.parse("2021-02-28T07:49:32Z"),
      value: 1024,
    },
    {
      customer_id: "elise_smith@myemail.com",
      orderdate: DateTime.parse("2020-10-03T13:49:44Z"),
      value: 102,
    },
  ]
)

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

Primero, crear una estructura de Rust para modelar los datos en la colección orders:

#[derive(Debug, Serialize, Deserialize)]
struct Order {
    customer_id: String,
    orderdate: DateTime,
    value: i32,
}

Para crear la colección orders e insertar los datos de muestra, se debe añadir el siguiente código a la aplicación:

let orders: Collection<Order> = agg_db.collection("orders");
orders.delete_many(doc! {}).await?;
let docs = vec![
    Order {
        customer_id: "elise_smith@myemail.com".to_string(),
        orderdate: DateTime::builder().year(2020).month(5).day(30).hour(8).minute(35).second(53).build().unwrap(),
        value: 231,
    },
    Order {
        customer_id: "elise_smith@myemail.com".to_string(),
        orderdate: DateTime::builder().year(2020).month(1).day(13).hour(9).minute(32).second(7).build().unwrap(),
        value: 99,
    },
    Order {
        customer_id: "oranieri@warmmail.com".to_string(),
        orderdate: DateTime::builder().year(2020).month(1).day(1).hour(8).minute(25).second(37).build().unwrap(),
        value: 63,
    },
    Order {
        customer_id: "tj@wheresmyemail.com".to_string(),
        orderdate: DateTime::builder().year(2019).month(5).day(28).hour(19).minute(13).second(32).build().unwrap(),
        value: 2,
    },
    Order {
        customer_id: "tj@wheresmyemail.com".to_string(),
        orderdate: DateTime::builder().year(2020).month(11).day(23).hour(22).minute(56).second(53).build().unwrap(),
        value: 187,
    },
    Order {
        customer_id: "tj@wheresmyemail.com".to_string(),
        orderdate: DateTime::builder().year(2020).month(8).day(18).hour(23).minute(4).second(48).build().unwrap(),
        value: 4,
    },
    Order {
        customer_id: "elise_smith@myemail.com".to_string(),
        orderdate: DateTime::builder().year(2020).month(12).day(26).hour(8).minute(55).second(46).build().unwrap(),
        value: 4,
    },
    Order {
        customer_id: "tj@wheresmyemail.com".to_string(),
        orderdate: DateTime::builder().year(2021).month(2).day(28).hour(7).minute(49).second(32).build().unwrap(),
        value: 1024,
    },
    Order {
        customer_id: "elise_smith@myemail.com".to_string(),
        orderdate: DateTime::builder().year(2020).month(10).day(3).hour(13).minute(49).second(44).build().unwrap(),
        value: 102,
    },
];
orders.insert_many(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

Para crear la colección orders e insertar los datos de muestra, se debe añadir el siguiente código a la aplicación:

val orders = aggDB.getCollection("orders")
orders.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"),
    "value" -> 231),
  Document("customer_id" -> "elise_smith@myemail.com",
    "orderdate" -> dateFormat.parse("2020-01-13T09:32:07"),
    "value" -> 99),
  Document("customer_id" -> "oranieri@warmmail.com",
    "orderdate" -> dateFormat.parse("2020-01-01T08:25:37"),
    "value" -> 63),
  Document("customer_id" -> "tj@wheresmyemail.com",
    "orderdate" -> dateFormat.parse("2019-05-28T19:13:32"),
    "value" -> 2),
  Document("customer_id" -> "tj@wheresmyemail.com",
    "orderdate" -> dateFormat.parse("2020-11-23T22:56:53"),
    "value" -> 187),
  Document("customer_id" -> "tj@wheresmyemail.com",
    "orderdate" -> dateFormat.parse("2020-08-18T23:04:48"),
    "value" -> 4),
  Document("customer_id" -> "elise_smith@myemail.com",
    "orderdate" -> dateFormat.parse("2020-12-26T08:55:46"),
    "value" -> 4),
  Document("customer_id" -> "tj@wheresmyemail.com",
    "orderdate" -> dateFormat.parse("2021-02-28T07:49:32"),
    "value" -> 1024),
  Document("customer_id" -> "elise_smith@myemail.com",
    "orderdate" -> dateFormat.parse("2020-10-03T13:49:44"),
    "value" -> 102)
)).subscribe(
  _ => {},
  e => println("Error: " + e.getMessage),
)

Pasos

Los siguientes pasos demuestran cómo crear y ejecutar una canalización de agregación para agrupar documentos y calcular nuevos campos.

Ejecute la canalización de agregación.

db.orders.aggregate( [
   // Stage 1: Match orders in 2020
   { $match: {
      orderdate: {
         $gte: new Date("2020-01-01T00:00:00Z"),
         $lt: new Date("2021-01-01T00:00:00Z"),
      }
   } },
   // Stage 2: Sort orders by date
   { $sort: { orderdate: 1 } },
   // Stage 3: Group orders by email address
   { $group: {
      _id: "$customer_id",
      first_purchase_date: { $first: "$orderdate" },
      total_value: { $sum: "$value" },
      total_orders: { $sum: 1 },
      orders: { $push:
         {
            orderdate: "$orderdate",
            value: "$value"
         }
      }
   } },
   // Stage 4: Sort orders by first order date
   { $sort: { first_purchase_date: 1 } },
   // Stage 5: Display the customers' email addresses
   { $set: { customer_id: "$_id" } },
   // Stage 6: Remove unneeded fields
   { $unset: ["_id"] }
] )

Interpretar los resultados de la agregación.

La agregación devuelve el siguiente resumen de los pedidos de los clientes desde 2020. Los documentos de resultados contienen detalles sobre todos los pedidos realizados por un cliente determinado, agrupados por la dirección de correo electrónico del cliente.

{
   first_purchase_date: ISODate("2020-01-01T08:25:37.000Z"),
   total_value: 63,
   total_orders: 1,
   orders: [ { orderdate: ISODate("2020-01-01T08:25:37.000Z"), value: 63 } ],
   customer_id: 'oranieri@warmmail.com'
}
{
   first_purchase_date: ISODate("2020-01-13T09:32:07.000Z"),
   total_value: 436,
   total_orders: 4,
   orders: [
      { orderdate: ISODate("2020-01-13T09:32:07.000Z"), value: 99 },
      { orderdate: ISODate("2020-05-30T08:35:52.000Z"), value: 231 },
      { orderdate: ISODate("2020-10-03T13:49:44.000Z"), value: 102 },
      { orderdate: ISODate("2020-12-26T08:55:46.000Z"), value: 4 }
   ],
   customer_id: 'elise_smith@myemail.com'
}
{
   first_purchase_date: ISODate("2020-08-18T23:04:48.000Z"),
   total_value: 191,
   total_orders: 2,
   orders: [
      { orderdate: ISODate("2020-08-18T23:04:48.000Z"), value: 4 },
      { orderdate: ISODate("2020-11-23T22:56:53.000Z"), value: 187 }
   ],
   customer_id: 'tj@wheresmyemail.com'
}

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

Primero, añadir una etapa $match que coincida con los pedidos realizados en 2020:

"{", "$match", "{",
"orderdate", "{",
"$gte", BCON_DATE_TIME(1577836800000UL), // Represents 2020-01-01T00:00:00Z
"$lt", BCON_DATE_TIME(1609459200000UL),  // Represents 2021-01-01T00:00:00Z
"}",
"}", "}",

Añadir una etapa de ordenación para clasificar por fecha de pedido.

A continuación, añadir una etapa $sort para establecer un orden ascendente en el campo orderdate para recuperar la compra más temprana de 2020 de cada cliente en la siguiente etapa:

"{", "$sort", "{", "orderdate", BCON_INT32(1), "}", "}",

Añadir una etapa de agrupación para agrupar por dirección de correo electrónico.

Añadir una etapa $group para recopilar documentos de pedido por el valor del campo customer_id. En esta etapa, añadir operaciones de agregación que creen los siguientes campos en los documentos resultantes:

first_purchase_date: la fecha de la primera compra del cliente
total_value: el valor total de todas las compras del cliente
total_orders: el número total de las compras del cliente
orders: la lista de todas las compras del cliente, incluyendo la fecha y el valor de cada compra

"{", "$group", "{",
"_id", BCON_UTF8("$customer_id"),
"first_purchase_date", "{", "$first", BCON_UTF8("$orderdate"), "}",
"total_value", "{", "$sum", BCON_UTF8("$value"), "}",
"total_orders", "{", "$sum", BCON_INT32(1), "}",
"orders", "{", "$push", "{",
"orderdate", BCON_UTF8("$orderdate"),
"value", BCON_UTF8("$value"),
"}", "}",
"}", "}",

Añadir una etapa de ordenación para clasificar por la fecha del primer pedido.

A continuación, añadir otra etapa $sort para establecer un orden ascendente en el campo first_purchase_date:

"{", "$sort", "{", "first_purchase_date", BCON_INT32(1), "}", "}",

Añadir una etapa para mostrar la dirección de correo electrónico.

Añadir una etapa $set para recrear el campo customer_id a partir de los valores en el campo _id que se establecieron durante la etapa $group:

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

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

Por último, añadir una etapa $unset. La etapa $unset remueve el campo _id de los documentos de resultado:

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

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

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.

La agregación devuelve el siguiente resumen de los pedidos de los clientes de 2020:

{ "first_purchase_date" : { "$date" : { "$numberLong" : "1577865937000" } }, "total_value" : { "$numberInt" : "63" }, "total_orders" : { "$numberInt" : "1" }, "orders" : [ { "orderdate" : { "$date" : { "$numberLong" : "1577865937000" } }, "value" : { "$numberInt" : "63" } } ], "customer_id" : "oranieri@warmmail.com" }
{ "first_purchase_date" : { "$date" : { "$numberLong" : "1578904327000" } }, "total_value" : { "$numberInt" : "436" }, "total_orders" : { "$numberInt" : "4" }, "orders" : [ { "orderdate" : { "$date" : { "$numberLong" : "1578904327000" } }, "value" : { "$numberInt" : "99" } }, { "orderdate" : { "$date" : { "$numberLong" : "1590825352000" } }, "value" : { "$numberInt" : "231" } }, { "orderdate" : { "$date" : { "$numberLong" : "1601722184000" } }, "value" : { "$numberInt" : "102" } }, { "orderdate" : { "$date" : { "$numberLong" : "1608963346000" } }, "value" : { "$numberInt" : "4" } } ], "customer_id" : "elise_smith@myemail.com" }
{ "first_purchase_date" : { "$date" : { "$numberLong" : "1597793088000" } }, "total_value" : { "$numberInt" : "191" }, "total_orders" : { "$numberInt" : "2" }, "orders" : [ { "orderdate" : { "$date" : { "$numberLong" : "1597793088000" } }, "value" : { "$numberInt" : "4" } }, { "orderdate" : { "$date" : { "$numberLong" : "1606171013000" } }, "value" : { "$numberInt" : "187" } } ], "customer_id" : "tj@wheresmyemail.com" }

Los documentos de resultados contienen detalles de todos los pedidos de un cliente dado, agrupados por la dirección de correo electrónico del cliente.

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

Primero, añadir una etapa $match que coincida con los pedidos realizados en 2020:

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

Añadir una etapa de ordenación para clasificar por fecha de pedido.

A continuación, añadir una etapa $sort para establecer un orden ascendente en el campo orderdate para recuperar la compra más temprana de 2020 de cada cliente en la siguiente etapa:

pipeline.sort(bsoncxx::from_json(R"({
    "orderdate": 1
})"));

Añadir una etapa de agrupación para agrupar por dirección de correo electrónico.

first_purchase_date: la fecha de la primera compra del cliente
total_value: el valor total de todas las compras del cliente
total_orders: el número total de las compras del cliente
orders: la lista de todas las compras del cliente, incluyendo la fecha y el valor de cada compra

pipeline.group(bsoncxx::from_json(R"({
    "_id": "$customer_id",
    "first_purchase_date": {"$first": "$orderdate"},
    "total_value": {"$sum": "$value"},
    "total_orders": {"$sum": 1},
    "orders": {"$push": {
        "orderdate": "$orderdate",
        "value": "$value"
    }}
})"));

Añadir una etapa de ordenación para clasificar por la fecha del primer pedido.

A continuación, añadir otra etapa $sort para establecer un orden ascendente en el campo first_purchase_date:

pipeline.sort(bsoncxx::from_json(R"({
    "first_purchase_date": 1
})"));

Añadir una etapa $addFields para mostrar la dirección de correo electrónico.

Añadir una etapa $addFields, un alias para la etapa $set, para recrear el campo customer_id a partir de los valores en el campo _id que se establecieron durante la etapa $group:

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

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

Por último, añadir una etapa $unset. La etapa $unset remueve el campo _id de los documentos de resultado:

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

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.

La agregación devuelve el siguiente resumen de los pedidos de los clientes de 2020:

{ "first_purchase_date" : { "$date" : "1970-01-19T06:17:41.137Z" }, "total_value" : 63,
"total_orders" : 1, "orders" : [ { "orderdate" : { "$date" : "1970-01-19T06:17:41.137Z" },
"value" : 63 } ], "customer_id" : "oranieri@warmmail.com" }
{ "first_purchase_date" : { "$date" : "1970-01-19T06:35:01.927Z" }, "total_value" : 436,
"total_orders" : 4, "orders" : [ { "orderdate" : { "$date" : "1970-01-19T06:35:01.927Z" },
"value" : 99 }, { "orderdate" : { "$date" : "2020-05-30T06:55:52Z" }, "value" : 231 },
{ "orderdate" : { "$date" : "2020-10-03T10:49:44Z" }, "value" : 102 }, { "orderdate" :
{ "$date" : "2020-12-26T08:55:46Z" }, "value" : 4 } ], "customer_id" : "elise_smith@myemail.com" }
{ "first_purchase_date" : { "$date" : "1970-01-19T11:49:54.288Z" }, "total_value" : 1215,
"total_orders" : 3, "orders" : [ { "orderdate" : { "$date" : "1970-01-19T11:49:54.288Z" },
"value" : 4 }, { "orderdate" : { "$date" : "1970-01-19T14:09:32.213Z" }, "value" : 187 },
{ "orderdate" : { "$date" : "1970-01-19T16:29:30.572Z" }, "value" : 1024 } ], "customer_id" : "tj@wheresmyemail.com" }

Los documentos de resultados contienen detalles de todos los pedidos de un cliente dado, agrupados por la dirección de correo electrónico del cliente.

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

Añadir una etapa de ordenación para clasificar por fecha de pedido.

A continuación, añadir una etapa $sort para establecer un orden ascendente en el campo OrderDate para recuperar la compra más temprana de 2020 de cada cliente en la siguiente etapa:

.SortBy(o => o.OrderDate)

Añadir una etapa de agrupación para agrupar por dirección de correo electrónico.

Añadir una etapa $group para recopilar documentos de pedido por el valor del campo CustomerId. En esta etapa, añadir operaciones de agregación que creen los siguientes campos en los documentos resultantes:

CustomerId: la dirección de correo electrónico del cliente (la clave de agrupación)
FirstPurchaseDate: la fecha de la primera compra del cliente
TotalValue: el valor total de todas las compras del cliente
TotalOrders: el número total de las compras del cliente
Orders: la lista de todas las compras del cliente, incluyendo la fecha y el valor de cada compra

.Group(
    o => o.CustomerId,
    g => new
    {
      CustomerId = g.Key,
      FirstPurchaseDate = g.First().OrderDate,
      TotalValue = g.Sum(i => i.Value),
      TotalOrders = g.Count(),
      Orders = g.Select(i => new { i.OrderDate, i.Value }).ToList()
    }
)

Añadir una etapa de ordenación para clasificar por la fecha del primer pedido.

A continuación, añadir otra etapa $sort para establecer un orden ascendente en el campo FirstPurchaseDate:

.SortBy(c => c.FirstPurchaseDate)
.As<BsonDocument>();

El código anterior también convierte los documentos de salida en instancias de BsonDocument para imprimir.

Ejecutar la agregación e interpretar los resultados.

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

La agregación devuelve el siguiente resumen de los pedidos de los clientes de 2020:

{ "CustomerId" : "oranieri@warmmail.com", "FirstPurchaseDate" : { "$date" : "2020-01-01T08:25:37Z" }, "TotalValue" : 63, "TotalOrders" : 1, "Orders" : [{ "OrderDate" : { "$date" : "2020-01-01T08:25:37Z" }, "Value" : 63 }] }
{ "CustomerId" : "elise_smith@myemail.com", "FirstPurchaseDate" : { "$date" : "2020-01-13T09:32:07Z" }, "TotalValue" : 436, "TotalOrders" : 4, "Orders" : [{ "OrderDate" : { "$date" : "2020-01-13T09:32:07Z" }, "Value" : 99 }, { "OrderDate" : { "$date" : "2020-05-30T08:35:52Z" }, "Value" : 231 }, { "OrderDate" : { "$date" : "2020-10-03T13:49:44Z" }, "Value" : 102 }, { "OrderDate" : { "$date" : "2020-12-26T08:55:46Z" }, "Value" : 4 }] }
{ "CustomerId" : "tj@wheresmyemail.com", "FirstPurchaseDate" : { "$date" : "2020-08-18T23:04:48Z" }, "TotalValue" : 191, "TotalOrders" : 2, "Orders" : [{ "OrderDate" : { "$date" : "2020-08-18T23:04:48Z" }, "Value" : 4 }, { "OrderDate" : { "$date" : "2020-11-23T22:56:53Z" }, "Value" : 187 }] }

Los documentos de resultados contienen detalles de todos los pedidos de un cliente dado, agrupados por la dirección de correo electrónico del cliente.

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

Primero, añadir una etapa $match que coincida con los pedidos realizados en 2020:

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

Añadir una etapa de ordenación para clasificar por fecha de pedido.

A continuación, añadir una etapa $sort para establecer un orden ascendente en el campo orderdate para recuperar la compra más temprana de 2020 de cada cliente en la siguiente etapa:

sortStage1 := bson.D{{Key: "$sort", Value: bson.D{
	{Key: "orderdate", Value: 1},
}}}

Añadir una etapa de agrupación para agrupar por dirección de correo electrónico.

first_purchase_date: la fecha de la primera compra del cliente
total_value: el valor total de todas las compras del cliente
total_orders: el número total de las compras del cliente
orders: la lista de todas las compras del cliente, incluyendo la fecha y el valor de cada compra

groupStage := bson.D{{Key: "$group", Value: bson.D{
	{Key: "_id", Value: "$customer_id"},
	{Key: "first_purchase_date", Value: bson.D{{Key: "$first", Value: "$orderdate"}}},
	{Key: "total_value", Value: bson.D{{Key: "$sum", Value: "$value"}}},
	{Key: "total_orders", Value: bson.D{{Key: "$sum", Value: 1}}},
	{Key: "orders", Value: bson.D{{Key: "$push", Value: bson.D{
		{Key: "orderdate", Value: "$orderdate"},
		{Key: "value", Value: "$value"},
	}}}},
}}}

Añadir una etapa de ordenación para clasificar por la fecha del primer pedido.

A continuación, añadir otra etapa $sort para establecer un orden ascendente en el campo first_purchase_date:

sortStage2 := bson.D{{Key: "$sort", Value: bson.D{
	{Key: "first_purchase_date", Value: 1},
}}}

Añadir una etapa para mostrar la dirección de correo electrónico.

Añadir una etapa $set para recrear el campo customer_id a partir de los valores en el campo _id que se establecieron durante la etapa $group:

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

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

Por último, añadir una etapa $unset. La etapa $unset remueve el campo _id de los documentos de resultado:

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

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, sortStage1, groupStage, setStage, sortStage2, unsetStage}
cursor, err := orders.Aggregate(context.TODO(), pipeline)

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

go run agg_tutorial.go

Interpretar los resultados de la agregación.

La agregación devuelve el siguiente resumen de los pedidos de los clientes de 2020:

{"first_purchase_date":{"$date":"2020-01-01T08:25:37Z"},"total_value":63,"total_orders":1,"orders":[{"orderdate":{"$date":"2020-01-01T08:25:37Z"},"value":63}],"customer_id":"oranieri@warmmail.com"}
{"first_purchase_date":{"$date":"2020-01-13T09:32:07Z"},"total_value":436,"total_orders":4,"orders":[{"orderdate":{"$date":"2020-01-13T09:32:07Z"},"value":99},{"orderdate":{"$date":"2020-05-30T08:35:53Z"},"value":231},{"orderdate":{"$date":"2020-10-03T13:49:44Z"},"value":102},{"orderdate":{"$date":"2020-12-26T08:55:46Z"},"value":4}],"customer_id":"elise_smith@myemail.com"}
{"first_purchase_date":{"$date":"2020-08-18T23:04:48Z"},"total_value":191,"total_orders":2,"orders":[{"orderdate":{"$date":"2020-08-18T23:04:48Z"},"value":4},{"orderdate":{"$date":"2020-11-23T22:56:53Z"},"value":187}],"customer_id":"tj@wheresmyemail.com"}

Los documentos de resultados contienen detalles de todos los pedidos de un cliente dado, agrupados por la dirección de correo electrónico del cliente.

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

Primero, añadir una etapa $match que coincida con los pedidos realizados en 2020:

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

Añadir una etapa de ordenación para clasificar por fecha de pedido.

A continuación, añadir una etapa $sort para establecer un orden ascendente en el campo orderdate para recuperar la compra más temprana de 2020 de cada cliente en la siguiente etapa:

pipeline.add(Aggregates.sort(Sorts.ascending("orderdate")));

Añadir una etapa de agrupación para agrupar por dirección de correo electrónico.

first_purchase_date: la fecha de la primera compra del cliente
total_value: el valor total de todas las compras del cliente
total_orders: el número total de las compras del cliente
orders: la lista de todas las compras del cliente, incluyendo la fecha y el valor de cada compra

pipeline.add(Aggregates.group(
        "$customer_id",
        Accumulators.first("first_purchase_date", "$orderdate"),
        Accumulators.sum("total_value", "$value"),
        Accumulators.sum("total_orders", 1),
        Accumulators.push("orders",
                new Document("orderdate", "$orderdate")
                        .append("value", "$value")
        )
));

Añadir una etapa de ordenación para clasificar por la fecha del primer pedido.

A continuación, añadir otra etapa $sort para establecer un orden ascendente en el campo first_purchase_date:

pipeline.add(Aggregates.sort(Sorts.ascending("first_purchase_date")));

Añadir una etapa para mostrar la dirección de correo electrónico.

Añadir una etapa $set para recrear el campo customer_id a partir de los valores en el campo _id que se establecieron durante la etapa $group:

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

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

Por último, añadir una etapa $unset. La etapa $unset remueve el campo _id de los documentos de resultado:

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

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.

La agregación devuelve el siguiente resumen de los pedidos de los clientes de 2020:

{"first_purchase_date": {"$date": "2020-01-01T08:25:37Z"}, "total_value": 63, "total_orders": 1, "orders": [{"orderdate": {"$date": "2020-01-01T08:25:37Z"}, "value": 63}], "customer_id": "oranieri@warmmail.com"}
{"first_purchase_date": {"$date": "2020-01-13T09:32:07Z"}, "total_value": 436, "total_orders": 4, "orders": [{"orderdate": {"$date": "2020-01-13T09:32:07Z"}, "value": 99}, {"orderdate": {"$date": "2020-05-30T08:35:52Z"}, "value": 231}, {"orderdate": {"$date": "2020-10-03T13:49:44Z"}, "value": 102}, {"orderdate": {"$date": "2020-12-26T08:55:46Z"}, "value": 4}], "customer_id": "elise_smith@myemail.com"}
{"first_purchase_date": {"$date": "2020-08-18T23:04:48Z"}, "total_value": 191, "total_orders": 2, "orders": [{"orderdate": {"$date": "2020-08-18T23:04:48Z"}, "value": 4}, {"orderdate": {"$date": "2020-11-23T22:56:53Z"}, "value": 187}], "customer_id": "tj@wheresmyemail.com"}

Los documentos de resultados contienen detalles de todos los pedidos de un cliente dado, agrupados por la dirección de correo electrónico del cliente.

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

Primero, añadir una etapa $match que coincida con los pedidos realizados en 2020:

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())
        )
    )
)

Añadir una etapa de ordenación para clasificar por fecha de pedido.

A continuación, añadir una etapa $sort para establecer un orden ascendente en el campo orderDate para recuperar la compra más temprana de 2020 de cada cliente en la siguiente etapa:

pipeline.add(Aggregates.sort(Sorts.ascending(Order::orderDate.name)))

Añadir una etapa de agrupación para agrupar por dirección de correo electrónico.

first_purchase_date: la fecha de la primera compra del cliente
total_value: el valor total de todas las compras del cliente
total_orders: el número total de las compras del cliente
orders: la lista de todas las compras del cliente, incluyendo la fecha y el valor de cada compra

pipeline.add(
    Aggregates.group(
        "\$${Order::customerID.name}",
        Accumulators.first("first_purchase_date", "\$${Order::orderDate.name}"),
        Accumulators.sum("total_value", "\$${Order::value.name}"),
        Accumulators.sum("total_orders", 1),
        Accumulators.push(
            "orders",
            Document("orderdate", "\$${Order::orderDate.name}")
                .append("value", "\$${Order::value.name}")
        )
    )
)

Añadir una etapa de ordenación para clasificar por la fecha del primer pedido.

A continuación, añadir otra etapa $sort para establecer un orden ascendente en el campo first_purchase_date:

pipeline.add(Aggregates.sort(Sorts.ascending("first_purchase_date")))

Añadir una etapa para mostrar la dirección de correo electrónico.

Añadir una etapa $set para recrear el campo customer_id a partir de los valores en el campo _id que se establecieron durante la etapa $group:

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

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

Por último, añadir una etapa $unset. La etapa $unset remueve el campo _id de los documentos de resultado:

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

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.

La agregación devuelve el siguiente resumen de los pedidos de los clientes de 2020:

Document{{first_purchase_date=Wed Jan 01 03:25:37 EST 2020, total_value=63, total_orders=1, orders=[Document{{orderdate=Wed Jan 01 03:25:37 EST 2020, value=63}}], customer_id=oranieri@warmmail.com}}
Document{{first_purchase_date=Mon Jan 13 04:32:07 EST 2020, total_value=436, total_orders=4, orders=[Document{{orderdate=Mon Jan 13 04:32:07 EST 2020, value=99}}, Document{{orderdate=Sat May 30 04:35:52 EDT 2020, value=231}}, Document{{orderdate=Sat Oct 03 09:49:44 EDT 2020, value=102}}, Document{{orderdate=Sat Dec 26 03:55:46 EST 2020, value=4}}], customer_id=elise_smith@myemail.com}}
Document{{first_purchase_date=Tue Aug 18 19:04:48 EDT 2020, total_value=191, total_orders=2, orders=[Document{{orderdate=Tue Aug 18 19:04:48 EDT 2020, value=4}}, Document{{orderdate=Mon Nov 23 17:56:53 EST 2020, value=187}}], customer_id=tj@wheresmyemail.com}}

Los documentos de resultados contienen detalles de todos los pedidos de un cliente dado, agrupados por la dirección de correo electrónico del cliente.

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

Primero, añadir una etapa $match que coincida con los pedidos realizados en 2020:

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

Añadir una etapa de ordenación para clasificar por fecha de pedido.

A continuación, añadir una etapa $sort para establecer un orden ascendente en el campo orderdate para recuperar la compra más temprana de 2020 de cada cliente en la siguiente etapa:

pipeline.push({
  $sort: {
    orderdate: 1,
  },
});

Añadir una etapa de agrupación para agrupar por dirección de correo electrónico.

Añadir una etapa $group para agrupar los pedidos por el valor del campo customer_id. En esta etapa, añadir operaciones de agregación que creen los siguientes campos en los documentos resultantes:

first_purchase_date: la fecha de la primera compra del cliente
total_value: el valor total de todas las compras del cliente
total_orders: el número total de las compras del cliente
orders: la lista de todas las compras del cliente, incluyendo la fecha y el valor de cada compra

pipeline.push({
  $group: {
    _id: "$customer_id",
    first_purchase_date: { $first: "$orderdate" },
    total_value: { $sum: "$value" },
    total_orders: { $sum: 1 },
    orders: {
      $push: {
        orderdate: "$orderdate",
        value: "$value",
      },
    },
  },
});

Añadir una etapa de ordenación para clasificar por la fecha del primer pedido.

A continuación, añadir otra etapa $sort para establecer un orden ascendente en el campo first_purchase_date:

pipeline.push({
  $sort: {
    first_purchase_date: 1,
  },
});

Añadir una etapa para mostrar la dirección de correo electrónico.

Añadir una etapa $set para recrear el campo customer_id a partir de los valores en el campo _id que se establecieron durante la etapa $group:

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

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

Por último, añadir una etapa $unset. La etapa $unset remueve el campo _id de los documentos de resultado:

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

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 siguiente comando en su shell para iniciar su aplicación:

node agg_tutorial.js

Interpretar los resultados de la agregación.

La agregación devuelve el siguiente resumen de los pedidos de los clientes de 2020:

{
  first_purchase_date: 2020-01-01T08:25:37.000Z,
  total_value: 63,
  total_orders: 1,
  orders: [ { orderdate: 2020-01-01T08:25:37.000Z, value: 63 } ],
  customer_id: 'oranieri@warmmail.com'
}
{
  first_purchase_date: 2020-01-13T09:32:07.000Z,
  total_value: 436,
  total_orders: 4,
  orders: [
    { orderdate: 2020-01-13T09:32:07.000Z, value: 99 },
    { orderdate: 2020-05-30T08:35:52.000Z, value: 231 },
    { orderdate: 2020-10-03T13:49:44.000Z, value: 102 },
    { orderdate: 2020-12-26T08:55:46.000Z, value: 4 }
  ],
  customer_id: 'elise_smith@myemail.com'
}
{
  first_purchase_date: 2020-08-18T23:04:48.000Z,
  total_value: 191,
  total_orders: 2,
  orders: [
    { orderdate: 2020-08-18T23:04:48.000Z, value: 4 },
    { orderdate: 2020-11-23T22:56:53.000Z, value: 187 }
  ],
  customer_id: 'tj@wheresmyemail.com'
}

Los documentos de resultados contienen detalles de todos los pedidos de un cliente dado, agrupados por la dirección de correo electrónico del cliente.

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

En la instancia de Pipeline, añadir una etapa $match que coincida con los pedidos realizados en 2020:

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'))),
    ]
),

Añadir una etapa de ordenación para clasificar por fecha de pedido.

A continuación, añadir una etapa $sort para establecer un orden ascendente en el campo orderdate para recuperar la compra más temprana de 2020 de cada cliente en la siguiente etapa:

Stage::sort(orderdate: Sort::Asc),

Añadir una etapa de agrupación para agrupar por dirección de correo electrónico.

Fuera de la instancia Pipeline, crear una etapa $group en una función de fábrica para recopilar documentos de pedido según el valor del campo customer_id. En esta etapa, añadir operaciones de agregación que creen los siguientes campos en los documentos resultantes:

first_purchase_date: la fecha de la primera compra del cliente
total_value: el valor total de todas las compras del cliente
total_orders: el número total de las compras del cliente
orders: la lista de todas las compras del cliente, incluyendo la fecha y el valor de cada compra

function groupByCustomerStage()
{
    return Stage::group(
        _id: Expression::stringFieldPath('customer_id'),
        first_purchase_date: Accumulator::first(
            Expression::arrayFieldPath('orderdate')
        ),
        total_value: Accumulator::sum(
            Expression::numberFieldPath('value'),
        ),
        total_orders: Accumulator::sum(1),
        orders: Accumulator::push(
            object(
                orderdate: Expression::dateFieldPath('orderdate'),
                value: Expression::numberFieldPath('value'),
            ),
        ),
    );
}

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

groupByCustomerStage(),

Añadir una etapa de ordenación para clasificar por la fecha del primer pedido.

A continuación, crear otra etapa $sort para establecer un orden ascendente en el campo first_purchase_date:

Stage::sort(first_purchase_date: Sort::Asc),

Añadir una etapa para mostrar la dirección de correo electrónico.

Añadir una etapa $set para recrear el campo customer_id a partir de los valores en el campo _id que se establecieron durante la etapa $group:

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

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

Por último, añadir una etapa $unset. La etapa $unset remueve el campo _id de los documentos de resultado:

Stage::unset('_id')

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.

La agregación devuelve el siguiente resumen de los pedidos de los clientes de 2020:

{
    "first_purchase_date": {
        "$date": {
            "$numberLong": "1577867137000"
        }
    },
    "total_value": 63,
    "total_orders": 1,
    "orders": [
        {
            "orderdate": {
                "$date": {
                    "$numberLong": "1577867137000"
                }
            },
            "value": 63
        }
    ],
    "customer_id": "oranieri@warmmail.com"
}
{
    "first_purchase_date": {
        "$date": {
            "$numberLong": "1578907927000"
        }
    },
    "total_value": 436,
    "total_orders": 4,
    "orders": [
        {
            "orderdate": {
                "$date": {
                    "$numberLong": "1578907927000"
                }
            },
            "value": 99
        },
        {
            "orderdate": {
                "$date": {
                    "$numberLong": "1590827752000"
                }
            },
            "value": 231
        },
        {
            "orderdate": {
                "$date": {
                    "$numberLong": "1601732984000"
                }
            },
            "value": 102
        },
        {
            "orderdate": {
                "$date": {
                    "$numberLong": "1608972946000"
                }
            },
            "value": 4
        }
    ],
    "customer_id": "elise_smith@myemail.com"
}
{
    "first_purchase_date": {
        "$date": {
            "$numberLong": "1597791888000"
        }
    },
    "total_value": 191,
    "total_orders": 2,
    "orders": [
        {
            "orderdate": {
                "$date": {
                    "$numberLong": "1597791888000"
                }
            },
            "value": 4
        },
        {
            "orderdate": {
                "$date": {
                    "$numberLong": "1606172213000"
                }
            },
            "value": 187
        }
    ],
    "customer_id": "tj@wheresmyemail.com"
}

Los documentos de resultados contienen detalles de todos los pedidos de un cliente dado, agrupados por la dirección de correo electrónico del cliente.

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

En la instancia de Pipeline, añadir una etapa $match que coincida con los pedidos realizados en 2020:

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

Añadir una etapa de ordenación para clasificar por fecha de pedido.

A continuación, añadir una etapa $sort para establecer un orden ascendente en el campo orderdate para recuperar la compra más temprana de 2020 de cada cliente en la siguiente etapa:

pipeline.append({"$sort": {"orderdate": 1}})

Añadir una etapa de agrupación para agrupar por dirección de correo electrónico.

first_purchase_date: la fecha de la primera compra del cliente
total_value: el valor total de todas las compras del cliente
total_orders: el número total de las compras del cliente
orders: la lista de todas las compras del cliente, incluyendo la fecha y el valor de cada compra

pipeline.append(
    {
        "$group": {
            "_id": "$customer_id",
            "first_purchase_date": {"$first": "$orderdate"},
            "total_value": {"$sum": "$value"},
            "total_orders": {"$sum": 1},
            "orders": {"$push": {"orderdate": "$orderdate", "value": "$value"}},
        }
    }
)

Añadir una etapa de ordenación para clasificar por la fecha del primer pedido.

A continuación, crear otra etapa $sort para establecer un orden ascendente en el campo first_purchase_date:

pipeline.append({"$sort": {"first_purchase_date": 1}})

Añadir una etapa para mostrar la dirección de correo electrónico.

Añadir una etapa $set para recrear el campo customer_id a partir de los valores en el campo _id que se establecieron durante la etapa $group:

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

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

Por último, añadir una etapa $unset. La etapa $unset remueve el campo _id de los documentos de resultado:

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

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.

La agregación devuelve el siguiente resumen de los pedidos de los clientes de 2020:

{'first_purchase_date': datetime.datetime(2020, 1, 1, 8, 25, 37), 'total_value': 63, 'total_orders': 1, 'orders': [{'orderdate': datetime.datetime(2020, 1, 1, 8, 25, 37), 'value': 63}], 'customer_id': 'oranieri@warmmail.com'}
{'first_purchase_date': datetime.datetime(2020, 1, 13, 9, 32, 7), 'total_value': 436, 'total_orders': 4, 'orders': [{'orderdate': datetime.datetime(2020, 1, 13, 9, 32, 7), 'value': 99}, {'orderdate': datetime.datetime(2020, 5, 30, 8, 35, 52), 'value': 231}, {'orderdate': datetime.datetime(2020, 10, 3, 13, 49, 44), 'value': 102}, {'orderdate': datetime.datetime(2020, 12, 26, 8, 55, 46), 'value': 4}], 'customer_id': 'elise_smith@myemail.com'}
{'first_purchase_date': datetime.datetime(2020, 8, 18, 23, 4, 48), 'total_value': 191, 'total_orders': 2, 'orders': [{'orderdate': datetime.datetime(2020, 8, 18, 23, 4, 48), 'value': 4}, {'orderdate': datetime.datetime(2020, 11, 23, 22, 56, 53), 'value': 187}], 'customer_id': 'tj@wheresmyemail.com'}

Los documentos de resultados contienen detalles de todos los pedidos de un cliente dado, agrupados por la dirección de correo electrónico del cliente.

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

Primero, añadir una etapa $match que coincida con los pedidos realizados en 2020:

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

Añadir una etapa de ordenación para clasificar por fecha de pedido.

A continuación, añadir una etapa $sort para establecer un orden ascendente en el campo orderdate para recuperar la compra más temprana de 2020 de cada cliente en la siguiente etapa:

{
  "$sort": {
    orderdate: 1,
  },
},

Añadir una etapa de agrupación para agrupar por dirección de correo electrónico.

first_purchase_date: la fecha de la primera compra del cliente
total_value: el valor total de todas las compras del cliente
total_orders: el número total de las compras del cliente
orders: la lista de todas las compras del cliente, incluyendo la fecha y el valor de cada compra

{
  "$group": {
    _id: "$customer_id",
    first_purchase_date: { "$first": "$orderdate" },
    total_value: { "$sum": "$value" },
    total_orders: { "$sum": 1 },
    orders: { "$push": {
      orderdate: "$orderdate",
      value: "$value",
    } },
  },
},

Añadir una etapa de ordenación para clasificar por la fecha del primer pedido.

A continuación, añadir otra etapa $sort para establecer un orden ascendente en el campo first_purchase_date:

{
  "$sort": {
    first_purchase_date: 1,
  },
},

Añadir una etapa para mostrar la dirección de correo electrónico.

Añadir una etapa $set para recrear el campo customer_id a partir de los valores en el campo _id que se establecieron durante la etapa $group:

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

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

Por último, añadir una etapa $unset. La etapa $unset remueve el campo _id de los documentos de resultado:

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

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.

La agregación devuelve el siguiente resumen de los pedidos de los clientes de 2020:

{"first_purchase_date"=>2020-01-01 08:25:37 UTC, "total_value"=>63, "total_orders"=>1, "orders"=>[{"orderdate"=>2020-01-01 08:25:37 UTC, "value"=>63}], "customer_id"=>"oranieri@warmmail.com"}
{"first_purchase_date"=>2020-01-13 09:32:07 UTC, "total_value"=>436, "total_orders"=>4, "orders"=>[{"orderdate"=>2020-01-13 09:32:07 UTC, "value"=>99}, {"orderdate"=>2020-05-30 08:35:52 UTC, "value"=>231}, {"orderdate"=>2020-10-03 13:49:44 UTC, "value"=>102}, {"orderdate"=>2020-12-26 08:55:46 UTC, "value"=>4}], "customer_id"=>"elise_smith@myemail.com"}
{"first_purchase_date"=>2020-08-18 23:04:48 UTC, "total_value"=>191, "total_orders"=>2, "orders"=>[{"orderdate"=>2020-08-18 23:04:48 UTC, "value"=>4}, {"orderdate"=>2020-11-23 22:56:53 UTC, "value"=>187}], "customer_id"=>"tj@wheresmyemail.com"}

Los documentos de resultados contienen detalles de todos los pedidos de un cliente dado, agrupados por la dirección de correo electrónico del cliente.

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

Primero, añadir una etapa $match que coincida con los pedidos realizados en 2020:

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

Añadir una etapa de ordenación para clasificar por fecha de pedido.

A continuación, añadir una etapa $sort para establecer un orden ascendente en el campo orderdate para recuperar la compra más temprana de 2020 de cada cliente en la siguiente etapa:

pipeline.push(doc! {
    "$sort": {
        "orderdate": 1
    }
});

Añadir una etapa de agrupación para agrupar por dirección de correo electrónico.

first_purchase_date: la fecha de la primera compra del cliente
total_value: el valor total de todas las compras del cliente
total_orders: el número total de las compras del cliente
orders: la lista de todas las compras del cliente, incluyendo la fecha y el valor de cada compra

pipeline.push(doc! {
    "$group": {
        "_id": "$customer_id",
        "first_purchase_date": { "$first": "$orderdate" },
        "total_value": { "$sum": "$value" },
        "total_orders": { "$sum": 1 },
        "orders": {
            "$push": {
                "orderdate": "$orderdate",
                "value": "$value"
            }
        }
    }
});

Añadir una etapa de ordenación para clasificar por la fecha del primer pedido.

A continuación, añadir otra etapa $sort para establecer un orden ascendente en el campo first_purchase_date:

pipeline.push(doc! {
    "$sort": {
        "first_purchase_date": 1
    }
});

Añadir una etapa para mostrar la dirección de correo electrónico.

Añadir una etapa $set para recrear el campo customer_id a partir de los valores en el campo _id que se establecieron durante la etapa $group:

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

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

Por último, añadir una etapa $unset. La etapa $unset remueve el campo _id de los documentos de resultado:

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

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.

La agregación devuelve el siguiente resumen de los pedidos de los clientes de 2020:

Document({"first_purchase_date": DateTime(2020-01-01 8:25:37.0 +00:00:00), "total_value": Int32(63), "total_orders": Int32(1),
"orders": Array([Document({"orderdate": DateTime(2020-01-01 8:25:37.0 +00:00:00), "value": Int32(63)})]), "customer_id": String("oranieri@warmmail.com")})
Document({"first_purchase_date": DateTime(2020-01-13 9:32:07.0 +00:00:00), "total_value": Int32(436), "total_orders": Int32(4),
"orders": Array([Document({"orderdate": DateTime(2020-01-13 9:32:07.0 +00:00:00), "value": Int32(99)}), Document({"orderdate":
DateTime(2020-05-30 8:35:53.0 +00:00:00), "value": Int32(231)}), Document({"orderdate": DateTime(2020-10-03 13:49:44.0 +00:00:00),
"value": Int32(102)}), Document({"orderdate": DateTime(2020-12-26 8:55:46.0 +00:00:00), "value": Int32(4)})]), "customer_id": String("elise_smith@myemail.com")})
Document({"first_purchase_date": DateTime(2020-08-18 23:04:48.0 +00:00:00), "total_value": Int32(191), "total_orders": Int32(2),
"orders": Array([Document({"orderdate": DateTime(2020-08-18 23:04:48.0 +00:00:00), "value": Int32(4)}), Document({"orderdate":
DateTime(2020-11-23 22:56:53.0 +00:00:00), "value": Int32(187)})]), "customer_id": String("tj@wheresmyemail.com")})

Los documentos de resultados contienen detalles de todos los pedidos de un cliente dado, agrupados por la dirección de correo electrónico del cliente.

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

Primero, añadir una etapa $match que coincida con los pedidos realizados en 2020:

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

Añadir una etapa de ordenación para clasificar por fecha de pedido.

A continuación, añadir una etapa $sort para establecer un orden ascendente en el campo orderdate para recuperar la compra más temprana de 2020 de cada cliente en la siguiente etapa:

Aggregates.sort(Sorts.ascending("orderdate")),

Añadir una etapa de agrupación para agrupar por dirección de correo electrónico.

first_purchase_date: la fecha de la primera compra del cliente
total_value: el valor total de todas las compras del cliente
total_orders: el número total de las compras del cliente
orders: la lista de todas las compras del cliente, incluyendo la fecha y el valor de cada compra

Aggregates.group(
  "$customer_id",
  Accumulators.first("first_purchase_date", "$orderdate"),
  Accumulators.sum("total_value", "$value"),
  Accumulators.sum("total_orders", 1),
  Accumulators.push("orders", Document("orderdate" -> "$orderdate", "value" -> "$value"))
),

Añadir una etapa de ordenación para clasificar por la fecha del primer pedido.

A continuación, añadir otra etapa $sort para establecer un orden ascendente en el campo first_purchase_date:

Aggregates.sort(Sorts.ascending("first_purchase_date")),

Añadir una etapa para mostrar la dirección de correo electrónico.

Añadir una etapa $set para recrear el campo customer_id a partir de los valores en el campo _id que se establecieron durante la etapa $group:

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

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

Por último, añadir una etapa $unset. La etapa $unset remueve el campo _id de los documentos de resultado:

Aggregates.unset("_id")

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.

La agregación devuelve el siguiente resumen de los pedidos de los clientes de 2020:

{"first_purchase_date": {"$date": "2020-01-01T13:25:37Z"}, "total_value": 63, "total_orders": 1, "orders": [{"orderdate": {"$date": "2020-01-01T13:25:37Z"}, "value": 63}], "customer_id": "oranieri@warmmail.com"}
{"first_purchase_date": {"$date": "2020-01-13T14:32:07Z"}, "total_value": 436, "total_orders": 4, "orders": [{"orderdate": {"$date": "2020-01-13T14:32:07Z"}, "value": 99}, {"orderdate": {"$date": "2020-05-30T12:35:52Z"}, "value": 231}, {"orderdate": {"$date": "2020-10-03T17:49:44Z"}, "value": 102}, {"orderdate": {"$date": "2020-12-26T13:55:46Z"}, "value": 4}], "customer_id": "elise_smith@myemail.com"}
{"first_purchase_date": {"$date": "2020-08-19T03:04:48Z"}, "total_value": 191, "total_orders": 2, "orders": [{"orderdate": {"$date": "2020-08-19T03:04:48Z"}, "value": 4}, {"orderdate": {"$date": "2020-11-24T03:56:53Z"}, "value": 187}], "customer_id": "tj@wheresmyemail.com"}

Los documentos de resultados contienen detalles de todos los pedidos de un cliente dado, agrupados por la dirección de correo electrónico del cliente.

Volver

Filtro y Subconjunto

Descomponer arreglos