Perform Multi-Field Joins执行多字段联接

Create the Template App创建模板应用程序

Before you begin following this aggregation tutorial, you must set up a new C app. You can use this app to connect to a MongoDB deployment, insert sample data into MongoDB, and run the aggregation pipeline.在开始学习此聚合教程之前，您必须设置一个新的C应用程序。您可以使用此应用程序连接到MongoDB部署，将示例数据插入MongoDB，并运行聚合管道。

After you install the driver, create a file called agg-tutorial.c. Paste the following code in this file to create an app template for the aggregation tutorials.安装驱动程序后，创建一个名为agg-tutorial.c的文件。将以下代码粘贴到此文件中，为聚合教程创建应用程序模板。

#include <stdio.h>
#include <bson/bson.h>
#include <mongoc/mongoc.h>

int main(void)
{
    mongoc_init();

    // Replace the placeholder with your connection string.
    char *uri = "<connection string>";
    mongoc_client_t* client = mongoc_client_new(uri);

    // Get a reference to relevant collections.
    // ... mongoc_collection_t *some_coll = mongoc_client_get_collection(client, "agg_tutorials_db", "some_coll");
    // ... mongoc_collection_t *another_coll = mongoc_client_get_collection(client, "agg_tutorials_db", "another_coll");

    // Delete any existing documents in collections if needed.
    // ... {
    // ...     bson_t *filter = bson_new();
    // ...     bson_error_t error;
    // ...     if (!mongoc_collection_delete_many(some_coll, filter, NULL, NULL, &error))
    // ...     {
    // ...         fprintf(stderr, "Delete error: %s\n", error.message);
    // ...     }
    // ...     bson_destroy(filter);
    // ... }

    // Insert sample data into the collection or collections.
    // ... {
    // ...     size_t num_docs = ...;
    // ...     bson_t *docs[num_docs];
    // ...
    // ...     docs[0] = ...;
    // ...
    // ...     bson_error_t error;
    // ...     if (!mongoc_collection_insert_many(some_coll, (const bson_t **)docs, num_docs, NULL, NULL, &error))
    // ...     {
    // ...         fprintf(stderr, "Insert error: %s\n", error.message);
    // ...     }
    // ...
    // ...     for (int i = 0; i < num_docs; i++)
    // ...     {
    // ...         bson_destroy(docs[i]);
    // ...     }
    // ... }

    {
        const bson_t *doc;

        // Add code to create pipeline stages.
        bson_t *pipeline = BCON_NEW("pipeline", "[",
        // ... Add pipeline stages here.
        "]");

        // Run the aggregation.
        // ... mongoc_cursor_t *results = mongoc_collection_aggregate(some_coll, MONGOC_QUERY_NONE, pipeline, NULL, NULL);

        bson_destroy(pipeline);

        // Print the aggregation results.
        while (mongoc_cursor_next(results, &doc))
        {
            char *str = bson_as_canonical_extended_json(doc, NULL);
            printf("%s\n", str);
            bson_free(str);
        }
        bson_error_t error;
        if (mongoc_cursor_error(results, &error))
        {
            fprintf(stderr, "Aggregation error: %s\n", error.message);
        }

        mongoc_cursor_destroy(results);
    }

    // Clean up resources.
    // ... mongoc_collection_destroy(some_coll);
    mongoc_client_destroy(client);
    mongoc_cleanup();

    return EXIT_SUCCESS;
}

For every tutorial, you must replace the connection string placeholder with your deployment's connection string.对于每个教程，您必须将连接字符串占位符替换为部署的连接字符串。

For example, if your connection string is "mongodb+srv://mongodb-example:27017", your connection string assignment resembles the following:例如，如果连接字符串是"mongodb+srv://mongodb-example:27017"，连接字符串分配类似于以下内容：

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

Create the Collection创建集合

This example uses two collections:此示例使用两个集合：

• products, which contains documents describing the products that a shop sells，其中包含描述商店销售产品的文档
• orders, which contains documents describing individual orders for products in a shop，其中包含描述商店中产品的单个订单的文档

An order can only contain one product. The aggregation uses a multi-field join to match a product document to documents representing orders of that product. 一个订单只能包含一个产品。聚合使用多字段联接将产品文档与表示该产品订单的文档相匹配。The aggregation joins collections by the name and variation fields in documents in the products collection, corresponding to the product_name and product_variation fields in documents in the orders collection.聚合通过products集合中文档中的name和variation（变体）字段连接集合，对应于orders集合中文档的product_name和product_variation字段。

To create the products and orders collections and insert the sample data, add the following code to your application:要创建products和orders集合并插入示例数据，请将以下代码添加到应用程序中：

mongoc_collection_t *products = mongoc_client_get_collection(client, "agg_tutorials_db", "products");
mongoc_collection_t *orders = mongoc_client_get_collection(client, "agg_tutorials_db", "orders");

{
    bson_t *filter = bson_new();
    bson_error_t error;
    if (!mongoc_collection_delete_many(products, filter, NULL, NULL, &error))
    {
        fprintf(stderr, "Delete error: %s\n", error.message);
    }
    if (!mongoc_collection_delete_many(orders, filter, NULL, NULL, &error))
    {
        fprintf(stderr, "Delete error: %s\n", error.message);
    }
    bson_destroy(filter);
}

{
    size_t num_docs = 5;
    bson_t *product_docs[num_docs];

    product_docs[0] = BCON_NEW(
        "name", BCON_UTF8("Asus Laptop"),
        "variation", BCON_UTF8("Ultra HD"),
        "category", BCON_UTF8("ELECTRONICS"),
        "description", BCON_UTF8("Great for watching movies"));

    product_docs[1] = BCON_NEW(
        "name", BCON_UTF8("Asus Laptop"),
        "variation", BCON_UTF8("Standard Display"),
        "category", BCON_UTF8("ELECTRONICS"),
        "description", BCON_UTF8("Good value laptop for students"));

    product_docs[2] = BCON_NEW(
        "name", BCON_UTF8("The Day Of The Triffids"),
        "variation", BCON_UTF8("1st Edition"),
        "category", BCON_UTF8("BOOKS"),
        "description", BCON_UTF8("Classic post-apocalyptic novel"));

    product_docs[3] = BCON_NEW(
        "name", BCON_UTF8("The Day Of The Triffids"),
        "variation", BCON_UTF8("2nd Edition"),
        "category", BCON_UTF8("BOOKS"),
        "description", BCON_UTF8("Classic post-apocalyptic novel"));

    product_docs[4] = BCON_NEW(
        "name", BCON_UTF8("Morphy Richards Food Mixer"),
        "variation", BCON_UTF8("Deluxe"),
        "category", BCON_UTF8("KITCHENWARE"),
        "description", BCON_UTF8("Luxury mixer turning good cakes into great"));

    bson_error_t error;
    if (!mongoc_collection_insert_many(products, (const bson_t **)product_docs, num_docs, NULL, NULL, &error))
    {
        fprintf(stderr, "Insert error: %s\n", error.message);
    }

    for (int i = 0; i < num_docs; i++)
    {
        bson_destroy(product_docs[i]);
    }
}

{
    size_t num_docs = 4;
    bson_t *order_docs[num_docs];

    order_docs[0] = BCON_NEW(
        "customer_id", BCON_UTF8("elise_smith@myemail.com"),
        "orderdate", BCON_DATE_TIME(1590822952000UL), // 2020-05-30T08:35:52Z
        "product_name", BCON_UTF8("Asus Laptop"),
        "product_variation", BCON_UTF8("Standard Display"),
        "value", BCON_DOUBLE(431.43));

    order_docs[1] = BCON_NEW(
        "customer_id", BCON_UTF8("tj@wheresmyemail.com"),
        "orderdate", BCON_DATE_TIME(1559063612000UL), // 2019-05-28T19:13:32Z
        "product_name", BCON_UTF8("The Day Of The Triffids"),
        "product_variation", BCON_UTF8("2nd Edition"),
        "value", BCON_DOUBLE(5.01));

    order_docs[2] = BCON_NEW(
        "customer_id", BCON_UTF8("oranieri@warmmail.com"),
        "orderdate", BCON_DATE_TIME(1577869537000UL), // 2020-01-01T08:25:37Z
        "product_name", BCON_UTF8("Morphy Richards Food Mixer"),
        "product_variation", BCON_UTF8("Deluxe"),
        "value", BCON_DOUBLE(63.13));

    order_docs[3] = BCON_NEW(
        "customer_id", BCON_UTF8("jjones@tepidmail.com"),
        "orderdate", BCON_DATE_TIME(1608976546000UL), // 2020-12-26T08:55:46Z
        "product_name", BCON_UTF8("Asus Laptop"),
        "product_variation", BCON_UTF8("Standard Display"),
        "value", BCON_DOUBLE(429.65));

    bson_error_t error;
    if (!mongoc_collection_insert_many(orders, (const bson_t **)order_docs, num_docs, NULL, NULL, &error))
    {
        fprintf(stderr, "Insert error: %s\n", error.message);
    }

    for (int i = 0; i < num_docs; i++)
    {
        bson_destroy(order_docs[i]);
    }
}

Create the Template App创建模板应用程序

Before you begin following an aggregation tutorial, you must set up a new C++ app. You can use this app to connect to a MongoDB deployment, insert sample data into MongoDB, and run the aggregation pipeline.在开始学习聚合教程之前，您必须设置一个新的C++应用程序。您可以使用此应用程序连接到MongoDB部署，将示例数据插入MongoDB，并运行聚合管道。

After you install the driver, create a file called agg-tutorial.cpp. Paste the following code in this file to create an app template for the aggregation tutorials.安装驱动程序后，创建一个名为agg-tutorial.cpp的文件。将以下代码粘贴到此文件中，为聚合教程创建应用程序模板。

#include <iostream>
#include <bsoncxx/builder/basic/document.hpp>
#include <bsoncxx/builder/basic/kvp.hpp>
#include <bsoncxx/json.hpp>
#include <mongocxx/client.hpp>
#include <mongocxx/instance.hpp>
#include <mongocxx/pipeline.hpp>
#include <mongocxx/uri.hpp>
#include <chrono>

using bsoncxx::builder::basic::kvp;
using bsoncxx::builder::basic::make_document;
using bsoncxx::builder::basic::make_array;

int main() {
   mongocxx::instance instance;

   // Replace the placeholder with your connection string.
   mongocxx::uri uri("<connection string>");
   mongocxx::client client(uri);

   auto db = client["agg_tutorials_db"];
   // Delete existing data in the database, if necessary.
   db.drop();

   // Get a reference to relevant collections.
   // ... auto some_coll = db["..."];
   // ... auto another_coll = db["..."];

   // Insert sample data into the collection or collections.
   // ... some_coll.insert_many(docs);

   // Create an empty pipelne.
   mongocxx::pipeline pipeline;

   // Add code to create pipeline stages.
   // pipeline.match(make_document(...));

   // Run the aggregation and print the results.
   auto cursor = orders.aggregate(pipeline);
   for (auto&& doc : cursor) {
      std::cout << bsoncxx::to_json(doc, bsoncxx::ExtendedJsonMode::k_relaxed) << std::endl;
   }
}

For every tutorial, you must replace the connection string placeholder with your deployment's connection string.对于每个教程，您必须将连接字符串占位符替换为部署的连接字符串。

For example, if your connection string is "mongodb+srv://mongodb-example:27017", your connection string assignment resembles the following:例如，如果连接字符串是"mongodb+srv://mongodb-example:27017"，连接字符串分配类似于以下内容：

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

Create the Collection创建集合

This example uses two collections:此示例使用两个集合：

• products, which contains documents describing the products that a shop sells，其中包含描述商店销售产品的文档
• orders, which contains documents describing individual orders for products in a shop，其中包含描述商店中产品的单个订单的文档

An order can only contain one product. The aggregation uses a multi-field join to match a product document to documents representing orders of that product. 一个订单只能包含一个产品。聚合使用多字段联接将产品文档与表示该产品订单的文档相匹配。The aggregation joins collections by the name and variation fields in documents in the products collection, corresponding to the product_name and product_variation fields in documents in the orders collection.聚合通过products集合中文档中的name和variation（变体）字段连接集合，对应于orders集合中文档的product_name和product_variation字段。

To create the products and orders collections and insert the sample data, add the following code to your application:要创建products和orders集合并插入示例数据，请将以下代码添加到应用程序中：

auto products = db["products"];
auto orders = db["orders"];

std::vector<bsoncxx::document::value> product_docs = {
    bsoncxx::from_json(R"({
        "name": "Asus Laptop",
        "variation": "Ultra HD",
        "category": "ELECTRONICS",
        "description": "Great for watching movies"
    })"),
    bsoncxx::from_json(R"({
        "name": "Asus Laptop",
        "variation": "Standard Display",
        "category": "ELECTRONICS",
        "description": "Good value laptop for students"
    })"),
    bsoncxx::from_json(R"({
        "name": "The Day Of The Triffids",
        "variation": "1st Edition",
        "category": "BOOKS",
        "description": "Classic post-apocalyptic novel"
    })"),
    bsoncxx::from_json(R"({
        "name": "The Day Of The Triffids",
        "variation": "2nd Edition",
        "category": "BOOKS",
        "description": "Classic post-apocalyptic novel"
    })"),
    bsoncxx::from_json(R"({
        "name": "Morphy Richards Food Mixer",
        "variation": "Deluxe",
        "category": "KITCHENWARE",
        "description": "Luxury mixer turning good cakes into great"
    })")
};

products.insert_many(product_docs); // Might throw an exception

std::vector<bsoncxx::document::value> order_docs = {
    bsoncxx::from_json(R"({
        "customer_id": "elise_smith@myemail.com",
        "orderdate": {"$date": 1590821752000},
        "product_name": "Asus Laptop",
        "product_variation": "Standard Display",
        "value": 431.43
    })"),
    bsoncxx::from_json(R"({
        "customer_id": "tj@wheresmyemail.com",
        "orderdate": {"$date": 1559062412000},
        "product_name": "The Day Of The Triffids",
        "product_variation": "2nd Edition",
        "value": 5.01
    })"),
    bsoncxx::from_json(R"({
        "customer_id": "oranieri@warmmail.com",
        "orderdate": {"$date": 1577861137000},
        "product_name": "Morphy Richards Food Mixer",
        "product_variation": "Deluxe",
        "value": 63.13
    })"),
    bsoncxx::from_json(R"({
        "customer_id": "jjones@tepidmail.com",
        "orderdate": {"$date": 1608972946000},
        "product_name": "Asus Laptop",
        "product_variation": "Standard Display",
        "value": 429.65
    })")
};

orders.insert_many(order_docs); // Might throw an exception

Create the Template App创建模板应用程序

Before you begin following this aggregation tutorial, you must set up a new C#/.NET app. You can use this app to connect to a MongoDB deployment, insert sample data into MongoDB, and run the aggregation pipeline.在开始学习此聚合教程之前，您必须设置一个新的C#/NET应用程序。您可以使用此应用程序连接到MongoDB部署，将示例数据插入MongoDB，并运行聚合管道。

After you install the driver, paste the following code into your Program.cs file to create an app template for the aggregation tutorials.安装驱动程序后，将以下代码粘贴到Programs文件中，为聚合教程创建应用程序模板。

using MongoDB.Bson;
using MongoDB.Bson.Serialization.Attributes;
using MongoDB.Driver;

// Define data model classes.
// ... public class MyClass { ... }

// Replace the placeholder with your connection string.
var uri = "<connection string>";
var client = new MongoClient(uri);
var aggDB = client.GetDatabase("agg_tutorials_db");

// Get a reference to relevant collections.
// ... var someColl = aggDB.GetCollection<MyClass>("someColl");
// ... var anotherColl = aggDB.GetCollection<MyClass>("anotherColl");

// Delete any existing documents in collections if needed.
// ... someColl.DeleteMany(Builders<MyClass>.Filter.Empty);

// Insert sample data into the collection or collections.
// ... someColl.InsertMany(new List<MyClass> { ... });

// Add code to chain pipeline stages to the Aggregate() method.
// ... var results = someColl.Aggregate().Match(...);

// Print the aggregation results.
foreach (var result in results.ToList())
{
    Console.WriteLine(result);
}

For every tutorial, you must replace the connection string placeholder with your deployment's connection string.对于每个教程，您必须将连接字符串占位符替换为部署的连接字符串。

For example, if your connection string is "mongodb+srv://mongodb-example:27017", your connection string assignment resembles the following:例如，如果连接字符串是"mongodb+srv://mongodb-example:27017"，连接字符串分配类似于以下内容：

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

Create the Collection创建集合

This example uses two collections:此示例使用两个集合：

• products, which contains documents describing the products that a shop sells，其中包含描述商店销售产品的文档
• orders, which contains documents describing individual orders for products in a shop，其中包含描述商店中产品的单个订单的文档

An order can only contain one product. The aggregation uses a multi-field join to match a product document to documents representing orders of that product. 一个订单只能包含一个产品。聚合使用多字段联接将产品文档与表示该产品订单的文档相匹配。The aggregation joins collections by the Name and Variation fields in documents in the products collection, corresponding to the ProductName and ProductVariation fields in documents in the orders collection.聚合通过products集合中文档中的Name和Variation（变体）字段连接集合，对应于orders集合中文档的ProductName和ProductVariation字段。

First, create C# classes to model the data in the products and orders collections:首先，创建C#类来对products和orders集合中的数据进行建模：

public class Product
{
    [BsonId]
    public ObjectId Id { get; set; }

    public string Name { get; set; } = "";
    public string Variation { get; set; } = "";
    public string Category { get; set; } = "";
    public string Description { get; set; } = "";
}

public class Order
{
    [BsonId]
    public ObjectId Id { get; set; }

    public required string CustomerId { get; set; }
    public DateTime OrderDate { get; set; }
    public string ProductName { get; set; } = "";
    public string ProductVariation { get; set; } = "";
    public double Value { get; set; }
}

To create the products and orders collections and insert the sample data, add the following code to your application:要创建products和orders集合并插入示例数据，请将以下代码添加到应用程序中：

var orders = aggDB.GetCollection<Order>("orders");
var products = aggDB.GetCollection<Product>("products");

products.InsertMany(new List<Product>
{
    new Product
    {
        Name = "Asus Laptop",
        Variation = "Ultra HD",
        Category = "ELECTRONICS",
        Description = "Great for watching movies"
    },
    new Product
    {
        Name = "Asus Laptop",
        Variation = "Standard Display",
        Category = "ELECTRONICS",
        Description = "Good value laptop for students"
    },
    new Product
    {
        Name = "The Day Of The Triffids",
        Variation = "1st Edition",
        Category = "BOOKS",
        Description = "Classic post-apocalyptic novel"
    },
    new Product
    {
        Name = "The Day Of The Triffids",
        Variation = "2nd Edition",
        Category = "BOOKS",
        Description = "Classic post-apocalyptic novel"
    },
    new Product
    {
        Name = "Morphy Richards Food Mixer",
        Variation = "Deluxe",
        Category = "KITCHENWARE",
        Description = "Luxury mixer turning good cakes into great"
    }
});

orders.InsertMany(new List<Order>
{
    new Order
    {
        CustomerId = "elise_smith@myemail.com",
        OrderDate = DateTime.Parse("2020-05-30T08:35:52Z"),
        ProductName = "Asus Laptop",
        ProductVariation = "Standard Display",
        Value = 431.43
    },
    new Order
    {
        CustomerId = "tj@wheresmyemail.com",
        OrderDate = DateTime.Parse("2019-05-28T19:13:32Z"),
        ProductName = "The Day Of The Triffids",
        ProductVariation = "2nd Edition",
        Value = 5.01
    },
    new Order
    {
        CustomerId = "oranieri@warmmail.com",
        OrderDate = DateTime.Parse("2020-01-01T08:25:37Z"),
        ProductName = "Morphy Richards Food Mixer",
        ProductVariation = "Deluxe",
        Value = 63.13
    },
    new Order
    {
        CustomerId = "jjones@tepidmail.com",
        OrderDate = DateTime.Parse("2020-12-26T08:55:46Z"),
        ProductName = "Asus Laptop",
        ProductVariation = "Standard Display",
        Value = 429.65
    }
});

Create the Template App创建模板应用程序

Before you begin following this aggregation tutorial, you must set up a new Go app. You can use this app to connect to a MongoDB deployment, insert sample data into MongoDB, and run the aggregation pipeline.在开始学习此聚合教程之前，您必须设置一个新的Go应用程序。您可以使用此应用程序连接到MongoDB部署，将示例数据插入MongoDB，并运行聚合管道。

After you install the driver, create a file called agg_tutorial.go. Paste the following code in this file to create an app template for the aggregation tutorials.安装驱动程序后，创建一个名为agg_tutorial.go的文件。将以下代码粘贴到此文件中，为聚合教程创建应用程序模板。

package main

import (
	"context"
	"fmt"
	"log"

	"go.mongodb.org/mongo-driver/v2/bson"
	"go.mongodb.org/mongo-driver/v2/mongo"
	"go.mongodb.org/mongo-driver/v2/mongo/options"
)

// Define structs.
// type MyStruct struct { ... }

func main() {
	ctx := context.Background()
	// Replace the placeholder with your connection string.
	const uri = "<connection string>"

	client, err := mongo.Connect(options.Client().ApplyURI(uri))
	if err != nil {
		log.Fatal(err)
	}

	defer func() {
		if err = client.Disconnect(ctx); err != nil {
			log.Fatal(err)
		}
	}()

	aggDB := client.Database("agg_tutorials_db")

	// Get a reference to relevant collections.
	// ... someColl := aggDB.Collection("...")
	// ... anotherColl := aggDB.Collection("...")

	// Delete any existing documents in collections if needed.
	// ... someColl.DeleteMany(cxt, bson.D{})

	// Insert sample data into the collection or collections.
	// ... _, err = someColl.InsertMany(...)

	// Add code to create pipeline stages.
	// ... myStage := bson.D{{...}}

	// Create a pipeline that includes the stages.
	// ... pipeline := mongo.Pipeline{...}

	// Run the aggregation.
	// ... cursor, err := someColl.Aggregate(ctx, pipeline)

	if err != nil {
		log.Fatal(err)
	}

	defer func() {
		if err := cursor.Close(ctx); err != nil {
			log.Fatalf("failed to close cursor: %v", err)
		}
	}()

	// Decode the aggregation results.
	var results []bson.D
	if err = cursor.All(ctx, &results); err != nil {
		log.Fatalf("failed to decode results: %v", err)
	}

	// Print the aggregation results.
	for _, result := range results {
		res, _ := bson.MarshalExtJSON(result, false, false)
		fmt.Println(string(res))
	}
}

For every tutorial, you must replace the connection string placeholder with your deployment's connection string.对于每个教程，您必须将连接字符串占位符替换为部署的连接字符串。

For example, if your connection string is "mongodb+srv://mongodb-example:27017", your connection string assignment resembles the following:例如，如果连接字符串是"mongodb+srv://mongodb-example:27017"，连接字符串分配类似于以下内容：

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

Create the Collection创建集合

This example uses two collections:此示例使用两个集合：

• products, which contains documents describing the products that a shop sells，其中包含描述商店销售产品的文档
• orders, which contains documents describing individual orders for products in a shop，其中包含描述商店中产品的单个订单的文档

An order can only contain one product. The aggregation uses a multi-field join to match a product document to documents representing orders of that product. 一个订单只能包含一个产品。聚合使用多字段联接将产品文档与表示该产品订单的文档相匹配。The aggregation joins collections by the name and variation fields in documents in the products collection, corresponding to the product_name and product_variation fields in documents in the orders collection.聚合通过products集合中文档中的name和variation（变体）字段连接集合，对应于orders集合中文档的product_name和product_variation字段。

First, create Go structs to model the data in the products and orders collections:首先，创建Go结构体来对products和orders集合中的数据进行建模：

type Product struct {
	Name        string
	Variation   string
	Category    string
	Description string
}

type Order struct {
	CustomerID       string        `bson:"customer_id"`
	OrderDate        bson.DateTime `bson:"orderdate"`
	ProductName      string        `bson:"product_name"`
	ProductVariation string        `bson:"product_variation"`
	Value            float32       `bson:"value"`
}

To create the products and orders collections and insert the sample data, add the following code to your application:要创建products和orders集合并插入示例数据，请将以下代码添加到应用程序中：

products := aggDB.Collection("products")
orders := aggDB.Collection("orders")

_, err = products.InsertMany(ctx, []interface{}{
	Product{
		Name:        "Asus Laptop",
		Variation:   "Ultra HD",
		Category:    "ELECTRONICS",
		Description: "Great for watching movies",
	},
	Product{
		Name:        "Asus Laptop",
		Variation:   "Standard Display",
		Category:    "ELECTRONICS",
		Description: "Good value laptop for students",
	},
	Product{
		Name:        "The Day Of The Triffids",
		Variation:   "1st Edition",
		Category:    "BOOKS",
		Description: "Classic post-apocalyptic novel",
	},
	Product{
		Name:        "The Day Of The Triffids",
		Variation:   "2nd Edition",
		Category:    "BOOKS",
		Description: "Classic post-apocalyptic novel",
	},
	Product{
		Name:        "Morphy Richards Food Mixer",
		Variation:   "Deluxe",
		Category:    "KITCHENWARE",
		Description: "Luxury mixer turning good cakes into great",
	},
})
if err != nil {
	log.Fatal(err)
}

_, err = orders.InsertMany(ctx, []interface{}{
	Order{
		CustomerID:       "elise_smith@myemail.com",
		OrderDate:        bson.NewDateTimeFromTime(time.Date(2020, 5, 30, 8, 35, 52, 0, time.UTC)),
		ProductName:      "Asus Laptop",
		ProductVariation: "Standard Display",
		Value:            431.43,
	},
	Order{
		CustomerID:       "tj@wheresmyemail.com",
		OrderDate:        bson.NewDateTimeFromTime(time.Date(2019, 5, 28, 19, 13, 32, 0, time.UTC)),
		ProductName:      "The Day Of The Triffids",
		ProductVariation: "2nd Edition",
		Value:            5.01,
	},
	Order{
		CustomerID:       "oranieri@warmmail.com",
		OrderDate:        bson.NewDateTimeFromTime(time.Date(2020, 1, 1, 8, 25, 37, 0, time.UTC)),
		ProductName:      "Morphy Richards Food Mixer",
		ProductVariation: "Deluxe",
		Value:            63.13,
	},
	Order{
		CustomerID:       "jjones@tepidmail.com",
		OrderDate:        bson.NewDateTimeFromTime(time.Date(2020, 12, 26, 8, 55, 46, 0, time.UTC)),
		ProductName:      "Asus Laptop",
		ProductVariation: "Standard Display",
		Value:            429.65,
	},
})
if err != nil {

	log.Fatal(err)
}

Create the Template App创建模板应用程序

Before you begin following an aggregation tutorial, you must set up a new Java app. You can use this app to connect to a MongoDB deployment, insert sample data into MongoDB, and run the aggregation pipeline.在开始学习聚合教程之前，您必须设置一个新的Java应用程序。您可以使用此应用程序连接到MongoDB部署，将示例数据插入MongoDB，并运行聚合管道。

After you install the driver, create a file called AggTutorial.java. Paste the following code in this file to create an app template for the aggregation tutorials.安装驱动程序后，创建一个名为AggTutorial.java的文件。将以下代码粘贴到此文件中，为聚合教程创建应用程序模板。

package org.example;

// Modify imports for each tutorial as needed.
import com.mongodb.client.*;
import com.mongodb.client.model.Accumulators;
import com.mongodb.client.model.Aggregates;
import com.mongodb.client.model.Field;
import com.mongodb.client.model.Filters;
import com.mongodb.client.model.Sorts;
import com.mongodb.client.model.Variable;
import org.bson.Document;
import org.bson.conversions.Bson;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class AggTutorial {
    public static void main(String[] args) {
        // Replace the placeholder with your connection string.
        String uri = "<connection string>";

        try (MongoClient mongoClient = MongoClients.create(uri)) {
            MongoDatabase aggDB = mongoClient.getDatabase("agg_tutorials_db");

            // Get a reference to relevant collections.
            // ... MongoCollection<Document> someColl = ...
            // ... MongoCollection<Document> anotherColl = ...

            // Insert sample data into the collection or collections.
            // ... someColl.insertMany(...);

            // Create an empty pipeline array.
            List<Bson> pipeline = new ArrayList<>();

            // Add code to create pipeline stages.
            // ... pipeline.add(...);

            // Run the aggregation.
            // ... AggregateIterable<Document> aggregationResult =
            // someColl.aggregate(pipeline);

            // Print the aggregation results.
            for (Document document : aggregationResult) {
                System.out.println(document.toJson());
            }
        }
    }
}

For every tutorial, you must replace the connection string placeholder with your deployment's connection string.对于每个教程，您必须将连接字符串占位符替换为部署的连接字符串。

For example, if your connection string is "mongodb+srv://mongodb-example:27017", your connection string assignment resembles the following:例如，如果连接字符串是"mongodb+srv://mongodb-example:27017"，连接字符串分配类似于以下内容：

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

Create the Collection创建集合

This example uses two collections:此示例使用两个集合：

• products, which contains documents describing the products that a shop sells，其中包含描述商店销售产品的文档
• orders, which contains documents describing individual orders for products in a shop，其中包含描述商店中产品的单个订单的文档

An order can only contain one product. The aggregation uses a multi-field join to match a product document to documents representing orders of that product. 一个订单只能包含一个产品。聚合使用多字段联接将产品文档与表示该产品订单的文档相匹配。The aggregation joins collections by the name and variation fields in documents in the products collection, corresponding to the product_name and product_variation fields in documents in the orders collection.聚合通过products集合中文档中的name和variation字段连接集合，对应于orders集合中文档的product_name和product_variation字段。

To create the products and orders collections and insert the sample data, add the following code to your application:要创建products和orders集合并插入示例数据，请将以下代码添加到应用程序中：

MongoDatabase aggDB = mongoClient.getDatabase("agg_tutorials_db");
MongoCollection<Document> products = aggDB.getCollection("products");
MongoCollection<Document> orders = aggDB.getCollection("orders");

products.insertMany(
        Arrays.asList(
                new Document("name", "Asus Laptop")
                        .append("variation", "Ultra HD")
                        .append("category", "ELECTRONICS")
                        .append("description", "Great for watching movies"),

                new Document("name", "Asus Laptop")
                        .append("variation", "Standard Display")
                        .append("category", "ELECTRONICS")
                        .append("description", "Good value laptop for students"),

                new Document("name", "The Day Of The Triffids")
                        .append("variation", "1st Edition")
                        .append("category", "BOOKS")
                        .append("description", "Classic post-apocalyptic novel"),

                new Document("name", "The Day Of The Triffids")
                        .append("variation", "2nd Edition")
                        .append("category", "BOOKS")
                        .append("description", "Classic post-apocalyptic novel"),

                new Document("name", "Morphy Richards Food Mixer")
                        .append("variation", "Deluxe")
                        .append("category", "KITCHENWARE")
                        .append("description", "Luxury mixer turning good cakes into great")
        )
);

orders.insertMany(
        Arrays.asList(
                new Document("customer_id", "elise_smith@myemail.com")
                        .append("orderdate", LocalDateTime.parse("2020-05-30T08:35:52"))
                        .append("product_name", "Asus Laptop")
                        .append("product_variation", "Standard Display")
                        .append("value", 431.43),

                new Document("customer_id", "tj@wheresmyemail.com")
                        .append("orderdate", LocalDateTime.parse("2019-05-28T19:13:32"))
                        .append("product_name", "The Day Of The Triffids")
                        .append("product_variation", "2nd Edition")
                        .append("value", 5.01),

                new Document("customer_id", "oranieri@warmmail.com")
                        .append("orderdate", LocalDateTime.parse("2020-01-01T08:25:37"))
                        .append("product_name", "Morphy Richards Food Mixer")
                        .append("product_variation", "Deluxe")
                        .append("value", 63.13),

                new Document("customer_id", "jjones@tepidmail.com")
                        .append("orderdate", LocalDateTime.parse("2020-12-26T08:55:46"))
                        .append("product_name", "Asus Laptop")
                        .append("product_variation", "Standard Display")
                        .append("value", 429.65)
        )
);

Create the Template App创建模板应用程序

Before you begin following an aggregation tutorial, you must set up a new Java app. You can use this app to connect to a MongoDB deployment, insert sample data into MongoDB, and run the aggregation pipeline.在开始学习聚合教程之前，您必须设置一个新的Java应用程序。您可以使用此应用程序连接到MongoDB部署，将示例数据插入MongoDB，并运行聚合管道。

After you install the driver, create a file called AggTutorial.java. Paste the following code in this file to create an app template for the aggregation tutorials.安装驱动程序后，创建一个名为AggTutorial.java的文件。将以下代码粘贴到此文件中，为聚合教程创建应用程序模板。

package org.example;

// Modify imports for each tutorial as needed.
import com.mongodb.client.*;
import com.mongodb.client.model.Accumulators;
import com.mongodb.client.model.Aggregates;
import com.mongodb.client.model.Field;
import com.mongodb.client.model.Filters;
import com.mongodb.client.model.Sorts;
import com.mongodb.client.model.Variable;
import org.bson.Document;
import org.bson.conversions.Bson;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class AggTutorial {
    public static void main(String[] args) {
        // Replace the placeholder with your connection string.
        String uri = "<connection string>";

        try (MongoClient mongoClient = MongoClients.create(uri)) {
            MongoDatabase aggDB = mongoClient.getDatabase("agg_tutorials_db");

            // Get a reference to relevant collections.
            // ... MongoCollection<Document> someColl = ...
            // ... MongoCollection<Document> anotherColl = ...

            // Insert sample data into the collection or collections.
            // ... someColl.insertMany(...);

            // Create an empty pipeline array.
            List<Bson> pipeline = new ArrayList<>();

            // Add code to create pipeline stages.
            // ... pipeline.add(...);

            // Run the aggregation.
            // ... AggregateIterable<Document> aggregationResult =
            // someColl.aggregate(pipeline);

            // Print the aggregation results.
            for (Document document : aggregationResult) {
                System.out.println(document.toJson());
            }
        }
    }
}

For every tutorial, you must replace the connection string placeholder with your deployment's connection string.对于每个教程，您必须将连接字符串占位符替换为部署的连接字符串。

For example, if your connection string is "mongodb+srv://mongodb-example:27017", your connection string assignment resembles the following:例如，如果连接字符串是"mongodb+srv://mongodb-example:27017"，连接字符串分配类似于以下内容：

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

Create the Collection创建集合

This example uses two collections:此示例使用两个集合：

• products, which contains documents describing the products that a shop sells，其中包含描述商店销售产品的文档
• orders, which contains documents describing individual orders for products in a shop，其中包含描述商店中产品的单个订单的文档

An order can only contain one product. The aggregation uses a multi-field join to match a product document to documents representing orders of that product. 一个订单只能包含一个产品。聚合使用多字段联接将产品文档与表示该产品订单的文档相匹配。The aggregation joins collections by the name and variation fields in documents in the products collection, corresponding to the product_name and product_variation fields in documents in the orders collection.聚合通过products集合中文档中的name和variation（变体）字段连接集合，对应于orders集合中文档的product_name和product_variation字段。

First, create Kotlin data classes to model the data in the products and orders collections:首先，创建Kotlin数据类来对products和orders集合中的数据进行建模：

@Serializable
data class Product(
    val name: String,
    val variation: String,
    val category: String,
    val description: String
)

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

To create the products and orders collections and insert the sample data, add the following code to your application:要创建products和orders集合并插入示例数据，请将以下代码添加到应用程序中：

val products = aggDB.getCollection<Product>("products")
val orders = aggDB.getCollection<Order>("orders")

products.deleteMany(Filters.empty());
orders.deleteMany(Filters.empty());

products.insertMany(
    listOf(
        Product("Asus Laptop", "Ultra HD", "ELECTRONICS", "Great for watching movies"),
        Product("Asus Laptop", "Standard Display", "ELECTRONICS", "Good value laptop for students"),
        Product("The Day Of The Triffids", "1st Edition", "BOOKS", "Classic post-apocalyptic novel"),
        Product("The Day Of The Triffids", "2nd Edition", "BOOKS", "Classic post-apocalyptic novel"),
        Product(
            "Morphy Richards Food Mixer",
            "Deluxe",
            "KITCHENWARE",
            "Luxury mixer turning good cakes into great"
        )
    )
)

orders.insertMany(
    listOf(
        Order(
            "elise_smith@myemail.com",
            LocalDateTime.parse("2020-05-30T08:35:52"),
            "Asus Laptop",
            "Standard Display",
            431.43
        ),
        Order(
            "tj@wheresmyemail.com",
            LocalDateTime.parse("2019-05-28T19:13:32"),
            "The Day Of The Triffids",
            "2nd Edition",
            5.01
        ),
        Order(
            "oranieri@warmmail.com",
            LocalDateTime.parse("2020-01-01T08:25:37"),
            "Morphy Richards Food Mixer",
            "Deluxe",
            63.13
        ),
        Order(
            "jjones@tepidmail.com",
            LocalDateTime.parse("2020-12-26T08:55:46"),
            "Asus Laptop",
            "Standard Display",
            429.65
        )
    )
)

Create the Template App创建模板应用程序

Before you begin following this aggregation tutorial, you must set up a new Node.js app. You can use this app to connect to a MongoDB deployment, insert sample data into MongoDB, and run the aggregation pipeline.在开始学习本聚合教程之前，您必须设置一个新的Node.js应用程序。您可以使用此应用程序连接到MongoDB部署，将示例数据插入MongoDB，并运行聚合管道。

After you install the driver, create a file to run the tutorial template. Paste the following code in this file to create an app template for the aggregation tutorials.安装驱动程序后，创建一个文件来运行教程模板。将以下代码粘贴到此文件中，为聚合教程创建应用程序模板。

const { MongoClient } = require('mongodb');
// Replace the placeholder with your connection string.
const uri = '<connection-string>';
const client = new MongoClient(uri);
export async function run() {
  try {
    const aggDB = client.db('agg_tutorials_db');

    // Get a reference to relevant collections.
    // ... const someColl =
    // ... const anotherColl =

    // Delete any existing documents in collections.
    // ... await someColl.deleteMany({});

    // Insert sample data into the collection or collections.
    // ... const someData = [ ... ];
    // ... await someColl.insertMany(someData);

    // Create an empty pipeline array.
    const pipeline = [];

    // Add code to create pipeline stages.
    // ... pipeline.push({ ... })

    // Run the aggregation.
    // ... const aggregationResult = ...

    // Print the aggregation results.
    for await (const document of aggregationResult) {
      console.log(document);
    }
  } finally {
    await client.close();
  }
}

run().catch(console.dir);

For every tutorial, you must replace the connection string placeholder with your deployment's connection string.对于每个教程，您必须将连接字符串占位符替换为部署的连接字符串。

For example, if your connection string is "mongodb+srv://mongodb-example:27017", your connection string assignment resembles the following:例如，如果连接字符串是"mongodb+srv://mongodb-example:27017"，连接字符串分配类似于以下内容：

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

Create the Collection创建集合

This example uses two collections:此示例使用两个集合：

• products, which contains documents describing the products that a shop sells，其中包含描述商店销售产品的文档
• orders, which contains documents describing individual orders for products in a shop，其中包含描述商店中产品的单个订单的文档

An order can only contain one product. The aggregation uses a multi-field join to match a product document to documents representing orders of that product. The aggregation joins collections by the name and variation fields in documents in the products collection, corresponding to the product_name and product_variation fields in documents in the orders collection.一个订单只能包含一个产品。聚合使用多字段联接将产品文档与表示该产品订单的文档相匹配。聚合通过products集合中文档中的name和variation（变体）字段连接集合，对应于orders集合中文档的product_name和product_variation字段。

To create the products and orders collections and insert the sample data, add the following code to your application:要创建products和orders集合并插入示例数据，请将以下代码添加到应用程序中：

const products = aggDB.collection('products');
const orders = aggDB.collection('orders');

await products.insertMany([
  {
    name: 'Asus Laptop',
    variation: 'Ultra HD',
    category: 'ELECTRONICS',
    description: 'Great for watching movies',
  },
  {
    name: 'Asus Laptop',
    variation: 'Standard Display',
    category: 'ELECTRONICS',
    description: 'Good value laptop for students',
  },
  {
    name: 'The Day Of The Triffids',
    variation: '1st Edition',
    category: 'BOOKS',
    description: 'Classic post-apocalyptic novel',
  },
  {
    name: 'The Day Of The Triffids',
    variation: '2nd Edition',
    category: 'BOOKS',
    description: 'Classic post-apocalyptic novel',
  },
  {
    name: 'Morphy Richards Food Mixer',
    variation: 'Deluxe',
    category: 'KITCHENWARE',
    description: 'Luxury mixer turning good cakes into great',
  },
]);

await orders.insertMany([
  {
    customer_id: 'elise_smith@myemail.com',
    orderdate: new Date('2020-05-30T08:35:52Z'),
    product_name: 'Asus Laptop',
    product_variation: 'Standard Display',
    value: 431.43,
  },
  {
    customer_id: 'tj@wheresmyemail.com',
    orderdate: new Date('2019-05-28T19:13:32Z'),
    product_name: 'The Day Of The Triffids',
    product_variation: '2nd Edition',
    value: 5.01,
  },
  {
    customer_id: 'oranieri@warmmail.com',
    orderdate: new Date('2020-01-01T08:25:37Z'),
    product_name: 'Morphy Richards Food Mixer',
    product_variation: 'Deluxe',
    value: 63.13,
  },
  {
    customer_id: 'jjones@tepidmail.com',
    orderdate: new Date('2020-12-26T08:55:46Z'),
    product_name: 'Asus Laptop',
    product_variation: 'Standard Display',
    value: 429.65,
  },
]);

Create the Template App创建模板应用程序

Before you begin following this aggregation tutorial, you must set up a new Go app. You can use this app to connect to a MongoDB deployment, insert sample data into MongoDB, and run the aggregation pipeline.在开始学习此聚合教程之前，您必须设置一个新的Go应用程序。您可以使用此应用程序连接到MongoDB部署，将示例数据插入MongoDB，并运行聚合管道。

After you install the driver, create a file called agg_tutorial.go. Paste the following code in this file to create an app template for the aggregation tutorials.安装驱动程序后，创建一个名为agg_tutorial.go的文件。将以下代码粘贴到此文件中，为聚合教程创建应用程序模板。

package main

import (
	"context"
	"fmt"
	"log"

	"go.mongodb.org/mongo-driver/v2/bson"
	"go.mongodb.org/mongo-driver/v2/mongo"
	"go.mongodb.org/mongo-driver/v2/mongo/options"
)

// Define structs.
// type MyStruct struct { ... }

func main() {
	ctx := context.Background()
	// Replace the placeholder with your connection string.
	const uri = "<connection string>"

	client, err := mongo.Connect(options.Client().ApplyURI(uri))
	if err != nil {
		log.Fatal(err)
	}

	defer func() {
		if err = client.Disconnect(ctx); err != nil {
			log.Fatal(err)
		}
	}()

	aggDB := client.Database("agg_tutorials_db")

	// Get a reference to relevant collections.
	// ... someColl := aggDB.Collection("...")
	// ... anotherColl := aggDB.Collection("...")

	// Delete any existing documents in collections if needed.
	// ... someColl.DeleteMany(cxt, bson.D{})

	// Insert sample data into the collection or collections.
	// ... _, err = someColl.InsertMany(...)

	// Add code to create pipeline stages.
	// ... myStage := bson.D{{...}}

	// Create a pipeline that includes the stages.
	// ... pipeline := mongo.Pipeline{...}

	// Run the aggregation.
	// ... cursor, err := someColl.Aggregate(ctx, pipeline)

	if err != nil {
		log.Fatal(err)
	}

	defer func() {
		if err := cursor.Close(ctx); err != nil {
			log.Fatalf("failed to close cursor: %v", err)
		}
	}()

	// Decode the aggregation results.
	var results []bson.D
	if err = cursor.All(ctx, &results); err != nil {
		log.Fatalf("failed to decode results: %v", err)
	}

	// Print the aggregation results.
	for _, result := range results {
		res, _ := bson.MarshalExtJSON(result, false, false)
		fmt.Println(string(res))
	}
}

For every tutorial, you must replace the connection string placeholder with your deployment's connection string.对于每个教程，您必须将连接字符串占位符替换为部署的连接字符串。

For example, if your connection string is "mongodb+srv://mongodb-example:27017", your connection string assignment resembles the following:例如，如果连接字符串是"mongodb+srv://mongodb-example:27017"，连接字符串分配类似于以下内容：

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

Create the Collection创建集合

This example uses two collections:此示例使用两个集合：

• products, which contains documents describing the products that a shop sells，其中包含描述商店销售产品的文档
• orders, which contains documents describing individual orders for products in a shop，其中包含描述商店中产品的单个订单的文档

An order can only contain one product. The aggregation uses a multi-field join to match a product document to documents representing orders of that product. 一个订单只能包含一个产品。聚合使用多字段联接将产品文档与表示该产品订单的文档相匹配。The aggregation joins collections by the name and variation fields in documents in the products collection, corresponding to the product_name and product_variation fields in documents in the orders collection.聚合通过products集合中文档中的name和variation（变体）字段连接集合，对应于orders集合中文档的product_name和product_variation字段。

To create the products and orders collections and insert the sample data, add the following code to your application:要创建products和orders集合并插入示例数据，请将以下代码添加到应用程序中：

$products = $client->agg_tutorials_db->products;
$orders = $client->agg_tutorials_db->orders;

$products->deleteMany([]);
$orders->deleteMany([]);

$products->insertMany(
    [
        [
            'name' => "Asus Laptop",
            'variation' => "Ultra HD",
            'category' => "ELECTRONICS",
            'description' => "Great for watching movies"
        ],
        [
            'name' => "Asus Laptop",
            'variation' => "Standard Display",
            'category' => "ELECTRONICS",
            'description' => "Good value laptop for students"
        ],
        [
            'name' => "The Day Of The Triffids",
            'variation' => "1st Edition",
            'category' => "BOOKS",
            'description' => "Classic post-apocalyptic novel"
        ],
        [
            'name' => "The Day Of The Triffids",
            'variation' => "2nd Edition",
            'category' => "BOOKS",
            'description' => "Classic post-apocalyptic novel"
        ],
        [
            'name' => "Morphy Richards Food Mixer",
            'variation' => "Deluxe",
            'category' => "KITCHENWARE",
            'description' => "Luxury mixer turning good cakes into great"
        ]
    ]
);

$orders->insertMany(
    [
        [
            'customer_id' => "elise_smith@myemail.com",
            'orderdate' => new UTCDateTime((new DateTimeImmutable("2020-05-30T08:35:52"))),
            'product_name' => "Asus Laptop",
            'product_variation' => "Standard Display",
            'value' => 431.43
        ],
        [
            'customer_id' => "tj@wheresmyemail.com",
            'orderdate' => new UTCDateTime((new DateTimeImmutable("2019-05-28T19:13:32"))),
            'product_name' => "The Day Of The Triffids",
            'product_variation' => "2nd Edition",
            'value' => 5.01
        ],
        [
            'customer_id' => "oranieri@warmmail.com",
            'orderdate' => new UTCDateTime((new DateTimeImmutable("2020-01-01T08:25:37"))),
            'product_name' => "Morphy Richards Food Mixer",
            'product_variation' => "Deluxe",
            'value' => 63.13
        ],
        [
            'customer_id' => "jjones@tepidmail.com",
            'orderdate' => new UTCDateTime((new DateTimeImmutable("2020-12-26T08:55:46"))),
            'product_name' => "Asus Laptop",
            'product_variation' => "Standard Display",
            'value' => 429.65
        ]
    ]
);

Create the Template App创建模板应用程序

Before you begin following this aggregation tutorial, you must set up a new Python app. You can use this app to connect to a MongoDB deployment, insert sample data into MongoDB, and run the aggregation pipeline.在开始学习本聚合教程之前，您必须设置一个新的Python应用程序。您可以使用此应用程序连接到MongoDB部署，将示例数据插入MongoDB，并运行聚合管道。

After you install the library, create a file called agg_tutorial.py. Paste the following code in this file to create an app template for the aggregation tutorials.安装库后，创建一个名为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()

For every tutorial, you must replace the connection string placeholder with your deployment's connection string.对于每个教程，您必须将连接字符串占位符替换为部署的连接字符串。

For example, if your connection string is "mongodb+srv://mongodb-example:27017", your connection string assignment resembles the following:例如，如果连接字符串是"mongodb+srv://mongodb-example:27017"，连接字符串分配类似于以下内容：

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

Create the Collection创建集合

This example uses two collections:此示例使用两个集合：

• products, which contains documents describing the products that a shop sells，其中包含描述商店销售产品的文档
• orders, which contains documents describing individual orders for products in a shop，其中包含描述商店中产品的单个订单的文档

An order can only contain one product. The aggregation uses a multi-field join to match a product document to documents representing orders of that product. 一个订单只能包含一个产品。聚合使用多字段联接将产品文档与表示该产品订单的文档相匹配。The aggregation joins collections by the name and variation fields in documents in the products collection, corresponding to the product_name and product_variation fields in documents in the orders collection.聚合通过products集合中文档中的name和variation（变体）字段连接集合，对应于orders集合中文档的product_name和product_variation字段。

To create the products and orders collections and insert the sample data, add the following code to your application:要创建products和orders集合并插入示例数据，请将以下代码添加到应用程序中：

products_coll = agg_db["products"]
orders_coll = agg_db["orders"]

order_data = [
    {
        "customer_id": "elise_smith@myemail.com",
        "orderdate": datetime(2020, 5, 30, 8, 35, 52),
        "product_name": "Asus Laptop",
        "product_variation": "Standard Display",
        "value": 431.43,
    },
    {
        "customer_id": "tj@wheresmyemail.com",
        "orderdate": datetime(2019, 5, 28, 19, 13, 32),
        "product_name": "The Day Of The Triffids",
        "product_variation": "2nd Edition",
        "value": 5.01,
    },
    {
        "customer_id": "oranieri@warmmail.com",
        "orderdate": datetime(2020, 1, 1, 8, 25, 37),
        "product_name": "Morphy Richards Food Mixer",
        "product_variation": "Deluxe",
        "value": 63.13,
    },
    {
        "customer_id": "jjones@tepidmail.com",
        "orderdate": datetime(2020, 12, 26, 8, 55, 46),
        "product_name": "Asus Laptop",
        "product_variation": "Standard Display",
        "value": 429.65,
    },
]

orders_coll.insert_many(order_data)

products_data = [
    {
        "name": "Asus Laptop",
        "variation": "Ultra HD",
        "category": "ELECTRONICS",
        "description": "Great for watching movies",
    },
    {
        "name": "Asus Laptop",
        "variation": "Standard Display",
        "category": "ELECTRONICS",
        "description": "Good value laptop for students",
    },
    {
        "name": "The Day Of The Triffids",
        "variation": "1st Edition",
        "category": "BOOKS",
        "description": "Classic post-apocalyptic novel",
    },
    {
        "name": "The Day Of The Triffids",
        "variation": "2nd Edition",
        "category": "BOOKS",
        "description": "Classic post-apocalyptic novel",
    },
    {
        "name": "Morphy Richards Food Mixer",
        "variation": "Deluxe",
        "category": "KITCHENWARE",
        "description": "Luxury mixer turning good cakes into great",
    },
]

products_coll.insert_many(products_data)

Create the Template App创建模板应用程序

Before you begin following this aggregation tutorial, you must set up a new Ruby app. You can use this app to connect to a MongoDB deployment, insert sample data into MongoDB, and run the aggregation pipeline.在开始学习本聚合教程之前，您必须设置一个新的Ruby应用程序。您可以使用此应用程序连接到MongoDB部署，将示例数据插入MongoDB，并运行聚合管道。

After you install the driver, create a file called agg_tutorial.rb. Paste the following code in this file to create an app template for the aggregation tutorials.安装驱动程序后，创建一个名为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

For every tutorial, you must replace the connection string placeholder with your deployment's connection string.对于每个教程，您必须将连接字符串占位符替换为部署的连接字符串。

For example, if your connection string is "mongodb+srv://mongodb-example:27017", your connection string assignment resembles the following:例如，如果连接字符串是"mongodb+srv://mongodb-example:27017"，连接字符串分配类似于以下内容：

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

Create the Collection创建集合

This example uses two collections:此示例使用两个集合：

• products, which contains documents describing the products that a shop sells，其中包含描述商店销售产品的文档
• orders, which contains documents describing individual orders for products in a shop，其中包含描述商店中产品的单个订单的文档

An order can only contain one product. The aggregation uses a multi-field join to match a product document to documents representing orders of that product. 一个订单只能包含一个产品。聚合使用多字段联接将产品文档与表示该产品订单的文档相匹配。The aggregation joins collections by the name and variation fields in documents in the products collection, corresponding to the product_name and product_variation fields in documents in the orders collection.聚合通过products集合中文档中的name和variation（变体）字段连接集合，对应于orders集合中文档的product_name和product_variation字段。

To create the products and orders collections and insert the sample data, add the following code to your application:要创建products和orders集合并插入示例数据，请将以下代码添加到应用程序中：

products = agg_db[:products]
orders = agg_db[:orders]

products.delete_many({})
orders.delete_many({})

products.insert_many(
  [
    {
      name: "Asus Laptop",
      variation: "Ultra HD",
      category: "ELECTRONICS",
      description: "Great for watching movies",
    },
    {
      name: "Asus Laptop",
      variation: "Standard Display",
      category: "ELECTRONICS",
      description: "Good value laptop for students",
    },
    {
      name: "The Day Of The Triffids",
      variation: "1st Edition",
      category: "BOOKS",
      description: "Classic post-apocalyptic novel",
    },
    {
      name: "The Day Of The Triffids",
      variation: "2nd Edition",
      category: "BOOKS",
      description: "Classic post-apocalyptic novel",
    },
    {
      name: "Morphy Richards Food Mixer",
      variation: "Deluxe",
      category: "KITCHENWARE",
      description: "Luxury mixer turning good cakes into great",
    },
  ]
)

orders.insert_many(
  [
    {
      customer_id: "elise_smith@myemail.com",
      orderdate: DateTime.parse("2020-05-30T08:35:52Z"),
      product_name: "Asus Laptop",
      product_variation: "Standard Display",
      value: 431.43,
    },
    {
      customer_id: "tj@wheresmyemail.com",
      orderdate: DateTime.parse("2019-05-28T19:13:32Z"),
      product_name: "The Day Of The Triffids",
      product_variation: "2nd Edition",
      value: 5.01,
    },
    {
      customer_id: "oranieri@warmmail.com",
      orderdate: DateTime.parse("2020-01-01T08:25:37Z"),
      product_name: "Morphy Richards Food Mixer",
      product_variation: "Deluxe",
      value: 63.13,
    },
    {
      customer_id: "jjones@tepidmail.com",
      orderdate: DateTime.parse("2020-12-26T08:55:46Z"),
      product_name: "Asus Laptop",
      product_variation: "Standard Display",
      value: 429.65,
    },
  ]
)

Create the Template App创建模板应用程序

Before you begin following this aggregation tutorial, you must set up a new Rust app. You can use this app to connect to a MongoDB deployment, insert sample data into MongoDB, and run the aggregation pipeline.在开始学习本聚合教程之前，您必须设置一个新的Rust应用程序。您可以使用此应用程序连接到MongoDB部署，将示例数据插入MongoDB，并运行聚合管道。

After you install the driver, create a file called agg-tutorial.rs. Paste the following code in this file to create an app template for the aggregation tutorials.安装驱动程序后，创建一个名为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 { ... }

#[tokio::main]
async fn main() mongodb::error::Result<()> {
    // Replace the placeholder with your connection string.
    let uri = "<connection string>";
    let client = Client::with_uri_str(uri).await?;

    let agg_db = client.database("agg_tutorials_db");

    // Get a reference to relevant collections.
    // ... let some_coll: Collection<T> = agg_db.collection("...");
    // ... let another_coll: Collection<T> = agg_db.collection("...");

    // Delete any existing documents in collections if needed.
    // ... some_coll.delete_many(doc! {}).await?;

    // Insert sample data into the collection or collections.
    // ... some_coll.insert_many(vec![...]).await?;

    // Create an empty pipeline.
    let mut pipeline = Vec::new();

    // Add code to create pipeline stages.
    // pipeline.push(doc! { ... });

    // Run the aggregation and print the results.
    let mut results = some_coll.aggregate(pipeline).await?;
    while let Some(result) = results.try_next().await? {
       println!("{:?}\n", result);
    }
    Ok(())
}

For every tutorial, you must replace the connection string placeholder with your deployment's connection string.对于每个教程，您必须将连接字符串占位符替换为部署的连接字符串。

For example, if your connection string is "mongodb+srv://mongodb-example:27017", your connection string assignment resembles the following:例如，如果连接字符串是"mongodb+srv://mongodb-example:27017"，连接字符串分配类似于以下内容：

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

Create the Collection创建集合

This example uses two collections:此示例使用两个集合：

• products, which contains documents describing the products that a shop sells，其中包含描述商店销售产品的文档
• orders, which contains documents describing individual orders for products in a shop，其中包含描述商店中产品的单个订单的文档

An order can only contain one product. The aggregation uses a multi-field join to match a product document to documents representing orders of that product. 一个订单只能包含一个产品。聚合使用多字段联接将产品文档与表示该产品订单的文档相匹配。The aggregation joins collections by the name and variation fields in documents in the products collection, corresponding to the product_name and product_variation fields in documents in the orders collection.聚合通过products集合中文档中的name和variation（变体）字段连接集合，对应于orders集合中文档的product_name和product_variation字段。

First, create Rust structs to model the data in the products and orders collections:首先，创建Rust结构体来对products和orders集合中的数据进行建模：

#[derive(Debug, Serialize, Deserialize)]
struct Product {
    name: String,
    variation: String,
    category: String,
    description: String,
}

#[derive(Debug, Serialize, Deserialize)]
struct Order {
    customer_id: String,
    order_date: DateTime,
    product_name: String,
    product_variation: String,
    value: f32,
}

To create the products and orders collections and insert the sample data, add the following code to your application:要创建products和orders集合并插入示例数据，请将以下代码添加到应用程序中：

let products: Collection<Product> = agg_db.collection("products");
let orders: Collection<Order> = agg_db.collection("orders");

products.delete_many(doc! {}).await?;
orders.delete_many(doc! {}).await?;

let product_docs = vec![
    Product {
        name: "Asus Laptop".to_string(),
        variation: "Ultra HD".to_string(),
        category: "ELECTRONICS".to_string(),
        description: "Great for watching movies".to_string(),
    },
    Product {
        name: "Asus Laptop".to_string(),
        variation: "Standard Display".to_string(),
        category: "ELECTRONICS".to_string(),
        description: "Good value laptop for students".to_string(),
    },
    Product {
        name: "The Day Of The Triffids".to_string(),
        variation: "1st Edition".to_string(),
        category: "BOOKS".to_string(),
        description: "Classic post-apocalyptic novel".to_string(),
    },
    Product {
        name: "The Day Of The Triffids".to_string(),
        variation: "2nd Edition".to_string(),
        category: "BOOKS".to_string(),
        description: "Classic post-apocalyptic novel".to_string(),
    },
    Product {
        name: "Morphy Richards Food Mixer".to_string(),
        variation: "Deluxe".to_string(),
        category: "KITCHENWARE".to_string(),
        description: "Luxury mixer turning good cakes into great".to_string(),
    },
];
products.insert_many(product_docs).await?;

let order_docs = vec![
    Order {
        customer_id: "elise_smith@myemail.com".to_string(),
        order_date: DateTime::builder().year(2020).month(5).day(30).hour(8).minute(35).second(52).build().unwrap(),
        product_name: "Asus Laptop".to_string(),
        product_variation: "Standard Display".to_string(),
        value: 431.43,
    },
    Order {
        customer_id: "tj@wheresmyemail.com".to_string(),
        order_date: DateTime::builder().year(2019).month(5).day(28).hour(19).minute(13).second(32).build().unwrap(),
        product_name: "The Day Of The Triffids".to_string(),
        product_variation: "2nd Edition".to_string(),
        value: 5.01,
    },
    Order {
        customer_id: "oranieri@warmmail.com".to_string(),
        order_date: DateTime::builder().year(2020).month(1).day(1).hour(8).minute(25).second(37).build().unwrap(),
        product_name: "Morphy Richards Food Mixer".to_string(),
        product_variation: "Deluxe".to_string(),
        value: 63.13,
    },
    Order {
        customer_id: "jjones@tepidmail.com".to_string(),
        order_date: DateTime::builder().year(2020).month(12).day(26).hour(8).minute(55).second(46).build().unwrap(),
        product_name: "Asus Laptop".to_string(),
        product_variation: "Standard Display".to_string(),
        value: 429.65,
    },
];
orders.insert_many(order_docs).await?;

Create the Template App创建模板应用程序

Before you begin following an aggregation tutorial, you must set up a new Scala app. You can use this app to connect to a MongoDB deployment, insert sample data into MongoDB, and run the aggregation pipeline.在开始学习聚合教程之前，您必须设置一个新的Scala应用程序。您可以使用此应用程序连接到MongoDB部署，将示例数据插入MongoDB，并运行聚合管道。

After you install the driver, create a file called AggTutorial.scala. Paste the following code in this file to create an app template for the aggregation tutorials.安装驱动程序后，创建一个名为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()
  }
}

For every tutorial, you must replace the connection string placeholder with your deployment's connection string.对于每个教程，您必须将连接字符串占位符替换为部署的连接字符串。

For example, if your connection string is "mongodb+srv://mongodb-example:27017", your connection string assignment resembles the following:例如，如果连接字符串是"mongodb+srv://mongodb-example:27017"，连接字符串分配类似于以下内容：

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

Create the Collection创建集合

This example uses two collections:此示例使用两个集合：

• products, which contains documents describing the products that a shop sells，其中包含描述商店销售产品的文档
• orders, which contains documents describing individual orders for products in a shop，其中包含描述商店中产品的单个订单的文档

An order can only contain one product. The aggregation uses a multi-field join to match a product document to documents representing orders of that product. 一个订单只能包含一个产品。聚合使用多字段联接将产品文档与表示该产品订单的文档相匹配。The aggregation joins collections by the name and variation fields in documents in the products collection, corresponding to the product_name and product_variation fields in documents in the orders collection.聚合通过产品集合中文档中的name和variation（变体）字段连接集合，对应于orders集合中文档的product_name和product_variation字段。

To create the products and orders collections and insert the sample data, add the following code to your application:要创建products和orders集合并插入示例数据，请将以下代码添加到应用程序中：

val products = aggDB.getCollection("products")
val orders = aggDB.getCollection("orders")

products.deleteMany(Filters.empty()).subscribe(
  _ => {},
  e => println("Error: " + e.getMessage),
)

orders.deleteMany(Filters.empty()).subscribe(
  _ => {},
  e => println("Error: " + e.getMessage),
)

val dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss")

products.insertMany(
  Seq(
    Document(
      "name" -> "Asus Laptop",
      "variation" -> "Ultra HD",
      "category" -> "ELECTRONICS",
      "description" -> "Great for watching movies"
    ),
    Document(
      "name" -> "Asus Laptop",
      "variation" -> "Standard Display",
      "category" -> "ELECTRONICS",
      "description" -> "Good value laptop for students"
    ),
    Document(
      "name" -> "The Day Of The Triffids",
      "variation" -> "1st Edition",
      "category" -> "BOOKS",
      "description" -> "Classic post-apocalyptic novel"
    ),
    Document(
      "name" -> "The Day Of The Triffids",
      "variation" -> "2nd Edition",
      "category" -> "BOOKS",
      "description" -> "Classic post-apocalyptic novel"
    ),
    Document(
      "name" -> "Morphy Richards Food Mixer",
      "variation" -> "Deluxe",
      "category" -> "KITCHENWARE",
      "description" -> "Luxury mixer turning good cakes into great"
    )
  )
).subscribe(
  _ => {},
  e => println("Error: " + e.getMessage),
)

orders.insertMany(
  Seq(
    Document(
      "customer_id" -> "elise_smith@myemail.com",
      "orderdate" -> dateFormat.parse("2020-05-30T08:35:52"),
      "product_name" -> "Asus Laptop",
      "product_variation" -> "Standard Display",
      "value" -> 431.43
    ),
    Document(
      "customer_id" -> "tj@wheresmyemail.com",
      "orderdate" -> dateFormat.parse("2019-05-28T19:13:32"),
      "product_name" -> "The Day Of The Triffids",
      "product_variation" -> "2nd Edition",
      "value" -> 5.01
    ),
    Document(
      "customer_id" -> "oranieri@warmmail.com",
      "orderdate" -> dateFormat.parse("2020-01-01T08:25:37"),
      "product_name" -> "Morphy Richards Food Mixer",
      "product_variation" -> "Deluxe",
      "value" -> 63.13
    ),
    Document(
      "customer_id" -> "jjones@tepidmail.com",
      "orderdate" -> dateFormat.parse("2020-12-26T08:55:46"),
      "product_name" -> "Asus Laptop",
      "product_variation" -> "Standard Display",
      "value" -> 429.65
    )
  )
).subscribe(
  _ => {},
  e => println("Error: " + e.getMessage),
)