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 combinar datos de una colección que describe información de productos con otra colección que describe pedidos de clientes. Los resultados muestran una lista de productos solicitados en 2020 y detalles sobre cada pedido.
Esta agregación realiza una unión de varios campos utilizando $lookup. Una unión de varios campos ocurre cuando hay varios campos correspondientes en los documentos de dos colecciones. La agregación compara estos documentos en los campos correspondientes y combina la información de ambos en un solo documento.
Antes de comenzar
➤ Usar el menú desplegable Seleccionar lenguaje en la parte superior derecha para establecer el lenguaje de los siguientes ejemplos o seleccionar MongoDB Shell.
Este ejemplo utiliza dos colecciones:
products, que contiene documentos que describen los productos que vende una tiendaorders, que contiene documentos que describen pedidos individuales de productos en una tienda
Una orden sólo puede contener un producto. La agregación utiliza una unión de múltiples campos para emparejar un documento de producto con documentos que representan pedidos de ese producto. La agregación une colecciones por los campos name y variation en los documentos de la colección products, correspondientes a los campos product_name y product_variation en los documentos de la colección orders.
Para crear las colecciones orders y products, utiliza el método insertMany():
db.orders.insertMany( [ { customer_id: "elise_smith@myemail.com", orderdate: new Date("2020-05-30T08:35:52Z"), product_name: "Asus Laptop", product_variation: "Standard Display", value: 431.43, }, { customer_id: "tj@wheresmyemail.com", orderdate: new Date("2019-05-28T19:13:32Z"), product_name: "The Day Of The Triffids", product_variation: "2nd Edition", value: 5.01, }, { customer_id: "oranieri@warmmail.com", orderdate: new Date("2020-01-01T08:25:37Z"), product_name: "Morphy Richards Food Mixer", product_variation: "Deluxe", value: 63.13, }, { customer_id: "jjones@tepidmail.com", orderdate: new Date("2020-12-26T08:55:46Z"), product_name: "Asus Laptop", product_variation: "Standard Display", value: 429.65, } ] )
db.products.insertMany( [ { name: "Asus Laptop", variation: "Ultra HD", category: "ELECTRONICS", description: "Great for watching movies" }, { name: "Asus Laptop", variation: "Standard Display", category: "ELECTRONICS", description: "Good value laptop for students" }, { name: "The Day Of The Triffids", variation: "1st Edition", category: "BOOKS", description: "Classic post-apocalyptic novel" }, { name: "The Day Of The Triffids", variation: "2nd Edition", category: "BOOKS", description: "Classic post-apocalyptic novel" }, { name: "Morphy Richards Food Mixer", variation: "Deluxe", category: "KITCHENWARE", description: "Luxury mixer turning good cakes into great" } ] )
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.
int main(void) { mongoc_init(); // Replace the placeholder with your connection string. char *uri = "<connection string>"; mongoc_client_t* client = mongoc_client_new(uri); // Get a reference to relevant collections. // ... mongoc_collection_t *some_coll = mongoc_client_get_collection(client, "agg_tutorials_db", "some_coll"); // ... mongoc_collection_t *another_coll = mongoc_client_get_collection(client, "agg_tutorials_db", "another_coll"); // Delete any existing documents in collections if needed. // ... { // ... bson_t *filter = bson_new(); // ... bson_error_t error; // ... if (!mongoc_collection_delete_many(some_coll, filter, NULL, NULL, &error)) // ... { // ... fprintf(stderr, "Delete error: %s\n", error.message); // ... } // ... bson_destroy(filter); // ... } // Insert sample data into the collection or collections. // ... { // ... size_t num_docs = ...; // ... bson_t *docs[num_docs]; // ... // ... docs[0] = ...; // ... // ... bson_error_t error; // ... if (!mongoc_collection_insert_many(some_coll, (const bson_t **)docs, num_docs, NULL, NULL, &error)) // ... { // ... fprintf(stderr, "Insert error: %s\n", error.message); // ... } // ... // ... for (int i = 0; i < num_docs; i++) // ... { // ... bson_destroy(docs[i]); // ... } // ... } { const bson_t *doc; // Add code to create pipeline stages. bson_t *pipeline = BCON_NEW("pipeline", "[", // ... Add pipeline stages here. "]"); // Run the aggregation. // ... mongoc_cursor_t *results = mongoc_collection_aggregate(some_coll, MONGOC_QUERY_NONE, pipeline, NULL, NULL); bson_destroy(pipeline); // Print the aggregation results. while (mongoc_cursor_next(results, &doc)) { char *str = bson_as_canonical_extended_json(doc, NULL); printf("%s\n", str); bson_free(str); } bson_error_t error; if (mongoc_cursor_error(results, &error)) { fprintf(stderr, "Aggregation error: %s\n", error.message); } mongoc_cursor_destroy(results); } // Clean up resources. // ... mongoc_collection_destroy(some_coll); mongoc_client_destroy(client); mongoc_cleanup(); return EXIT_SUCCESS; }
Para cada tutorial, se debe reemplazar el marcador de posición de la cadena de conexión con la cadena de conexión de la implementación.
Tip
Para aprender a localizar la cadena de conexión de la implementación, se debe consultar el paso Crear una cadena de conexión de la guía de introducción a C++.
Por ejemplo, si la cadena de conexión es "mongodb+srv://mongodb-example:27017", la asignación de cadena de conexión se asemeja a lo siguiente:
char *uri = "mongodb+srv://mongodb-example:27017";
Crear la colección
Este ejemplo utiliza dos colecciones:
products, que contiene documentos que describen los productos que vende una tiendaorders, que contiene documentos que describen pedidos individuales de productos en una tienda
Una orden sólo puede contener un producto. La agregación utiliza una unión de múltiples campos para emparejar un documento de producto con documentos que representan pedidos de ese producto. La agregación une colecciones por los campos name y variation en los documentos de la colección products, correspondientes a los campos product_name y product_variation en los documentos de la colección orders.
Para crear las colecciones products y orders e insertar los datos de muestra, agregue el siguiente código a su aplicación:
mongoc_collection_t *products = mongoc_client_get_collection(client, "agg_tutorials_db", "products"); 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(products, filter, NULL, NULL, &error)) { fprintf(stderr, "Delete error: %s\n", error.message); } 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 = 5; bson_t *product_docs[num_docs]; product_docs[0] = BCON_NEW( "name", BCON_UTF8("Asus Laptop"), "variation", BCON_UTF8("Ultra HD"), "category", BCON_UTF8("ELECTRONICS"), "description", BCON_UTF8("Great for watching movies")); product_docs[1] = BCON_NEW( "name", BCON_UTF8("Asus Laptop"), "variation", BCON_UTF8("Standard Display"), "category", BCON_UTF8("ELECTRONICS"), "description", BCON_UTF8("Good value laptop for students")); product_docs[2] = BCON_NEW( "name", BCON_UTF8("The Day Of The Triffids"), "variation", BCON_UTF8("1st Edition"), "category", BCON_UTF8("BOOKS"), "description", BCON_UTF8("Classic post-apocalyptic novel")); product_docs[3] = BCON_NEW( "name", BCON_UTF8("The Day Of The Triffids"), "variation", BCON_UTF8("2nd Edition"), "category", BCON_UTF8("BOOKS"), "description", BCON_UTF8("Classic post-apocalyptic novel")); product_docs[4] = BCON_NEW( "name", BCON_UTF8("Morphy Richards Food Mixer"), "variation", BCON_UTF8("Deluxe"), "category", BCON_UTF8("KITCHENWARE"), "description", BCON_UTF8("Luxury mixer turning good cakes into great")); bson_error_t error; if (!mongoc_collection_insert_many(products, (const bson_t **)product_docs, num_docs, NULL, NULL, &error)) { fprintf(stderr, "Insert error: %s\n", error.message); } for (int i = 0; i < num_docs; i++) { bson_destroy(product_docs[i]); } } { size_t num_docs = 4; bson_t *order_docs[num_docs]; order_docs[0] = BCON_NEW( "customer_id", BCON_UTF8("elise_smith@myemail.com"), "orderdate", BCON_DATE_TIME(1590822952000UL), // 2020-05-30T08:35:52Z "product_name", BCON_UTF8("Asus Laptop"), "product_variation", BCON_UTF8("Standard Display"), "value", BCON_DOUBLE(431.43)); order_docs[1] = BCON_NEW( "customer_id", BCON_UTF8("tj@wheresmyemail.com"), "orderdate", BCON_DATE_TIME(1559063612000UL), // 2019-05-28T19:13:32Z "product_name", BCON_UTF8("The Day Of The Triffids"), "product_variation", BCON_UTF8("2nd Edition"), "value", BCON_DOUBLE(5.01)); order_docs[2] = BCON_NEW( "customer_id", BCON_UTF8("oranieri@warmmail.com"), "orderdate", BCON_DATE_TIME(1577869537000UL), // 2020-01-01T08:25:37Z "product_name", BCON_UTF8("Morphy Richards Food Mixer"), "product_variation", BCON_UTF8("Deluxe"), "value", BCON_DOUBLE(63.13)); order_docs[3] = BCON_NEW( "customer_id", BCON_UTF8("jjones@tepidmail.com"), "orderdate", BCON_DATE_TIME(1608976546000UL), // 2020-12-26T08:55:46Z "product_name", BCON_UTF8("Asus Laptop"), "product_variation", BCON_UTF8("Standard Display"), "value", BCON_DOUBLE(429.65)); bson_error_t error; if (!mongoc_collection_insert_many(orders, (const bson_t **)order_docs, num_docs, NULL, NULL, &error)) { fprintf(stderr, "Insert error: %s\n", error.message); } for (int i = 0; i < num_docs; i++) { bson_destroy(order_docs[i]); } }
Crea la aplicación de plantilla
Antes de comenzar a seguir un tutorial de agregación, debes configurar una nueva aplicación de C++. Puedes usar esta aplicación para conectarte a una implementación de MongoDB, insertar datos de muestra en MongoDB y ejecutar el pipeline de agregación.
Tip
Para aprender cómo instalar el controlador y conectarte a MongoDB, consulta el tutorial Comienza con C++.
Para aprender más sobre el uso del controlador C++, consulta la documentación de la API.
Para obtener más información sobre cómo realizar agregaciones en el controlador C++, consulta la guía de agregación.
Después de instalar el controlador, crea un archivo llamado agg-tutorial.cpp. Pega el siguiente código en este archivo para crear una plantilla de aplicación para los tutoriales de agregación.
Importante
En el siguiente código, lee los comentarios del código para encontrar las secciones del código que debes modificar para el tutorial que estás siguiendo.
Si intenta ejecutar el código sin hacer ningún cambio, se encontrará con un error de conexión.
using bsoncxx::builder::basic::kvp; using bsoncxx::builder::basic::make_document; using bsoncxx::builder::basic::make_array; int main() { mongocxx::instance instance; // Replace the placeholder with your connection string. mongocxx::uri uri("<connection string>"); mongocxx::client client(uri); auto db = client["agg_tutorials_db"]; // Delete existing data in the database, if necessary. db.drop(); // Get a reference to relevant collections. // ... auto some_coll = db["..."]; // ... auto another_coll = db["..."]; // Insert sample data into the collection or collections. // ... some_coll.insert_many(docs); // Create an empty pipelne. mongocxx::pipeline pipeline; // Add code to create pipeline stages. // pipeline.match(make_document(...)); // Run the aggregation and print the results. auto cursor = orders.aggregate(pipeline); for (auto&& doc : cursor) { std::cout << bsoncxx::to_json(doc, bsoncxx::ExtendedJsonMode::k_relaxed) << std::endl; } }
Para cada tutorial, se debe reemplazar el marcador de posición de la cadena de conexión con la cadena de conexión de la implementación.
Tip
Para aprender a localizar la cadena de conexión de la implementación, se debe consultar el paso Crear una cadena de conexión del tutorial de introducción a C++.
Por ejemplo, si la cadena de conexión es "mongodb+srv://mongodb-example:27017", la asignación de cadena de conexión se asemeja a lo siguiente:
mongocxx::uri uri{"mongodb+srv://mongodb-example:27017"};
Crear la colección
Este ejemplo utiliza dos colecciones:
products, que contiene documentos que describen los productos que vende una tiendaorders, que contiene documentos que describen pedidos individuales de productos en una tienda
Una orden sólo puede contener un producto. La agregación utiliza una unión de múltiples campos para emparejar un documento de producto con documentos que representan pedidos de ese producto. La agregación une colecciones por los campos name y variation en los documentos de la colección products, correspondientes a los campos product_name y product_variation en los documentos de la colección orders.
Para crear las colecciones products y orders e insertar los datos de muestra, agregue el siguiente código a su aplicación:
auto products = db["products"]; auto orders = db["orders"]; std::vector<bsoncxx::document::value> product_docs = { bsoncxx::from_json(R"({ "name": "Asus Laptop", "variation": "Ultra HD", "category": "ELECTRONICS", "description": "Great for watching movies" })"), bsoncxx::from_json(R"({ "name": "Asus Laptop", "variation": "Standard Display", "category": "ELECTRONICS", "description": "Good value laptop for students" })"), bsoncxx::from_json(R"({ "name": "The Day Of The Triffids", "variation": "1st Edition", "category": "BOOKS", "description": "Classic post-apocalyptic novel" })"), bsoncxx::from_json(R"({ "name": "The Day Of The Triffids", "variation": "2nd Edition", "category": "BOOKS", "description": "Classic post-apocalyptic novel" })"), bsoncxx::from_json(R"({ "name": "Morphy Richards Food Mixer", "variation": "Deluxe", "category": "KITCHENWARE", "description": "Luxury mixer turning good cakes into great" })") }; products.insert_many(product_docs); // Might throw an exception std::vector<bsoncxx::document::value> order_docs = { bsoncxx::from_json(R"({ "customer_id": "elise_smith@myemail.com", "orderdate": {"$date": 1590821752000}, "product_name": "Asus Laptop", "product_variation": "Standard Display", "value": 431.43 })"), bsoncxx::from_json(R"({ "customer_id": "tj@wheresmyemail.com", "orderdate": {"$date": 1559062412000}, "product_name": "The Day Of The Triffids", "product_variation": "2nd Edition", "value": 5.01 })"), bsoncxx::from_json(R"({ "customer_id": "oranieri@warmmail.com", "orderdate": {"$date": 1577861137000}, "product_name": "Morphy Richards Food Mixer", "product_variation": "Deluxe", "value": 63.13 })"), bsoncxx::from_json(R"({ "customer_id": "jjones@tepidmail.com", "orderdate": {"$date": 1608972946000}, "product_name": "Asus Laptop", "product_variation": "Standard Display", "value": 429.65 })") }; orders.insert_many(order_docs); // Might throw an exception
Crea la aplicación de plantilla
Antes de comenzar a seguir este tutorial de agregación, debes configurar una nueva aplicación de C#/.NET. Puedes usar esta aplicación para conectarte a una implementación de MongoDB, insertar datos de muestra en MongoDB y ejecutar el pipeline de agregación.
Tip
Para aprender cómo instalar el controlador y conectarte a MongoDB, consulta la Guía de inicio rápido del controlador C#/.NET.
Para obtener más información sobre cómo realizar agregaciones en el controlador C#/.NET, consulta la Guía de agregación.
Después de instalar el controlador, pegue el siguiente código en su archivo Program.cs para crear una plantilla de aplicación para los tutoriales de agregación.
Importante
En el siguiente código, lee los comentarios del código para encontrar las secciones del código que debes modificar para el tutorial que estás siguiendo.
Si intenta ejecutar el código sin hacer ningún cambio, se encontrará con un error de conexión.
using MongoDB.Bson; using MongoDB.Bson.Serialization.Attributes; using MongoDB.Driver; // Define data model classes. // ... public class MyClass { ... } // Replace the placeholder with your connection string. var uri = "<connection string>"; var client = new MongoClient(uri); var aggDB = client.GetDatabase("agg_tutorials_db"); // Get a reference to relevant collections. // ... var someColl = aggDB.GetCollection<MyClass>("someColl"); // ... var anotherColl = aggDB.GetCollection<MyClass>("anotherColl"); // Delete any existing documents in collections if needed. // ... someColl.DeleteMany(Builders<MyClass>.Filter.Empty); // Insert sample data into the collection or collections. // ... someColl.InsertMany(new List<MyClass> { ... }); // Add code to chain pipeline stages to the Aggregate() method. // ... var results = someColl.Aggregate().Match(...); // Print the aggregation results. foreach (var result in results.ToList()) { Console.WriteLine(result); }
Para cada tutorial, se debe reemplazar el marcador de posición de la cadena de conexión con la cadena de conexión de la implementación.
Tip
Para aprender a localizar la cadena de conexión de la implementación, se debe consultar el paso Configurar un clúster gratuito en Atlas de la guía de inicio rápido de C#.
Por ejemplo, si la cadena de conexión es "mongodb+srv://mongodb-example:27017", la asignación de cadena de conexión se asemeja a lo siguiente:
var uri = "mongodb+srv://mongodb-example:27017";
Crear la colección
Este ejemplo utiliza dos colecciones:
products, que contiene documentos que describen los productos que vende una tiendaorders, que contiene documentos que describen pedidos individuales de productos en una tienda
Una orden sólo puede contener un producto. La agregación utiliza una unión de múltiples campos para emparejar un documento de producto con documentos que representan pedidos de ese producto. La agregación une colecciones por los campos Name y Variation en los documentos de la colección products, correspondientes a los campos ProductName y ProductVariation en los documentos de la colección orders.
Primero, crea clases de C# para modelar los datos en las colecciones products y orders:
public class Product { [] public ObjectId Id { get; set; } public string Name { get; set; } = ""; public string Variation { get; set; } = ""; public string Category { get; set; } = ""; public string Description { get; set; } = ""; } public class Order { [] public ObjectId Id { get; set; } public required string CustomerId { get; set; } public DateTime OrderDate { get; set; } public string ProductName { get; set; } = ""; public string ProductVariation { get; set; } = ""; public double Value { get; set; } }
Para crear las colecciones products y orders e insertar los datos de muestra, agregue el siguiente código a su aplicación:
var orders = aggDB.GetCollection<Order>("orders"); var products = aggDB.GetCollection<Product>("products"); products.InsertMany(new List<Product> { new Product() { Name = "Asus Laptop", Variation = "Ultra HD", Category = "ELECTRONICS", Description = "Great for watching movies" }, new Product() { Name = "Asus Laptop", Variation = "Standard Display", Category = "ELECTRONICS", Description = "Good value laptop for students" }, new Product() { Name = "The Day Of The Triffids", Variation = "1st Edition", Category = "BOOKS", Description = "Classic post-apocalyptic novel" }, new Product() { Name = "The Day Of The Triffids", Variation = "2nd Edition", Category = "BOOKS", Description = "Classic post-apocalyptic novel" }, new Product() { Name = "Morphy Richards Food Mixer", Variation = "Deluxe", Category = "KITCHENWARE", Description = "Luxury mixer turning good cakes into great" } }); orders.InsertMany(new List<Order> { new Order() { CustomerId = "elise_smith@myemail.com", OrderDate = DateTime.Parse("2020-05-30T08:35:52Z"), ProductName = "Asus Laptop", ProductVariation = "Standard Display", Value = 431.43 }, new Order() { CustomerId = "tj@wheresmyemail.com", OrderDate = DateTime.Parse("2019-05-28T19:13:32Z"), ProductName = "The Day Of The Triffids", ProductVariation = "2nd Edition", Value = 5.01 }, new Order() { CustomerId = "oranieri@warmmail.com", OrderDate = DateTime.Parse("2020-01-01T08:25:37Z"), ProductName = "Morphy Richards Food Mixer", ProductVariation = "Deluxe", Value = 63.13 }, new Order() { CustomerId = "jjones@tepidmail.com", OrderDate = DateTime.Parse("2020-12-26T08:55:46Z"), ProductName = "Asus Laptop", ProductVariation = "Standard Display", Value = 429.65 } });
Crea la aplicación de plantilla
Antes de comenzar a seguir este tutorial de agregación, debes configurar una nueva aplicación Go. Puedes usar esta aplicación para conectarte a una implementación de MongoDB, insertar datos de muestra en MongoDB y ejecutar el pipeline de agregación.
Tip
Para aprender cómo instalar el controlador y conectarse a MongoDB, consulte la Guía de inicio rápido del controlador Go.
Para obtener más información sobre cómo realizar agregaciones en el controlador de Go, consulta la Guía de agregación.
Después de instalar el controlador, crea un archivo llamado agg_tutorial.go. Pega el siguiente código en este archivo para crear una plantilla de aplicación para los tutoriales de agregación.
Importante
En el siguiente código, lee los comentarios del código para encontrar las secciones del código que debes modificar para el tutorial que estás siguiendo.
Si intenta ejecutar el código sin hacer ningún cambio, se encontrará con un error de conexión.
package main import ( "context" "fmt" "log" "go.mongodb.org/mongo-driver/v2/bson" "go.mongodb.org/mongo-driver/v2/mongo" "go.mongodb.org/mongo-driver/v2/mongo/options" ) // Define structs. // type MyStruct struct { ... } func main() { ctx := context.Background() // Replace the placeholder with your connection string. const uri = "<connection string>" client, err := mongo.Connect(options.Client().ApplyURI(uri)) if err != nil { log.Fatal(err) } defer func() { if err = client.Disconnect(ctx); err != nil { log.Fatal(err) } }() aggDB := client.Database("agg_tutorials_db") // Get a reference to relevant collections. // ... someColl := aggDB.Collection("...") // ... anotherColl := aggDB.Collection("...") // Delete any existing documents in collections if needed. // ... someColl.DeleteMany(cxt, bson.D{}) // Insert sample data into the collection or collections. // ... _, err = someColl.InsertMany(...) // Add code to create pipeline stages. // ... myStage := bson.D{{...}} // Create a pipeline that includes the stages. // ... pipeline := mongo.Pipeline{...} // Run the aggregation. // ... cursor, err := someColl.Aggregate(ctx, pipeline) if err != nil { log.Fatal(err) } defer func() { if err := cursor.Close(ctx); err != nil { log.Fatalf("failed to close cursor: %v", err) } }() // Decode the aggregation results. var results []bson.D if err = cursor.All(ctx, &results); err != nil { log.Fatalf("failed to decode results: %v", err) } // Print the aggregation results. for _, result := range results { res, _ := bson.MarshalExtJSON(result, false, false) fmt.Println(string(res)) } }
Para cada tutorial, se debe reemplazar el marcador de posición de la cadena de conexión con la cadena de conexión de la implementación.
Tip
Para aprender a localizar la cadena de conexión de la implementación, se debe consultar el paso Crear un clúster de MongoDB de la guía de inicio rápido de Go.
Por ejemplo, si la cadena de conexión es "mongodb+srv://mongodb-example:27017", la asignación de cadena de conexión se asemeja a lo siguiente:
const uri = "mongodb+srv://mongodb-example:27017";
Crear la colección
Este ejemplo utiliza dos colecciones:
products, que contiene documentos que describen los productos que vende una tiendaorders, que contiene documentos que describen pedidos individuales de productos en una tienda
Una orden sólo puede contener un producto. La agregación utiliza una unión de múltiples campos para emparejar un documento de producto con documentos que representan pedidos de ese producto. La agregación une colecciones por los campos name y variation en los documentos de la colección products, correspondientes a los campos product_name y product_variation en los documentos de la colección orders.
Primero, crea structs de Go para modelar los datos en las colecciones products y orders:
type Product struct { Name string Variation string Category string Description string } type Order struct { CustomerID string `bson:"customer_id"` OrderDate bson.DateTime `bson:"orderdate"` ProductName string `bson:"product_name"` ProductVariation string `bson:"product_variation"` Value float32 `bson:"value"` }
Para crear las colecciones products y orders e insertar los datos de muestra, agregue el siguiente código a su aplicación:
products := aggDB.Collection("products") orders := aggDB.Collection("orders") products.DeleteMany(context.TODO(), bson.D{}) orders.DeleteMany(context.TODO(), bson.D{}) _, err = products.InsertMany(context.TODO(), []interface{}{ Product{ Name: "Asus Laptop", Variation: "Ultra HD", Category: "ELECTRONICS", Description: "Great for watching movies", }, Product{ Name: "Asus Laptop", Variation: "Standard Display", Category: "ELECTRONICS", Description: "Good value laptop for students", }, Product{ Name: "The Day Of The Triffids", Variation: "1st Edition", Category: "BOOKS", Description: "Classic post-apocalyptic novel", }, Product{ Name: "The Day Of The Triffids", Variation: "2nd Edition", Category: "BOOKS", Description: "Classic post-apocalyptic novel", }, Product{ Name: "Morphy Richards Food Mixer", Variation: "Deluxe", Category: "KITCHENWARE", Description: "Luxury mixer turning good cakes into great", }, }) if err != nil { log.Fatal(err) } _, err = orders.InsertMany(context.TODO(), []interface{}{ Order{ CustomerID: "elise_smith@myemail.com", OrderDate: bson.NewDateTimeFromTime(time.Date(2020, 5, 30, 8, 35, 52, 0, time.UTC)), ProductName: "Asus Laptop", ProductVariation: "Standard Display", Value: 431.43, }, Order{ CustomerID: "tj@wheresmyemail.com", OrderDate: bson.NewDateTimeFromTime(time.Date(2019, 5, 28, 19, 13, 32, 0, time.UTC)), ProductName: "The Day Of The Triffids", ProductVariation: "2nd Edition", Value: 5.01, }, Order{ CustomerID: "oranieri@warmmail.com", OrderDate: bson.NewDateTimeFromTime(time.Date(2020, 1, 1, 8, 25, 37, 0, time.UTC)), ProductName: "Morphy Richards Food Mixer", ProductVariation: "Deluxe", Value: 63.13, }, Order{ CustomerID: "jjones@tepidmail.com", OrderDate: bson.NewDateTimeFromTime(time.Date(2020, 12, 26, 8, 55, 46, 0, time.UTC)), ProductName: "Asus Laptop", ProductVariation: "Standard Display", Value: 429.65, }, }) if err != nil { log.Fatal(err) }
Crea la aplicación de plantilla
Antes de comenzar a seguir un tutorial de agregación, debes configurar una nueva aplicación de Java. Puedes usar esta aplicación para conectarte a una implementación de MongoDB, insertar datos de muestra en MongoDB y ejecutar el pipeline de agregación.
Tip
Para aprender cómo instalar el controlador y conectarte a MongoDB, consulta la Guía de inicio del controlador de Java.
Para obtener más información sobre cómo realizar agregaciones en el Java Sync Driver, consulta la Guía de agregación.
Después de instalar el controlador, crea un archivo llamado AggTutorial.java. Pega el siguiente código en este archivo para crear una plantilla de aplicación para los tutoriales de agregación.
Importante
En el siguiente código, lee los comentarios del código para encontrar las secciones del código que debes modificar para el tutorial que estás siguiendo.
Si intenta ejecutar el código sin hacer ningún cambio, se encontrará con un error de conexión.
package org.example; // Modify imports for each tutorial as needed. import com.mongodb.client.*; import com.mongodb.client.model.Accumulators; import com.mongodb.client.model.Aggregates; import com.mongodb.client.model.Field; import com.mongodb.client.model.Filters; import com.mongodb.client.model.Sorts; import com.mongodb.client.model.Variable; import org.bson.Document; import org.bson.conversions.Bson; import java.time.LocalDateTime; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.List; public class AggTutorial { public static void main(String[] args) { // Replace the placeholder with your connection string. String uri = "<connection string>"; try (MongoClient mongoClient = MongoClients.create(uri)) { MongoDatabase aggDB = mongoClient.getDatabase("agg_tutorials_db"); // Get a reference to relevant collections. // ... MongoCollection<Document> someColl = ... // ... MongoCollection<Document> anotherColl = ... // Insert sample data into the collection or collections. // ... someColl.insertMany(...); // Create an empty pipeline array. List<Bson> pipeline = new ArrayList<>(); // Add code to create pipeline stages. // ... pipeline.add(...); // Run the aggregation. // ... AggregateIterable<Document> aggregationResult = // someColl.aggregate(pipeline); // Print the aggregation results. for (Document document : aggregationResult) { System.out.println(document.toJson()); } } } }
Para cada tutorial, se debe reemplazar el marcador de posición de la cadena de conexión con la cadena de conexión de la implementación.
Tip
Para aprender a localizar la cadena de conexión de la implementación, se debe consultar el paso Crear una cadena de conexión de la guía de inicio rápido de Java Sync.
Por ejemplo, si la cadena de conexión es "mongodb+srv://mongodb-example:27017", la asignación de cadena de conexión se asemeja a lo siguiente:
String uri = "mongodb+srv://mongodb-example:27017";
Crear la colección
Este ejemplo utiliza dos colecciones:
products, que contiene documentos que describen los productos que vende una tiendaorders, que contiene documentos que describen pedidos individuales de productos en una tienda
Una orden sólo puede contener un producto. La agregación utiliza una unión de múltiples campos para emparejar un documento de producto con documentos que representan pedidos de ese producto. La agregación une colecciones por los campos name y variation en los documentos de la colección products, correspondientes a los campos product_name y product_variation en los documentos de la colección orders.
Para crear las colecciones products y orders e insertar los datos de muestra, agregue el siguiente código a su aplicación:
MongoDatabase aggDB = mongoClient.getDatabase("agg_tutorials_db"); MongoCollection<Document> products = aggDB.getCollection("products"); MongoCollection<Document> orders = aggDB.getCollection("orders"); products.insertMany( Arrays.asList( new Document("name", "Asus Laptop") .append("variation", "Ultra HD") .append("category", "ELECTRONICS") .append("description", "Great for watching movies"), new Document("name", "Asus Laptop") .append("variation", "Standard Display") .append("category", "ELECTRONICS") .append("description", "Good value laptop for students"), new Document("name", "The Day Of The Triffids") .append("variation", "1st Edition") .append("category", "BOOKS") .append("description", "Classic post-apocalyptic novel"), new Document("name", "The Day Of The Triffids") .append("variation", "2nd Edition") .append("category", "BOOKS") .append("description", "Classic post-apocalyptic novel"), new Document("name", "Morphy Richards Food Mixer") .append("variation", "Deluxe") .append("category", "KITCHENWARE") .append("description", "Luxury mixer turning good cakes into great") ) ); orders.insertMany( Arrays.asList( new Document("customer_id", "elise_smith@myemail.com") .append("orderdate", LocalDateTime.parse("2020-05-30T08:35:52")) .append("product_name", "Asus Laptop") .append("product_variation", "Standard Display") .append("value", 431.43), new Document("customer_id", "tj@wheresmyemail.com") .append("orderdate", LocalDateTime.parse("2019-05-28T19:13:32")) .append("product_name", "The Day Of The Triffids") .append("product_variation", "2nd Edition") .append("value", 5.01), new Document("customer_id", "oranieri@warmmail.com") .append("orderdate", LocalDateTime.parse("2020-01-01T08:25:37")) .append("product_name", "Morphy Richards Food Mixer") .append("product_variation", "Deluxe") .append("value", 63.13), new Document("customer_id", "jjones@tepidmail.com") .append("orderdate", LocalDateTime.parse("2020-12-26T08:55:46")) .append("product_name", "Asus Laptop") .append("product_variation", "Standard Display") .append("value", 429.65) ) );
Crea la aplicación de plantilla
Antes de comenzar a seguir un tutorial de agregación, debes configurar una nueva aplicación de Java. Puedes usar esta aplicación para conectarte a una implementación de MongoDB, insertar datos de muestra en MongoDB y ejecutar el pipeline de agregación.
Tip
Para aprender cómo instalar el controlador y conectarte a MongoDB, consulta la Guía de inicio del controlador de Java.
Para obtener más información sobre cómo realizar agregaciones en el Java Sync Driver, consulta la Guía de agregación.
Después de instalar el controlador, crea un archivo llamado AggTutorial.java. Pega el siguiente código en este archivo para crear una plantilla de aplicación para los tutoriales de agregación.
Importante
En el siguiente código, lee los comentarios del código para encontrar las secciones del código que debes modificar para el tutorial que estás siguiendo.
Si intenta ejecutar el código sin hacer ningún cambio, se encontrará con un error de conexión.
package org.example; // Modify imports for each tutorial as needed. import com.mongodb.client.*; import com.mongodb.client.model.Accumulators; import com.mongodb.client.model.Aggregates; import com.mongodb.client.model.Field; import com.mongodb.client.model.Filters; import com.mongodb.client.model.Sorts; import com.mongodb.client.model.Variable; import org.bson.Document; import org.bson.conversions.Bson; import java.time.LocalDateTime; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.List; public class AggTutorial { public static void main(String[] args) { // Replace the placeholder with your connection string. String uri = "<connection string>"; try (MongoClient mongoClient = MongoClients.create(uri)) { MongoDatabase aggDB = mongoClient.getDatabase("agg_tutorials_db"); // Get a reference to relevant collections. // ... MongoCollection<Document> someColl = ... // ... MongoCollection<Document> anotherColl = ... // Insert sample data into the collection or collections. // ... someColl.insertMany(...); // Create an empty pipeline array. List<Bson> pipeline = new ArrayList<>(); // Add code to create pipeline stages. // ... pipeline.add(...); // Run the aggregation. // ... AggregateIterable<Document> aggregationResult = // someColl.aggregate(pipeline); // Print the aggregation results. for (Document document : aggregationResult) { System.out.println(document.toJson()); } } } }
Para cada tutorial, se debe reemplazar el marcador de posición de la cadena de conexión con la cadena de conexión de la implementación.
Tip
Para aprender a localizar la cadena de conexión de la implementación, se debe consultar el paso Crear una cadena de conexión de la guía de inicio rápido de Java Sync.
Por ejemplo, si la cadena de conexión es "mongodb+srv://mongodb-example:27017", la asignación de cadena de conexión se asemeja a lo siguiente:
String uri = "mongodb+srv://mongodb-example:27017";
Crear la colección
Este ejemplo utiliza dos colecciones:
products, que contiene documentos que describen los productos que vende una tiendaorders, que contiene documentos que describen pedidos individuales de productos en una tienda
Una orden sólo puede contener un producto. La agregación utiliza una unión de múltiples campos para emparejar un documento de producto con documentos que representan pedidos de ese producto. La agregación une colecciones por los campos name y variation en los documentos de la colección products, correspondientes a los campos product_name y product_variation en los documentos de la colección orders.
Primero, crea clases de datos de Kotlin para modelar los datos en las colecciones products y orders:
data class Product( val name: String, val variation: String, val category: String, val description: String ) data class Order( val customerID: String, val orderDate: LocalDateTime, val productName: String, val productVariation: String, val value: Double )
Para crear las colecciones products y orders e insertar los datos de muestra, agregue el siguiente código a su aplicación:
val products = aggDB.getCollection<Product>("products") val orders = aggDB.getCollection<Order>("orders") products.deleteMany(Filters.empty()); orders.deleteMany(Filters.empty()); products.insertMany( listOf( Product("Asus Laptop", "Ultra HD", "ELECTRONICS", "Great for watching movies"), Product("Asus Laptop", "Standard Display", "ELECTRONICS", "Good value laptop for students"), Product("The Day Of The Triffids", "1st Edition", "BOOKS", "Classic post-apocalyptic novel"), Product("The Day Of The Triffids", "2nd Edition", "BOOKS", "Classic post-apocalyptic novel"), Product( "Morphy Richards Food Mixer", "Deluxe", "KITCHENWARE", "Luxury mixer turning good cakes into great" ) ) ) orders.insertMany( listOf( Order( "elise_smith@myemail.com", LocalDateTime.parse("2020-05-30T08:35:52"), "Asus Laptop", "Standard Display", 431.43 ), Order( "tj@wheresmyemail.com", LocalDateTime.parse("2019-05-28T19:13:32"), "The Day Of The Triffids", "2nd Edition", 5.01 ), Order( "oranieri@warmmail.com", LocalDateTime.parse("2020-01-01T08:25:37"), "Morphy Richards Food Mixer", "Deluxe", 63.13 ), Order( "jjones@tepidmail.com", LocalDateTime.parse("2020-12-26T08:55:46"), "Asus Laptop", "Standard Display", 429.65 ) ) )
Crea la aplicación de plantilla
Antes de comenzar a seguir este tutorial de agregación, debes configurar una nueva aplicación de Node.js. Puedes usar esta aplicación para conectarte a una implementación de MongoDB, insertar datos de muestra en MongoDB y ejecutar el pipeline de agregación.
Tip
Para aprender a instalar el controlador y conectarte a MongoDB, consulta la Guía de inicio rápido del controlador de Node.js.
Para obtener más información sobre cómo realizar agregaciones en el controlador de Nodo.js, consulta la Guía de agregación.
Después de instalar el controlador, crea un archivo para ejecutar la plantilla del tutorial. Pega el siguiente código en este archivo para crear una plantilla de aplicación para los tutoriales de agregación.
Importante
En el siguiente código, lee los comentarios del código para encontrar las secciones del código que debes modificar para el tutorial que estás siguiendo.
Si intenta ejecutar el código sin hacer ningún cambio, se encontrará con un error de conexión.
import { MongoClient } from 'mongodb'; // Replace the placeholder with your connection string. const uri = '<connection-string>'; const client = new MongoClient(uri); export async function run() { try { const aggDB = client.db('agg_tutorials_db'); // Get a reference to relevant collections. // ... const someColl = // ... const anotherColl = // Delete any existing documents in collections. // ... await someColl.deleteMany({}); // Insert sample data into the collection or collections. // ... const someData = [ ... ]; // ... await someColl.insertMany(someData); // Create an empty pipeline array. const pipeline = []; // Add code to create pipeline stages. // ... pipeline.push({ ... }) // Run the aggregation. // ... const aggregationResult = ... // Print the aggregation results. for await (const document of aggregationResult) { console.log(document); } } finally { await client.close(); } } run().catch(console.dir);
Para cada tutorial, se debe reemplazar el marcador de posición de la cadena de conexión con la cadena de conexión de la implementación.
Tip
Para aprender a localizar la cadena de conexión de la implementación, se debe consultar el paso Crear una cadena de conexión de la guía de inicio rápido de Nodo.js.
Por ejemplo, si la cadena de conexión es "mongodb+srv://mongodb-example:27017", la asignación de cadena de conexión se asemeja a lo siguiente:
const uri = "mongodb+srv://mongodb-example:27017";
Crear la colección
Este ejemplo utiliza dos colecciones:
products, que contiene documentos que describen los productos que vende una tiendaorders, que contiene documentos que describen pedidos individuales de productos en una tienda
Una orden sólo puede contener un producto. La agregación utiliza una unión de múltiples campos para emparejar un documento de producto con documentos que representan pedidos de ese producto. La agregación une colecciones por los campos name y variation en los documentos de la colección products, correspondientes a los campos product_name y product_variation en los documentos de la colección orders.
Para crear las colecciones products y orders e insertar los datos de muestra, agregue el siguiente código a su aplicación:
const products = aggDB.collection('products'); const orders = aggDB.collection('orders'); await products.insertMany([ { name: 'Asus Laptop', variation: 'Ultra HD', category: 'ELECTRONICS', description: 'Great for watching movies', }, { name: 'Asus Laptop', variation: 'Standard Display', category: 'ELECTRONICS', description: 'Good value laptop for students', }, { name: 'The Day Of The Triffids', variation: '1st Edition', category: 'BOOKS', description: 'Classic post-apocalyptic novel', }, { name: 'The Day Of The Triffids', variation: '2nd Edition', category: 'BOOKS', description: 'Classic post-apocalyptic novel', }, { name: 'Morphy Richards Food Mixer', variation: 'Deluxe', category: 'KITCHENWARE', description: 'Luxury mixer turning good cakes into great', }, ]); await orders.insertMany([ { customer_id: 'elise_smith@myemail.com', orderdate: new Date('2020-05-30T08:35:52Z'), product_name: 'Asus Laptop', product_variation: 'Standard Display', value: 431.43, }, { customer_id: 'tj@wheresmyemail.com', orderdate: new Date('2019-05-28T19:13:32Z'), product_name: 'The Day Of The Triffids', product_variation: '2nd Edition', value: 5.01, }, { customer_id: 'oranieri@warmmail.com', orderdate: new Date('2020-01-01T08:25:37Z'), product_name: 'Morphy Richards Food Mixer', product_variation: 'Deluxe', value: 63.13, }, { customer_id: 'jjones@tepidmail.com', orderdate: new Date('2020-12-26T08:55:46Z'), product_name: 'Asus Laptop', product_variation: 'Standard Display', value: 429.65, }, ]);
Crea la aplicación de plantilla
Antes de comenzar a seguir este tutorial de agregación, debes configurar una nueva aplicación Go. Puedes usar esta aplicación para conectarte a una implementación de MongoDB, insertar datos de muestra en MongoDB y ejecutar el pipeline de agregación.
Tip
Para aprender cómo instalar el controlador y conectarse a MongoDB, consulte la Guía de inicio rápido del controlador Go.
Para obtener más información sobre cómo realizar agregaciones en el controlador de Go, consulta la Guía de agregación.
Después de instalar el controlador, crea un archivo llamado agg_tutorial.go. Pega el siguiente código en este archivo para crear una plantilla de aplicación para los tutoriales de agregación.
Importante
En el siguiente código, lee los comentarios del código para encontrar las secciones del código que debes modificar para el tutorial que estás siguiendo.
Si intenta ejecutar el código sin hacer ningún cambio, se encontrará con un error de conexión.
package main import ( "context" "fmt" "log" "go.mongodb.org/mongo-driver/v2/bson" "go.mongodb.org/mongo-driver/v2/mongo" "go.mongodb.org/mongo-driver/v2/mongo/options" ) // Define structs. // type MyStruct struct { ... } func main() { ctx := context.Background() // Replace the placeholder with your connection string. const uri = "<connection string>" client, err := mongo.Connect(options.Client().ApplyURI(uri)) if err != nil { log.Fatal(err) } defer func() { if err = client.Disconnect(ctx); err != nil { log.Fatal(err) } }() aggDB := client.Database("agg_tutorials_db") // Get a reference to relevant collections. // ... someColl := aggDB.Collection("...") // ... anotherColl := aggDB.Collection("...") // Delete any existing documents in collections if needed. // ... someColl.DeleteMany(cxt, bson.D{}) // Insert sample data into the collection or collections. // ... _, err = someColl.InsertMany(...) // Add code to create pipeline stages. // ... myStage := bson.D{{...}} // Create a pipeline that includes the stages. // ... pipeline := mongo.Pipeline{...} // Run the aggregation. // ... cursor, err := someColl.Aggregate(ctx, pipeline) if err != nil { log.Fatal(err) } defer func() { if err := cursor.Close(ctx); err != nil { log.Fatalf("failed to close cursor: %v", err) } }() // Decode the aggregation results. var results []bson.D if err = cursor.All(ctx, &results); err != nil { log.Fatalf("failed to decode results: %v", err) } // Print the aggregation results. for _, result := range results { res, _ := bson.MarshalExtJSON(result, false, false) fmt.Println(string(res)) } }
Para cada tutorial, se debe reemplazar el marcador de posición de la cadena de conexión con la cadena de conexión de la implementación.
Tip
Para aprender a localizar la cadena de conexión de la implementación, se debe consultar el paso Crear un clúster de MongoDB de la guía de inicio rápido de Go.
Por ejemplo, si la cadena de conexión es "mongodb+srv://mongodb-example:27017", la asignación de cadena de conexión se asemeja a lo siguiente:
const uri = "mongodb+srv://mongodb-example:27017";
Crear la colección
Este ejemplo utiliza dos colecciones:
products, que contiene documentos que describen los productos que vende una tiendaorders, que contiene documentos que describen pedidos individuales de productos en una tienda
Una orden sólo puede contener un producto. La agregación utiliza una unión de múltiples campos para emparejar un documento de producto con documentos que representan pedidos de ese producto. La agregación une colecciones por los campos name y variation en los documentos de la colección products, correspondientes a los campos product_name y product_variation en los documentos de la colección orders.
Para crear las colecciones products y orders e insertar los datos de muestra, agregue el siguiente código a su aplicación:
$products = $client->agg_tutorials_db->products; $orders = $client->agg_tutorials_db->orders; $products->deleteMany([]); $orders->deleteMany([]); $products->insertMany( [ [ 'name' => "Asus Laptop", 'variation' => "Ultra HD", 'category' => "ELECTRONICS", 'description' => "Great for watching movies" ], [ 'name' => "Asus Laptop", 'variation' => "Standard Display", 'category' => "ELECTRONICS", 'description' => "Good value laptop for students" ], [ 'name' => "The Day Of The Triffids", 'variation' => "1st Edition", 'category' => "BOOKS", 'description' => "Classic post-apocalyptic novel" ], [ 'name' => "The Day Of The Triffids", 'variation' => "2nd Edition", 'category' => "BOOKS", 'description' => "Classic post-apocalyptic novel" ], [ 'name' => "Morphy Richards Food Mixer", 'variation' => "Deluxe", 'category' => "KITCHENWARE", 'description' => "Luxury mixer turning good cakes into great" ] ] ); $orders->insertMany( [ [ 'customer_id' => "elise_smith@myemail.com", 'orderdate' => new UTCDateTime((new DateTimeImmutable("2020-05-30T08:35:52"))), 'product_name' => "Asus Laptop", 'product_variation' => "Standard Display", 'value' => 431.43 ], [ 'customer_id' => "tj@wheresmyemail.com", 'orderdate' => new UTCDateTime((new DateTimeImmutable("2019-05-28T19:13:32"))), 'product_name' => "The Day Of The Triffids", 'product_variation' => "2nd Edition", 'value' => 5.01 ], [ 'customer_id' => "oranieri@warmmail.com", 'orderdate' => new UTCDateTime((new DateTimeImmutable("2020-01-01T08:25:37"))), 'product_name' => "Morphy Richards Food Mixer", 'product_variation' => "Deluxe", 'value' => 63.13 ], [ 'customer_id' => "jjones@tepidmail.com", 'orderdate' => new UTCDateTime((new DateTimeImmutable("2020-12-26T08:55:46"))), 'product_name' => "Asus Laptop", 'product_variation' => "Standard Display", 'value' => 429.65 ] ] );
Crea la aplicación de plantilla
Antes de comenzar a seguir este tutorial de agregación, debe configurar una nueva aplicación de Python. Puedes usar esta aplicación para conectarte a una implementación de MongoDB, insertar datos de muestra en MongoDB y ejecutar el pipeline de agregación.
Tip
Para aprender a instalar PyMongo y conectarte a MongoDB, consulta el tutorial Get Started with PyMongo.
Para obtener más información sobre cómo realizar agregaciones en PyMongo, consulta la Guía de agregación.
Después de instalar la biblioteca, crea un archivo llamado agg_tutorial.py. Pega el siguiente código en este archivo para crear una plantilla de aplicación para los tutoriales de agregación.
Importante
En el siguiente código, lee los comentarios del código para encontrar las secciones del código que debes modificar para el tutorial que estás siguiendo.
Si intenta ejecutar el código sin hacer ningún cambio, se encontrará con un error de conexión.
# Modify imports for each tutorial as needed. from pymongo import MongoClient # Replace the placeholder with your connection string. uri = "<connection-string>" client = MongoClient(uri) try: agg_db = client["agg_tutorials_db"] # Get a reference to relevant collections. # ... some_coll = agg_db["some_coll"] # ... another_coll = agg_db["another_coll"] # Delete any existing documents in collections if needed. # ... some_coll.delete_many({}) # Insert sample data into the collection or collections. # ... some_coll.insert_many(...) # Create an empty pipeline array. pipeline = [] # Add code to create pipeline stages. # ... pipeline.append({...}) # Run the aggregation. # ... aggregation_result = ... # Print the aggregation results. for document in aggregation_result: print(document) finally: client.close()
Para cada tutorial, se debe reemplazar el marcador de posición de la cadena de conexión con la cadena de conexión de la implementación.
Tip
Para aprender a localizar la cadena de conexión de la implementación, se debe consultar el paso Crear una cadena de conexión del tutorial Comenzar con la librería PHP.
Por ejemplo, si la cadena de conexión es "mongodb+srv://mongodb-example:27017", la asignación de cadena de conexión se asemeja a lo siguiente:
uri = "mongodb+srv://mongodb-example:27017"
Crear la colección
Este ejemplo utiliza dos colecciones:
products, que contiene documentos que describen los productos que vende una tiendaorders, que contiene documentos que describen pedidos individuales de productos en una tienda
Una orden sólo puede contener un producto. La agregación utiliza una unión de múltiples campos para emparejar un documento de producto con documentos que representan pedidos de ese producto. La agregación une colecciones por los campos name y variation en los documentos de la colección products, correspondientes a los campos product_name y product_variation en los documentos de la colección orders.
Para crear las colecciones products y orders e insertar los datos de muestra, agregue el siguiente código a su aplicación:
products_coll = agg_db["products"] orders_coll = agg_db["orders"] order_data = [ { "customer_id": "elise_smith@myemail.com", "orderdate": datetime(2020, 5, 30, 8, 35, 52), "product_name": "Asus Laptop", "product_variation": "Standard Display", "value": 431.43, }, { "customer_id": "tj@wheresmyemail.com", "orderdate": datetime(2019, 5, 28, 19, 13, 32), "product_name": "The Day Of The Triffids", "product_variation": "2nd Edition", "value": 5.01, }, { "customer_id": "oranieri@warmmail.com", "orderdate": datetime(2020, 1, 1, 8, 25, 37), "product_name": "Morphy Richards Food Mixer", "product_variation": "Deluxe", "value": 63.13, }, { "customer_id": "jjones@tepidmail.com", "orderdate": datetime(2020, 12, 26, 8, 55, 46), "product_name": "Asus Laptop", "product_variation": "Standard Display", "value": 429.65, }, ] orders_coll.insert_many(order_data) products_data = [ { "name": "Asus Laptop", "variation": "Ultra HD", "category": "ELECTRONICS", "description": "Great for watching movies", }, { "name": "Asus Laptop", "variation": "Standard Display", "category": "ELECTRONICS", "description": "Good value laptop for students", }, { "name": "The Day Of The Triffids", "variation": "1st Edition", "category": "BOOKS", "description": "Classic post-apocalyptic novel", }, { "name": "The Day Of The Triffids", "variation": "2nd Edition", "category": "BOOKS", "description": "Classic post-apocalyptic novel", }, { "name": "Morphy Richards Food Mixer", "variation": "Deluxe", "category": "KITCHENWARE", "description": "Luxury mixer turning good cakes into great", }, ] products_coll.insert_many(products_data)
Crea la aplicación de plantilla
Antes de comenzar a seguir este tutorial de agregación, debes configurar una nueva aplicación de Ruby. Puedes usar esta aplicación para conectarte a una implementación de MongoDB, insertar datos de muestra en MongoDB y ejecutar el pipeline de agregación.
Tip
Para aprender cómo instalar el controlador de Ruby y conectarte a MongoDB, consulta la Guía de introducción al controlador de Ruby.
Para obtener más información sobre cómo realizar agregaciones en el controlador Ruby, consulta la Guía de agregación.
Después de instalar el controlador, crea un archivo llamado agg_tutorial.rb. Pega el siguiente código en este archivo para crear una plantilla de aplicación para los tutoriales de agregación.
Importante
En el siguiente código, lee los comentarios del código para encontrar las secciones del código que debes modificar para el tutorial que estás siguiendo.
Si intenta ejecutar el código sin hacer ningún cambio, se encontrará con un error de conexión.
# typed: strict require 'mongo' require 'bson' # Replace the placeholder with your connection string. uri = "<connection string>" Mongo::Client.new(uri) do |client| agg_db = client.use('agg_tutorials_db') # Get a reference to relevant collections. # ... some_coll = agg_db[:some_coll] # Delete any existing documents in collections if needed. # ... some_coll.delete_many({}) # Insert sample data into the collection or collections. # ... some_coll.insert_many( ... ) # Add code to create pipeline stages within the array. # ... pipeline = [ ... ] # Run the aggregation. # ... aggregation_result = some_coll.aggregate(pipeline) # Print the aggregation results. aggregation_result.each do |doc| puts doc end end
Para cada tutorial, se debe reemplazar el marcador de posición de la cadena de conexión con la cadena de conexión de la implementación.
Tip
Para aprender a localizar la cadena de conexión de la implementación, se debe consultar el paso Crear una cadena de conexión de la guía de inicio de Ruby.
Por ejemplo, si la cadena de conexión es "mongodb+srv://mongodb-example:27017", la asignación de cadena de conexión se asemeja a lo siguiente:
uri = "mongodb+srv://mongodb-example:27017"
Crear la colección
Este ejemplo utiliza dos colecciones:
products, que contiene documentos que describen los productos que vende una tiendaorders, que contiene documentos que describen pedidos individuales de productos en una tienda
Una orden sólo puede contener un producto. La agregación utiliza una unión de múltiples campos para emparejar un documento de producto con documentos que representan pedidos de ese producto. La agregación une colecciones por los campos name y variation en los documentos de la colección products, correspondientes a los campos product_name y product_variation en los documentos de la colección orders.
Para crear las colecciones products y orders e insertar los datos de muestra, agregue el siguiente código a su aplicación:
products = agg_db[:products] orders = agg_db[:orders] products.delete_many({}) orders.delete_many({}) products.insert_many( [ { name: "Asus Laptop", variation: "Ultra HD", category: "ELECTRONICS", description: "Great for watching movies", }, { name: "Asus Laptop", variation: "Standard Display", category: "ELECTRONICS", description: "Good value laptop for students", }, { name: "The Day Of The Triffids", variation: "1st Edition", category: "BOOKS", description: "Classic post-apocalyptic novel", }, { name: "The Day Of The Triffids", variation: "2nd Edition", category: "BOOKS", description: "Classic post-apocalyptic novel", }, { name: "Morphy Richards Food Mixer", variation: "Deluxe", category: "KITCHENWARE", description: "Luxury mixer turning good cakes into great", }, ] ) orders.insert_many( [ { customer_id: "elise_smith@myemail.com", orderdate: DateTime.parse("2020-05-30T08:35:52Z"), product_name: "Asus Laptop", product_variation: "Standard Display", value: 431.43, }, { customer_id: "tj@wheresmyemail.com", orderdate: DateTime.parse("2019-05-28T19:13:32Z"), product_name: "The Day Of The Triffids", product_variation: "2nd Edition", value: 5.01, }, { customer_id: "oranieri@warmmail.com", orderdate: DateTime.parse("2020-01-01T08:25:37Z"), product_name: "Morphy Richards Food Mixer", product_variation: "Deluxe", value: 63.13, }, { customer_id: "jjones@tepidmail.com", orderdate: DateTime.parse("2020-12-26T08:55:46Z"), product_name: "Asus Laptop", product_variation: "Standard Display", value: 429.65, }, ] )
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 { ... } async fn main() mongodb::error::Result<()> { // Replace the placeholder with your connection string. let uri = "<connection string>"; let client = Client::with_uri_str(uri).await?; let agg_db = client.database("agg_tutorials_db"); // Get a reference to relevant collections. // ... let some_coll: Collection<T> = agg_db.collection("..."); // ... let another_coll: Collection<T> = agg_db.collection("..."); // Delete any existing documents in collections if needed. // ... some_coll.delete_many(doc! {}).await?; // Insert sample data into the collection or collections. // ... some_coll.insert_many(vec![...]).await?; // Create an empty pipeline. let mut pipeline = Vec::new(); // Add code to create pipeline stages. // pipeline.push(doc! { ... }); // Run the aggregation and print the results. let mut results = some_coll.aggregate(pipeline).await?; while let Some(result) = results.try_next().await? { println!("{:?}\n", result); } Ok(()) }
Para cada tutorial, se debe reemplazar el marcador de posición de la cadena de conexión con la cadena de conexión de la implementación.
Tip
Para aprender a localizar la cadena de conexión de su implementación, consulte el paso Crear una cadena de conexión de la guía de inicio rápido de Rust.
Por ejemplo, si la cadena de conexión es "mongodb+srv://mongodb-example:27017", la asignación de cadena de conexión se asemeja a lo siguiente:
let uri = "mongodb+srv://mongodb-example:27017";
Crear la colección
Este ejemplo utiliza dos colecciones:
products, que contiene documentos que describen los productos que vende una tiendaorders, que contiene documentos que describen pedidos individuales de productos en una tienda
Una orden sólo puede contener un producto. La agregación utiliza una unión de múltiples campos para emparejar un documento de producto con documentos que representan pedidos de ese producto. La agregación une colecciones por los campos name y variation en los documentos de la colección products, correspondientes a los campos product_name y product_variation en los documentos de la colección orders.
Primero, crea estructuras en Rust para modelar los datos en las colecciónes products y orders:
struct Product { name: String, variation: String, category: String, description: String, } struct Order { customer_id: String, order_date: DateTime, product_name: String, product_variation: String, value: f32, }
Para crear las colecciones products y orders e insertar los datos de muestra, agregue el siguiente código a su aplicación:
let products: Collection<Product> = agg_db.collection("products"); let orders: Collection<Order> = agg_db.collection("orders"); products.delete_many(doc! {}).await?; orders.delete_many(doc! {}).await?; let product_docs = vec![ Product { name: "Asus Laptop".to_string(), variation: "Ultra HD".to_string(), category: "ELECTRONICS".to_string(), description: "Great for watching movies".to_string(), }, Product { name: "Asus Laptop".to_string(), variation: "Standard Display".to_string(), category: "ELECTRONICS".to_string(), description: "Good value laptop for students".to_string(), }, Product { name: "The Day Of The Triffids".to_string(), variation: "1st Edition".to_string(), category: "BOOKS".to_string(), description: "Classic post-apocalyptic novel".to_string(), }, Product { name: "The Day Of The Triffids".to_string(), variation: "2nd Edition".to_string(), category: "BOOKS".to_string(), description: "Classic post-apocalyptic novel".to_string(), }, Product { name: "Morphy Richards Food Mixer".to_string(), variation: "Deluxe".to_string(), category: "KITCHENWARE".to_string(), description: "Luxury mixer turning good cakes into great".to_string(), }, ]; products.insert_many(product_docs).await?; let order_docs = vec![ Order { customer_id: "elise_smith@myemail.com".to_string(), order_date: DateTime::builder().year(2020).month(5).day(30).hour(8).minute(35).second(52).build().unwrap(), product_name: "Asus Laptop".to_string(), product_variation: "Standard Display".to_string(), value: 431.43, }, Order { customer_id: "tj@wheresmyemail.com".to_string(), order_date: DateTime::builder().year(2019).month(5).day(28).hour(19).minute(13).second(32).build().unwrap(), product_name: "The Day Of The Triffids".to_string(), product_variation: "2nd Edition".to_string(), value: 5.01, }, Order { customer_id: "oranieri@warmmail.com".to_string(), order_date: DateTime::builder().year(2020).month(1).day(1).hour(8).minute(25).second(37).build().unwrap(), product_name: "Morphy Richards Food Mixer".to_string(), product_variation: "Deluxe".to_string(), value: 63.13, }, Order { customer_id: "jjones@tepidmail.com".to_string(), order_date: DateTime::builder().year(2020).month(12).day(26).hour(8).minute(55).second(46).build().unwrap(), product_name: "Asus Laptop".to_string(), product_variation: "Standard Display".to_string(), value: 429.65, }, ]; orders.insert_many(order_docs).await?;
Crea la aplicación de plantilla
Antes de comenzar a seguir un tutorial de agregación, debe configurar una nueva aplicación de Scala. Puede usar esta aplicación para conectarse a una implementación de MongoDB, insertar datos de muestra en MongoDB y ejecutar la canalización de agregación.
Tip
Para aprender cómo instalar el controlador y conectarte a MongoDB, consulta la Guía para comenzar con el controlador de Scala.
Para obtener más información sobre cómo realizar agregaciones en el Scala Driver, consulta la Guía de agregación.
Después de instalar el controlador, crea un archivo llamado AggTutorial.scala. Pega el siguiente código en este archivo para crear una plantilla de aplicación para los tutoriales de agregación.
Importante
En el siguiente código, lee los comentarios del código para encontrar las secciones del código que debes modificar para el tutorial que estás siguiendo.
Si intenta ejecutar el código sin hacer ningún cambio, se encontrará con un error de conexión.
package org.example; // Modify imports for each tutorial as needed. import org.mongodb.scala.MongoClient import org.mongodb.scala.bson.Document import org.mongodb.scala.model.{Accumulators, Aggregates, Field, Filters, Variable} import java.text.SimpleDateFormat object FilteredSubset { def main(args: Array[String]): Unit = { // Replace the placeholder with your connection string. val uri = "<connection string>" val mongoClient = MongoClient(uri) Thread.sleep(1000) val aggDB = mongoClient.getDatabase("agg_tutorials_db") // Get a reference to relevant collections. // ... val someColl = aggDB.getCollection("someColl") // ... val anotherColl = aggDB.getCollection("anotherColl") // Delete any existing documents in collections if needed. // ... someColl.deleteMany(Filters.empty()).subscribe(...) // If needed, create the date format template. val dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss") // Insert sample data into the collection or collections. // ... someColl.insertMany(...).subscribe(...) Thread.sleep(1000) // Add code to create pipeline stages within the Seq. // ... val pipeline = Seq(...) // Run the aggregation and print the results. // ... someColl.aggregate(pipeline).subscribe(...) Thread.sleep(1000) mongoClient.close() } }
Para cada tutorial, se debe reemplazar el marcador de posición de la cadena de conexión con la cadena de conexión de la implementación.
Tip
Para aprender a localizar la cadena de conexión de la implementación, se debe consultar el paso Crear una cadena de conexión de la guía de inicio del driver de Scala.
Por ejemplo, si la cadena de conexión es "mongodb+srv://mongodb-example:27017", la asignación de cadena de conexión se asemeja a lo siguiente:
val uri = "mongodb+srv://mongodb-example:27017"
Crear la colección
Este ejemplo utiliza dos colecciones:
products, que contiene documentos que describen los productos que vende una tiendaorders, que contiene documentos que describen pedidos individuales de productos en una tienda
Una orden sólo puede contener un producto. La agregación utiliza una unión de múltiples campos para emparejar un documento de producto con documentos que representan pedidos de ese producto. La agregación une colecciones por los campos name y variation en los documentos de la colección products, correspondientes a los campos product_name y product_variation en los documentos de la colección orders.
Para crear las colecciones products y orders e insertar los datos de muestra, agregue el siguiente código a su aplicación:
val products = aggDB.getCollection("products") val orders = aggDB.getCollection("orders") products.deleteMany(Filters.empty()).subscribe( _ => {}, e => println("Error: " + e.getMessage), ) orders.deleteMany(Filters.empty()).subscribe( _ => {}, e => println("Error: " + e.getMessage), ) val dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss") products.insertMany( Seq( Document( "name" -> "Asus Laptop", "variation" -> "Ultra HD", "category" -> "ELECTRONICS", "description" -> "Great for watching movies" ), Document( "name" -> "Asus Laptop", "variation" -> "Standard Display", "category" -> "ELECTRONICS", "description" -> "Good value laptop for students" ), Document( "name" -> "The Day Of The Triffids", "variation" -> "1st Edition", "category" -> "BOOKS", "description" -> "Classic post-apocalyptic novel" ), Document( "name" -> "The Day Of The Triffids", "variation" -> "2nd Edition", "category" -> "BOOKS", "description" -> "Classic post-apocalyptic novel" ), Document( "name" -> "Morphy Richards Food Mixer", "variation" -> "Deluxe", "category" -> "KITCHENWARE", "description" -> "Luxury mixer turning good cakes into great" ) ) ).subscribe( _ => {}, e => println("Error: " + e.getMessage), ) orders.insertMany( Seq( Document( "customer_id" -> "elise_smith@myemail.com", "orderdate" -> dateFormat.parse("2020-05-30T08:35:52"), "product_name" -> "Asus Laptop", "product_variation" -> "Standard Display", "value" -> 431.43 ), Document( "customer_id" -> "tj@wheresmyemail.com", "orderdate" -> dateFormat.parse("2019-05-28T19:13:32"), "product_name" -> "The Day Of The Triffids", "product_variation" -> "2nd Edition", "value" -> 5.01 ), Document( "customer_id" -> "oranieri@warmmail.com", "orderdate" -> dateFormat.parse("2020-01-01T08:25:37"), "product_name" -> "Morphy Richards Food Mixer", "product_variation" -> "Deluxe", "value" -> 63.13 ), Document( "customer_id" -> "jjones@tepidmail.com", "orderdate" -> dateFormat.parse("2020-12-26T08:55:46"), "product_name" -> "Asus Laptop", "product_variation" -> "Standard Display", "value" -> 429.65 ) ) ).subscribe( _ => {}, e => println("Error: " + e.getMessage), )
Pasos
Los siguientes pasos demuestran cómo crear y ejecutar un pipeline de agregación para unir colecciones en múltiples campos.
Crea un pipeline integrado para usar en la etapa de búsqueda.
La primera etapa del pipeline es una etapa de $lookup para unir la colección orders con la colección products por dos campos en cada colección. La etapa $lookup contiene un pipeline integrado para configurar la unión.
embedded_pl = [ // Stage 1: Match the values of two fields on each side of the join // The $eq filter uses aliases for the name and variation fields set { $match: { $expr: { $and: [ { $eq: ["$product_name", "$$prdname"] }, { $eq: ["$product_variation", "$$prdvartn"] } ] } } }, // Stage 2: Match orders placed in 2020 { $match: { orderdate: { $gte: new Date("2020-01-01T00:00:00Z"), $lt: new Date("2021-01-01T00:00:00Z") } } }, // Stage 3: Remove unneeded fields from the orders collection side of the join { $unset: ["_id", "product_name", "product_variation"] } ]
Ejecute la canalización de agregación.
db.products.aggregate( [ // Use the embedded pipeline in a lookup stage { $lookup: { from: "orders", let: { prdname: "$name", prdvartn: "$variation" }, pipeline: embedded_pl, as: "orders" } }, // Match products ordered in 2020 { $match: { orders: { $ne: [] } } }, // Remove unneeded fields { $unset: ["_id", "description"] } ] )
Interpretar los resultados de la agregación.
Los resultados agregados contienen dos documentos. Los documentos representan productos ordenados 2020. Cada documento contiene un campo arreglo orders que enumera los detalles sobre cada pedido de ese producto.
{ name: 'Asus Laptop', variation: 'Standard Display', category: 'ELECTRONICS', orders: [ { customer_id: 'elise_smith@myemail.com', orderdate: ISODate('2020-05-30T08:35:52.000Z'), value: 431.43 }, { customer_id: 'jjones@tepidmail.com', orderdate: ISODate('2020-12-26T08:55:46.000Z'), value: 429.65 } ] } { name: 'Morphy Richards Food Mixer', variation: 'Deluxe', category: 'KITCHENWARE', orders: [ { customer_id: 'oranieri@warmmail.com', orderdate: ISODate('2020-01-01T08:25:37.000Z'), value: 63.13 } ] }
Agregue una etapa de búsqueda para vincular las colecciones e importar campos.
La primera etapa del pipeline es una etapa $lookup para unir la colección orders a la colección products por dos campos en cada colección. La etapa de búsqueda contiene un pipeline integrado para configurar la unión.
Crea la pipeline incrustada y, a continuación, añade una etapa $match para que se correspondan los valores de dos campos a cada lado de la unión. Tenga en cuenta que el siguiente código utiliza alias para los campos name y variation establecidos al crear la etapa $lookup:
bson_t embedded_pipeline; bson_array_builder_t *bab = bson_array_builder_new(); bson_array_builder_append_document(bab, BCON_NEW( "$match", "{", "$expr", "{", "$and", "[", "{", "$eq", "[", BCON_UTF8("$product_name"), BCON_UTF8("$$prdname"), "]", "}", "{", "$eq", "[", BCON_UTF8("$product_variation"), BCON_UTF8("$$prdvartn"), "]", "}", "]", "}", "}"));
Dentro del pipeline embebido, añade otra etapa $match para igualar los pedidos realizados en 2020:
bson_array_builder_append_document(bab, BCON_NEW( "$match", "{", "orderdate", "{", "$gte", BCON_DATE_TIME(1577836800000UL), "$lt", BCON_DATE_TIME(1609459200000UL), "}", "}"));
Dentro de la pipeline incrustada, añade una etapa $unset para remover los campos innecesarios del lado de la colección orders del join:
bson_array_builder_append_document(bab, BCON_NEW( "$unset", "[", BCON_UTF8("_id"), BCON_UTF8("product_name"), BCON_UTF8("product_variation"), "]")); // Builds the embedded pipeline array and cleans up resources bson_array_builder_build(bab, &embedded_pipeline); bson_array_builder_destroy(bab);
Después de completar la pipeline embebida, añade la etapa $lookup a la pipeline de agregación principal. Configura esta etapa para almacenar los campos de búsqueda procesados en un campo de tipo arreglo llamado orders:
"{", "$lookup", "{", "from", BCON_UTF8("orders"), "let", "{", "prdname", BCON_UTF8("$name"), "prdvartn", BCON_UTF8("$variation"), "}", "pipeline", BCON_ARRAY(&embedded_pipeline), "as", BCON_UTF8("orders"), "}", "}",
Añade una etapa de coinicidencia para los productos pedidos en 2020.
A continuación, añade una etapa $match para mostrar solo los productos para los que hay al menos un pedido en 2020, según el arreglo orders calculado en el paso anterior:
"{", "$match", "{", "orders", "{", "$ne", "[", "]", "}", "}", "}",
Añade una etapa de Remoción para remover campos innecesarios
Finalmente, añade un etapa $unset. La etapa $unset elimina los campos _id y description de los documentos de resultados:
"{", "$unset", "[", BCON_UTF8("_id"), BCON_UTF8("description"), "]", "}",
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 products:
mongoc_cursor_t *results = mongoc_collection_aggregate(products, MONGOC_QUERY_NONE, pipeline, NULL, NULL); bson_destroy(&embedded_pipeline); 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(products); 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.
El resultado agregado contiene dos documentos. Los documentos representan productos para los cuales se realizaron pedidos en 2020. Cada documento contiene un campo de arreglo orders que lista detalles sobre cada pedido de ese producto:
{ "name" : "Asus Laptop", "variation" : "Standard Display", "category" : "ELECTRONICS", "orders" : [ { "customer_id" : "elise_smith@myemail.com", "orderdate" : { "$date" : { "$numberLong" : "1590822952000" } }, "value" : { "$numberDouble" : "431.43000000000000682" } }, { "customer_id" : "jjones@tepidmail.com", "orderdate" : { "$date" : { "$numberLong" : "1608976546000" } }, "value" : { "$numberDouble" : "429.64999999999997726" } } ] } { "name" : "Morphy Richards Food Mixer", "variation" : "Deluxe", "category" : "KITCHENWARE", "orders" : [ { "customer_id" : "oranieri@warmmail.com", "orderdate" : { "$date" : { "$numberLong" : "1577869537000" } }, "value" : { "$numberDouble" : "63.130000000000002558" } } ] }
Los documentos de resultados contienen detalles de los documentos en la colección orders y en la colección products, unidos por los nombres de los productos y las variaciones.
Agregue una etapa de búsqueda para vincular las colecciones e importar campos.
La primera etapa del pipeline es una etapa $lookup para unir la colección orders a la colección products por dos campos en cada colección. La etapa de búsqueda contiene un pipeline integrado para configurar la unión.
Dentro de la pipeline integrada, agregue una etapa $match para hacer coincidir los valores de dos campos en cada lado de la unión. Tenga en cuenta que el siguiente código utiliza alias para los campos name y variation establecidos cuando crea la etapa $lookup:
auto embed_match_stage1 = bsoncxx::from_json(R"({ "$match": { "$expr": { "$and": [ { "$eq": ["$product_name", "$$prdname"] }, { "$eq": ["$product_variation", "$$prdvartn"] } ] } } })");
Dentro del pipeline embebido, añade otra etapa $match para igualar los pedidos realizados en 2020:
auto embed_match_stage2 = bsoncxx::from_json(R"({ "$match": { "orderdate": { "$gte": { "$date": 1577836800000 }, "$lt": { "$date": 1609459200000 } } } })");
Dentro de la pipeline incrustada, añade una etapa $unset para remover los campos innecesarios del lado de la colección orders del join:
auto embed_unset_stage = bsoncxx::from_json(R"({ "$unset": ["_id", "product_name", "product_variation"] })");
Después de completar la pipeline embebida, añade la etapa $lookup a la pipeline de agregación principal. Configura esta etapa para almacenar los campos de búsqueda procesados en un campo de tipo arreglo llamado orders:
pipeline.lookup(make_document( kvp("from", "orders"), kvp("let", make_document( kvp("prdname", "$name"), kvp("prdvartn", "$variation") )), kvp("pipeline", make_array(embed_match_stage1, embed_match_stage2, embed_unset_stage)), kvp("as", "orders") ));
Añade una etapa de coinicidencia para los productos pedidos en 2020.
A continuación, añade una etapa $match para mostrar solo los productos para los que hay al menos un pedido en 2020, según el arreglo orders calculado en el paso anterior:
pipeline.match(bsoncxx::from_json(R"({ "orders": { "$ne": [] } })"));
Añade una etapa de Remoción para remover campos innecesarios
Finalmente, añade un etapa $unset. La etapa $unset elimina los campos _id y description de los documentos de resultados:
pipeline.append_stage(bsoncxx::from_json(R"({ "$unset": ["_id", "description"] })"));
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 products:
auto cursor = products.aggregate(pipeline);
Finalmente, ejecute el siguiente comando en su shell para iniciar su aplicación:
c++ --std=c++17 agg-tutorial.cpp $(pkg-config --cflags --libs libmongocxx) -o ./app.out ./app.out
Interpretar los resultados de la agregación.
El resultado agregado contiene dos documentos. Los documentos representan productos para los cuales se realizaron pedidos en 2020. Cada documento contiene un campo de arreglo orders que lista detalles sobre cada pedido de ese producto:
{ "name" : "Asus Laptop", "variation" : "Standard Display", "category" : "ELECTRONICS", "orders" : [ { "customer_id" : "elise_smith@myemail.com", "orderdate" : { "$date" : "2020-05-30T06:55:52Z" }, "value" : 431.43000000000000682 }, { "customer_id" : "jjones@tepidmail.com", "orderdate" : { "$date" : "2020-12-26T08:55:46Z" }, "value" : 429.64999999999997726 } ] } { "name" : "Morphy Richards Food Mixer", "variation" : "Deluxe", "category" : "KITCHENWARE", "orders" : [ { "customer_id" : "oranieri@warmmail.com", "orderdate" : { "$date" : "2020-01-01T06:45:37Z" }, "value" : 63.130000000000002558 } ] }
Los documentos de resultados contienen detalles de los documentos en la colección orders y en la colección products, unidos por los nombres de los productos y las variaciones.
Agregue una etapa de búsqueda para vincular las colecciones e importar campos.
La primera etapa del pipeline es una etapa $lookup para unir la colección orders a la colección products por dos campos en cada colección. La etapa de búsqueda contiene un pipeline integrado para configurar la unión.
Instancia la pipeline incrustada y luego encadena una etapa $match para hacer coincidir los valores de dos campos a cada lado de la unión. Tenga en cuenta que el siguiente código utiliza alias para los campos Name y Variation establecidos al crear la etapa $lookup:
var embeddedPipeline = new EmptyPipelineDefinition<Order>() .Match(new BsonDocument("$expr", new BsonDocument("$and", new BsonArray { new BsonDocument("$eq", new BsonArray { "$ProductName", "$$prdname" }), new BsonDocument("$eq", new BsonArray { "$ProductVariation", "$$prdvartn" }) })))
Dentro del pipeline embebido, añade otra etapa $match para igualar los pedidos realizados en 2020:
.Match(o => o.OrderDate >= DateTime.Parse("2020-01-01T00:00:00Z") && o.OrderDate < DateTime.Parse("2021-01-01T00:00:00Z"))
Dentro de la pipeline incrustada, añade una etapa $project para remover los campos innecesarios del lado de la colección orders de la unión:
.Project(Builders<Order>.Projection .Exclude(o => o.Id) .Exclude(o => o.ProductName) .Exclude(o => o.ProductVariation));
Después de que se complete el pipeline incrustado, inicia la agregación principal en la colección products y encadena la etapa $lookup. Configura esta etapa para almacenar los campos de búsqueda procesados en un campo de arreglo llamado Orders:
var results = products.Aggregate() .Lookup<Order, BsonDocument, IEnumerable<BsonDocument>, BsonDocument>( foreignCollection: orders, let: new BsonDocument { { "prdname", "$Name" }, { "prdvartn", "$Variation" } }, lookupPipeline: embeddedPipeline, "Orders" )
Añade una etapa de coinicidencia para los productos pedidos en 2020.
Luego, agregue una etapa $match para mostrar solo los productos para los que hay al menos un pedido en 2020, según el arreglo Orders creada en el paso anterior:
.Match(Builders<BsonDocument>.Filter.Ne("Orders", new BsonArray()))
Añade una etapa de proyección para Remover campos innecesarios.
Por último, agregue una etapa de $project. La etapa $project remueve los campos _id y Description de los documentos de resultados:
.Project(Builders<BsonDocument>.Projection .Exclude("_id") .Exclude("Description") );
Ejecutar la agregación e interpretar los resultados.
Por último, se debe ejecutar la aplicación en el IDE e inspeccionar los resultados.
El resultado agregado contiene dos documentos. Los documentos representan productos para los cuales se realizaron pedidos en 2020. Cada documento contiene un campo de arreglo Orders que lista detalles sobre cada pedido de ese producto:
{ "Name" : "Asus Laptop", "Variation" : "Standard Display", "Category" : "ELECTRONICS", "Orders" : [{ "CustomerId" : "elise_smith@myemail.com", "OrderDate" : { "$date" : "2020-05-30T08:35:52Z" }, "Value" : 431.43000000000001 }, { "CustomerId" : "jjones@tepidmail.com", "OrderDate" : { "$date" : "2020-12-26T08:55:46Z" }, "Value" : 429.64999999999998 }] } { "Name" : "Morphy Richards Food Mixer", "Variation" : "Deluxe", "Category" : "KITCHENWARE", "Orders" : [{ "CustomerId" : "oranieri@warmmail.com", "OrderDate" : { "$date" : "2020-01-01T08:25:37Z" }, "Value" : 63.130000000000003 }] }
Los documentos de resultados contienen detalles de los documentos en la colección orders y en la colección products, unidos por los nombres de los productos y las variaciones.
Agregue una etapa de búsqueda para vincular las colecciones e importar campos.
La primera etapa del pipeline es una etapa $lookup para unir la colección orders a la colección products por dos campos en cada colección. La etapa de búsqueda contiene un pipeline integrado para configurar la unión.
Dentro de la pipeline integrada, agregue una etapa $match para hacer coincidir los valores de dos campos en cada lado de la unión. Tenga en cuenta que el siguiente código utiliza alias para los campos name y variation establecidos cuando crea la etapa $lookup:
embeddedMatchStage1 := bson.D{ {Key: "$match", Value: bson.D{ {Key: "$expr", Value: bson.D{ {Key: "$and", Value: bson.A{ bson.D{{Key: "$eq", Value: bson.A{"$product_name", "$$prdname"}}}, bson.D{{Key: "$eq", Value: bson.A{"$product_variation", "$$prdvartn"}}}, }}, }}, }}, }
Dentro del pipeline embebido, añade otra etapa $match para igualar los pedidos realizados en 2020:
embeddedMatchStage2 := 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)}, }}, }}, }
Dentro de la pipeline incrustada, añade una etapa $unset para remover los campos innecesarios del lado de la colección orders del join:
embeddedUnsetStage := bson.D{ {Key: "$unset", Value: bson.A{"_id", "product_name", "product_variation"}}, }
Después de completar la pipeline embebida, añade la etapa $lookup a la pipeline de agregación principal. Configura esta etapa para almacenar los campos de búsqueda procesados en un campo de tipo arreglo llamado orders:
embeddedPipeline := mongo.Pipeline{embeddedMatchStage1, embeddedMatchStage2, embeddedUnsetStage} lookupStage := bson.D{ {Key: "$lookup", Value: bson.D{ {Key: "from", Value: "orders"}, {Key: "let", Value: bson.D{ {Key: "prdname", Value: "$name"}, {Key: "prdvartn", Value: "$variation"}, }}, {Key: "pipeline", Value: embeddedPipeline}, {Key: "as", Value: "orders"}, }}, }
Añade una etapa de coinicidencia para los productos pedidos en 2020.
A continuación, añade una etapa $match para mostrar solo los productos para los que hay al menos un pedido en 2020, según el arreglo orders calculado en el paso anterior:
matchStage := bson.D{ {Key: "$match", Value: bson.D{ {Key: "orders", Value: bson.D{{Key: "$ne", Value: bson.A{}}}}, }}, }
Añade una etapa de Remoción para remover campos innecesarios
Finalmente, añade un etapa $unset. La etapa $unset elimina los campos _id y description de los documentos de resultados:
unsetStage := bson.D{ {Key: "$unset", Value: bson.A{"_id", "description"}}, }
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 products:
pipeline := mongo.Pipeline{lookupStage, matchStage, unsetStage} cursor, err := products.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.
El resultado agregado contiene dos documentos. Los documentos representan productos para los cuales se realizaron pedidos en 2020. Cada documento contiene un campo de arreglo orders que lista detalles sobre cada pedido de ese producto:
{"name":"Asus Laptop","variation":"Standard Display","category":"ELECTRONICS","orders":[{"customer_id":"elise_smith@myemail.com","orderdate":{"$date":"2020-05-30T08:35:52Z"},"value":431.42999267578125},{"customer_id":"jjones@tepidmail.com","orderdate":{"$date":"2020-12-26T08:55:46Z"},"value":429.6499938964844}]} {"name":"Morphy Richards Food Mixer","variation":"Deluxe","category":"KITCHENWARE","orders":[{"customer_id":"oranieri@warmmail.com","orderdate":{"$date":"2020-01-01T08:25:37Z"},"value":63.130001068115234}]}
Los documentos de resultados contienen detalles de los documentos en la colección orders y en la colección products, unidos por los nombres de los productos y las variaciones.
Agregue una etapa de búsqueda para vincular las colecciones e importar campos.
La primera etapa del pipeline es una etapa $lookup para unir la colección orders a la colección products por dos campos en cada colección. La etapa de búsqueda contiene un pipeline integrado para configurar la unión.
Dentro de la pipeline integrada, agregue una etapa $match para hacer coincidir los valores de dos campos en cada lado de la unión. Tenga en cuenta que el siguiente código utiliza alias para los campos name y variation establecidos cuando crea la etapa $lookup:
List<Bson> embeddedPipeline = new ArrayList<>(); embeddedPipeline.add(Aggregates.match( Filters.expr( Filters.and( new Document("$eq", Arrays.asList("$product_name", "$$prdname")), new Document("$eq", Arrays.asList("$product_variation", "$$prdvartn")) ) ) ));
Dentro del pipeline embebido, añade otra etapa $match para igualar los pedidos realizados en 2020:
embeddedPipeline.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")) )));
Dentro de la pipeline incrustada, añade una etapa $unset para remover los campos innecesarios del lado de la colección orders del join:
embeddedPipeline.add(Aggregates.unset("_id", "product_name", "product_variation"));
Después de completar la pipeline embebida, añade la etapa $lookup a la pipeline de agregación principal. Configura esta etapa para almacenar los campos de búsqueda procesados en un campo de tipo arreglo llamado orders:
pipeline.add(Aggregates.lookup( "orders", Arrays.asList( new Variable<>("prdname", "$name"), new Variable<>("prdvartn", "$variation") ), embeddedPipeline, "orders" ));
Añade una etapa de coinicidencia para los productos pedidos en 2020.
A continuación, añade una etapa $match para mostrar solo los productos para los que hay al menos un pedido en 2020, según el arreglo orders calculado en el paso anterior:
pipeline.add(Aggregates.match( Filters.ne("orders", new ArrayList<>()) ));
Añade una etapa de Remoción para remover campos innecesarios
Finalmente, añade un etapa $unset. La etapa $unset elimina los campos _id y description de los documentos de resultados:
pipeline.add(Aggregates.unset("_id", "description"));
Interpretar los resultados de la agregación.
El resultado agregado contiene dos documentos. Los documentos representan productos para los cuales se realizaron pedidos en 2020. Cada documento contiene un campo de arreglo orders que lista detalles sobre cada pedido de ese producto:
{"name": "Asus Laptop", "variation": "Standard Display", "category": "ELECTRONICS", "orders": [{"customer_id": "elise_smith@myemail.com", "orderdate": {"$date": "2020-05-30T08:35:52Z"}, "value": 431.43}, {"customer_id": "jjones@tepidmail.com", "orderdate": {"$date": "2020-12-26T08:55:46Z"}, "value": 429.65}]} {"name": "Morphy Richards Food Mixer", "variation": "Deluxe", "category": "KITCHENWARE", "orders": [{"customer_id": "oranieri@warmmail.com", "orderdate": {"$date": "2020-01-01T08:25:37Z"}, "value": 63.13}]}
Los documentos de resultados contienen detalles de los documentos en la colección orders y en la colección products, unidos por los nombres de los productos y las variaciones.
Agregue una etapa de búsqueda para vincular las colecciones e importar campos.
La primera etapa del pipeline es una etapa $lookup para unir la colección orders a la colección products por dos campos en cada colección. La etapa de búsqueda contiene un pipeline integrado para configurar la unión.
Dentro de la pipeline integrada, agregue una etapa $match para hacer coincidir los valores de dos campos en cada lado de la unión. Tenga en cuenta que el siguiente código utiliza alias para los campos name y variation establecidos cuando crea la etapa $lookup:
val embeddedPipeline = mutableListOf<Bson>() embeddedPipeline.add( Aggregates.match( Filters.expr( Document( "\$and", listOf( Document("\$eq", listOf("\$${Order::productName.name}", "$\$prdname")), Document("\$eq", listOf("\$${Order::productVariation.name}", "$\$prdvartn")) ) ) ) ) )
Dentro del pipeline embebido, añade otra etapa $match para igualar los pedidos realizados en 2020:
embeddedPipeline.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()) ) ) )
Dentro de la pipeline incrustada, añade una etapa $unset para remover los campos innecesarios del lado de la colección orders del join:
embeddedPipeline.add(Aggregates.unset("_id", Order::productName.name, Order::productVariation.name))
Después de completar la pipeline embebida, añade la etapa $lookup a la pipeline de agregación principal. Configura esta etapa para almacenar los campos de búsqueda procesados en un campo de tipo arreglo llamado orders:
pipeline.add( Aggregates.lookup( "orders", listOf( Variable("prdname", "\$${Product::name.name}"), Variable("prdvartn", "\$${Product::variation.name}") ), embeddedPipeline, "orders" ) )
Añade una etapa de coinicidencia para los productos pedidos en 2020.
A continuación, añade una etapa $match para mostrar solo los productos para los que hay al menos un pedido en 2020, según el arreglo orders calculado en el paso anterior:
pipeline.add( Aggregates.match( Filters.ne("orders", mutableListOf<Document>()) ) )
Añade una etapa de Remoción para remover campos innecesarios
Finalmente, añade un etapa $unset. La etapa $unset elimina los campos _id y description de los documentos de resultados:
pipeline.add(Aggregates.unset("_id", "description"))
Interpretar los resultados de la agregación.
El resultado agregado contiene dos documentos. Los documentos representan productos para los cuales se realizaron pedidos en 2020. Cada documento contiene un campo de arreglo orders que lista detalles sobre cada pedido de ese producto:
Document{{name=Asus Laptop, variation=Standard Display, category=ELECTRONICS, orders=[Document{{customerID=elise_smith@myemail.com, orderDate=Sat May 30 04:35:52 EDT 2020, value=431.43}}, Document{{customerID=jjones@tepidmail.com, orderDate=Sat Dec 26 03:55:46 EST 2020, value=429.65}}]}} Document{{name=Morphy Richards Food Mixer, variation=Deluxe, category=KITCHENWARE, orders=[Document{{customerID=oranieri@warmmail.com, orderDate=Wed Jan 01 03:25:37 EST 2020, value=63.13}}]}}
Los documentos de resultados contienen detalles de los documentos en la colección orders y en la colección products, unidos por los nombres de los productos y las variaciones.
Agregue una etapa de búsqueda para vincular las colecciones e importar campos.
La primera etapa del pipeline es una etapa $lookup para unir la colección orders a la colección products por dos campos en cada colección. La etapa de búsqueda contiene un pipeline integrado para configurar la unión.
Dentro de la pipeline integrada, agregue una etapa $match para hacer coincidir los valores de dos campos en cada lado de la unión. Tenga en cuenta que el siguiente código utiliza alias para los campos name y variation establecidos cuando crea la etapa $lookup:
const embedded_pl = []; embedded_pl.push({ $match: { $expr: { $and: [ { $eq: ['$product_name', '$$prdname'] }, { $eq: ['$product_variation', '$$prdvartn'] }, ], }, }, });
Dentro del pipeline embebido, añade otra etapa $match para igualar los pedidos realizados en 2020:
embedded_pl.push({ $match: { orderdate: { $gte: new Date('2020-01-01T00:00:00Z'), $lt: new Date('2021-01-01T00:00:00Z'), }, }, });
Dentro de la pipeline incrustada, añade una etapa $unset para remover los campos innecesarios del lado de la colección orders del join:
embedded_pl.push({ $unset: ['_id', 'product_name', 'product_variation'], });
Después de completar la pipeline embebida, añade la etapa $lookup a la pipeline de agregación principal. Configura esta etapa para almacenar los campos de búsqueda procesados en un campo de tipo arreglo llamado orders:
pipeline.push({ $lookup: { from: 'orders', let: { prdname: '$name', prdvartn: '$variation', }, pipeline: embedded_pl, as: 'orders', }, });
Añade una etapa de coinicidencia para los productos pedidos en 2020.
A continuación, añade una etapa $match para mostrar solo los productos para los que hay al menos un pedido en 2020, según el arreglo orders calculado en el paso anterior:
pipeline.push({ $match: { orders: { $ne: [] }, }, });
Añade una etapa de Remoción para remover campos innecesarios
Finalmente, añade un etapa $unset. La etapa $unset elimina los campos _id y description de los documentos de resultados:
pipeline.push({ $unset: ['_id', 'description'], });
Interpretar los resultados de la agregación.
El resultado agregado contiene dos documentos. Los documentos representan productos para los cuales se realizaron pedidos en 2020. Cada documento contiene un campo de arreglo orders que lista detalles sobre cada pedido de ese producto:
{ name: 'Asus Laptop', variation: 'Standard Display', category: 'ELECTRONICS', orders: [ { customer_id: 'elise_smith@myemail.com', orderdate: 2020-05-30T08:35:52.000Z, value: 431.43 }, { customer_id: 'jjones@tepidmail.com', orderdate: 2020-12-26T08:55:46.000Z, value: 429.65 } ] } { name: 'Morphy Richards Food Mixer', variation: 'Deluxe', category: 'KITCHENWARE', orders: [ { customer_id: 'oranieri@warmmail.com', orderdate: 2020-01-01T08:25:37.000Z, value: 63.13 } ] }
Los documentos de resultados contienen detalles de los documentos en la colección orders y en la colección products, unidos por los nombres de los productos y las variaciones.
Agregue una etapa de búsqueda para vincular las colecciones e importar campos.
La primera etapa del pipeline es una etapa $lookup para unir la colección orders a la colección products por dos campos en cada colección. La etapa de búsqueda contiene una pipeline incorporada para configurar la unión. Primero, crea la pipeline incrustada:
$embeddedPipeline = new Pipeline( // Add stages within embedded pipeline. };
Dentro de la pipeline integrada, agregue una etapa $match para hacer coincidir los valores de dos campos en cada lado de la unión. Tenga en cuenta que el siguiente código utiliza alias para los campos name y variation establecidos cuando crea la etapa $lookup:
Stage::match( Query::expr( Expression::and( Expression::eq( Expression::stringFieldPath('product_name'), Expression::variable('prdname') ), Expression::eq( Expression::stringFieldPath('product_variation'), Expression::variable('prdvartn') ), ) ) ),
Dentro del pipeline embebido, añade otra etapa $match para igualar 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'))), ] ),
Dentro de la pipeline incrustada, añade una etapa $unset para remover los campos innecesarios del lado de la colección orders del join:
Stage::unset('_id', 'product_name', 'product_variation')
A continuación, fuera de tus instancias Pipeline, crea la etapa $lookup en una función de fábrica. Configura esta etapa para almacenar los campos de búsqueda procesados en un campo arreglo llamado orders:
function lookupOrdersStage(Pipeline $embeddedPipeline) { return Stage::lookup( from: 'orders', let: object( prdname: Expression::stringFieldPath('name'), prdvartn: Expression::stringFieldPath('variation'), ), pipeline: $embeddedPipeline, as: 'orders', ); }
Luego, en tu instancia principal de Pipeline, llama a la función lookupOrdersStage():
lookupOrdersStage($embeddedPipeline),
Añade una etapa de coinicidencia para los productos pedidos en 2020.
A continuación, añade una etapa $match para mostrar solo los productos para los que hay al menos un pedido en 2020, según el arreglo orders calculado en el paso anterior:
Stage::match( orders: Query::ne([]) ),
Añade una etapa de Remoción para remover campos innecesarios
Finalmente, añade un etapa $unset. La etapa $unset elimina los campos _id y description de los documentos de resultados:
Stage::unset('_id', 'description')
Interpretar los resultados de la agregación.
El resultado agregado contiene dos documentos. Los documentos representan productos para los cuales se realizaron pedidos en 2020. Cada documento contiene un campo de arreglo orders que lista detalles sobre cada pedido de ese producto:
{ "name": "Asus Laptop", "variation": "Standard Display", "category": "ELECTRONICS", "orders": [ { "customer_id": "elise_smith@myemail.com", "orderdate": { "$date": { "$numberLong": "1590827752000" } }, "value": 431.43 }, { "customer_id": "jjones@tepidmail.com", "orderdate": { "$date": { "$numberLong": "1608972946000" } }, "value": 429.65 } ] } { "name": "Morphy Richards Food Mixer", "variation": "Deluxe", "category": "KITCHENWARE", "orders": [ { "customer_id": "oranieri@warmmail.com", "orderdate": { "$date": { "$numberLong": "1577867137000" } }, "value": 63.13 } ] }
Los documentos de resultados contienen detalles de los documentos en la colección orders y en la colección products, unidos por los nombres de los productos y las variaciones.
Agregue una etapa de búsqueda para vincular las colecciones e importar campos.
La primera etapa del pipeline es una etapa $lookup para unir la colección orders a la colección products por dos campos en cada colección. La etapa de búsqueda contiene un pipeline integrado para configurar la unión.
Dentro de la pipeline integrada, agregue una etapa $match para hacer coincidir los valores de dos campos en cada lado de la unión. Tenga en cuenta que el siguiente código utiliza alias para los campos name y variation establecidos cuando crea la etapa $lookup:
embedded_pl = [ { "$match": { "$expr": { "$and": [ {"$eq": ["$product_name", "$$prdname"]}, {"$eq": ["$product_variation", "$$prdvartn"]}, ] } } } ]
Dentro del pipeline embebido, añade otra etapa $match para igualar los pedidos realizados en 2020:
embedded_pl.append( { "$match": { "orderdate": { "$gte": datetime(2020, 1, 1, 0, 0, 0), "$lt": datetime(2021, 1, 1, 0, 0, 0), } } } )
Dentro de la pipeline incrustada, añade una etapa $unset para remover los campos innecesarios del lado de la colección orders del join:
embedded_pl.append({"$unset": ["_id", "product_name", "product_variation"]})
Después de completar la pipeline embebida, añade la etapa $lookup a la pipeline de agregación principal. Configura esta etapa para almacenar los campos de búsqueda procesados en un campo de tipo arreglo llamado orders:
pipeline.append( { "$lookup": { "from": "orders", "let": {"prdname": "$name", "prdvartn": "$variation"}, "pipeline": embedded_pl, "as": "orders", } } )
Añade una etapa de coinicidencia para los productos pedidos en 2020.
A continuación, añade una etapa $match para mostrar solo los productos para los que hay al menos un pedido en 2020, según el arreglo orders calculado en el paso anterior:
pipeline.append({"$match": {"orders": {"$ne": []}}})
Añade una etapa de Remoción para remover campos innecesarios
Finalmente, añade un etapa $unset. La etapa $unset elimina los campos _id y description de los documentos de resultados:
pipeline.append({"$unset": ["_id", "description"]})
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 products:
aggregation_result = products_coll.aggregate(pipeline)
Finalmente, ejecute el siguiente comando en su shell para iniciar su aplicación:
python3 agg_tutorial.py
Interpretar los resultados de la agregación.
El resultado agregado contiene dos documentos. Los documentos representan productos para los cuales se realizaron pedidos en 2020. Cada documento contiene un campo de arreglo orders que lista detalles sobre cada pedido de ese producto:
{'name': 'Asus Laptop', 'variation': 'Standard Display', 'category': 'ELECTRONICS', 'orders': [{'customer_id': 'elise_smith@myemail.com', 'orderdate': datetime.datetime(2020, 5, 30, 8, 35, 52), 'value': 431.43}, {'customer_id': 'jjones@tepidmail.com', 'orderdate': datetime.datetime(2020, 12, 26, 8, 55, 46), 'value': 429.65}]} {'name': 'Morphy Richards Food Mixer', 'variation': 'Deluxe', 'category': 'KITCHENWARE', 'orders': [{'customer_id': 'oranieri@warmmail.com', 'orderdate': datetime.datetime(2020, 1, 1, 8, 25, 37), 'value': 63.13}]}
Los documentos de resultados contienen detalles de los documentos en la colección orders y en la colección products, unidos por los nombres de los productos y las variaciones.
Agregue una etapa de búsqueda para vincular las colecciones e importar campos.
La primera etapa del pipeline es una etapa $lookup para unir la colección orders a la colección products por dos campos en cada colección. La etapa de búsqueda contiene un pipeline integrado para configurar la unión.
Dentro de la pipeline integrada, agregue una etapa $match para hacer coincidir los valores de dos campos en cada lado de la unión. Tenga en cuenta que el siguiente código utiliza alias para los campos name y variation establecidos cuando crea la etapa $lookup:
{ "$match": { "$expr": { "$and": [ { "$eq": ["$product_name", "$$prdname"] }, { "$eq": ["$product_variation", "$$prdvartn"] }, ], }, }, },
Dentro del pipeline embebido, añade otra etapa $match para igualar los pedidos realizados en 2020:
{ "$match": { orderdate: { "$gte": DateTime.parse("2020-01-01T00:00:00Z"), "$lt": DateTime.parse("2021-01-01T00:00:00Z"), }, }, },
Dentro de la pipeline incrustada, añade una etapa $unset para remover los campos innecesarios del lado de la colección orders del join:
{ "$unset": ["_id", "product_name", "product_variation"], },
Después de completar la pipeline embebida, añade la etapa $lookup a la pipeline de agregación principal. Configura esta etapa para almacenar los campos de búsqueda procesados en un campo de tipo arreglo llamado orders:
{ "$lookup": { from: "orders", let: { prdname: "$name", prdvartn: "$variation", }, pipeline: embedded_pipeline, as: "orders", }, },
Añade una etapa de coinicidencia para los productos pedidos en 2020.
A continuación, añade una etapa $match para mostrar solo los productos para los que hay al menos un pedido en 2020, según el arreglo orders calculado en el paso anterior:
{ "$match": { orders: { "$ne": [] }, }, },
Añade una etapa de Remoción para remover campos innecesarios
Finalmente, añade un etapa $unset. La etapa $unset elimina los campos _id y description de los documentos de resultados:
{ "$unset": ["_id", "description"], },
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 products:
aggregation_result = products.aggregate(pipeline)
Finalmente, ejecute el siguiente comando en su shell para iniciar su aplicación:
ruby agg_tutorial.rb
Interpretar los resultados de la agregación.
El resultado agregado contiene dos documentos. Los documentos representan productos para los cuales se realizaron pedidos en 2020. Cada documento contiene un campo de arreglo orders que lista detalles sobre cada pedido de ese producto:
{"name"=>"Asus Laptop", "variation"=>"Standard Display", "category"=>"ELECTRONICS", "orders"=>[{"customer_id"=>"elise_smith@myemail.com", "orderdate"=>2020-05-30 08:35:52 UTC, "value"=>431.43}, {"customer_id"=>"jjones@tepidmail.com", "orderdate"=>2020-12-26 08:55:46 UTC, "value"=>429.65}]} {"name"=>"Morphy Richards Food Mixer", "variation"=>"Deluxe", "category"=>"KITCHENWARE", "orders"=>[{"customer_id"=>"oranieri@warmmail.com", "orderdate"=>2020-01-01 08:25:37 UTC, "value"=>63.13}]}
Los documentos de resultados contienen detalles de los documentos en la colección orders y en la colección products, unidos por los nombres de los productos y las variaciones.
Agregue una etapa de búsqueda para vincular las colecciones e importar campos.
La primera etapa del pipeline es una etapa $lookup para unir la colección orders a la colección products por dos campos en cada colección. La etapa de búsqueda contiene un pipeline integrado para configurar la unión.
Dentro de la pipeline integrada, agregue una etapa $match para hacer coincidir los valores de dos campos en cada lado de la unión. Tenga en cuenta que el siguiente código utiliza alias para los campos name y variation establecidos cuando crea la etapa $lookup:
let mut embedded_pipeline = Vec::new(); embedded_pipeline.push(doc! { "$match": { "$expr": { "$and": [ { "$eq": ["$product_name", "$$prdname"] }, { "$eq": ["$product_variation", "$$prdvartn"] } ] } } });
Dentro del pipeline embebido, añade otra etapa $match para igualar los pedidos realizados en 2020:
embedded_pipeline.push(doc! { "$match": { "order_date": { "$gte": DateTime::builder().year(2020).month(1).day(1).build().unwrap(), "$lt": DateTime::builder().year(2021).month(1).day(1).build().unwrap() } } });
Dentro de la pipeline incrustada, añade una etapa $unset para remover los campos innecesarios del lado de la colección orders del join:
embedded_pipeline.push(doc! { "$unset": ["_id", "product_name", "product_variation"] });
Después de completar la pipeline embebida, añade la etapa $lookup a la pipeline de agregación principal. Configura esta etapa para almacenar los campos de búsqueda procesados en un campo de tipo arreglo llamado orders:
pipeline.push(doc! { "$lookup": { "from": "orders", "let": { "prdname": "$name", "prdvartn": "$variation" }, "pipeline": embedded_pipeline, "as": "orders" } });
Añade una etapa de coinicidencia para los productos pedidos en 2020.
A continuación, añade una etapa $match para mostrar solo los productos para los que hay al menos un pedido en 2020, según el arreglo orders calculado en el paso anterior:
pipeline.push(doc! { "$match": { "orders": { "$ne": [] } } });
Añade una etapa de Remoción para remover campos innecesarios
Finalmente, añade un etapa $unset. La etapa $unset elimina los campos _id y description de los documentos de resultados:
pipeline.push(doc! { "$unset": ["_id", "description"] });
Interpretar los resultados de la agregación.
El resultado agregado contiene dos documentos. Los documentos representan productos para los cuales se realizaron pedidos en 2020. Cada documento contiene un campo de arreglo orders que lista detalles sobre cada pedido de ese producto:
Document({"name": String("Asus Laptop"), "variation": String("Standard Display"), "category": String("ELECTRONICS"), "orders": Array([Document({"customer_id": String("elise_smith@myemail.com"), "order_date": DateTime(2020-05-30 8:35:52.0 +00:00:00), "value": Double(431.42999267578125)}), Document({"customer_id": String("jjones@tepidmail.com"), "order_date": DateTime(2020-12-26 8:55:46.0 +00:00:00), "value": Double(429.6499938964844)})])}) Document({"name": String("Morphy Richards Food Mixer"), "variation": String("Deluxe"), "category": String("KITCHENWARE"), "orders": Array([Document({"customer_id": String("oranieri@warmmail.com"), "order_date": DateTime(2020-01-01 8:25:37.0 +00:00:00), "value": Double(63.130001068115234)})])})
Los documentos de resultados contienen detalles de los documentos en la colección orders y en la colección products, unidos por los nombres de los productos y las variaciones.
Agregue una etapa de búsqueda para vincular las colecciones e importar campos.
La primera etapa del pipeline es una etapa $lookup para unir la colección orders a la colección products por dos campos en cada colección. La etapa de búsqueda contiene un pipeline integrado para configurar la unión.
Dentro de la pipeline integrada, agregue una etapa $match para hacer coincidir los valores de dos campos en cada lado de la unión. Tenga en cuenta que el siguiente código utiliza alias para los campos name y variation establecidos cuando crea la etapa $lookup:
Aggregates.filter( Filters.expr( Filters.and( Document("$eq" -> Seq("$product_name", "$$prdname")), Document("$eq" -> Seq("$product_variation", "$$prdvartn")) ) ) ),
Dentro del pipeline embebido, añade otra etapa $match para igualar 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")) ) ),
Dentro de la pipeline incrustada, añade una etapa $unset para remover los campos innecesarios del lado de la colección orders del join:
Aggregates.unset("_id", "product_name", "product_variation"),
Después de completar la pipeline embebida, añade la etapa $lookup a la pipeline de agregación principal. Configura esta etapa para almacenar los campos de búsqueda procesados en un campo de tipo arreglo llamado orders:
Aggregates.lookup( "orders", Seq( Variable("prdname", "$name"), Variable("prdvartn", "$variation"), ), embeddedPipeline, "orders" ),
Añade una etapa de coinicidencia para los productos pedidos en 2020.
A continuación, añade una etapa $match para mostrar solo los productos para los que hay al menos un pedido en 2020, según el arreglo orders calculado en el paso anterior:
Aggregates.filter(Filters.ne("orders", Seq())),
Añade una etapa de Remoción para remover campos innecesarios
Finalmente, añade un etapa $unset. La etapa $unset elimina los campos _id y description de los documentos de resultados:
Aggregates.unset("_id", "description")
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 products:
products.aggregate(pipeline) .subscribe( (doc: Document) => println(doc.toJson()), (e: Throwable) => println(s"Error: $e"), )
Finalmente, ejecute la aplicación en su IDE.
Interpretar los resultados de la agregación.
El resultado agregado contiene dos documentos. Los documentos representan productos para los cuales se realizaron pedidos en 2020. Cada documento contiene un campo de arreglo orders que lista detalles sobre cada pedido de ese producto:
{"name": "Asus Laptop", "variation": "Standard Display", "category": "ELECTRONICS", "orders": [{"customer_id": "elise_smith@myemail.com", "orderdate": {"$date": "2020-05-30T12:35:52Z"}, "value": 431.43}, {"customer_id": "jjones@tepidmail.com", "orderdate": {"$date": "2020-12-26T13:55:46Z"}, "value": 429.65}]} {"name": "Morphy Richards Food Mixer", "variation": "Deluxe", "category": "KITCHENWARE", "orders": [{"customer_id": "oranieri@warmmail.com", "orderdate": {"$date": "2020-01-01T13:25:37Z"}, "value": 63.13}]}
Los documentos de resultados contienen detalles de los documentos en la colección orders y en la colección products, unidos por los nombres de los productos y las variaciones.