执行多字段联接

#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;
}

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

#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;
   }
}

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

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

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

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

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

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"`
}

products := aggDB.Collection("products")
orders := aggDB.Collection("orders")
products.DeleteMany(context.TODO(), bson.D{})
orders.DeleteMany(context.TODO(), bson.D{})
_, err = products.InsertMany(context.TODO(), []interface{}{
	Product{
		Name:        "Asus Laptop",
		Variation:   "Ultra HD",
		Category:    "ELECTRONICS",
		Description: "Great for watching movies",
	},
	Product{
		Name:        "Asus Laptop",
		Variation:   "Standard Display",
		Category:    "ELECTRONICS",
		Description: "Good value laptop for students",
	},
	Product{
		Name:        "The Day Of The Triffids",
		Variation:   "1st Edition",
		Category:    "BOOKS",
		Description: "Classic post-apocalyptic novel",
	},
	Product{
		Name:        "The Day Of The Triffids",
		Variation:   "2nd Edition",
		Category:    "BOOKS",
		Description: "Classic post-apocalyptic novel",
	},
	Product{
		Name:        "Morphy Richards Food Mixer",
		Variation:   "Deluxe",
		Category:    "KITCHENWARE",
		Description: "Luxury mixer turning good cakes into great",
	},
})
if err != nil {
	log.Fatal(err)
}
_, err = orders.InsertMany(context.TODO(), []interface{}{
	Order{
		CustomerID:       "elise_smith@myemail.com",
		OrderDate:        bson.NewDateTimeFromTime(time.Date(2020, 5, 30, 8, 35, 52, 0, time.UTC)),
		ProductName:      "Asus Laptop",
		ProductVariation: "Standard Display",
		Value:            431.43,
	},
	Order{
		CustomerID:       "tj@wheresmyemail.com",
		OrderDate:        bson.NewDateTimeFromTime(time.Date(2019, 5, 28, 19, 13, 32, 0, time.UTC)),
		ProductName:      "The Day Of The Triffids",
		ProductVariation: "2nd Edition",
		Value:            5.01,
	},
	Order{
		CustomerID:       "oranieri@warmmail.com",
		OrderDate:        bson.NewDateTimeFromTime(time.Date(2020, 1, 1, 8, 25, 37, 0, time.UTC)),
		ProductName:      "Morphy Richards Food Mixer",
		ProductVariation: "Deluxe",
		Value:            63.13,
	},
	Order{
		CustomerID:       "jjones@tepidmail.com",
		OrderDate:        bson.NewDateTimeFromTime(time.Date(2020, 12, 26, 8, 55, 46, 0, time.UTC)),
		ProductName:      "Asus Laptop",
		ProductVariation: "Standard Display",
		Value:            429.65,
	},
})
if err != nil {
	log.Fatal(err)
}

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

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

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

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

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

import { MongoClient } from 'mongodb';
// Replace the placeholder with your connection string.
const uri = '<connection-string>';
const client = new MongoClient(uri);
export async function run() {
  try {
    const aggDB = client.db('agg_tutorials_db');
    // Get a reference to relevant collections.
    // ... const someColl =
    // ... const anotherColl =
    // Delete any existing documents in collections.
    // ... await someColl.deleteMany({});
    // Insert sample data into the collection or collections.
    // ... const someData = [ ... ];
    // ... await someColl.insertMany(someData);
    // Create an empty pipeline array.
    const pipeline = [];
    // Add code to create pipeline stages.
    // ... pipeline.push({ ... })
    // Run the aggregation.
    // ... const aggregationResult = ...
    // Print the aggregation results.
    for await (const document of aggregationResult) {
      console.log(document);
    }
  } finally {
    await client.close();
  }
}
run().catch(console.dir);

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

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

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

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

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)

# 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

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

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

#[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,
}

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

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

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