本教程说明了如何构建聚合管道、对集合执行聚合以及使用您选择的语言显示结果。
关于此任务
本教程演示如何对客户订单数据群组和分析。结果显示在 2020 购买商品的客户列表，并包括每个客户的 2020 订单历史记录。
聚合管道执行以下操作：
根据字段值匹配文档子集
按公共字段值对文档进行分组
为每个结果文档添加计算字段
开始之前
➤ 使用右上角的 Select your 语言）下拉菜单设立以下示例的语言，或选择MongoDB Shell。
此示例使用 orders集合，其中包含描述单个产品订单的文档。由于每个订单仅对应一个客户，因此聚合按 customer_id字段（包含客户电子邮件地址）对订单文档进行分组。
要创建 orders集合，请使用 insertMany() 方法：
db.orders.deleteMany({}) db.orders.insertMany( [ { customer_id: "elise_smith@myemail.com", orderdate: new Date("2020-05-30T08:35:52Z"), value: 231, }, { customer_id: "elise_smith@myemail.com", orderdate: new Date("2020-01-13T09:32:07Z"), value: 99, }, { customer_id: "oranieri@warmmail.com", orderdate: new Date("2020-01-01T08:25:37Z"), value: 63, }, { customer_id: "tj@wheresmyemail.com", orderdate: new Date("2019-05-28T19:13:32Z"), value: 2, }, { customer_id: "tj@wheresmyemail.com", orderdate: new Date("2020-11-23T22:56:53Z"), value: 187, }, { customer_id: "tj@wheresmyemail.com", orderdate: new Date("2020-08-18T23:04:48Z"), value: 4, }, { customer_id: "elise_smith@myemail.com", orderdate: new Date("2020-12-26T08:55:46Z"), value: 4, }, { customer_id: "tj@wheresmyemail.com", orderdate: new Date("2021-02-29T07:49:32Z"), value: 1024, }, { customer_id: "elise_smith@myemail.com", orderdate: new Date("2020-10-03T13:49:44Z"), value: 102, } ] )
创建模板应用
在开始学习本聚合教程之前，您必须设立一个新的C应用。您可以使用此应用连接到MongoDB 部署，将示例数据插入MongoDB，然后运行聚合管道。
提示
要学习；了解如何安装驾驶员和连接到MongoDB，请参阅 C驱动程序入门指南。
要学习；了解有关在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; }
对于每个教程，您必须用部署的连接字符串替换连接字符串占位符。
提示
要学习；了解如何找到部署的连接字符串，请参阅C语言入门指南中的创建连接字符串步骤。
例如，如果连接字符串为 "mongodb+srv://mongodb-example:27017"，则其赋值应如下所示：
char *uri = "mongodb+srv://mongodb-example:27017";
创建集合
此示例使用 orders集合，其中包含描述单个产品订单的文档。由于每个订单只对应一个客户，因此聚合按 customer_id字段（包含客户电子邮件地址）对订单文档进行分组。
要创建 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 = 9; bson_t *docs[num_docs]; docs[0] = BCON_NEW( "customer_id", BCON_UTF8("elise_smith@myemail.com"), "orderdate", BCON_DATE_TIME(1590825352000UL), // 2020-05-30T08:35:52Z "value", BCON_INT32(231)); docs[1] = BCON_NEW( "customer_id", BCON_UTF8("elise_smith@myemail.com"), "orderdate", BCON_DATE_TIME(1578904327000UL), // 2020-01-13T09:32:07Z "value", BCON_INT32(99)); docs[2] = BCON_NEW( "customer_id", BCON_UTF8("oranieri@warmmail.com"), "orderdate", BCON_DATE_TIME(1577865937000UL), // 2020-01-01T08:25:37Z "value", BCON_INT32(63)); docs[3] = BCON_NEW( "customer_id", BCON_UTF8("tj@wheresmyemail.com"), "orderdate", BCON_DATE_TIME(1559061212000UL), // 2019-05-28T19:13:32Z "value", BCON_INT32(2)); docs[4] = BCON_NEW( "customer_id", BCON_UTF8("tj@wheresmyemail.com"), "orderdate", BCON_DATE_TIME(1606171013000UL), // 2020-11-23T22:56:53Z "value", BCON_INT32(187)); docs[5] = BCON_NEW( "customer_id", BCON_UTF8("tj@wheresmyemail.com"), "orderdate", BCON_DATE_TIME(1597793088000UL), // 2020-08-18T23:04:48Z "value", BCON_INT32(4)); docs[6] = BCON_NEW( "customer_id", BCON_UTF8("elise_smith@myemail.com"), "orderdate", BCON_DATE_TIME(1608963346000UL), // 2020-12-26T08:55:46Z "value", BCON_INT32(4)); docs[7] = BCON_NEW( "customer_id", BCON_UTF8("tj@wheresmyemail.com"), "orderdate", BCON_DATE_TIME(1614496172000UL), // 2021-02-28T07:49:32Z "value", BCON_INT32(1024)); docs[8] = BCON_NEW( "customer_id", BCON_UTF8("elise_smith@myemail.com"), "orderdate", BCON_DATE_TIME(1601722184000UL), // 2020-10-03T13:49:44Z "value", BCON_INT32(102)); bson_error_t error; if (!mongoc_collection_insert_many(orders, (const bson_t **)docs, num_docs, NULL, NULL, &error)) { fprintf(stderr, "Insert error: %s\n", error.message); } for (int i = 0; i < num_docs; i++) { bson_destroy(docs[i]); } }
创建模板应用
在开始学习聚合教程之前，您必须设立一个新的C++应用。您可以使用此应用连接到MongoDB 部署，将示例数据插入MongoDB，然后运行聚合管道。
提示
安装驾驶员后，创建一个名为 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; } }
对于每个教程，您必须用部署的连接字符串替换连接字符串占位符。
提示
要学习；了解如何找到部署的连接字符串，请参阅C++入门教程中的创建连接字符串步骤。
例如，如果连接字符串为 "mongodb+srv://mongodb-example:27017"，则其赋值应如下所示：
mongocxx::uri uri{"mongodb+srv://mongodb-example:27017"};
创建集合
此示例使用 orders集合，其中包含描述单个产品订单的文档。由于每个订单只对应一个客户，因此聚合按 customer_id字段（包含客户电子邮件地址）对订单文档进行分组。
要创建 orders集合并插入示例数据，请将以下代码添加到您的应用程序中：
auto orders = db["orders"]; std::vector<bsoncxx::document::value> docs = { bsoncxx::from_json(R"({ "customer_id": "elise_smith@myemail.com", "orderdate": {"$date": 1590821752000}, "value": 231 })"), bsoncxx::from_json(R"({ "customer_id": "elise_smith@myemail.com", "orderdate": {"$date": 1578901927}, "value": 99 })"), bsoncxx::from_json(R"({ "customer_id": "oranieri@warmmail.com", "orderdate": {"$date": 1577861137}, "value": 63 })"), bsoncxx::from_json(R"({ "customer_id": "tj@wheresmyemail.com", "orderdate": {"$date": 1559076812}, "value": 2 })"), bsoncxx::from_json(R"({ "customer_id": "tj@wheresmyemail.com", "orderdate": {"$date": 1606172213}, "value": 187 })"), bsoncxx::from_json(R"({ "customer_id": "tj@wheresmyemail.com", "orderdate": {"$date": 1597794288}, "value": 4 })"), bsoncxx::from_json(R"({ "customer_id": "elise_smith@myemail.com", "orderdate": {"$date": 1608972946000}, "value": 4 })"), bsoncxx::from_json(R"({ "customer_id": "tj@wheresmyemail.com", "orderdate": {"$date": 1614570572}, "value": 1024 })"), bsoncxx::from_json(R"({ "customer_id": "elise_smith@myemail.com", "orderdate": {"$date": 1601722184000}, "value": 102 })") }; auto result = orders.insert_many(docs); // Might throw an exception
创建模板应用
在开始学习此聚合教程之前，必须设立一个新的C#/ .NET应用。您可以使用此应用连接到MongoDB 部署，将示例数据插入MongoDB，然后运行聚合管道。
提示
要学习；了解如何安装驾驶员和连接到MongoDB，请参阅C#/.NET驱动程序快速入门指南。
要学习；了解有关在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); }
对于每个教程，您必须用部署的连接字符串替换连接字符串占位符。
提示
要学习；了解如何找到部署的连接字符串，请参阅C#快速入门指南中的在Atlas中设置免费层级集群步骤。
例如，如果连接字符串为 "mongodb+srv://mongodb-example:27017"，则其赋值应如下所示：
var uri = "mongodb+srv://mongodb-example:27017";
创建集合
此示例使用 orders集合，其中包含描述单个产品订单的文档。由于每个订单只对应一个客户，因此聚合按 CustomerId字段（包含客户电子邮件地址）对订单文档进行分组。
首先，创建一个C#类来对 orders集合中的数据进行建模：
public class Order { [] public ObjectId Id { get; set; } public string CustomerId { get; set; } public DateTime OrderDate { get; set; } public int Value { get; set; } }
要创建 orders集合并插入示例数据，请将以下代码添加到您的应用程序中：
var orders = aggDB.GetCollection<Order>("orders"); orders.DeleteMany(Builders<Order>.Filter.Empty); orders.InsertMany(new List<Order> { new Order { CustomerId = "elise_smith@myemail.com", OrderDate = DateTime.Parse("2020-05-30T08:35:52Z"), Value = 231 }, new Order { CustomerId = "elise_smith@myemail.com", OrderDate = DateTime.Parse("2020-01-13T09:32:07Z"), Value = 99 }, new Order { CustomerId = "oranieri@warmmail.com", OrderDate = DateTime.Parse("2020-01-01T08:25:37Z"), Value = 63 }, new Order { CustomerId = "tj@wheresmyemail.com", OrderDate = DateTime.Parse("2019-05-28T19:13:32Z"), Value = 2 }, new Order { CustomerId = "tj@wheresmyemail.com", OrderDate = DateTime.Parse("2020-11-23T22:56:53Z"), Value = 187 }, new Order { CustomerId = "tj@wheresmyemail.com", OrderDate = DateTime.Parse("2020-08-18T23:04:48Z"), Value = 4 }, new Order { CustomerId = "elise_smith@myemail.com", OrderDate = DateTime.Parse("2020-12-26T08:55:46Z"), Value = 4 }, new Order { CustomerId = "tj@wheresmyemail.com", OrderDate = DateTime.Parse("2021-02-28T07:49:32Z"), Value = 1024 }, new Order { CustomerId = "elise_smith@myemail.com", OrderDate = DateTime.Parse("2020-10-03T13:49:44Z"), Value = 102 } });
创建模板应用
在开始学习此聚合教程之前，您必须设立一个新的Go应用。您可以使用此应用连接到MongoDB 部署，将示例数据插入MongoDB，然后运行聚合管道。
提示
要学习；了解如何安装驾驶员并连接到MongoDB，请参阅Go驱动程序快速入门指南。
要学习；了解有关在Go驱动程序中执行聚合的更多信息，请参阅聚合指南。
安装驾驶员后，创建一个名为 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)) } }
对于每个教程，您必须用部署的连接字符串替换连接字符串占位符。
提示
要学习；了解如何找到部署的连接字符串，请参阅Go快速入门指南中的创建MongoDB集群步骤。
例如，如果连接字符串为 "mongodb+srv://mongodb-example:27017"，则其赋值应如下所示：
const uri = "mongodb+srv://mongodb-example:27017";
创建集合
此示例使用 orders集合，其中包含描述单个产品订单的文档。由于每个订单只对应一个客户，因此聚合按 customer_id字段（包含客户电子邮件地址）对订单文档进行分组。
首先，创建一个Go结构体来对 orders集合中的数据进行建模：
type Order struct { CustomerID string `bson:"customer_id,omitempty"` OrderDate bson.DateTime `bson:"orderdate"` Value int `bson:"value"` }
要创建 orders集合并插入示例数据，请将以下代码添加到您的应用程序中：
orders := aggDB.Collection("orders") orders.DeleteMany(context.TODO(), bson.D{}) _, err = orders.InsertMany(context.TODO(), []interface{}{ Order{ CustomerID: "elise_smith@myemail.com", OrderDate: bson.NewDateTimeFromTime(time.Date(2020, 5, 30, 8, 35, 53, 0, time.UTC)), Value: 231, }, Order{ CustomerID: "elise_smith@myemail.com", OrderDate: bson.NewDateTimeFromTime(time.Date(2020, 1, 13, 9, 32, 7, 0, time.UTC)), Value: 99, }, Order{ CustomerID: "oranieri@warmmail.com", OrderDate: bson.NewDateTimeFromTime(time.Date(2020, 1, 01, 8, 25, 37, 0, time.UTC)), Value: 63, }, Order{ CustomerID: "tj@wheresmyemail.com", OrderDate: bson.NewDateTimeFromTime(time.Date(2019, 5, 28, 19, 13, 32, 0, time.UTC)), Value: 2, }, Order{ CustomerID: "tj@wheresmyemail.com", OrderDate: bson.NewDateTimeFromTime(time.Date(2020, 11, 23, 22, 56, 53, 0, time.UTC)), Value: 187, }, Order{ CustomerID: "tj@wheresmyemail.com", OrderDate: bson.NewDateTimeFromTime(time.Date(2020, 8, 18, 23, 4, 48, 0, time.UTC)), Value: 4, }, Order{ CustomerID: "elise_smith@myemail.com", OrderDate: bson.NewDateTimeFromTime(time.Date(2020, 12, 26, 8, 55, 46, 0, time.UTC)), Value: 4, }, Order{ CustomerID: "tj@wheresmyemail.com", OrderDate: bson.NewDateTimeFromTime(time.Date(2021, 2, 29, 7, 49, 32, 0, time.UTC)), Value: 1024, }, Order{ CustomerID: "elise_smith@myemail.com", OrderDate: bson.NewDateTimeFromTime(time.Date(2020, 10, 3, 13, 49, 44, 0, time.UTC)), Value: 102, }, }) if err != nil { log.Fatal(err) }
创建模板应用
在开始学习聚合教程之前，您必须设立一个新的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()); } } } }
对于每个教程，您必须用部署的连接字符串替换连接字符串占位符。
提示
要学习；了解如何找到部署的连接字符串，请参阅Java Sync 快速入门指南的创建连接字符串步骤。
例如，如果连接字符串为 "mongodb+srv://mongodb-example:27017"，则其赋值应如下所示：
String uri = "mongodb+srv://mongodb-example:27017";
创建集合
此示例使用 orders集合，其中包含描述单个产品订单的文档。由于每个订单只对应一个客户，因此聚合按 customer_id字段（包含客户电子邮件地址）对订单文档进行分组。
要创建 orders集合并插入示例数据，请将以下代码添加到您的应用程序中：
MongoCollection<Document> orders = aggDB.getCollection("orders"); orders.deleteMany(Filters.empty()); orders.insertMany( Arrays.asList( new Document("customer_id", "elise_smith@myemail.com") .append("orderdate", LocalDateTime.parse("2020-05-30T08:35:52")) .append("value", 231), new Document("customer_id", "elise_smith@myemail.com") .append("orderdate", LocalDateTime.parse("2020-01-13T09:32:07")) .append("value", 99), new Document("customer_id", "oranieri@warmmail.com") .append("orderdate", LocalDateTime.parse("2020-01-01T08:25:37")) .append("value", 63), new Document("customer_id", "tj@wheresmyemail.com") .append("orderdate", LocalDateTime.parse("2019-05-28T19:13:32")) .append("value", 2), new Document("customer_id", "tj@wheresmyemail.com") .append("orderdate", LocalDateTime.parse("2020-11-23T22:56:53")) .append("value", 187), new Document("customer_id", "tj@wheresmyemail.com") .append("orderdate", LocalDateTime.parse("2020-08-18T23:04:48")) .append("value", 4), new Document("customer_id", "elise_smith@myemail.com") .append("orderdate", LocalDateTime.parse("2020-12-26T08:55:46")) .append("value", 4), new Document("customer_id", "tj@wheresmyemail.com") .append("orderdate", LocalDateTime.parse("2021-02-28T07:49:32")) .append("value", 1024), new Document("customer_id", "elise_smith@myemail.com") .append("orderdate", LocalDateTime.parse("2020-10-03T13:49:44")) .append("value", 102) ) );
创建模板应用
在开始学习聚合教程之前，您必须设立一个新的Kotlin应用。您可以使用此应用连接到MongoDB 部署，将示例数据插入MongoDB，然后运行聚合管道。
提示
要学习；了解如何安装驾驶员并连接到MongoDB，请参阅Kotlin驱动程序快速入门指南。
要学习；了解有关在Kotlin驱动程序中执行聚合的更多信息，请参阅聚合指南。
除驾驶员外，您还必须将以下依赖项添加到 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) } } }
对于每个教程，您必须用部署的连接字符串替换连接字符串占位符。
提示
要学习；了解如何找到部署的连接字符串，请参阅Kotlin驱动程序快速入门指南中的连接到集群步骤。
例如，如果连接字符串为 "mongodb+srv://mongodb-example:27017"，则其赋值应如下所示：
val uri = "mongodb+srv://mongodb-example:27017"
创建集合
此示例使用 orders集合，其中包含描述单个产品订单的文档。由于每个订单只对应一个客户，因此聚合按 customer_id字段（包含客户电子邮件地址）对订单文档进行分组。
首先，创建一个Kotlin数据类，对 orders集合中的数据进行建模：
data class Order( val customerID: String, val orderDate: LocalDateTime, val value: Int )
要创建 orders集合并插入示例数据，请将以下代码添加到您的应用程序中：
val orders = aggDB.getCollection<Order>("orders") orders.deleteMany(Filters.empty()) orders.insertMany( listOf( Order("elise_smith@myemail.com", LocalDateTime.parse("2020-05-30T08:35:52"), 231), Order("elise_smith@myemail.com", LocalDateTime.parse("2020-01-13T09:32:07"), 99), Order("oranieri@warmmail.com", LocalDateTime.parse("2020-01-01T08:25:37"), 63), Order("tj@wheresmyemail.com", LocalDateTime.parse("2019-05-28T19:13:32"), 2), Order("tj@wheresmyemail.com", LocalDateTime.parse("2020-11-23T22:56:53"), 187), Order("tj@wheresmyemail.com", LocalDateTime.parse("2020-08-18T23:04:48"), 4), Order("elise_smith@myemail.com", LocalDateTime.parse("2020-12-26T08:55:46"), 4), Order("tj@wheresmyemail.com", LocalDateTime.parse("2021-02-28T07:49:32"), 1024), Order("elise_smith@myemail.com", LocalDateTime.parse("2020-10-03T13:49:44"), 102) ) )
创建模板应用
在开始学习此聚合教程之前，您必须设立一个新的 Node.js应用。您可以使用此应用连接到MongoDB 部署，将示例数据插入MongoDB，然后运行聚合管道。
提示
要学习；了解如何安装驾驶员和连接到MongoDB，请参阅 Node.js驱动程序快速入门指南。
要学习；了解有关在 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);
对于每个教程，您必须用部署的连接字符串替换连接字符串占位符。
提示
要学习；了解如何查找部署的连接字符串，请参阅 Node.js 快速入门指南的创建连接字符串步骤。
例如，如果连接字符串为 "mongodb+srv://mongodb-example:27017"，则其赋值应如下所示：
const uri = "mongodb+srv://mongodb-example:27017";
创建集合
此示例使用 orders集合，其中包含描述单个产品订单的文档。由于每个订单只对应一个客户，因此聚合按 customer_id字段（包含客户电子邮件地址）对订单文档进行分组。
要创建 orders集合并插入示例数据，请将以下代码添加到您的应用程序中：
const orders = aggDB.collection("orders"); await orders.deleteMany({}); await orders.insertMany([ { customer_id: "elise_smith@myemail.com", orderdate: new Date("2020-05-30T08:35:52Z"), value: 231, }, { customer_id: "elise_smith@myemail.com", orderdate: new Date("2020-01-13T09:32:07Z"), value: 99, }, { customer_id: "oranieri@warmmail.com", orderdate: new Date("2020-01-01T08:25:37Z"), value: 63, }, { customer_id: "tj@wheresmyemail.com", orderdate: new Date("2019-05-28T19:13:32Z"), value: 2, }, { customer_id: "tj@wheresmyemail.com", orderdate: new Date("2020-11-23T22:56:53Z"), value: 187, }, { customer_id: "tj@wheresmyemail.com", orderdate: new Date("2020-08-18T23:04:48Z"), value: 4, }, { customer_id: "elise_smith@myemail.com", orderdate: new Date("2020-12-26T08:55:46Z"), value: 4, }, { customer_id: "tj@wheresmyemail.com", orderdate: new Date("2021-02-29T07:49:32Z"), value: 1024, }, { customer_id: "elise_smith@myemail.com", orderdate: new Date("2020-10-03T13:49:44Z"), value: 102, }, ]);
创建模板应用
在开始学习此聚合教程之前，您必须设立一个新的PHP应用。您可以使用此应用连接到MongoDB 部署，将示例数据插入MongoDB，然后运行聚合管道。
安装该库后，创建一个名为 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; }
对于每个教程，您必须用部署的连接字符串替换连接字符串占位符。
提示
要学习；了解如何找到部署的连接字符串，请参阅PHP库入门教程中的创建连接字符串步骤。
例如，如果连接字符串为 "mongodb+srv://mongodb-example:27017"，则其赋值应如下所示：
$uri = 'mongodb+srv://mongodb-example:27017';
创建集合
此示例使用 orders集合，其中包含描述单个产品订单的文档。由于每个订单只对应一个客户，因此聚合按 customer_id字段（包含客户电子邮件地址）对订单文档进行分组。
要创建 orders集合并插入示例数据，请将以下代码添加到您的应用程序中：
$orders = $client->agg_tutorials_db->orders; $orders->deleteMany([]); $orders->insertMany( [ [ 'customer_id' => 'elise_smith@myemail.com', 'orderdate' => new UTCDateTime(new DateTimeImmutable('2020-05-30T08:35:52')), 'value' => 231 ], [ 'customer_id' => 'elise_smith@myemail.com', 'orderdate' => new UTCDateTime(new DateTimeImmutable('2020-01-13T09:32:07')), 'value' => 99 ], [ 'customer_id' => 'oranieri@warmmail.com', 'orderdate' => new UTCDateTime(new DateTimeImmutable('2020-01-01T08:25:37')), 'value' => 63 ], [ 'customer_id' => 'tj@wheresmyemail.com', 'orderdate' => new UTCDateTime(new DateTimeImmutable('2019-05-28T19:13:32')), 'value' => 2 ], [ 'customer_id' => 'tj@wheresmyemail.com', 'orderdate' => new UTCDateTime(new DateTimeImmutable('2020-11-23T22:56:53')), 'value' => 187 ], [ 'customer_id' => 'tj@wheresmyemail.com', 'orderdate' => new UTCDateTime(new DateTimeImmutable('2020-08-18T23:04:48')), 'value' => 4 ], [ 'customer_id' => 'elise_smith@myemail.com', 'orderdate' => new UTCDateTime(new DateTimeImmutable('2020-12-26T08:55:46')), 'value' => 4 ], [ 'customer_id' => 'tj@wheresmyemail.com', 'orderdate' => new UTCDateTime(new DateTimeImmutable('2021-02-28T07:49:32')), 'value' => 1024 ], [ 'customer_id' => 'elise_smith@myemail.com', 'orderdate' => new UTCDateTime(new DateTimeImmutable('2020-10-03T13:49:44')), 'value' => 102 ] ] );
创建模板应用
在开始学习本聚合教程之前，您必须设立一个新的Python应用。您可以使用此应用连接到MongoDB 部署，将示例数据插入MongoDB，然后运行聚合管道。
提示
要学习；了解如何安装PyMongo并连接到MongoDB，请参阅PyMongo入门教程。
要学习；了解有关在PyMongo中执行聚合的更多信息，请参阅聚合指南。
安装该库后，创建一个名为 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()
对于每个教程，您必须用部署的连接字符串替换连接字符串占位符。
提示
要学习；了解如何找到部署的连接字符串，请参阅PHP库入门教程中的创建连接字符串步骤。
例如，如果连接字符串为 "mongodb+srv://mongodb-example:27017"，则其赋值应如下所示：
uri = "mongodb+srv://mongodb-example:27017"
创建集合
此示例使用 orders集合，其中包含描述单个产品订单的文档。由于每个订单只对应一个客户，因此聚合按 customer_id字段（包含客户电子邮件地址）对订单文档进行分组。
要创建 orders集合并插入示例数据，请将以下代码添加到您的应用程序中：
orders_coll = agg_db["orders"] orders_coll.delete_many({}) order_data = [ { "customer_id": "elise_smith@myemail.com", "orderdate": datetime(2020, 5, 30, 8, 35, 52), "value": 231, }, { "customer_id": "elise_smith@myemail.com", "orderdate": datetime(2020, 1, 13, 9, 32, 7), "value": 99, }, { "customer_id": "oranieri@warmmail.com", "orderdate": datetime(2020, 1, 1, 8, 25, 37), "value": 63, }, { "customer_id": "tj@wheresmyemail.com", "orderdate": datetime(2019, 5, 28, 19, 13, 32), "value": 2, }, { "customer_id": "tj@wheresmyemail.com", "orderdate": datetime(2020, 11, 23, 22, 56, 53), "value": 187, }, { "customer_id": "tj@wheresmyemail.com", "orderdate": datetime(2020, 8, 18, 23, 4, 48), "value": 4, }, { "customer_id": "elise_smith@myemail.com", "orderdate": datetime(2020, 12, 26, 8, 55, 46), "value": 4, }, { "customer_id": "tj@wheresmyemail.com", "orderdate": datetime(2021, 2, 28, 7, 49, 32), "value": 1024, }, { "customer_id": "elise_smith@myemail.com", "orderdate": datetime(2020, 10, 3, 13, 49, 44), "value": 102, }, ] orders_coll.insert_many(order_data)
创建模板应用
在开始学习此聚合教程之前，您必须设立一个新的Ruby应用。您可以使用此应用连接到MongoDB 部署，将示例数据插入MongoDB，然后运行聚合管道。
提示
要学习；了解如何安装Ruby驱动程序并连接到MongoDB，请参阅Ruby驱动程序入门指南。
要学习；了解有关在Ruby驱动程序中执行聚合的更多信息，请参阅聚合指南。
安装驾驶员后，创建一个名为 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
对于每个教程，您必须用部署的连接字符串替换连接字符串占位符。
提示
要学习；了解如何查找部署的连接字符串，请参阅Ruby入门指南的创建连接字符串步骤。
例如，如果连接字符串为 "mongodb+srv://mongodb-example:27017"，则其赋值应如下所示：
uri = "mongodb+srv://mongodb-example:27017"
创建集合
此示例使用 orders集合，其中包含描述单个产品订单的文档。由于每个订单只对应一个客户，因此聚合按 customer_id字段（包含客户电子邮件地址）对订单文档进行分组。
要创建 orders集合并插入示例数据，请将以下代码添加到您的应用程序中：
orders = agg_db[:orders] orders.delete_many({}) orders.insert_many( [ { customer_id: "elise_smith@myemail.com", orderdate: DateTime.parse("2020-05-30T08:35:52Z"), value: 231, }, { customer_id: "elise_smith@myemail.com", orderdate: DateTime.parse("2020-01-13T09:32:07Z"), value: 99, }, { customer_id: "oranieri@warmmail.com", orderdate: DateTime.parse("2020-01-01T08:25:37Z"), value: 63, }, { customer_id: "tj@wheresmyemail.com", orderdate: DateTime.parse("2019-05-28T19:13:32Z"), value: 2, }, { customer_id: "tj@wheresmyemail.com", orderdate: DateTime.parse("2020-11-23T22:56:53Z"), value: 187, }, { customer_id: "tj@wheresmyemail.com", orderdate: DateTime.parse("2020-08-18T23:04:48Z"), value: 4, }, { customer_id: "elise_smith@myemail.com", orderdate: DateTime.parse("2020-12-26T08:55:46Z"), value: 4, }, { customer_id: "tj@wheresmyemail.com", orderdate: DateTime.parse("2021-02-28T07:49:32Z"), value: 1024, }, { customer_id: "elise_smith@myemail.com", orderdate: DateTime.parse("2020-10-03T13:49:44Z"), value: 102, }, ] )
创建模板应用
在开始学习本聚合教程之前，您必须设立一个新的Rust应用。您可以使用此应用连接到MongoDB 部署，将示例数据插入MongoDB，然后运行聚合管道。
提示
要学习；了解如何安装驾驶员并连接到MongoDB，请参阅Rust驱动程序快速入门指南。
要学习；了解有关在Rust驱动程序中执行聚合的更多信息，请参阅聚合指南。
安装驾驶员后，创建一个名为 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(()) }
对于每个教程，您必须用部署的连接字符串替换连接字符串占位符。
提示
要学习；了解如何找到部署的连接字符串，请参阅Rust快速入门指南的创建连接字符串步骤。
例如，如果连接字符串为 "mongodb+srv://mongodb-example:27017"，则其赋值应如下所示：
let uri = "mongodb+srv://mongodb-example:27017";
创建集合
此示例使用 orders集合，其中包含描述单个产品订单的文档。由于每个订单只对应一个客户，因此聚合按 customer_id字段（包含客户电子邮件地址）对订单文档进行分组。
首先，创建一个Rust结构体来对 orders集合中的数据进行建模：
struct Order { customer_id: String, orderdate: DateTime, value: i32, }
要创建 orders集合并插入示例数据，请将以下代码添加到您的应用程序中：
let orders: Collection<Order> = agg_db.collection("orders"); orders.delete_many(doc! {}).await?; let docs = vec![ Order { customer_id: "elise_smith@myemail.com".to_string(), orderdate: DateTime::builder().year(2020).month(5).day(30).hour(8).minute(35).second(53).build().unwrap(), value: 231, }, Order { customer_id: "elise_smith@myemail.com".to_string(), orderdate: DateTime::builder().year(2020).month(1).day(13).hour(9).minute(32).second(7).build().unwrap(), value: 99, }, Order { customer_id: "oranieri@warmmail.com".to_string(), orderdate: DateTime::builder().year(2020).month(1).day(1).hour(8).minute(25).second(37).build().unwrap(), value: 63, }, Order { customer_id: "tj@wheresmyemail.com".to_string(), orderdate: DateTime::builder().year(2019).month(5).day(28).hour(19).minute(13).second(32).build().unwrap(), value: 2, }, Order { customer_id: "tj@wheresmyemail.com".to_string(), orderdate: DateTime::builder().year(2020).month(11).day(23).hour(22).minute(56).second(53).build().unwrap(), value: 187, }, Order { customer_id: "tj@wheresmyemail.com".to_string(), orderdate: DateTime::builder().year(2020).month(8).day(18).hour(23).minute(4).second(48).build().unwrap(), value: 4, }, Order { customer_id: "elise_smith@myemail.com".to_string(), orderdate: DateTime::builder().year(2020).month(12).day(26).hour(8).minute(55).second(46).build().unwrap(), value: 4, }, Order { customer_id: "tj@wheresmyemail.com".to_string(), orderdate: DateTime::builder().year(2021).month(2).day(28).hour(7).minute(49).second(32).build().unwrap(), value: 1024, }, Order { customer_id: "elise_smith@myemail.com".to_string(), orderdate: DateTime::builder().year(2020).month(10).day(3).hour(13).minute(49).second(44).build().unwrap(), value: 102, }, ]; orders.insert_many(docs).await?;
创建模板应用
在开始学习聚合教程之前，您必须设立一个新的Scala应用。您可以使用此应用连接到MongoDB 部署，将示例数据插入MongoDB，然后运行聚合管道。
提示
要学习；了解如何安装驾驶员并连接到MongoDB，请参阅Scala驱动程序指南。
要学习；了解有关在Scala驱动程序中执行聚合的更多信息，请参阅聚合指南。
安装驾驶员后，创建一个名为 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() } }
对于每个教程，您必须用部署的连接字符串替换连接字符串占位符。
提示
要学习；了解如何找到部署的连接字符串，请参阅Scala驱动程序入门指南中的创建连接字符串步骤。
例如，如果连接字符串为 "mongodb+srv://mongodb-example:27017"，则其赋值应如下所示：
val uri = "mongodb+srv://mongodb-example:27017"
创建集合
此示例使用 orders集合，其中包含描述单个产品订单的文档。由于每个订单只对应一个客户，因此聚合按 customer_id字段（包含客户电子邮件地址）对订单文档进行分组。
要创建 orders集合并插入示例数据，请将以下代码添加到您的应用程序中：
val orders = aggDB.getCollection("orders") orders.deleteMany(Filters.empty()).subscribe( _ => {}, e => println("Error: " + e.getMessage), ) val dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss") orders.insertMany(Seq( Document("customer_id" -> "elise_smith@myemail.com", "orderdate" -> dateFormat.parse("2020-05-30T08:35:52"), "value" -> 231), Document("customer_id" -> "elise_smith@myemail.com", "orderdate" -> dateFormat.parse("2020-01-13T09:32:07"), "value" -> 99), Document("customer_id" -> "oranieri@warmmail.com", "orderdate" -> dateFormat.parse("2020-01-01T08:25:37"), "value" -> 63), Document("customer_id" -> "tj@wheresmyemail.com", "orderdate" -> dateFormat.parse("2019-05-28T19:13:32"), "value" -> 2), Document("customer_id" -> "tj@wheresmyemail.com", "orderdate" -> dateFormat.parse("2020-11-23T22:56:53"), "value" -> 187), Document("customer_id" -> "tj@wheresmyemail.com", "orderdate" -> dateFormat.parse("2020-08-18T23:04:48"), "value" -> 4), Document("customer_id" -> "elise_smith@myemail.com", "orderdate" -> dateFormat.parse("2020-12-26T08:55:46"), "value" -> 4), Document("customer_id" -> "tj@wheresmyemail.com", "orderdate" -> dateFormat.parse("2021-02-28T07:49:32"), "value" -> 1024), Document("customer_id" -> "elise_smith@myemail.com", "orderdate" -> dateFormat.parse("2020-10-03T13:49:44"), "value" -> 102) )).subscribe( _ => {}, e => println("Error: " + e.getMessage), )
步骤
以下步骤演示了如何创建和运行聚合管道以对文档群组并计算新字段。
1
运行聚合管道。
db.orders.aggregate( [ // Stage 1: Match orders in 2020 { $match: { orderdate: { $gte: new Date("2020-01-01T00:00:00Z"), $lt: new Date("2021-01-01T00:00:00Z"), } } }, // Stage 2: Sort orders by date { $sort: { orderdate: 1 } }, // Stage 3: Group orders by email address { $group: { _id: "$customer_id", first_purchase_date: { $first: "$orderdate" }, total_value: { $sum: "$value" }, total_orders: { $sum: 1 }, orders: { $push: { orderdate: "$orderdate", value: "$value" } } } }, // Stage 4: Sort orders by first order date { $sort: { first_purchase_date: 1 } }, // Stage 5: Display the customers' email addresses { $set: { customer_id: "$_id" } }, // Stage 6: Remove unneeded fields { $unset: ["_id"] } ] )
2
解释聚合结果。
该聚合返回来自 2020 的客户订单的以下摘要。结果文档包含给定客户下的所有订单的详细信息，按客户的电子邮件解决分组。
{ first_purchase_date: ISODate("2020-01-01T08:25:37.000Z"), total_value: 63, total_orders: 1, orders: [ { orderdate: ISODate("2020-01-01T08:25:37.000Z"), value: 63 } ], customer_id: 'oranieri@warmmail.com' } { first_purchase_date: ISODate("2020-01-13T09:32:07.000Z"), total_value: 436, total_orders: 4, orders: [ { orderdate: ISODate("2020-01-13T09:32:07.000Z"), value: 99 }, { orderdate: ISODate("2020-05-30T08:35:52.000Z"), value: 231 }, { orderdate: ISODate("2020-10-03T13:49:44.000Z"), value: 102 }, { orderdate: ISODate("2020-12-26T08:55:46.000Z"), value: 4 } ], customer_id: 'elise_smith@myemail.com' } { first_purchase_date: ISODate("2020-08-18T23:04:48.000Z"), total_value: 191, total_orders: 2, orders: [ { orderdate: ISODate("2020-08-18T23:04:48.000Z"), value: 4 }, { orderdate: ISODate("2020-11-23T22:56:53.000Z"), value: 187 } ], customer_id: 'tj@wheresmyemail.com' }
1
为 2020 中的订单添加匹配阶段。
首先，添加一个$match阶段，用于匹配 2020 中所下订单：
"{", "$match", "{", "orderdate", "{", "$gte", BCON_DATE_TIME(1577836800000UL), // Represents 2020-01-01T00:00:00Z "$lt", BCON_DATE_TIME(1609459200000UL), // Represents 2021-01-01T00:00:00Z "}", "}", "}",
2
添加排序阶段以按订单日期排序。
接下来，添加一个 $sort 阶段以对 orderdate字段设立升序排序，从而检索每个客户在下一阶段中最早的 2020 购买行为：
"{", "$sort", "{", "orderdate", BCON_INT32(1), "}", "}",
3
将群组阶段添加到按电子邮件解决群组。
添加 $group 阶段以按 customer_id字段的值收集订单文档。在此阶段，添加聚合操作，在结果文档中创建以下字段：
first_purchase_date：客户首次购买的日期total_value：客户所有购买的总价值total_orders：客户的购买总数orders：客户的所有购买清单，包括每次购买的日期和价值
"{", "$group", "{", "_id", BCON_UTF8("$customer_id"), "first_purchase_date", "{", "$first", BCON_UTF8("$orderdate"), "}", "total_value", "{", "$sum", BCON_UTF8("$value"), "}", "total_orders", "{", "$sum", BCON_INT32(1), "}", "orders", "{", "$push", "{", "orderdate", BCON_UTF8("$orderdate"), "value", BCON_UTF8("$value"), "}", "}", "}", "}",
4
添加排序阶段以按第一个订单日期排序。
接下来，添加另一个 $sort 阶段，对 first_purchase_date字段设立升序排序：
"{", "$sort", "{", "first_purchase_date", BCON_INT32(1), "}", "}",
5
添加设立阶段以显示电子邮件解决。
添加$set阶段，以根据 $group 阶段设立的_id字段中的值重新创建 customer_id字段：
"{", "$set", "{", "customer_id", BCON_UTF8("$_id"), "}", "}",
6
添加未设置阶段以删除不需要的字段。
最后，添加一个$unset阶段。$unset 阶段从结果文档中删除 _id字段：
"{", "$unset", "[", BCON_UTF8("_id"), "]", "}",
7
运行聚合管道。
将以下代码添加到应用程序末尾，以对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
提示
如果在一次调用中运行上述命令时遇到连接错误，可以单独运行。
8
解释聚合结果。
该聚合返回 2020 年以来客户订单的以下摘要：
{ "first_purchase_date" : { "$date" : { "$numberLong" : "1577865937000" } }, "total_value" : { "$numberInt" : "63" }, "total_orders" : { "$numberInt" : "1" }, "orders" : [ { "orderdate" : { "$date" : { "$numberLong" : "1577865937000" } }, "value" : { "$numberInt" : "63" } } ], "customer_id" : "oranieri@warmmail.com" } { "first_purchase_date" : { "$date" : { "$numberLong" : "1578904327000" } }, "total_value" : { "$numberInt" : "436" }, "total_orders" : { "$numberInt" : "4" }, "orders" : [ { "orderdate" : { "$date" : { "$numberLong" : "1578904327000" } }, "value" : { "$numberInt" : "99" } }, { "orderdate" : { "$date" : { "$numberLong" : "1590825352000" } }, "value" : { "$numberInt" : "231" } }, { "orderdate" : { "$date" : { "$numberLong" : "1601722184000" } }, "value" : { "$numberInt" : "102" } }, { "orderdate" : { "$date" : { "$numberLong" : "1608963346000" } }, "value" : { "$numberInt" : "4" } } ], "customer_id" : "elise_smith@myemail.com" } { "first_purchase_date" : { "$date" : { "$numberLong" : "1597793088000" } }, "total_value" : { "$numberInt" : "191" }, "total_orders" : { "$numberInt" : "2" }, "orders" : [ { "orderdate" : { "$date" : { "$numberLong" : "1597793088000" } }, "value" : { "$numberInt" : "4" } }, { "orderdate" : { "$date" : { "$numberLong" : "1606171013000" } }, "value" : { "$numberInt" : "187" } } ], "customer_id" : "tj@wheresmyemail.com" }
结果文档包含来自给定客户的所有订单的详细信息，按客户的电子邮件地址分组。
1
为 2020 中的订单添加匹配阶段。
首先，添加一个$match阶段，用于匹配 2020 中所下订单：
pipeline.match(bsoncxx::from_json(R"({ "orderdate": { "$gte": {"$date": 1577836800}, "$lt": {"$date": 1609459200000} } })"));
2
添加排序阶段以按订单日期排序。
接下来，添加一个 $sort 阶段以对 orderdate字段设立升序排序，从而检索每个客户在下一阶段中最早的 2020 购买行为：
pipeline.sort(bsoncxx::from_json(R"({ "orderdate": 1 })"));
3
将群组阶段添加到按电子邮件解决群组。
添加 $group 阶段以按 customer_id字段的值收集订单文档。在此阶段，添加聚合操作，在结果文档中创建以下字段：
first_purchase_date：客户首次购买的日期total_value：客户所有购买的总价值total_orders：客户的购买总数orders：客户的所有购买清单，包括每次购买的日期和价值
pipeline.group(bsoncxx::from_json(R"({ "_id": "$customer_id", "first_purchase_date": {"$first": "$orderdate"}, "total_value": {"$sum": "$value"}, "total_orders": {"$sum": 1}, "orders": {"$push": { "orderdate": "$orderdate", "value": "$value" }} })"));
4
添加排序阶段以按第一个订单日期排序。
接下来，添加另一个 $sort 阶段，对 first_purchase_date字段设立升序排序：
pipeline.sort(bsoncxx::from_json(R"({ "first_purchase_date": 1 })"));
5
添加 addFields 阶段以显示电子邮件解决。
添加 $addFields 阶段（$set 阶段的别名），以根据在 $group 阶段设立的_id字段中的值重新创建 customer_id字段：
pipeline.add_fields(bsoncxx::from_json(R"({ "customer_id": "$_id" })"));
6
添加未设置阶段以删除不需要的字段。
最后，添加一个$unset阶段。$unset 阶段从结果文档中删除 _id字段：
pipeline.append_stage(bsoncxx::from_json(R"({ "$unset": ["_id"] })"));
7
8
解释聚合结果。
该聚合返回 2020 年以来客户订单的以下摘要：
{ "first_purchase_date" : { "$date" : "1970-01-19T06:17:41.137Z" }, "total_value" : 63, "total_orders" : 1, "orders" : [ { "orderdate" : { "$date" : "1970-01-19T06:17:41.137Z" }, "value" : 63 } ], "customer_id" : "oranieri@warmmail.com" } { "first_purchase_date" : { "$date" : "1970-01-19T06:35:01.927Z" }, "total_value" : 436, "total_orders" : 4, "orders" : [ { "orderdate" : { "$date" : "1970-01-19T06:35:01.927Z" }, "value" : 99 }, { "orderdate" : { "$date" : "2020-05-30T06:55:52Z" }, "value" : 231 }, { "orderdate" : { "$date" : "2020-10-03T10:49:44Z" }, "value" : 102 }, { "orderdate" : { "$date" : "2020-12-26T08:55:46Z" }, "value" : 4 } ], "customer_id" : "elise_smith@myemail.com" } { "first_purchase_date" : { "$date" : "1970-01-19T11:49:54.288Z" }, "total_value" : 1215, "total_orders" : 3, "orders" : [ { "orderdate" : { "$date" : "1970-01-19T11:49:54.288Z" }, "value" : 4 }, { "orderdate" : { "$date" : "1970-01-19T14:09:32.213Z" }, "value" : 187 }, { "orderdate" : { "$date" : "1970-01-19T16:29:30.572Z" }, "value" : 1024 } ], "customer_id" : "tj@wheresmyemail.com" }
结果文档包含来自给定客户的所有订单的详细信息，按客户的电子邮件地址分组。
1
为 2020 中的订单添加匹配阶段。
首先，添加一个$match阶段，用于匹配 2020 中所下订单：
matchStage := bson.D{{Key: "$match", Value: bson.D{ {Key: "orderdate", Value: bson.D{ {Key: "$gte", Value: time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)}, {Key: "$lt", Value: time.Date(2021, 1, 1, 0, 0, 0, 0, time.UTC)}, }}, }}}
2
添加排序阶段以按订单日期排序。
接下来，添加一个 $sort 阶段以对 orderdate字段设立升序排序，从而检索每个客户在下一阶段中最早的 2020 购买行为：
sortStage1 := bson.D{{Key: "$sort", Value: bson.D{ {Key: "orderdate", Value: 1}, }}}
3
将群组阶段添加到按电子邮件解决群组。
添加 $group 阶段以按 customer_id字段的值收集订单文档。在此阶段，添加聚合操作，在结果文档中创建以下字段：
first_purchase_date：客户首次购买的日期total_value：客户所有购买的总价值total_orders：客户的购买总数orders：客户的所有购买清单，包括每次购买的日期和价值
groupStage := bson.D{{Key: "$group", Value: bson.D{ {Key: "_id", Value: "$customer_id"}, {Key: "first_purchase_date", Value: bson.D{{Key: "$first", Value: "$orderdate"}}}, {Key: "total_value", Value: bson.D{{Key: "$sum", Value: "$value"}}}, {Key: "total_orders", Value: bson.D{{Key: "$sum", Value: 1}}}, {Key: "orders", Value: bson.D{{Key: "$push", Value: bson.D{ {Key: "orderdate", Value: "$orderdate"}, {Key: "value", Value: "$value"}, }}}}, }}}
4
添加排序阶段以按第一个订单日期排序。
接下来，添加另一个 $sort 阶段，对 first_purchase_date字段设立升序排序：
sortStage2 := bson.D{{Key: "$sort", Value: bson.D{ {Key: "first_purchase_date", Value: 1}, }}}
5
添加设立阶段以显示电子邮件解决。
添加$set阶段，以根据 $group 阶段设立的_id字段中的值重新创建 customer_id字段：
setStage := bson.D{{Key: "$set", Value: bson.D{ {Key: "customer_id", Value: "$_id"}, }}}
6
添加未设置阶段以删除不需要的字段。
最后，添加一个$unset阶段。$unset 阶段从结果文档中删除 _id字段：
unsetStage := bson.D{{Key: "$unset", Value: bson.A{"_id"}}}
7
8
解释聚合结果。
该聚合返回 2020 年以来客户订单的以下摘要：
{"first_purchase_date":{"$date":"2020-01-01T08:25:37Z"},"total_value":63,"total_orders":1,"orders":[{"orderdate":{"$date":"2020-01-01T08:25:37Z"},"value":63}],"customer_id":"oranieri@warmmail.com"} {"first_purchase_date":{"$date":"2020-01-13T09:32:07Z"},"total_value":436,"total_orders":4,"orders":[{"orderdate":{"$date":"2020-01-13T09:32:07Z"},"value":99},{"orderdate":{"$date":"2020-05-30T08:35:53Z"},"value":231},{"orderdate":{"$date":"2020-10-03T13:49:44Z"},"value":102},{"orderdate":{"$date":"2020-12-26T08:55:46Z"},"value":4}],"customer_id":"elise_smith@myemail.com"} {"first_purchase_date":{"$date":"2020-08-18T23:04:48Z"},"total_value":191,"total_orders":2,"orders":[{"orderdate":{"$date":"2020-08-18T23:04:48Z"},"value":4},{"orderdate":{"$date":"2020-11-23T22:56:53Z"},"value":187}],"customer_id":"tj@wheresmyemail.com"}
结果文档包含来自给定客户的所有订单的详细信息，按客户的电子邮件地址分组。
1
为 2020 中的订单添加匹配阶段。
首先，添加一个$match阶段，用于匹配 2020 中所下订单：
pipeline.add(Aggregates.match(Filters.and( Filters.gte("orderdate", LocalDateTime.parse("2020-01-01T00:00:00")), Filters.lt("orderdate", LocalDateTime.parse("2021-01-01T00:00:00")) )));
2
添加排序阶段以按订单日期排序。
接下来，添加一个 $sort 阶段以对 orderdate字段设立升序排序，从而检索每个客户在下一阶段中最早的 2020 购买行为：
pipeline.add(Aggregates.sort(Sorts.ascending("orderdate")));
3
将群组阶段添加到按电子邮件解决群组。
添加 $group 阶段以按 customer_id字段的值收集订单文档。在此阶段，添加聚合操作，在结果文档中创建以下字段：
first_purchase_date：客户首次购买的日期total_value：客户所有购买的总价值total_orders：客户的购买总数orders：客户的所有购买清单，包括每次购买的日期和价值
pipeline.add(Aggregates.group( "$customer_id", Accumulators.first("first_purchase_date", "$orderdate"), Accumulators.sum("total_value", "$value"), Accumulators.sum("total_orders", 1), Accumulators.push("orders", new Document("orderdate", "$orderdate") .append("value", "$value") ) ));
4
添加排序阶段以按第一个订单日期排序。
接下来，添加另一个 $sort 阶段，对 first_purchase_date字段设立升序排序：
pipeline.add(Aggregates.sort(Sorts.ascending("first_purchase_date")));
5
添加设立阶段以显示电子邮件解决。
添加$set阶段，以根据 $group 阶段设立的_id字段中的值重新创建 customer_id字段：
pipeline.add(Aggregates.set(new Field<>("customer_id", "$_id")));
6
添加未设置阶段以删除不需要的字段。
最后，添加一个$unset阶段。$unset 阶段从结果文档中删除 _id字段：
pipeline.add(Aggregates.unset("_id"));
7
8
解释聚合结果。
该聚合返回 2020 年以来客户订单的以下摘要：
{"first_purchase_date": {"$date": "2020-01-01T08:25:37Z"}, "total_value": 63, "total_orders": 1, "orders": [{"orderdate": {"$date": "2020-01-01T08:25:37Z"}, "value": 63}], "customer_id": "oranieri@warmmail.com"} {"first_purchase_date": {"$date": "2020-01-13T09:32:07Z"}, "total_value": 436, "total_orders": 4, "orders": [{"orderdate": {"$date": "2020-01-13T09:32:07Z"}, "value": 99}, {"orderdate": {"$date": "2020-05-30T08:35:52Z"}, "value": 231}, {"orderdate": {"$date": "2020-10-03T13:49:44Z"}, "value": 102}, {"orderdate": {"$date": "2020-12-26T08:55:46Z"}, "value": 4}], "customer_id": "elise_smith@myemail.com"} {"first_purchase_date": {"$date": "2020-08-18T23:04:48Z"}, "total_value": 191, "total_orders": 2, "orders": [{"orderdate": {"$date": "2020-08-18T23:04:48Z"}, "value": 4}, {"orderdate": {"$date": "2020-11-23T22:56:53Z"}, "value": 187}], "customer_id": "tj@wheresmyemail.com"}
结果文档包含来自给定客户的所有订单的详细信息，按客户的电子邮件地址分组。
1
为 2020 中的订单添加匹配阶段。
首先，添加一个$match阶段，用于匹配 2020 中所下订单：
pipeline.add( Aggregates.match( Filters.and( Filters.gte(Order::orderDate.name, LocalDateTime.parse("2020-01-01T00:00:00").toJavaLocalDateTime()), Filters.lt(Order::orderDate.name, LocalDateTime.parse("2021-01-01T00:00:00").toJavaLocalDateTime()) ) ) )
2
添加排序阶段以按订单日期排序。
接下来，添加一个 $sort 阶段以对 orderDate字段设立升序排序，从而检索每个客户在下一阶段中最早的 2020 购买行为：
pipeline.add(Aggregates.sort(Sorts.ascending(Order::orderDate.name)))
3
将群组阶段添加到按电子邮件解决群组。
添加 $group 阶段以按 customer_id字段的值收集订单文档。在此阶段，添加聚合操作，在结果文档中创建以下字段：
first_purchase_date：客户首次购买的日期total_value：客户所有购买的总价值total_orders：客户的购买总数orders：客户的所有购买清单，包括每次购买的日期和价值
pipeline.add( Aggregates.group( "\$${Order::customerID.name}", Accumulators.first("first_purchase_date", "\$${Order::orderDate.name}"), Accumulators.sum("total_value", "\$${Order::value.name}"), Accumulators.sum("total_orders", 1), Accumulators.push( "orders", Document("orderdate", "\$${Order::orderDate.name}") .append("value", "\$${Order::value.name}") ) ) )
4
添加排序阶段以按第一个订单日期排序。
接下来，添加另一个 $sort 阶段，对 first_purchase_date字段设立升序排序：
pipeline.add(Aggregates.sort(Sorts.ascending("first_purchase_date")))
5
添加设立阶段以显示电子邮件解决。
添加$set阶段，以根据 $group 阶段设立的_id字段中的值重新创建 customer_id字段：
pipeline.add(Aggregates.set(Field("customer_id", "\$_id")))
6
添加未设置阶段以删除不需要的字段。
最后，添加一个$unset阶段。$unset 阶段从结果文档中删除 _id字段：
pipeline.add(Aggregates.unset("_id"))
7
8
解释聚合结果。
该聚合返回 2020 年以来客户订单的以下摘要：
Document{{first_purchase_date=Wed Jan 01 03:25:37 EST 2020, total_value=63, total_orders=1, orders=[Document{{orderdate=Wed Jan 01 03:25:37 EST 2020, value=63}}], customer_id=oranieri@warmmail.com}} Document{{first_purchase_date=Mon Jan 13 04:32:07 EST 2020, total_value=436, total_orders=4, orders=[Document{{orderdate=Mon Jan 13 04:32:07 EST 2020, value=99}}, Document{{orderdate=Sat May 30 04:35:52 EDT 2020, value=231}}, Document{{orderdate=Sat Oct 03 09:49:44 EDT 2020, value=102}}, Document{{orderdate=Sat Dec 26 03:55:46 EST 2020, value=4}}], customer_id=elise_smith@myemail.com}} Document{{first_purchase_date=Tue Aug 18 19:04:48 EDT 2020, total_value=191, total_orders=2, orders=[Document{{orderdate=Tue Aug 18 19:04:48 EDT 2020, value=4}}, Document{{orderdate=Mon Nov 23 17:56:53 EST 2020, value=187}}], customer_id=tj@wheresmyemail.com}}
结果文档包含来自给定客户的所有订单的详细信息，按客户的电子邮件地址分组。
1
为 2020 中的订单添加匹配阶段。
首先，添加一个$match阶段，用于匹配 2020 中所下订单：
pipeline.push({ $match: { orderdate: { $gte: new Date("2020-01-01T00:00:00Z"), $lt: new Date("2021-01-01T00:00:00Z"), }, }, });
2
添加排序阶段以按订单日期排序。
接下来，添加一个 $sort 阶段以对 orderdate字段设立升序排序，从而检索每个客户在下一阶段中最早的 2020 购买行为：
pipeline.push({ $sort: { orderdate: 1, }, });
3
将群组阶段添加到按电子邮件解决群组。
添加 $group 阶段，以按 customer_id字段的值对订单群组。在此阶段，添加聚合操作，在结果文档中创建以下字段：
first_purchase_date：客户首次购买的日期total_value：客户所有购买的总价值total_orders：客户的购买总数orders：客户的所有购买清单，包括每次购买的日期和价值
pipeline.push({ $group: { _id: "$customer_id", first_purchase_date: { $first: "$orderdate" }, total_value: { $sum: "$value" }, total_orders: { $sum: 1 }, orders: { $push: { orderdate: "$orderdate", value: "$value", }, }, }, });
4
添加排序阶段以按第一个订单日期排序。
接下来，添加另一个 $sort 阶段，对 first_purchase_date字段设立升序排序：
pipeline.push({ $sort: { first_purchase_date: 1, }, });
5
添加设立阶段以显示电子邮件解决。
添加$set阶段，以根据 $group 阶段设立的_id字段中的值重新创建 customer_id字段：
pipeline.push({ $set: { customer_id: "$_id", }, });
6
添加未设置阶段以删除不需要的字段。
最后，添加一个$unset阶段。$unset 阶段从结果文档中删除 _id字段：
pipeline.push({ $unset: ["_id"] });
7
8
解释聚合结果。
该聚合返回 2020 年以来客户订单的以下摘要：
{ first_purchase_date: 2020-01-01T08:25:37.000Z, total_value: 63, total_orders: 1, orders: [ { orderdate: 2020-01-01T08:25:37.000Z, value: 63 } ], customer_id: 'oranieri@warmmail.com' } { first_purchase_date: 2020-01-13T09:32:07.000Z, total_value: 436, total_orders: 4, orders: [ { orderdate: 2020-01-13T09:32:07.000Z, value: 99 }, { orderdate: 2020-05-30T08:35:52.000Z, value: 231 }, { orderdate: 2020-10-03T13:49:44.000Z, value: 102 }, { orderdate: 2020-12-26T08:55:46.000Z, value: 4 } ], customer_id: 'elise_smith@myemail.com' } { first_purchase_date: 2020-08-18T23:04:48.000Z, total_value: 191, total_orders: 2, orders: [ { orderdate: 2020-08-18T23:04:48.000Z, value: 4 }, { orderdate: 2020-11-23T22:56:53.000Z, value: 187 } ], customer_id: 'tj@wheresmyemail.com' }
结果文档包含来自给定客户的所有订单的详细信息，按客户的电子邮件地址分组。
1
为 2020 中的订单添加匹配阶段。
在 Pipeline 实例中，添加一个$match 阶段，用于匹配在 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'))), ] ),
2
添加排序阶段以按订单日期排序。
接下来，添加一个 $sort 阶段以对 orderdate字段设立升序排序，从而检索每个客户在下一阶段中最早的 2020 购买行为：
Stage::sort(orderdate: Sort::Asc),
3
将群组阶段添加到按电子邮件解决群组。
在 Pipeline 实例之外，在工厂函数中创建 $group 阶段，以按 customer_id 字段的值收集订单文档。在此阶段，添加聚合操作，在结果文档中创建以下字段：
first_purchase_date：客户首次购买的日期total_value：客户所有购买的总价值total_orders：客户的购买总数orders：客户的所有购买清单，包括每次购买的日期和价值
function groupByCustomerStage() { return Stage::group( _id: Expression::stringFieldPath('customer_id'), first_purchase_date: Accumulator::first( Expression::arrayFieldPath('orderdate') ), total_value: Accumulator::sum( Expression::numberFieldPath('value'), ), total_orders: Accumulator::sum(1), orders: Accumulator::push( object( orderdate: Expression::dateFieldPath('orderdate'), value: Expression::numberFieldPath('value'), ), ), ); }
然后，在 Pipeline实例中调用 groupByCustomerStage() 函数：
groupByCustomerStage(),
4
添加排序阶段以按第一个订单日期排序。
接下来，创建另一个 $sort 阶段，对 first_purchase_date字段设立升序排序：
Stage::sort(first_purchase_date: Sort::Asc),
5
添加设立阶段以显示电子邮件解决。
添加$set阶段，以根据 $group 阶段设立的_id字段中的值重新创建 customer_id字段：
Stage::set(customer_id: Expression::stringFieldPath('_id')),
6
添加未设置阶段以删除不需要的字段。
最后，添加一个$unset阶段。$unset 阶段从结果文档中删除 _id字段：
Stage::unset('_id')
7
8
解释聚合结果。
该聚合返回 2020 年以来客户订单的以下摘要：
{ "first_purchase_date": { "$date": { "$numberLong": "1577867137000" } }, "total_value": 63, "total_orders": 1, "orders": [ { "orderdate": { "$date": { "$numberLong": "1577867137000" } }, "value": 63 } ], "customer_id": "oranieri@warmmail.com" } { "first_purchase_date": { "$date": { "$numberLong": "1578907927000" } }, "total_value": 436, "total_orders": 4, "orders": [ { "orderdate": { "$date": { "$numberLong": "1578907927000" } }, "value": 99 }, { "orderdate": { "$date": { "$numberLong": "1590827752000" } }, "value": 231 }, { "orderdate": { "$date": { "$numberLong": "1601732984000" } }, "value": 102 }, { "orderdate": { "$date": { "$numberLong": "1608972946000" } }, "value": 4 } ], "customer_id": "elise_smith@myemail.com" } { "first_purchase_date": { "$date": { "$numberLong": "1597791888000" } }, "total_value": 191, "total_orders": 2, "orders": [ { "orderdate": { "$date": { "$numberLong": "1597791888000" } }, "value": 4 }, { "orderdate": { "$date": { "$numberLong": "1606172213000" } }, "value": 187 } ], "customer_id": "tj@wheresmyemail.com" }
结果文档包含来自给定客户的所有订单的详细信息，按客户的电子邮件地址分组。
1
为 2020 中的订单添加匹配阶段。
在 Pipeline 实例中，添加一个$match 阶段，用于匹配在 2020 中下达的订单：
pipeline.append( { "$match": { "orderdate": { "$gte": datetime(2020, 1, 1, 0, 0, 0), "$lt": datetime(2021, 1, 1, 0, 0, 0), } } } )
2
添加排序阶段以按订单日期排序。
接下来，添加一个 $sort 阶段以对 orderdate字段设立升序排序，从而检索每个客户在下一阶段中最早的 2020 购买行为：
pipeline.append({"$sort": {"orderdate": 1}})
3
将群组阶段添加到按电子邮件解决群组。
添加 $group 阶段，以按 customer_id字段的值对订单群组。在此阶段，添加聚合操作，在结果文档中创建以下字段：
first_purchase_date：客户首次购买的日期total_value：客户所有购买的总价值total_orders：客户的购买总数orders：客户的所有购买清单，包括每次购买的日期和价值
pipeline.append( { "$group": { "_id": "$customer_id", "first_purchase_date": {"$first": "$orderdate"}, "total_value": {"$sum": "$value"}, "total_orders": {"$sum": 1}, "orders": {"$push": {"orderdate": "$orderdate", "value": "$value"}}, } } )
4
添加排序阶段以按第一个订单日期排序。
接下来，创建另一个 $sort 阶段，对 first_purchase_date字段设立升序排序：
pipeline.append({"$sort": {"first_purchase_date": 1}})
5
添加设立阶段以显示电子邮件解决。
添加$set阶段，以根据 $group 阶段设立的_id字段中的值重新创建 customer_id字段：
pipeline.append({"$set": {"customer_id": "$_id"}})
6
添加未设置阶段以删除不需要的字段。
最后，添加一个$unset阶段。$unset 阶段从结果文档中删除 _id字段：
pipeline.append({"$unset": ["_id"]})
7
8
解释聚合结果。
该聚合返回 2020 年以来客户订单的以下摘要：
{'first_purchase_date': datetime.datetime(2020, 1, 1, 8, 25, 37), 'total_value': 63, 'total_orders': 1, 'orders': [{'orderdate': datetime.datetime(2020, 1, 1, 8, 25, 37), 'value': 63}], 'customer_id': 'oranieri@warmmail.com'} {'first_purchase_date': datetime.datetime(2020, 1, 13, 9, 32, 7), 'total_value': 436, 'total_orders': 4, 'orders': [{'orderdate': datetime.datetime(2020, 1, 13, 9, 32, 7), 'value': 99}, {'orderdate': datetime.datetime(2020, 5, 30, 8, 35, 52), 'value': 231}, {'orderdate': datetime.datetime(2020, 10, 3, 13, 49, 44), 'value': 102}, {'orderdate': datetime.datetime(2020, 12, 26, 8, 55, 46), 'value': 4}], 'customer_id': 'elise_smith@myemail.com'} {'first_purchase_date': datetime.datetime(2020, 8, 18, 23, 4, 48), 'total_value': 191, 'total_orders': 2, 'orders': [{'orderdate': datetime.datetime(2020, 8, 18, 23, 4, 48), 'value': 4}, {'orderdate': datetime.datetime(2020, 11, 23, 22, 56, 53), 'value': 187}], 'customer_id': 'tj@wheresmyemail.com'}
结果文档包含来自给定客户的所有订单的详细信息，按客户的电子邮件地址分组。
1
为 2020 中的订单添加匹配阶段。
首先，添加一个$match阶段，用于匹配 2020 中所下订单：
{ "$match": { orderdate: { "$gte": DateTime.parse("2020-01-01T00:00:00Z"), "$lt": DateTime.parse("2021-01-01T00:00:00Z"), }, }, },
2
添加排序阶段以按订单日期排序。
接下来，添加一个 $sort 阶段以对 orderdate字段设立升序排序，从而检索每个客户在下一阶段中最早的 2020 购买行为：
{ "$sort": { orderdate: 1, }, },
3
将群组阶段添加到按电子邮件解决群组。
添加 $group 阶段以按 customer_id字段的值收集订单文档。在此阶段，添加聚合操作，在结果文档中创建以下字段：
first_purchase_date：客户首次购买的日期total_value：客户所有购买的总价值total_orders：客户的购买总数orders：客户的所有购买清单，包括每次购买的日期和价值
{ "$group": { _id: "$customer_id", first_purchase_date: { "$first": "$orderdate" }, total_value: { "$sum": "$value" }, total_orders: { "$sum": 1 }, orders: { "$push": { orderdate: "$orderdate", value: "$value", } }, }, },
4
添加排序阶段以按第一个订单日期排序。
接下来，添加另一个 $sort 阶段，对 first_purchase_date字段设立升序排序：
{ "$sort": { first_purchase_date: 1, }, },
5
添加设立阶段以显示电子邮件解决。
添加$set阶段，以根据 $group 阶段设立的_id字段中的值重新创建 customer_id字段：
{ "$set": { customer_id: "$_id", }, },
6
添加未设置阶段以删除不需要的字段。
最后，添加一个$unset阶段。$unset 阶段从结果文档中删除 _id字段：
{ "$unset": ["_id"] },
7
8
解释聚合结果。
该聚合返回 2020 年以来客户订单的以下摘要：
{"first_purchase_date"=>2020-01-01 08:25:37 UTC, "total_value"=>63, "total_orders"=>1, "orders"=>[{"orderdate"=>2020-01-01 08:25:37 UTC, "value"=>63}], "customer_id"=>"oranieri@warmmail.com"} {"first_purchase_date"=>2020-01-13 09:32:07 UTC, "total_value"=>436, "total_orders"=>4, "orders"=>[{"orderdate"=>2020-01-13 09:32:07 UTC, "value"=>99}, {"orderdate"=>2020-05-30 08:35:52 UTC, "value"=>231}, {"orderdate"=>2020-10-03 13:49:44 UTC, "value"=>102}, {"orderdate"=>2020-12-26 08:55:46 UTC, "value"=>4}], "customer_id"=>"elise_smith@myemail.com"} {"first_purchase_date"=>2020-08-18 23:04:48 UTC, "total_value"=>191, "total_orders"=>2, "orders"=>[{"orderdate"=>2020-08-18 23:04:48 UTC, "value"=>4}, {"orderdate"=>2020-11-23 22:56:53 UTC, "value"=>187}], "customer_id"=>"tj@wheresmyemail.com"}
结果文档包含来自给定客户的所有订单的详细信息，按客户的电子邮件地址分组。
1
为 2020 中的订单添加匹配阶段。
首先，添加一个$match阶段，用于匹配 2020 中所下订单：
pipeline.push(doc! { "$match": { "orderdate": { "$gte": DateTime::builder().year(2020).month(1).day(1).build().unwrap(), "$lt": DateTime::builder().year(2021).month(1).day(1).build().unwrap(), } } });
2
添加排序阶段以按订单日期排序。
接下来，添加一个 $sort 阶段以对 orderdate字段设立升序排序，从而检索每个客户在下一阶段中最早的 2020 购买行为：
pipeline.push(doc! { "$sort": { "orderdate": 1 } });
3
将群组阶段添加到按电子邮件解决群组。
添加 $group 阶段以按 customer_id字段的值收集订单文档。在此阶段，添加聚合操作，在结果文档中创建以下字段：
first_purchase_date：客户首次购买的日期total_value：客户所有购买的总价值total_orders：客户的购买总数orders：客户的所有购买清单，包括每次购买的日期和价值
pipeline.push(doc! { "$group": { "_id": "$customer_id", "first_purchase_date": { "$first": "$orderdate" }, "total_value": { "$sum": "$value" }, "total_orders": { "$sum": 1 }, "orders": { "$push": { "orderdate": "$orderdate", "value": "$value" } } } });
4
添加排序阶段以按第一个订单日期排序。
接下来，添加另一个 $sort 阶段，对 first_purchase_date字段设立升序排序：
pipeline.push(doc! { "$sort": { "first_purchase_date": 1 } });
5
添加设立阶段以显示电子邮件解决。
添加$set阶段，以根据 $group 阶段设立的_id字段中的值重新创建 customer_id字段：
pipeline.push(doc! { "$set": { "customer_id": "$_id" } });
6
添加未设置阶段以删除不需要的字段。
最后，添加一个$unset阶段。$unset 阶段从结果文档中删除 _id字段：
pipeline.push(doc! {"$unset": ["_id"] });
7
8
解释聚合结果。
该聚合返回 2020 年以来客户订单的以下摘要：
Document({"first_purchase_date": DateTime(2020-01-01 8:25:37.0 +00:00:00), "total_value": Int32(63), "total_orders": Int32(1), "orders": Array([Document({"orderdate": DateTime(2020-01-01 8:25:37.0 +00:00:00), "value": Int32(63)})]), "customer_id": String("oranieri@warmmail.com")}) Document({"first_purchase_date": DateTime(2020-01-13 9:32:07.0 +00:00:00), "total_value": Int32(436), "total_orders": Int32(4), "orders": Array([Document({"orderdate": DateTime(2020-01-13 9:32:07.0 +00:00:00), "value": Int32(99)}), Document({"orderdate": DateTime(2020-05-30 8:35:53.0 +00:00:00), "value": Int32(231)}), Document({"orderdate": DateTime(2020-10-03 13:49:44.0 +00:00:00), "value": Int32(102)}), Document({"orderdate": DateTime(2020-12-26 8:55:46.0 +00:00:00), "value": Int32(4)})]), "customer_id": String("elise_smith@myemail.com")}) Document({"first_purchase_date": DateTime(2020-08-18 23:04:48.0 +00:00:00), "total_value": Int32(191), "total_orders": Int32(2), "orders": Array([Document({"orderdate": DateTime(2020-08-18 23:04:48.0 +00:00:00), "value": Int32(4)}), Document({"orderdate": DateTime(2020-11-23 22:56:53.0 +00:00:00), "value": Int32(187)})]), "customer_id": String("tj@wheresmyemail.com")})
结果文档包含来自给定客户的所有订单的详细信息，按客户的电子邮件地址分组。
1
为 2020 中的订单添加匹配阶段。
首先，添加一个$match阶段，用于匹配 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")) )),
2
添加排序阶段以按订单日期排序。
接下来，添加一个 $sort 阶段以对 orderdate字段设立升序排序，从而检索每个客户在下一阶段中最早的 2020 购买行为：
Aggregates.sort(Sorts.ascending("orderdate")),
3
将群组阶段添加到按电子邮件解决群组。
添加 $group 阶段以按 customer_id字段的值收集订单文档。在此阶段，添加聚合操作，在结果文档中创建以下字段：
first_purchase_date：客户首次购买的日期total_value：客户所有购买的总价值total_orders：客户的购买总数orders：客户的所有购买清单，包括每次购买的日期和价值
Aggregates.group( "$customer_id", Accumulators.first("first_purchase_date", "$orderdate"), Accumulators.sum("total_value", "$value"), Accumulators.sum("total_orders", 1), Accumulators.push("orders", Document("orderdate" -> "$orderdate", "value" -> "$value")) ),
4
添加排序阶段以按第一个订单日期排序。
接下来，添加另一个 $sort 阶段，对 first_purchase_date字段设立升序排序：
Aggregates.sort(Sorts.ascending("first_purchase_date")),
5
添加设立阶段以显示电子邮件解决。
添加$set阶段，以根据 $group 阶段设立的_id字段中的值重新创建 customer_id字段：
Aggregates.set(Field("customer_id", "$_id")),
6
添加未设置阶段以删除不需要的字段。
最后，添加一个$unset阶段。$unset 阶段从结果文档中删除 _id字段：
Aggregates.unset("_id")
7
8
解释聚合结果。
该聚合返回 2020 年以来客户订单的以下摘要：
{"first_purchase_date": {"$date": "2020-01-01T13:25:37Z"}, "total_value": 63, "total_orders": 1, "orders": [{"orderdate": {"$date": "2020-01-01T13:25:37Z"}, "value": 63}], "customer_id": "oranieri@warmmail.com"} {"first_purchase_date": {"$date": "2020-01-13T14:32:07Z"}, "total_value": 436, "total_orders": 4, "orders": [{"orderdate": {"$date": "2020-01-13T14:32:07Z"}, "value": 99}, {"orderdate": {"$date": "2020-05-30T12:35:52Z"}, "value": 231}, {"orderdate": {"$date": "2020-10-03T17:49:44Z"}, "value": 102}, {"orderdate": {"$date": "2020-12-26T13:55:46Z"}, "value": 4}], "customer_id": "elise_smith@myemail.com"} {"first_purchase_date": {"$date": "2020-08-19T03:04:48Z"}, "total_value": 191, "total_orders": 2, "orders": [{"orderdate": {"$date": "2020-08-19T03:04:48Z"}, "value": 4}, {"orderdate": {"$date": "2020-11-24T03:56:53Z"}, "value": 187}], "customer_id": "tj@wheresmyemail.com"}
结果文档包含来自给定客户的所有订单的详细信息，按客户的电子邮件地址分组。