本教程说明了如何构建聚合管道、对集合执行聚合以及使用您选择的语言显示结果。
关于此任务
本教程演示如何从客户订单数据中创建见解。结果显示了费用超过 15 美元的订购产品列表。每个文档都包含每种产品的销售单位数和总销售价值。
聚合管道执行以下操作：
将数组字段展开到单独的文档中
根据字段值匹配文档子集
按公共字段值对文档进行分组
将计算字段添加到每个结果文档
开始之前
➤ 使用右上角的 Select your 语言）下拉菜单设立以下示例的语言，或选择MongoDB Shell。
此示例使用 orders集合，其中包含描述产品订单的文档。由于每个订单都包含多个产品，因此聚合的第一步是将产品大量解包为单个产品订单文档。
要创建orders 集合，请使用insertMany() 方法：
db.orders.deleteMany({}) db.orders.insertMany( [ { order_id: 6363763262239, products: [ { prod_id: "abc12345", name: "Asus Laptop", price: 431 }, { prod_id: "def45678", name: "Karcher Hose Set", price: 22 } ] }, { order_id: 1197372932325, products: [ { prod_id: "abc12345", name: "Asus Laptop", price: 429 } ] }, { order_id: 9812343774839, products: [ { prod_id: "pqr88223", name: "Morphy Richards Food Mixer", price: 431 }, { prod_id: "def45678", name: "Karcher Hose Set", price: 21 } ] }, { order_id: 4433997244387, products: [ { prod_id: "def45678", name: "Karcher Hose Set", price: 23 }, { prod_id: "jkl77336", name: "Picky Pencil Sharpener", price: 1 }, { prod_id: "xyz11228", name: "Russell Hobbs Chrome Kettle", price: 16 } ] } ] )
创建模板应用
在开始学习本聚合教程之前，您必须设立一个新的C应用。您可以使用此应用连接到MongoDB 部署，将示例数据插入MongoDB，然后运行聚合管道。
提示
要学习；了解如何安装驾驶员和连接到MongoDB，请参阅 C驱动程序入门指南。
安装驾驶员后，创建一个名为 agg-tutorial.c 的文件。将以下代码粘贴到此文件中，为聚合教程创建应用模板。
重要
在以下代码中，阅读代码注释，找到在您关注的教程中必须修改的代码部分。
如果您尝试在不进行任何更改的情况下运行代码，则会遇到连接错误。
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; }
对于每个教程，您必须用部署的连接字符串替换连接字符串占位符。
例如，如果连接字符串为 "mongodb+srv://mongodb-example:27017"，则其赋值应如下所示：
char *uri = "mongodb+srv://mongodb-example:27017";
创建集合
此示例使用 orders集合，其中包含描述产品订单的文档。由于每个订单都包含多个产品，因此聚合的第一步是将产品大量解包为单个产品订单文档。
要创建 orders集合并插入示例数据，请将以下代码添加到您的应用程序中：
mongoc_collection_t *orders = mongoc_client_get_collection(client, "agg_tutorials_db", "orders"); { bson_t *filter = bson_new(); bson_error_t error; if (!mongoc_collection_delete_many(orders, filter, NULL, NULL, &error)) { fprintf(stderr, "Delete error: %s\n", error.message); } bson_destroy(filter); } { size_t num_docs = 4; bson_t *docs[num_docs]; docs[0] = BCON_NEW( "order_id", BCON_INT64(6363763262239), "products", "[", "{", "prod_id", BCON_UTF8("abc12345"), "name", BCON_UTF8("Asus Laptop"), "price", BCON_INT32(431), "}", "{", "prod_id", BCON_UTF8("def45678"), "name", BCON_UTF8("Karcher Hose Set"), "price", BCON_INT32(22), "}", "]"); docs[1] = BCON_NEW( "order_id", BCON_INT64(1197372932325), "products", "[", "{", "prod_id", BCON_UTF8("abc12345"), "name", BCON_UTF8("Asus Laptop"), "price", BCON_INT32(429), "}", "]"); docs[2] = BCON_NEW( "order_id", BCON_INT64(9812343774839), "products", "[", "{", "prod_id", BCON_UTF8("pqr88223"), "name", BCON_UTF8("Morphy Richards Food Mixer"), "price", BCON_INT32(431), "}", "{", "prod_id", BCON_UTF8("def45678"), "name", BCON_UTF8("Karcher Hose Set"), "price", BCON_INT32(21), "}", "]"); docs[3] = BCON_NEW( "order_id", BCON_INT64(4433997244387), "products", "[", "{", "prod_id", BCON_UTF8("def45678"), "name", BCON_UTF8("Karcher Hose Set"), "price", BCON_INT32(23), "}", "{", "prod_id", BCON_UTF8("jkl77336"), "name", BCON_UTF8("Picky Pencil Sharpener"), "price", BCON_INT32(1), "}", "{", "prod_id", BCON_UTF8("xyz11228"), "name", BCON_UTF8("Russell Hobbs Chrome Kettle"), "price", BCON_INT32(16), "}", "]"); bson_error_t error; if (!mongoc_collection_insert_many(orders, (const bson_t **)docs, num_docs, NULL, NULL, &error)) { fprintf(stderr, "Insert error: %s\n", error.message); } for (int i = 0; i < num_docs; i++) { bson_destroy(docs[i]); } }
创建模板应用
在开始学习聚合教程之前，您必须设立一个新的C++应用。您可以使用此应用连接到MongoDB 部署，将示例数据插入MongoDB，然后运行聚合管道。
提示
要学习；了解如何安装驾驶员并连接到MongoDB，请参阅C++入门教程。
安装驾驶员后，创建一个名为 agg-tutorial.cpp 的文件。将以下代码粘贴到此文件中，为聚合教程创建应用模板。
重要
在以下代码中，阅读代码注释，找到在您关注的教程中必须修改的代码部分。
如果您尝试在不进行任何更改的情况下运行代码，则会遇到连接错误。
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; } }
对于每个教程，您必须用部署的连接字符串替换连接字符串占位符。
例如，如果连接字符串为 "mongodb+srv://mongodb-example:27017"，则其赋值应如下所示：
mongocxx::uri uri{"mongodb+srv://mongodb-example:27017"};
创建集合
此示例使用 orders集合，其中包含描述产品订单的文档。由于每个订单都包含多个产品，因此聚合的第一步是将产品大量解包为单个产品订单文档。
要创建 orders集合并插入示例数据，请将以下代码添加到您的应用程序中：
auto orders = db["orders"]; std::vector<bsoncxx::document::value> order_docs = { bsoncxx::from_json(R"({ "order_id": 6363763262239, "products": [ { "prod_id": "abc12345", "name": "Asus Laptop", "price": 431 }, { "prod_id": "def45678", "name": "Karcher Hose Set", "price": 22 } ] })"), bsoncxx::from_json(R"({ "order_id": 1197372932325, "products": [ { "prod_id": "abc12345", "name": "Asus Laptop", "price": 429 } ] })"), bsoncxx::from_json(R"({ "order_id": 9812343774839, "products": [ { "prod_id": "pqr88223", "name": "Morphy Richards Food Mixer", "price": 431 }, { "prod_id": "def45678", "name": "Karcher Hose Set", "price": 21 } ] })"), bsoncxx::from_json(R"({ "order_id": 4433997244387, "products": [ { "prod_id": "def45678", "name": "Karcher Hose Set", "price": 23 }, { "prod_id": "jkl77336", "name": "Picky Pencil Sharpener", "price": 1 }, { "prod_id": "xyz11228", "name": "Russell Hobbs Chrome Kettle", "price": 16 } ] })") }; orders.insert_many(order_docs); // Might throw an exception
创建模板应用
在开始学习此聚合教程之前，必须设立一个新的C#/ .NET应用。您可以使用此应用连接到MongoDB 部署，将示例数据插入MongoDB，然后运行聚合管道。
提示
要学习；了解如何安装驾驶员和连接到MongoDB，请参阅C#/. .NET驱动程序快速入门指南。
安装驾驶员后，将以下代码粘贴到 Program.cs文件中，为聚合教程创建应用模板。
重要
在以下代码中，阅读代码注释，找到在您关注的教程中必须修改的代码部分。
如果您尝试在不进行任何更改的情况下运行代码，则会遇到连接错误。
using MongoDB.Driver; using MongoDB.Bson; using MongoDB.Bson.Serialization.Attributes; // Define data model classes. // ... public class MyClass { ... } // Replace the placeholder with your connection string. var uri = "<connection string>"; var client = new MongoClient(uri); var aggDB = client.GetDatabase("agg_tutorials_db"); // Get a reference to relevant collections. // ... var someColl = aggDB.GetCollection<MyClass>("someColl"); // ... var anotherColl = aggDB.GetCollection<MyClass>("anotherColl"); // Delete any existing documents in collections if needed. // ... someColl.DeleteMany(Builders<MyClass>.Filter.Empty); // Insert sample data into the collection or collections. // ... someColl.InsertMany(new List<MyClass> { ... }); // Add code to chain pipeline stages to the Aggregate() method. // ... var results = someColl.Aggregate().Match(...); // Print the aggregation results. foreach (var result in results.ToList()) { Console.WriteLine(result); }
对于每个教程，您必须用部署的连接字符串替换连接字符串占位符。
例如，如果连接字符串为 "mongodb+srv://mongodb-example:27017"，则其赋值应如下所示：
var uri = "mongodb+srv://mongodb-example:27017";
创建集合
此示例使用 orders集合，其中包含描述产品订单的文档。由于每个订单都包含多个产品，因此聚合的第一步是将产品大量解包为单个产品订单文档。
首先，创建C#类来对 orders集合中的数据进行建模：
public class Order { [] public ObjectId Id { get; set; } public long OrderId { get; set; } public List<Product> Products { get; set; } } public class OrderUnwound { public long OrderId { get; set; } public Product Products { get; set; } } public class Product { public string ProductId { get; set; } public string Name { get; set; } public int Price { get; set; } }
要创建 orders集合并插入示例数据，请将以下代码添加到您的应用程序中：
var orders = aggDB.GetCollection<Order>("orders"); orders.DeleteMany(Builders<Order>.Filter.Empty); orders.InsertMany(new List<Order> { new Order { OrderId = 6363763262239L, Products = new List<Product> { new Product { ProductId = "abc12345", Name = "Asus Laptop", Price = 431 }, new Product { ProductId = "def45678", Name = "Karcher Hose Set", Price = 22 } } }, new Order { OrderId = 1197372932325L, Products = new List<Product> { new Product { ProductId = "abc12345", Name = "Asus Laptop", Price = 429 } } }, new Order { OrderId = 9812343774839L, Products = new List<Product> { new Product { ProductId = "pqr88223", Name = "Morphy Richards Food Mixer", Price = 431 }, new Product { ProductId = "def45678", Name = "Karcher Hose Set", Price = 21 } } }, new Order { OrderId = 4433997244387L, Products = new List<Product> { new Product { ProductId = "def45678", Name = "Karcher Hose Set", Price = 23 }, new Product { ProductId = "jkl77336", Name = "Picky Pencil Sharpener", Price = 1 }, new Product { ProductId = "xyz11228", Name = "Russell Hobbs Chrome Kettle", Price = 16 } } } });
创建模板应用
在开始学习此聚合教程之前，您必须设立一个新的Go应用。您可以使用此应用连接到MongoDB 部署，将示例数据插入MongoDB，然后运行聚合管道。
安装驾驶员后，创建一个名为 agg_tutorial.go 的文件。将以下代码粘贴到此文件中，为聚合教程创建应用模板。
重要
在以下代码中，阅读代码注释，找到在您关注的教程中必须修改的代码部分。
如果您尝试在不进行任何更改的情况下运行代码，则会遇到连接错误。
package main import ( "context" "fmt" "log" "time" "go.mongodb.org/mongo-driver/v2/bson" "go.mongodb.org/mongo-driver/v2/mongo" "go.mongodb.org/mongo-driver/v2/mongo/options" ) // Define structs. // type MyStruct struct { ... } func main() { // Replace the placeholder with your connection string. const uri = "<connection string>" client, err := mongo.Connect(options.Client().ApplyURI(uri)) if err != nil { log.Fatal(err) } defer func() { if err = client.Disconnect(context.TODO()); err != nil { log.Fatal(err) } }() aggDB := client.Database("agg_tutorials_db") // Get a reference to relevant collections. // ... someColl := aggDB.Collection("...") // ... anotherColl := aggDB.Collection("...") // Delete any existing documents in collections if needed. // ... someColl.DeleteMany(context.TODO(), bson.D{}) // Insert sample data into the collection or collections. // ... _, err = someColl.InsertMany(...) // Add code to create pipeline stages. // ... myStage := bson.D{{...}} // Create a pipeline that includes the stages. // ... pipeline := mongo.Pipeline{...} // Run the aggregation. // ... cursor, err := someColl.Aggregate(context.TODO(), pipeline) if err != nil { log.Fatal(err) } defer func() { if err := cursor.Close(context.TODO()); err != nil { log.Fatalf("failed to close cursor: %v", err) } }() // Decode the aggregation results. var results []bson.D if err = cursor.All(context.TODO(), &results); err != nil { log.Fatalf("failed to decode results: %v", err) } // Print the aggregation results. for _, result := range results { res, _ := bson.MarshalExtJSON(result, false, false) fmt.Println(string(res)) } }
对于每个教程，您必须用部署的连接字符串替换连接字符串占位符。
例如，如果连接字符串为 "mongodb+srv://mongodb-example:27017"，则其赋值应如下所示：
const uri = "mongodb+srv://mongodb-example:27017";
创建集合
此示例使用 orders集合，其中包含描述产品订单的文档。由于每个订单都包含多个产品，因此聚合的第一步是将产品大量解包为单个产品订单文档。
首先，创建Go结构体以对 orders集合中的数据进行建模：
type Order struct { OrderID int `bson:"order_id"` Products []Product `bson:"products"` } type Product struct { ProductID string `bson:"prod_id"` Name string `bson:"name"` Price int `bson:"price"` }
要创建 orders集合并插入示例数据，请将以下代码添加到您的应用程序中：
orders := aggDB.Collection("orders") orders.DeleteMany(context.TODO(), bson.D{}) _, err = orders.InsertMany(context.TODO(), []interface{}{ Order{ OrderID: 6363763262239, Products: []Product{ {ProductID: "abc12345", Name: "Asus Laptop", Price: 431}, {ProductID: "def45678", Name: "Karcher Hose Set", Price: 22}, }, }, Order{ OrderID: 1197372932325, Products: []Product{ {ProductID: "abc12345", Name: "Asus Laptop", Price: 429}, }, }, Order{ OrderID: 9812343774839, Products: []Product{ {ProductID: "pqr88223", Name: "Morphy Richards Food Mixer", Price: 431}, {ProductID: "def45678", Name: "Karcher Hose Set", Price: 21}, }, }, Order{ OrderID: 4433997244387, Products: []Product{ {ProductID: "def45678", Name: "Karcher Hose Set", Price: 23}, {ProductID: "jkl77336", Name: "Picky Pencil Sharpene", Price: 1}, {ProductID: "xyz11228", Name: "Russell Hobbs Chrome Kettle", Price: 16}, }, }, }) if err != nil { log.Fatal(err) }
创建模板应用
在开始学习聚合教程之前，您必须设立一个新的Java应用。您可以使用此应用连接到MongoDB 部署，将示例数据插入MongoDB，然后运行聚合管道。
提示
要学习；了解如何安装驾驶员并连接到MongoDB，请参阅Java驱动程序入门指南。
要学习；了解有关在Java Sync 驱动程序中执行聚合的更多信息，请参阅聚合指南。
安装驾驶员后，创建一个名为 AggTutorial.java 的文件。将以下代码粘贴到此文件中，为聚合教程创建应用模板。
重要
在以下代码中，阅读代码注释，找到在您关注的教程中必须修改的代码部分。
如果您尝试在不进行任何更改的情况下运行代码，则会遇到连接错误。
package org.example; // Modify imports for each tutorial as needed. import com.mongodb.client.*; import com.mongodb.client.model.Aggregates; import com.mongodb.client.model.Filters; import com.mongodb.client.model.Sorts; import org.bson.Document; import org.bson.conversions.Bson; import java.util.ArrayList; import java.util.Arrays; import java.util.List; public class AggTutorial { public static void main( String[] args ) { // Replace the placeholder with your connection string. String uri = "<connection string>"; try (MongoClient mongoClient = MongoClients.create(uri)) { MongoDatabase aggDB = mongoClient.getDatabase("agg_tutorials_db"); // Get a reference to relevant collections. // ... MongoCollection<Document> someColl = ... // ... MongoCollection<Document> anotherColl = ... // Delete any existing documents in collections if needed. // ... someColl.deleteMany(Filters.empty()); // Insert sample data into the collection or collections. // ... someColl.insertMany(...); // Create an empty pipeline array. List<Bson> pipeline = new ArrayList<>(); // Add code to create pipeline stages. // ... pipeline.add(...); // Run the aggregation. // ... AggregateIterable<Document> aggregationResult = someColl.aggregate(pipeline); // Print the aggregation results. for (Document document : aggregationResult) { System.out.println(document.toJson()); } } } }
对于每个教程，您必须用部署的连接字符串替换连接字符串占位符。
例如，如果连接字符串为 "mongodb+srv://mongodb-example:27017"，则其赋值应如下所示：
String uri = "mongodb+srv://mongodb-example:27017";
创建集合
此示例使用 orders集合，其中包含描述产品订单的文档。由于每个订单都包含多个产品，因此聚合的第一步是将产品大量解包为单个产品订单文档。
要创建 orders集合并插入示例数据，请将以下代码添加到您的应用程序中：
MongoCollection<Document> orders = aggDB.getCollection("orders"); orders.deleteMany(Filters.empty()); orders.insertMany( Arrays.asList( new Document("order_id", 6363763262239f) .append("products", Arrays.asList( new Document("prod_id", "abc12345") .append("name", "Asus Laptop") .append("price", 431), new Document("prod_id", "def45678") .append("name", "Karcher Hose Set") .append("price", 22) )), new Document("order_id", 1197372932325f) .append("products", Collections.singletonList( new Document("prod_id", "abc12345") .append("name", "Asus Laptop") .append("price", 429) )), new Document("order_id", 9812343774839f) .append("products", Arrays.asList( new Document("prod_id", "pqr88223") .append("name", "Morphy Richards Food Mixer") .append("price", 431), new Document("prod_id", "def45678") .append("name", "Karcher Hose Set") .append("price", 21) )), new Document("order_id", 4433997244387f) .append("products", Arrays.asList( new Document("prod_id", "def45678") .append("name", "Karcher Hose Set") .append("price", 23), new Document("prod_id", "jkl77336") .append("name", "Picky Pencil Sharpener") .append("price", 1), new Document("prod_id", "xyz11228") .append("name", "Russell Hobbs Chrome Kettle") .append("price", 16) )) ) );
创建模板应用
在开始学习聚合教程之前，您必须设立一个新的Kotlin应用。您可以使用此应用连接到MongoDB 部署，将示例数据插入MongoDB，然后运行聚合管道。
除驾驶员外，您还必须将以下依赖项添加到 build.gradle.kts文件中并重新加载项目：
dependencies { // Implements Kotlin serialization implementation("org.jetbrains.kotlinx:kotlinx-serialization-core:1.5.1") // Implements Kotlin date and time handling implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.6.1") }
安装驾驶员后，创建一个名为 AggTutorial.kt 的文件。将以下代码粘贴到此文件中，为聚合教程创建应用模板。
重要
在以下代码中，阅读代码注释，找到在您关注的教程中必须修改的代码部分。
如果您尝试在不进行任何更改的情况下运行代码，则会遇到连接错误。
package org.example // Modify imports for each tutorial as needed. import com.mongodb.client.model.* import com.mongodb.kotlin.client.coroutine.MongoClient import kotlinx.coroutines.runBlocking import kotlinx.datetime.LocalDateTime import kotlinx.datetime.toJavaLocalDateTime import kotlinx.serialization.Contextual import kotlinx.serialization.Serializable import org.bson.Document import org.bson.conversions.Bson // Define data classes. data class MyClass( ... ) suspend fun main() { // Replace the placeholder with your connection string. val uri = "<connection string>" MongoClient.create(uri).use { mongoClient -> val aggDB = mongoClient.getDatabase("agg_tutorials_db") // Get a reference to relevant collections. // ... val someColl = ... // Delete any existing documents in collections if needed. // ... someColl.deleteMany(empty()) // Insert sample data into the collection or collections. // ... someColl.insertMany( ... ) // Create an empty pipeline. val pipeline = mutableListOf<Bson>() // Add code to create pipeline stages. // ... pipeline.add(...) // Run the aggregation. // ... val aggregationResult = someColl.aggregate<Document>(pipeline) // Print the aggregation results. aggregationResult.collect { println(it) } } }
对于每个教程，您必须用部署的连接字符串替换连接字符串占位符。
例如，如果连接字符串为 "mongodb+srv://mongodb-example:27017"，则其赋值应如下所示：
val uri = "mongodb+srv://mongodb-example:27017"
创建集合
此示例使用 orders集合，其中包含描述产品订单的文档。由于每个订单都包含多个产品，因此聚合的第一步是将产品大量解包为单个产品订单文档。
首先，创建Kotlin数据类以对 orders集合中的数据进行建模：
data class Order( val orderID: Float, val products: List<Product> ) data class Product( val prodID: String, val name: String, val price: Int )
要创建 orders集合并插入示例数据，请将以下代码添加到您的应用程序中：
val orders = aggDB.getCollection<Order>("orders") orders.deleteMany(Filters.empty()) orders.insertMany( listOf( Order( 6363763262239f, listOf( Product("abc12345", "Asus Laptop", 431), Product("def45678", "Karcher Hose Set", 22) ) ), Order( 1197372932325f, listOf( Product("abc12345", "Asus Laptop", 429) ) ), Order( 9812343774839f, listOf( Product("pqr88223", "Morphy Richards Food Mixer", 431), Product("def45678", "Karcher Hose Set", 21) ) ), Order( 4433997244387f, listOf( Product("def45678", "Karcher Hose Set", 23), Product("jkl77336", "Picky Pencil Sharpener", 1), Product("xyz11228", "Russell Hobbs Chrome Kettle", 16) ) ) ) )
创建模板应用
在开始学习此聚合教程之前，您必须设立一个新的 Node.js应用。您可以使用此应用连接到MongoDB 部署，将示例数据插入MongoDB，然后运行聚合管道。
提示
要学习；了解如何安装驾驶员和连接到MongoDB，请参阅 Node.js驱动程序快速入门指南。
安装驾驶员后，创建一个名为 agg_tutorial.js 的文件。将以下代码粘贴到此文件中，为聚合教程创建应用模板。
重要
在以下代码中，阅读代码注释，找到在您关注的教程中必须修改的代码部分。
如果您尝试在不进行任何更改的情况下运行代码，则会遇到连接错误。
const { MongoClient } = require("mongodb"); // Replace the placeholder with your connection string. const uri = "<connection string>"; const client = new MongoClient(uri); async function run() { try { const aggDB = client.db("agg_tutorials_db"); // Get a reference to relevant collections. // ... const someColl = // ... const anotherColl = // Delete any existing documents in collections. // ... await someColl.deleteMany({}); // Insert sample data into the collection or collections. // ... const someData = [ ... ]; // ... await someColl.insertMany(someData); // Create an empty pipeline array. const pipeline = []; // Add code to create pipeline stages. // ... pipeline.push({ ... }) // Run the aggregation. // ... const aggregationResult = ... // Print the aggregation results. for await (const document of aggregationResult) { console.log(document); } } finally { await client.close(); } } run().catch(console.dir);
对于每个教程，您必须用部署的连接字符串替换连接字符串占位符。
例如，如果连接字符串为 "mongodb+srv://mongodb-example:27017"，则其赋值应如下所示：
const uri = "mongodb+srv://mongodb-example:27017";
创建集合
此示例使用 orders集合，其中包含描述产品订单的文档。由于每个订单都包含多个产品，因此聚合的第一步是将产品大量解包为单个产品订单文档。
要创建 orders集合并插入示例数据，请将以下代码添加到您的应用程序中：
const orders = aggDB.collection("orders"); await orders.deleteMany({}); await orders.insertMany([ { order_id: 6363763262239, products: [ { prod_id: "abc12345", name: "Asus Laptop", price: 431, }, { prod_id: "def45678", name: "Karcher Hose Set", price: 22, }, ], }, { order_id: 1197372932325, products: [ { prod_id: "abc12345", name: "Asus Laptop", price: 429, }, ], }, { order_id: 9812343774839, products: [ { prod_id: "pqr88223", name: "Morphy Richards Food Mixer", price: 431, }, { prod_id: "def45678", name: "Karcher Hose Set", price: 21, }, ], }, { order_id: 4433997244387, products: [ { prod_id: "def45678", name: "Karcher Hose Set", price: 23, }, { prod_id: "jkl77336", name: "Picky Pencil Sharpener", price: 1, }, { prod_id: "xyz11228", name: "Russell Hobbs Chrome Kettle", price: 16, }, ], }, ]);
创建模板应用
在开始学习此聚合教程之前，您必须设立一个新的PHP应用。您可以使用此应用连接到MongoDB 部署，将示例数据插入MongoDB，然后运行聚合管道。
提示
要学习；了解如何安装PHP库并连接到MongoDB，请参阅PHP库入门教程。
要学习；了解有关在PHP库中执行聚合的更多信息，请参阅 聚合指南。
安装该库后，创建一个名为 agg_tutorial.php 的文件。将以下代码粘贴到此文件中，为聚合教程创建应用模板。
重要
在以下代码中，阅读代码注释，找到在您关注的教程中必须修改的代码部分。
如果您尝试在不进行任何更改的情况下运行代码，则会遇到连接错误。
require 'vendor/autoload.php'; // Modify imports for each tutorial as needed. use MongoDB\Client; use MongoDB\BSON\UTCDateTime; use MongoDB\Builder\Pipeline; use MongoDB\Builder\Stage; use MongoDB\Builder\Type\Sort; use MongoDB\Builder\Query; use MongoDB\Builder\Expression; use MongoDB\Builder\Accumulator; use function MongoDB\object; // Replace the placeholder with your connection string. $uri = '<connection string>'; $client = new Client($uri); // Get a reference to relevant collections. // ... $someColl = $client->agg_tutorials_db->someColl; // ... $anotherColl = $client->agg_tutorials_db->anotherColl; // Delete any existing documents in collections if needed. // ... $someColl->deleteMany([]); // Insert sample data into the collection or collections. // ... $someColl->insertMany(...); // Add code to create pipeline stages within the Pipeline instance. // ... $pipeline = new Pipeline(...); // Run the aggregation. // ... $cursor = $someColl->aggregate($pipeline); // Print the aggregation results. foreach ($cursor as $doc) { echo json_encode($doc, JSON_PRETTY_PRINT), PHP_EOL; }
对于每个教程，您必须用部署的连接字符串替换连接字符串占位符。
例如，如果连接字符串为 "mongodb+srv://mongodb-example:27017"，则其赋值应如下所示：
$uri = 'mongodb+srv://mongodb-example:27017';
创建集合
此示例使用 orders集合，其中包含描述产品订单的文档。由于每个订单都包含多个产品，因此聚合的第一步是将产品大量解包为单个产品订单文档。
要创建 orders集合并插入示例数据，请将以下代码添加到您的应用程序中：
$orders = $client->agg_tutorials_db->orders; $orders->deleteMany([]); $orders->insertMany( [ [ 'order_id' => 6363763262239, 'products' => [ [ 'prod_id' => 'abc12345', 'name' => 'Asus Laptop', 'price' => 431, ], [ 'prod_id' => 'def45678', 'name' => 'Karcher Hose Set', 'price' => 22, ], ], ], [ 'order_id' => 1197372932325, 'products' => [ [ 'prod_id' => 'abc12345', 'name' => 'Asus Laptop', 'price' => 429, ], ], ], [ 'order_id' => 9812343774839, 'products' => [ [ 'prod_id' => 'pqr88223', 'name' => 'Morphy Richards Food Mixer', 'price' => 431, ], [ 'prod_id' => 'def45678', 'name' => 'Karcher Hose Set', 'price' => 21, ], ], ], [ 'order_id' => 4433997244387, 'products' => [ [ 'prod_id' => 'def45678', 'name' => 'Karcher Hose Set', 'price' => 23, ], [ 'prod_id' => 'jkl77336', 'name' => 'Picky Pencil Sharpener', 'price' => 1, ], [ 'prod_id' => 'xyz11228', 'name' => 'Russell Hobbs Chrome Kettle', 'price' => 16, ], ], ] ] );
创建模板应用
在开始学习本聚合教程之前，您必须设立一个新的Python应用。您可以使用此应用连接到MongoDB 部署，将示例数据插入MongoDB，然后运行聚合管道。
安装该库后，创建一个名为 agg_tutorial.py 的文件。将以下代码粘贴到此文件中，为聚合教程创建应用模板。
重要
在以下代码中，阅读代码注释，找到在您关注的教程中必须修改的代码部分。
如果您尝试在不进行任何更改的情况下运行代码，则会遇到连接错误。
# 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()
对于每个教程，您必须用部署的连接字符串替换连接字符串占位符。
例如，如果连接字符串为 "mongodb+srv://mongodb-example:27017"，则其赋值应如下所示：
uri = "mongodb+srv://mongodb-example:27017"
创建集合
此示例使用 orders集合，其中包含描述产品订单的文档。由于每个订单都包含多个产品，因此聚合的第一步是将产品大量解包为单个产品订单文档。
要创建 orders集合并插入示例数据，请将以下代码添加到您的应用程序中：
orders_coll = agg_db["orders"] orders_coll.delete_many({}) order_data = [ { "order_id": 6363763262239, "products": [ { "prod_id": "abc12345", "name": "Asus Laptop", "price": 431, }, { "prod_id": "def45678", "name": "Karcher Hose Set", "price": 22, }, ], }, { "order_id": 1197372932325, "products": [ { "prod_id": "abc12345", "name": "Asus Laptop", "price": 429, } ], }, { "order_id": 9812343774839, "products": [ { "prod_id": "pqr88223", "name": "Morphy Richards Food Mixer", "price": 431, }, { "prod_id": "def45678", "name": "Karcher Hose Set", "price": 21, }, ], }, { "order_id": 4433997244387, "products": [ { "prod_id": "def45678", "name": "Karcher Hose Set", "price": 23, }, { "prod_id": "jkl77336", "name": "Picky Pencil Sharpener", "price": 1, }, { "prod_id": "xyz11228", "name": "Russell Hobbs Chrome Kettle", "price": 16, }, ], }, ] orders_coll.insert_many(order_data)
创建模板应用
在开始学习此聚合教程之前，您必须设立一个新的Ruby应用。您可以使用此应用连接到MongoDB 部署，将示例数据插入MongoDB，然后运行聚合管道。
安装驾驶员后，创建一个名为 agg_tutorial.rb 的文件。将以下代码粘贴到此文件中，为聚合教程创建应用模板。
重要
在以下代码中，阅读代码注释，找到在您关注的教程中必须修改的代码部分。
如果您尝试在不进行任何更改的情况下运行代码，则会遇到连接错误。
# 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
对于每个教程，您必须用部署的连接字符串替换连接字符串占位符。
例如，如果连接字符串为 "mongodb+srv://mongodb-example:27017"，则其赋值应如下所示：
uri = "mongodb+srv://mongodb-example:27017"
创建集合
此示例使用 orders集合，其中包含描述产品订单的文档。由于每个订单都包含多个产品，因此聚合的第一步是将产品大量解包为单个产品订单文档。
要创建 orders集合并插入示例数据，请将以下代码添加到您的应用程序中：
orders = agg_db[:orders] orders.delete_many({}) orders.insert_many( [ { order_id: 6363763262239, products: [ { prod_id: "abc12345", name: "Asus Laptop", price: 431, }, { prod_id: "def45678", name: "Karcher Hose Set", price: 22, }, ], }, { order_id: 1197372932325, products: [ { prod_id: "abc12345", name: "Asus Laptop", price: 429, }, ], }, { order_id: 9812343774839, products: [ { prod_id: "pqr88223", name: "Morphy Richards Food Mixer", price: 431, }, { prod_id: "def45678", name: "Karcher Hose Set", price: 21, }, ], }, { order_id: 4433997244387, products: [ { prod_id: "def45678", name: "Karcher Hose Set", price: 23, }, { prod_id: "jkl77336", name: "Picky Pencil Sharpener", price: 1, }, { prod_id: "xyz11228", name: "Russell Hobbs Chrome Kettle", price: 16, }, ], }, ] )
创建模板应用
在开始学习本聚合教程之前，您必须设立一个新的Rust应用。您可以使用此应用连接到MongoDB 部署，将示例数据插入MongoDB，然后运行聚合管道。
安装驾驶员后，创建一个名为 agg-tutorial.rs 的文件。将以下代码粘贴到此文件中，为聚合教程创建应用模板。
重要
在以下代码中，阅读代码注释，找到在您关注的教程中必须修改的代码部分。
如果您尝试在不进行任何更改的情况下运行代码，则会遇到连接错误。
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(()) }
对于每个教程，您必须用部署的连接字符串替换连接字符串占位符。
例如，如果连接字符串为 "mongodb+srv://mongodb-example:27017"，则其赋值应如下所示：
let uri = "mongodb+srv://mongodb-example:27017";
创建集合
此示例使用 orders集合，其中包含描述产品订单的文档。由于每个订单都包含多个产品，因此聚合的第一步是将产品大量解包为单个产品订单文档。
首先，创建Rust结构体以对 orders集合中的数据进行建模：
struct Product { prod_id: String, name: String, price: i32, } struct Order { order_id: i64, products: Vec<Product>, }
要创建 orders集合并插入示例数据，请将以下代码添加到您的应用程序中：
let orders_coll: Collection<Order> = agg_db.collection("orders"); orders.delete_many(doc! {}).await?; let orders = vec![ Order { order_id: 6363763262239, products: vec![ Product { prod_id: "abc12345".to_string(), name: "Asus Laptop".to_string(), price: 431, }, Product { prod_id: "def45678".to_string(), name: "Karcher Hose Set".to_string(), price: 22, }, ], }, Order { order_id: 1197372932325, products: vec![Product { prod_id: "abc12345".to_string(), name: "Asus Laptop".to_string(), price: 429, }], }, Order { order_id: 9812343774839, products: vec![ Product { prod_id: "pqr88223".to_string(), name: "Morphy Richards Food Mixer".to_string(), price: 431, }, Product { prod_id: "def45678".to_string(), name: "Karcher Hose Set".to_string(), price: 21, }, ], }, Order { order_id: 4433997244387, products: vec![ Product { prod_id: "def45678".to_string(), name: "Karcher Hose Set".to_string(), price: 23, }, Product { prod_id: "jkl77336".to_string(), name: "Picky Pencil Sharpene".to_string(), price: 1, }, Product { prod_id: "xyz11228".to_string(), name: "Russell Hobbs Chrome Kettle".to_string(), price: 16, }, ], }, ]; orders_coll.insert_many(orders).await?;
创建模板应用
在开始学习聚合教程之前，您必须设立一个新的Scala应用。您可以使用此应用连接到MongoDB 部署，将示例数据插入MongoDB，然后运行聚合管道。
安装驾驶员后，创建一个名为 AggTutorial.scala 的文件。将以下代码粘贴到此文件中，为聚合教程创建应用模板。
重要
在以下代码中，阅读代码注释，找到在您关注的教程中必须修改的代码部分。
如果您尝试在不进行任何更改的情况下运行代码，则会遇到连接错误。
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() } }
对于每个教程，您必须用部署的连接字符串替换连接字符串占位符。
例如，如果连接字符串为 "mongodb+srv://mongodb-example:27017"，则其赋值应如下所示：
val uri = "mongodb+srv://mongodb-example:27017"
创建集合
此示例使用 orders集合，其中包含描述产品订单的文档。由于每个订单都包含多个产品，因此聚合的第一步是将产品大量解包为单个产品订单文档。
要创建 orders集合并插入示例数据，请将以下代码添加到您的应用程序中：
val orders = aggDB.getCollection("orders") orders.deleteMany(Filters.empty()).subscribe( _ => {}, e => println("Error: " + e.getMessage), ) orders.insertMany(Seq( Document( "order_id" -> 6363763262239L, "products" -> Seq( Document( "prod_id" -> "abc12345", "name" -> "Asus Laptop", "price" -> 431 ), Document( "prod_id" -> "def45678", "name" -> "Karcher Hose Set", "price" -> 22 ) ) ), Document( "order_id" -> 1197372932325L, "products" -> Seq( Document( "prod_id" -> "abc12345", "name" -> "Asus Laptop", "price" -> 429 ) ) ), Document( "order_id" -> 9812343774839L, "products" -> Seq( Document( "prod_id" -> "pqr88223", "name" -> "Morphy Richards Food Mixer", "price" -> 431 ), Document( "prod_id" -> "def45678", "name" -> "Karcher Hose Set", "price" -> 21 ) ) ), Document( "order_id" -> 4433997244387L, "products" -> Seq( Document( "prod_id" -> "def45678", "name" -> "Karcher Hose Set", "price" -> 23 ), Document( "prod_id" -> "jkl77336", "name" -> "Picky Pencil Sharpener", "price" -> 1 ), Document( "prod_id" -> "xyz11228", "name" -> "Russell Hobbs Chrome Kettle", "price" -> 16 ) ) ) )).subscribe( _ => {}, e => println("Error: " + e.getMessage), )
步骤
以下步骤演示了如何创建和运行聚合管道，将大量字段解包到单独的文档中，并根据常用值组计算新值。
1
运行聚合管道。
db.orders.aggregate( [ // Stage 1: Unwind the array of product orders { $unwind: { path: "$products" } }, // Stage 2: Match products that cost more than $15 { $match: { "products.price": { $gt: 15 } } }, // Stage 3: Group products by product type { $group: { _id: "$products.prod_id", product: { $first: "$products.name" }, total_value: { $sum: "$products.price" }, quantity: { $sum: 1 } } }, // Stage 4: Display the product ID { $set: { product_id: "$_id" } }, // Stage 5: Remove unneeded fields { $unset: [ "_id"] } ] )
2
解释聚合结果。
该聚合返回 2020 年以来客户订单的以下摘要：
{ product: 'Asus Laptop', total_value: 860, quantity: 2, product_id: 'abc12345' } { product: 'Morphy Richards Food Mixer', total_value: 431, quantity: 1, product_id: 'pqr88223' } { product: 'Russell Hobbs Chrome Kettle', total_value: 16, quantity: 1, product_id: 'xyz11228' } { product: 'Karcher Hose Set', total_value: 66, quantity: 3, product_id: 'def45678' }
注意
如果运行此示例，结果中的文档顺序可能与此页面上的文档顺序不同，因为聚合管道不包含排序阶段。
1
添加展开阶段以解压缩产品订单大量。
首先，添加一个$unwind 阶段以将products 大量中的条目分隔成单个文档：
"{", "$unwind", "{", "path", BCON_UTF8("$products"), "}", "}",
2
为费用超过 15 美元的产品添加匹配阶段。
接下来，添加一个$match 阶段，用于匹配products.price 值大于15 的产品：
"{", "$match", "{", "products.price", "{", "$gt", BCON_INT32(15), "}", "}", "}",
3
添加群组阶段以按产品类型群组。
添加$group 阶段以按prod_id 字段的值收集订单文档。在此阶段，添加聚合操作，在结果文档中创建以下字段：
product：产品名称total_value：产品所有销售的总价值quantity：产品的订单数
"{", "$group", "{", "_id", BCON_UTF8("$products.prod_id"), "product", "{", "$first", BCON_UTF8("$products.name"), "}", "total_value", "{", "$sum", BCON_UTF8("$products.price"), "}", "quantity", "{", "$sum", BCON_INT32(1), "}", "}", "}",
4
添加设立阶段以显示产品ID。
添加 阶段，以根据$set 阶段设立的product_id 字段中的值重新创建_id $group字段：
"{", "$set", "{", "product_id", BCON_UTF8("$_id"), "}", "}",
5
添加未设置阶段以删除不需要的字段。
最后，添加一个$unset 阶段。$unset 阶段从结果文档中删除_id 字段：
"{", "$unset", "[", BCON_UTF8("_id"), "]", "}",
6
运行聚合管道。
将以下代码添加到应用程序末尾，以对orderscollection执行聚合：
mongoc_cursor_t *results = mongoc_collection_aggregate(orders, MONGOC_QUERY_NONE, pipeline, NULL, NULL); bson_destroy(pipeline);
通过将以下行添加到清理语句中，确保清理集合资源：
mongoc_collection_destroy(orders);
最后，在Shell中运行以下命令，生成并运行可执行文件：
gcc -o aggc agg-tutorial.c $(pkg-config --libs --cflags libmongoc-1.0) ./aggc
提示
如果在一次调用中运行上述命令时遇到连接错误，可以单独运行。
7
解释聚合结果。
该聚合返回 2020 年以来客户订单的以下摘要：
{ "product" : "Asus Laptop", "total_value" : { "$numberInt" : "860" }, "quantity" : { "$numberInt" : "2" }, "product_id" : "abc12345" } { "product" : "Karcher Hose Set", "total_value" : { "$numberInt" : "66" }, "quantity" : { "$numberInt" : "3" }, "product_id" : "def45678" } { "product" : "Morphy Richards Food Mixer", "total_value" : { "$numberInt" : "431" }, "quantity" : { "$numberInt" : "1" }, "product_id" : "pqr88223" } { "product" : "Russell Hobbs Chrome Kettle", "total_value" : { "$numberInt" : "16" }, "quantity" : { "$numberInt" : "1" }, "product_id" : "xyz11228" }
结果文档包含有关成本超过 15 美元的产品订单的总值和数量的详细信息。
1
添加展开阶段以解压缩产品订单大量。
首先，添加一个$unwind 阶段以将products 大量中的条目分隔成单个文档：
pipeline.unwind("$products");
2
为费用超过 15 美元的产品添加匹配阶段。
接下来，添加一个$match 阶段，用于匹配products.price 值大于15 的产品：
pipeline.match(bsoncxx::from_json(R"({ "products.price": { "$gt": 15 } })"));
3
添加群组阶段以按产品类型群组。
添加$group 阶段以按prod_id 字段的值收集订单文档。在此阶段，添加聚合操作，在结果文档中创建以下字段：
product：产品名称total_value：产品所有销售的总价值quantity：产品的订单数
pipeline.group(bsoncxx::from_json(R"({ "_id": "$products.prod_id", "product": { "$first": "$products.name" }, "total_value": { "$sum": "$products.price" }, "quantity": { "$sum": 1 } })"));
4
添加 addFields 阶段以显示产品ID。
$addFields添加product_id 阶段，以根据 阶段设立的 字段中的值重新创建_id $group字段：
pipeline.add_fields(bsoncxx::from_json(R"({ "product_id": "$_id" })"));
5
添加未设置阶段以删除不需要的字段。
最后，添加一个$unset 阶段。$unset 阶段从结果文档中删除_id 字段：
pipeline.append_stage(bsoncxx::from_json(R"({ "$unset": ["_id"] })"));
6
7
解释聚合结果。
该聚合返回 2020 年以来客户订单的以下摘要：
{ "product" : "Karcher Hose Set", "total_value" : 66, "quantity" : 3, "product_id" : "def45678" } { "product" : "Asus Laptop", "total_value" : 860, "quantity" : 2, "product_id" : "abc12345" } { "product" : "Morphy Richards Food Mixer", "total_value" : 431, "quantity" : 1, "product_id" : "pqr88223" } { "product" : "Russell Hobbs Chrome Kettle", "total_value" : 16, "quantity" : 1, "product_id" : "xyz11228" }
结果文档包含有关成本超过 15 美元的产品订单的总值和数量的详细信息。
1
添加展开阶段以解压缩产品订单大量。
首先，在orders 集合上启动聚合，并链接$unwind 阶段，以将Products 大量中的条目分成单独的文档：
var results = orders.Aggregate() .Unwind<Order, OrderUnwound>(o => o.Products)
2
为费用超过 15 美元的产品添加匹配阶段。
接下来，添加一个$match 阶段，用于匹配Products.Price 值大于15 的产品：
.Match(o => o.Products.Price > 15)
3
添加群组阶段以按产品类型群组。
添加$group 阶段以按ProductId 字段的值收集订单文档。在此阶段，添加聚合操作，在结果文档中创建以下字段：
ProductId：产品ID （分组键）Product：产品名称TotalValue：产品所有销售的总价值Quantity：产品的订单数
.Group( id: o => o.Products.ProductId, group: g => new { ProductId = g.Key, Product = g.First().Products.Name, TotalValue = g.Sum(o => o.Products.Price), Quantity = g.Count(), } );
4
运行聚合并解释结果。
最后，在 IDE 中运行应用程序并检查结果。
该聚合返回 2020 年以来客户订单的以下摘要：
{ ProductId = pqr88223, Product = Morphy Richards Food Mixer, TotalValue = 431, Quantity = 1 } { ProductId = xyz11228, Product = Russell Hobbs Chrome Kettle, TotalValue = 16, Quantity = 1 } { ProductId = abc12345, Product = Asus Laptop, TotalValue = 860, Quantity = 2 } { ProductId = def45678, Product = Karcher Hose Set, TotalValue = 66, Quantity = 3 }
结果文档包含有关成本超过 15 美元的产品订单的总值和数量的详细信息。
1
添加展开阶段以解压缩产品订单大量。
首先，添加一个$unwind 阶段以将products 大量中的条目分隔成单个文档：
unwindStage := bson.D{{Key: "$unwind", Value: bson.D{ {Key: "path", Value: "$products"}, }}}
2
为费用超过 15 美元的产品添加匹配阶段。
接下来，添加一个$match 阶段，用于匹配products.price 值大于15 的产品：
matchStage := bson.D{{Key: "$match", Value: bson.D{ {Key: "products.price", Value: bson.D{{Key: "$gt", Value: 15}}}, }}}
3
添加群组阶段以按产品类型群组。
添加$group 阶段以按prod_id 字段的值收集订单文档。在此阶段，添加聚合操作，在结果文档中创建以下字段：
product：产品名称total_value：产品所有销售的总价值quantity：产品的订单数
groupStage := bson.D{{Key: "$group", Value: bson.D{ {Key: "_id", Value: "$products.prod_id"}, {Key: "product", Value: bson.D{{Key: "$first", Value: "$products.name"}}}, {Key: "total_value", Value: bson.D{{Key: "$sum", Value: "$products.price"}}}, {Key: "quantity", Value: bson.D{{Key: "$sum", Value: 1}}}, }}}
4
添加设立阶段以显示产品ID。
添加 阶段，以根据$set 阶段设立的product_id 字段中的值重新创建_id $group字段：
setStage := bson.D{{Key: "$set", Value: bson.D{ {Key: "product_id", Value: "$_id"}, }}}
5
添加未设置阶段以删除不需要的字段。
最后，添加一个$unset 阶段。$unset 阶段从结果文档中删除_id 字段：
unsetStage := bson.D{{Key: "$unset", Value: bson.A{"_id"}}}
6
7
解释聚合结果。
该聚合返回 2020 年以来客户订单的以下摘要：
{"product":"Morphy Richards Food Mixer","total_value":431,"quantity":1,"product_id":"pqr88223"} {"product":"Russell Hobbs Chrome Kettle","total_value":16,"quantity":1,"product_id":"xyz11228"} {"product":"Karcher Hose Set","total_value":66,"quantity":3,"product_id":"def45678"} {"product":"Asus Laptop","total_value":860,"quantity":2,"product_id":"abc12345"}
结果文档包含有关成本超过 15 美元的产品订单的总值和数量的详细信息。
1
添加展开阶段以解压缩产品订单大量。
首先，添加一个$unwind 阶段以将products 大量中的条目分隔成单个文档：
pipeline.add(Aggregates.unwind("$products"));
2
为费用超过 15 美元的产品添加匹配阶段。
接下来，添加一个$match 阶段，用于匹配products.price 值大于15 的产品：
pipeline.add(Aggregates.match( Filters.gt("products.price", 15) ));
3
添加群组阶段以按产品类型群组。
添加$group 阶段以按prod_id 字段的值收集订单文档。在此阶段，添加聚合操作，在结果文档中创建以下字段：
product：产品名称total_value：产品所有销售的总价值quantity：产品的订单数
pipeline.add(Aggregates.group( "$products.prod_id", Accumulators.first("product", "$products.name"), Accumulators.sum("total_value", "$products.price"), Accumulators.sum("quantity", 1) ));
4
添加设立阶段以显示产品ID。
添加 阶段，以根据$set 阶段设立的product_id 字段中的值重新创建_id $group字段：
pipeline.add(Aggregates.set(new Field<>("product_id", "$_id")));
5
添加未设置阶段以删除不需要的字段。
最后，添加一个$unset 阶段。$unset 阶段从结果文档中删除_id 字段：
pipeline.add(Aggregates.unset("_id"));
6
7
解释聚合结果。
该聚合返回 2020 年以来客户订单的以下摘要：
{"product": "Asus Laptop", "total_value": 860, "quantity": 2, "product_id": "abc12345"} {"product": "Russell Hobbs Chrome Kettle", "total_value": 16, "quantity": 1, "product_id": "xyz11228"} {"product": "Karcher Hose Set", "total_value": 66, "quantity": 3, "product_id": "def45678"} {"product": "Morphy Richards Food Mixer", "total_value": 431, "quantity": 1, "product_id": "pqr88223"}
结果文档包含有关成本超过 15 美元的产品订单的总值和数量的详细信息。
1
添加展开阶段以解压缩产品订单大量。
首先，添加一个$unwind 阶段以将products 大量中的条目分隔成单个文档：
pipeline.add( Aggregates.unwind("\$${Order::products.name}") )
2
为费用超过 15 美元的产品添加匹配阶段。
接下来，添加一个$match 阶段，用于匹配products.price 值大于15 的产品：
pipeline.add( Aggregates.match( Filters.gt("${Order::products.name}.${Product::price.name}", 15) ) )
3
添加群组阶段以按产品类型群组。
添加$group 阶段以按prodID 字段的值收集订单文档。在此阶段，添加聚合操作，在结果文档中创建以下字段：
product：产品名称total_value：产品所有销售的总价值quantity：产品的订单数
pipeline.add( Aggregates.group( "\$${Order::products.name}.${Product::prodID.name}", Accumulators.first("product", "\$${Order::products.name}.${Product::name.name}"), Accumulators.sum("total_value", "\$${Order::products.name}.${Product::price.name}"), Accumulators.sum("quantity", 1) ) )
4
添加设立阶段以显示产品ID。
添加 阶段，以根据$set 阶段设立的product_id 字段中的值重新创建_id $group字段：
pipeline.add(Aggregates.set(Field("product_id", "\$_id")))
5
添加未设置阶段以删除不需要的字段。
最后，添加一个$unset 阶段。$unset 阶段从结果文档中删除_id 字段：
pipeline.add(Aggregates.unset("_id"))
6
7
解释聚合结果。
该聚合返回 2020 年以来客户订单的以下摘要：
Document{{product=Russell Hobbs Chrome Kettle, total_value=16, quantity=1, product_id=xyz11228}} Document{{product=Karcher Hose Set, total_value=66, quantity=3, product_id=def45678}} Document{{product=Morphy Richards Food Mixer, total_value=431, quantity=1, product_id=pqr88223}} Document{{product=Asus Laptop, total_value=860, quantity=2, product_id=abc12345}}
结果文档包含有关成本超过 15 美元的产品订单的总值和数量的详细信息。
1
添加展开阶段以解压缩产品订单大量。
首先，添加一个$unwind 阶段以将products 大量中的条目分隔成单个文档：
pipeline.push({ $unwind: { path: "$products", }, });
2
为费用超过 15 美元的产品添加匹配阶段。
接下来，添加一个$match 阶段，用于匹配products.price 值大于15 的产品：
pipeline.push({ $match: { "products.price": { $gt: 15, }, }, });
3
添加群组阶段以按产品类型群组。
添加$group 阶段以按prod_id 字段的值收集订单文档。在此阶段，添加聚合操作，在结果文档中创建以下字段：
product：产品名称total_value：产品所有销售的总价值quantity：产品的订单数
pipeline.push({ $group: { _id: "$products.prod_id", product: { $first: "$products.name" }, total_value: { $sum: "$products.price" }, quantity: { $sum: 1 }, }, });
4
添加设立阶段以显示产品ID。
添加 阶段，以根据$set 阶段设立的product_id 字段中的值重新创建_id $group字段：
pipeline.push({ $set: { product_id: "$_id", }, });
5
添加未设置阶段以删除不需要的字段。
最后，添加一个$unset 阶段。$unset 阶段从结果文档中删除_id 字段：
pipeline.push({ $unset: ["_id"] });
6
7
解释聚合结果。
该聚合返回 2020 年以来客户订单的以下摘要：
{ product: 'Asus Laptop', total_value: 860, quantity: 2, product_id: 'abc12345' } { product: 'Morphy Richards Food Mixer', total_value: 431, quantity: 1, product_id: 'pqr88223' } { product: 'Russell Hobbs Chrome Kettle', total_value: 16, quantity: 1, product_id: 'xyz11228' } { product: 'Karcher Hose Set', total_value: 66, quantity: 3, product_id: 'def45678' }
结果文档包含有关成本超过 15 美元的产品订单的总值和数量的详细信息。
1
添加展开阶段以解压缩产品订单大量。
首先，添加一个$unwind 阶段以将products 大量中的条目分隔成单个文档：
Stage::unwind( path: Expression::arrayFieldPath('products') ),
2
为费用超过 15 美元的产品添加匹配阶段。
接下来，添加一个$match 阶段，用于匹配products.price 值大于15 的产品：
Stage::match( ['products.price' => Query::gt(15)] ),
3
添加群组阶段以按产品类型群组。
在Pipeline 实例之外，在工厂函数中创建$group prod_id阶段，以按 字段的值收集订单文档。在此阶段，添加聚合操作，在结果文档中创建以下字段：
product：产品名称total_value：产品所有销售的总价值quantity：产品的订单数
function groupByProductStage() { return Stage::group( _id: Expression::stringFieldPath('products.prod_id'), product: Accumulator::first( Expression::stringFieldPath('products.name') ), total_value: Accumulator::sum( Expression::numberFieldPath('products.price'), ), quantity: Accumulator::sum(1) ); }
然后，在 Pipeline实例中调用 groupByProductStage() 函数：
groupByProductStage(),
4
添加设立阶段以显示产品ID。
添加 阶段，以根据$set 阶段设立的product_id 字段中的值重新创建_id $group字段：
Stage::set(product_id: Expression::stringFieldPath('_id')),
5
添加未设置阶段以删除不需要的字段。
最后，添加一个$unset 阶段。$unset 阶段从结果文档中删除_id 字段：
Stage::unset('_id')
6
7
解释聚合结果。
该聚合返回 2020 年以来客户订单的以下摘要：
{ "product": "Russell Hobbs Chrome Kettle", "total_value": 16, "quantity": 1, "product_id": "xyz11228" } { "product": "Asus Laptop", "total_value": 860, "quantity": 2, "product_id": "abc12345" } { "product": "Karcher Hose Set", "total_value": 66, "quantity": 3, "product_id": "def45678" } { "product": "Morphy Richards Food Mixer", "total_value": 431, "quantity": 1, "product_id": "pqr88223" }
结果文档包含有关成本超过 15 美元的产品订单的总值和数量的详细信息。
1
添加展开阶段以解压缩产品订单大量。
首先，添加一个$unwind 阶段以将products 大量中的条目分隔成单个文档：
pipeline.append({"$unwind": {"path": "$products"}})
2
为费用超过 15 美元的产品添加匹配阶段。
接下来，添加一个$match 阶段，用于匹配products.price 值大于15 的产品：
pipeline.append({"$match": {"products.price": {"$gt": 15}}})
3
添加群组阶段以按产品类型群组。
添加$group 阶段以按prod_id 字段的值收集订单文档。在此阶段，添加聚合操作，在结果文档中创建以下字段：
product：产品名称total_value：产品所有销售的总价值quantity：产品的订单数
pipeline.append( { "$group": { "_id": "$products.prod_id", "product": {"$first": "$products.name"}, "total_value": {"$sum": "$products.price"}, "quantity": {"$sum": 1}, } } )
4
添加设立阶段以显示产品ID。
添加 阶段，以根据$set 阶段设立的product_id 字段中的值重新创建_id $group字段：
pipeline.append({"$set": {"product_id": "$_id"}})
5
添加未设置阶段以删除不需要的字段。
最后，添加一个$unset 阶段。$unset 阶段从结果文档中删除_id 字段：
pipeline.append({"$unset": ["_id"]})
6
7
解释聚合结果。
该聚合返回 2020 年以来客户订单的以下摘要：
{'product': 'Morphy Richards Food Mixer', 'total_value': 431, 'quantity': 1, 'product_id': 'pqr88223'} {'product': 'Asus Laptop', 'total_value': 860, 'quantity': 2, 'product_id': 'abc12345'} {'product': 'Russell Hobbs Chrome Kettle', 'total_value': 16, 'quantity': 1, 'product_id': 'xyz11228'} {'product': 'Karcher Hose Set', 'total_value': 66, 'quantity': 3, 'product_id': 'def45678'}
结果文档包含有关成本超过 15 美元的产品订单的总值和数量的详细信息。
1
添加展开阶段以解压缩产品订单大量。
首先，添加一个$unwind 阶段以将products 大量中的条目分隔成单个文档：
{ "$unwind": { path: "$products", }, },
2
为费用超过 15 美元的产品添加匹配阶段。
接下来，添加一个$match 阶段，用于匹配products.price 值大于15 的产品：
{ "$match": { "products.price": { "$gt": 15, }, }, },
3
添加群组阶段以按产品类型群组。
添加$group 阶段以按prod_id 字段的值收集订单文档。在此阶段，添加聚合操作，在结果文档中创建以下字段：
product：产品名称total_value：产品所有销售的总价值quantity：产品的订单数
{ "$group": { _id: "$products.prod_id", product: { "$first": "$products.name" }, total_value: { "$sum": "$products.price" }, quantity: { "$sum": 1 }, }, },
4
添加设立阶段以显示产品ID。
添加 阶段，以根据$set 阶段设立的product_id 字段中的值重新创建_id $group字段：
{ "$set": { product_id: "$_id", }, },
5
添加未设置阶段以删除不需要的字段。
最后，添加一个$unset 阶段。$unset 阶段从结果文档中删除_id 字段：
{ "$unset": ["_id"] },
6
7
解释聚合结果。
该聚合返回 2020 年以来客户订单的以下摘要：
{"product"=>"Asus Laptop", "total_value"=>860, "quantity"=>2, "product_id"=>"abc12345"} {"product"=>"Russell Hobbs Chrome Kettle", "total_value"=>16, "quantity"=>1, "product_id"=>"xyz11228"} {"product"=>"Karcher Hose Set", "total_value"=>66, "quantity"=>3, "product_id"=>"def45678"} {"product"=>"Morphy Richards Food Mixer", "total_value"=>431, "quantity"=>1, "product_id"=>"pqr88223"}
结果文档包含有关成本超过 15 美元的产品订单的总值和数量的详细信息。
1
添加展开阶段以解压缩产品订单大量。
首先，添加一个$unwind 阶段以将products 大量中的条目分隔成单个文档：
pipeline.push(doc! { "$unwind": { "path": "$products" } });
2
为费用超过 15 美元的产品添加匹配阶段。
接下来，添加一个$match 阶段，用于匹配products.price 值大于15 的产品：
pipeline.push(doc! { "$match": { "products.price": { "$gt": 15 } } });
3
添加群组阶段以按产品类型群组。
添加$group 阶段以按prod_id 字段的值收集订单文档。在此阶段，添加聚合操作，在结果文档中创建以下字段：
product：产品名称total_value：产品所有销售的总价值quantity：产品的订单数
pipeline.push(doc! { "$group": { "_id": "$products.prod_id", "product": { "$first": "$products.name" }, "total_value": { "$sum": "$products.price" }, "quantity": { "$sum": 1 } } });
4
添加设立阶段以显示产品ID。
添加 阶段，以根据$set 阶段设立的prod_id 字段中的值重新创建_id $group字段：
pipeline.push(doc! { "$set": { "prod_id": "$_id" } });
5
添加未设置阶段以删除不需要的字段。
最后，添加一个$unset 阶段。$unset 阶段从结果文档中删除_id 字段：
pipeline.push(doc! { "$unset": ["_id"] });
6
7
解释聚合结果。
该聚合返回 2020 年以来客户订单的以下摘要：
Document({"product": String("Russell Hobbs Chrome Kettle"), "total_value": Int32(16), "quantity": Int32(1), "prod_id": String("xyz11228")}) Document({"product": String("Morphy Richards Food Mixer"), "total_value": Int32(431), "quantity": Int32(1), "prod_id": String("pqr88223")}) Document({"product": String("Karcher Hose Set"), "total_value": Int32(66), "quantity": Int32(3), "prod_id": String("def45678")}) Document({"product": String("Asus Laptop"), "total_value": Int32(860), "quantity": Int32(2), "prod_id": String("abc12345")})
结果文档包含有关成本超过 15 美元的产品订单的总值和数量的详细信息。
1
添加展开阶段以解压缩产品订单大量。
首先，添加一个$unwind 阶段以将products 大量中的条目分隔成单个文档：
Aggregates.unwind("$products"),
2
为费用超过 15 美元的产品添加匹配阶段。
接下来，添加一个$match 阶段，用于匹配products.price 值大于15 的产品：
Aggregates.filter(Filters.gt("products.price", 15)),
3
添加群组阶段以按产品类型群组。
添加$group 阶段以按prod_id 字段的值收集订单文档。在此阶段，添加聚合操作，在结果文档中创建以下字段：
product：产品名称total_value：产品所有销售的总价值quantity：产品的订单数
Aggregates.group( "$products.prod_id", Accumulators.first("product", "$products.name"), Accumulators.sum("total_value", "$products.price"), Accumulators.sum("quantity", 1) ),
4
添加设立阶段以显示产品ID。
添加 阶段，以根据$set 阶段设立的product_id 字段中的值重新创建_id $group字段：
Aggregates.set(Field("product_id", "$_id")),
5
添加未设置阶段以删除不需要的字段。
最后，添加一个$unset 阶段。$unset 阶段从结果文档中删除_id 字段：
Aggregates.unset("_id")
6
7
解释聚合结果。
该聚合返回 2020 年以来客户订单的以下摘要：
{"product": "Morphy Richards Food Mixer", "total_value": 431, "quantity": 1, "product_id": "pqr88223"} {"product": "Karcher Hose Set", "total_value": 66, "quantity": 3, "product_id": "def45678"} {"product": "Russell Hobbs Chrome Kettle", "total_value": 16, "quantity": 1, "product_id": "xyz11228"} {"product": "Asus Laptop", "total_value": 860, "quantity": 2, "product_id": "abc12345"}
结果文档包含有关成本超过 15 美元的产品订单的总值和数量的详细信息。