Realizar junções um a um

#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 *orders = mongoc_client_get_collection(client, "agg_tutorials_db", "orders");
mongoc_collection_t *products = mongoc_client_get_collection(client, "agg_tutorials_db", "products");
{
    bson_t *filter = bson_new();
    bson_error_t error;
    if (!mongoc_collection_delete_many(orders, filter, NULL, NULL, &error))
    {
        fprintf(stderr, "Delete error: %s\n", error.message);
    }
    if (!mongoc_collection_delete_many(products, filter, NULL, NULL, &error))
    {
        fprintf(stderr, "Delete error: %s\n", error.message);
    }
    bson_destroy(filter);
}
{
    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_id", BCON_UTF8("a1b2c3d4"),
        "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_id", BCON_UTF8("z9y8x7w6"),
        "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_id", BCON_UTF8("ff11gg22hh33"),
        "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_id", BCON_UTF8("a1b2c3d4"),
        "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]);
    }
}
{
    size_t num_docs = 4;
    bson_t *product_docs[num_docs];
    product_docs[0] = BCON_NEW(
        "id", BCON_UTF8("a1b2c3d4"),
        "name", BCON_UTF8("Asus Laptop"),
        "category", BCON_UTF8("ELECTRONICS"),
        "description", BCON_UTF8("Good value laptop for students"));
    product_docs[1] = BCON_NEW(
        "id", BCON_UTF8("z9y8x7w6"),
        "name", BCON_UTF8("The Day Of The Triffids"),
        "category", BCON_UTF8("BOOKS"),
        "description", BCON_UTF8("Classic post-apocalyptic novel"));
    product_docs[2] = BCON_NEW(
        "id", BCON_UTF8("ff11gg22hh33"),
        "name", BCON_UTF8("Morphy Richardds Food Mixer"),
        "category", BCON_UTF8("KITCHENWARE"),
        "description", BCON_UTF8("Luxury mixer turning good cakes into great"));
    product_docs[3] = BCON_NEW(
        "id", BCON_UTF8("pqr678st"),
        "name", BCON_UTF8("Karcher Hose Set"),
        "category", BCON_UTF8("GARDEN"),
        "description", BCON_UTF8("Hose + nosels + winder for tidy storage"));
    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]);
    }
}

#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 orders = db["orders"];
auto products = db["products"];
std::vector<bsoncxx::document::value> order_docs = {
    bsoncxx::from_json(R"({
        "customer_id": "elise_smith@myemail.com",
        "orderdate": {"$date": 1590821752000},
        "product_id": "a1b2c3d4",
        "value": 431.43
    })"),
    bsoncxx::from_json(R"({
        "customer_id": "tj@wheresmyemail.com",
        "orderdate": {"$date": 1559062412},
        "product_id": "z9y8x7w6",
        "value": 5.01
    })"),
    bsoncxx::from_json(R"({
        "customer_id": "oranieri@warmmail.com",
        "orderdate": {"$date": 1577861137},
        "product_id": "ff11gg22hh33",
        "value": 63.13
    })"),
    bsoncxx::from_json(R"({
        "customer_id": "jjones@tepidmail.com",
        "orderdate": {"$date": 1608972946000},
        "product_id": "a1b2c3d4",
        "value": 429.65
    })")
};
orders.insert_many(order_docs); // Might throw an exception
std::vector<bsoncxx::document::value> product_docs = {
    bsoncxx::from_json(R"({
        "id": "a1b2c3d4",
        "name": "Asus Laptop",
        "category": "ELECTRONICS",
        "description": "Good value laptop for students"
    })"),
    bsoncxx::from_json(R"({
        "id": "z9y8x7w6",
        "name": "The Day Of The Triffids",
        "category": "BOOKS",
        "description": "Classic post-apocalyptic novel"
    })"),
    bsoncxx::from_json(R"({
        "id": "ff11gg22hh33",
        "name": "Morphy Richardds Food Mixer",
        "category": "KITCHENWARE",
        "description": "Luxury mixer turning good cakes into great"
    })"),
    bsoncxx::from_json(R"({
        "id": "pqr678st",
        "name": "Karcher Hose Set",
        "category": "GARDEN",
        "description": "Hose + nosels + winder for tidy storage"
    })")
};
products.insert_many(product_docs); // Might throw an exception

using MongoDB.Driver;
using MongoDB.Bson;
using MongoDB.Bson.Serialization.Attributes;
// Define data model classes.
// ... public class MyClass { ... }
// Replace the placeholder with your connection string.
var uri = "<connection string>";
var client = new MongoClient(uri);
var aggDB = client.GetDatabase("agg_tutorials_db");
// Get a reference to relevant collections.
// ... var someColl = aggDB.GetCollection<MyClass>("someColl");
// ... var anotherColl = aggDB.GetCollection<MyClass>("anotherColl");
// Delete any existing documents in collections if needed.
// ... someColl.DeleteMany(Builders<MyClass>.Filter.Empty);
// Insert sample data into the collection or collections.
// ... someColl.InsertMany(new List<MyClass> { ... });
// Add code to chain pipeline stages to the Aggregate() method.
// ... var results = someColl.Aggregate().Match(...);
// Print the aggregation results.
foreach (var result in results.ToList())
{
  Console.WriteLine(result);
}

public class Order
{
  [BsonId]
  public ObjectId Id { get; set; }
  public string CustomerId { get; set; }
  public DateTime OrderDate { get; set; }
  public string ProductId { get; set; }
  public double Value { get; set; }
}
public class Product
{
  [BsonId]
  public string Id { get; set; }
  public string Name { get; set; }
  public string Category { get; set; }
  public string Description { get; set; }
}

var orders = aggDB.GetCollection<Order>("orders");
var products = aggDB.GetCollection<Product>("products");
orders.DeleteMany(Builders<Order>.Filter.Empty);
products.DeleteMany(Builders<Product>.Filter.Empty);
orders.InsertMany(new List<Order>
{
    new Order
    {
        CustomerId = "elise_smith@myemail.com",
        OrderDate = DateTime.Parse("2020-05-30T08:35:52Z"),
        ProductId = "a1b2c3d4",
        Value = 431.43
    },
    new Order
    {
        CustomerId = "tj@wheresmyemail.com",
        OrderDate = DateTime.Parse("2019-05-28T19:13:32Z"),
        ProductId = "z9y8x7w6",
        Value = 5.01
    },
    new Order
    {
        CustomerId = "oranieri@warmmail.com",
        OrderDate = DateTime.Parse("2020-01-01T08:25:37Z"),
        ProductId = "ff11gg22hh33",
        Value = 63.13
    },
    new Order
    {
        CustomerId = "jjones@tepidmail.com",
        OrderDate = DateTime.Parse("2020-12-26T08:55:46Z"),
        ProductId = "a1b2c3d4",
        Value = 429.65
    }
});
products.InsertMany(new List<Product>
{
    new Product
    {
        Id = "a1b2c3d4",
        Name = "Asus Laptop",
        Category = "ELECTRONICS",
        Description = "Good value laptop for students"
    },
    new Product
    {
        Id = "z9y8x7w6",
        Name = "The Day Of The Triffids",
        Category = "BOOKS",
        Description = "Classic post-apocalyptic novel"
    },
    new Product
    {
        Id = "ff11gg22hh33",
        Name = "Morphy Richardds Food Mixer",
        Category = "KITCHENWARE",
        Description = "Luxury mixer turning good cakes into great"
    },
    new Product
    {
        Id = "pqr678st",
        Name = "Karcher Hose Set",
        Category = "GARDEN",
        Description = "Hose + nosels + winder for tidy storage"
    }
});

package main
import (
    "context"
    "fmt"
    "log"
    "time"
    "go.mongodb.org/mongo-driver/v2/bson"
    "go.mongodb.org/mongo-driver/v2/mongo"
    "go.mongodb.org/mongo-driver/v2/mongo/options"
)
// Define structs.
// type MyStruct struct { ... }
func main() {
    // Replace the placeholder with your connection string.
    const uri = "<connection string>"
    client, err := mongo.Connect(options.Client().ApplyURI(uri))
    if err != nil {
        log.Fatal(err)
    }
    defer func() {
        if err = client.Disconnect(context.TODO()); err != nil {
            log.Fatal(err)
        }
    }()
    aggDB := client.Database("agg_tutorials_db")
    // Get a reference to relevant collections.
    // ... someColl := aggDB.Collection("...")
    // ... anotherColl := aggDB.Collection("...")
    // Delete any existing documents in collections if needed.
    // ... someColl.DeleteMany(context.TODO(), bson.D{})
    // Insert sample data into the collection or collections.
    // ... _, err = someColl.InsertMany(...)
    // Add code to create pipeline stages.
    // ... myStage := bson.D{{...}}
    // Create a pipeline that includes the stages.
    // ... pipeline := mongo.Pipeline{...}
    // Run the aggregation.
    // ... cursor, err := someColl.Aggregate(context.TODO(), pipeline)
    if err != nil {
        log.Fatal(err)
    }
    defer func() {
        if err := cursor.Close(context.TODO()); err != nil {
            log.Fatalf("failed to close cursor: %v", err)
        }
    }()
    // Decode the aggregation results.
    var results []bson.D
    if err = cursor.All(context.TODO(), &results); err != nil {
        log.Fatalf("failed to decode results: %v", err)
    }
    // Print the aggregation results.
    for _, result := range results {
        res, _ := bson.MarshalExtJSON(result, false, false)
        fmt.Println(string(res))
    }
}

type Order struct {
	CustomerID string        `bson:"customer_id"`
	OrderDate  bson.DateTime `bson:"orderdate"`
	ProductID  string        `bson:"product_id"`
	Value      float32       `bson:"value"`
}
type Product struct {
	ID          string `bson:"id"`
	Name        string `bson:"name"`
	Category    string `bson:"category"`
	Description string `bson:"description"`
}

orders := aggDB.Collection("orders")
products := aggDB.Collection("products")
orders.DeleteMany(context.TODO(), bson.D{})
products.DeleteMany(context.TODO(), bson.D{})
_, err = orders.InsertMany(context.TODO(), []interface{}{
	Order{
		CustomerID: "elise_smith@myemail.com",
		OrderDate:  bson.NewDateTimeFromTime(time.Date(2020, 5, 30, 8, 35, 52, 0, time.UTC)),
		ProductID:  "a1b2c3d4",
		Value:      431.43,
	},
	Order{
		CustomerID: "tj@wheresmyemail.com",
		OrderDate:  bson.NewDateTimeFromTime(time.Date(2019, 5, 28, 19, 13, 32, 0, time.UTC)),
		ProductID:  "z9y8x7w6",
		Value:      5.01,
	},
	Order{
		CustomerID: "oranieri@warmmail.com",
		OrderDate:  bson.NewDateTimeFromTime(time.Date(2020, 01, 01, 8, 25, 37, 0, time.UTC)),
		ProductID:  "ff11gg22hh33",
		Value:      63.13,
	},
	Order{
		CustomerID: "jjones@tepidmail.com",
		OrderDate:  bson.NewDateTimeFromTime(time.Date(2020, 12, 26, 8, 55, 46, 0, time.UTC)),
		ProductID:  "a1b2c3d4",
		Value:      429.65,
	},
})
if err != nil {
	log.Fatal(err)
}
_, err = products.InsertMany(context.TODO(), []interface{}{
	Product{
		ID:          "a1b2c3d4",
		Name:        "Asus Laptop",
		Category:    "ELECTRONICS",
		Description: "Good value laptop for students",
	},
	Product{
		ID:          "z9y8x7w6",
		Name:        "The Day Of The Triffids",
		Category:    "BOOKS",
		Description: "Classic post-apocalyptic novel",
	},
	Product{
		ID:          "ff11gg22hh33",
		Name:        "Morphy Richardds Food Mixer",
		Category:    "KITCHENWARE",
		Description: "Luxury mixer turning good cakes into great",
	},
	Product{
		ID:          "pqr678st",
		Name:        "Karcher Hose Set",
		Category:    "GARDEN",
		Description: "Hose + nosels + winder for tidy storage",
	},
})
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.Aggregates;
import com.mongodb.client.model.Filters;
import com.mongodb.client.model.Sorts;
import org.bson.Document;
import org.bson.conversions.Bson;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class AggTutorial {
    public static void main( String[] args ) {
        // Replace the placeholder with your connection string.
        String uri = "<connection string>";
        try (MongoClient mongoClient = MongoClients.create(uri)) {
            MongoDatabase aggDB = mongoClient.getDatabase("agg_tutorials_db");
            // Get a reference to relevant collections.
            // ... MongoCollection<Document> someColl = ...
            // ... MongoCollection<Document> anotherColl = ...
            // Delete any existing documents in collections if needed.
            // ... someColl.deleteMany(Filters.empty());
            // Insert sample data into the collection or collections.
            // ... someColl.insertMany(...);
            // Create an empty pipeline array.
            List<Bson> pipeline = new ArrayList<>();
            // Add code to create pipeline stages.
            // ... pipeline.add(...);
            // Run the aggregation.
            // ... AggregateIterable<Document> aggregationResult = someColl.aggregate(pipeline);
            // Print the aggregation results.
            for (Document document : aggregationResult) {
                System.out.println(document.toJson());
            }
        }
    }
}

MongoCollection<Document> orders = aggDB.getCollection("orders");
MongoCollection<Document> products = aggDB.getCollection("products");
orders.deleteMany(Filters.empty());
products.deleteMany(Filters.empty());
orders.insertMany(
        Arrays.asList(
                new Document("customer_id", "elise_smith@myemail.com")
                        .append("orderdate", LocalDateTime.parse("2020-05-30T08:35:52"))
                        .append("product_id", "a1b2c3d4")
                        .append("value", 431.43),
                new Document("customer_id", "tj@wheresmyemail.com")
                        .append("orderdate", LocalDateTime.parse("2019-05-28T19:13:32"))
                        .append("product_id", "z9y8x7w6")
                        .append("value", 5.01),
                new Document("customer_id", "oranieri@warmmail.com")
                        .append("orderdate", LocalDateTime.parse("2020-01-01T08:25:37"))
                        .append("product_id", "ff11gg22hh33")
                        .append("value", 63.13),
                new Document("customer_id", "jjones@tepidmail.com")
                        .append("orderdate", LocalDateTime.parse("2020-12-26T08:55:46"))
                        .append("product_id", "a1b2c3d4")
                        .append("value", 429.65)
        )
);
products.insertMany(
        Arrays.asList(
                new Document("id", "a1b2c3d4")
                        .append("name", "Asus Laptop")
                        .append("category", "ELECTRONICS")
                        .append("description", "Good value laptop for students"),
                new Document("id", "z9y8x7w6")
                        .append("name", "The Day Of The Triffids")
                        .append("category", "BOOKS")
                        .append("description", "Classic post-apocalyptic novel"),
                new Document("id", "ff11gg22hh33")
                        .append("name", "Morphy Richardds Food Mixer")
                        .append("category", "KITCHENWARE")
                        .append("description", "Luxury mixer turning good cakes into great"),
                new Document("id", "pqr678st")
                        .append("name", "Karcher Hose Set")
                        .append("category", "GARDEN")
                        .append("description", "Hose + nosels + winder for tidy storage")
        )
);

dependencies {
    // Implements Kotlin serialization
    implementation("org.jetbrains.kotlinx:kotlinx-serialization-core:1.5.1")
    // Implements Kotlin date and time handling
    implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.6.1")
}

package org.example
// Modify imports for each tutorial as needed.
import com.mongodb.client.model.*
import com.mongodb.kotlin.client.coroutine.MongoClient
import kotlinx.coroutines.runBlocking
import kotlinx.datetime.LocalDateTime
import kotlinx.datetime.toJavaLocalDateTime
import kotlinx.serialization.Contextual
import kotlinx.serialization.Serializable
import org.bson.Document
import org.bson.conversions.Bson
// Define data classes.
@Serializable
data class MyClass(
    ...
)
suspend fun main() {
    // Replace the placeholder with your connection string.
    val uri = "<connection string>"
    MongoClient.create(uri).use { mongoClient ->
        val aggDB = mongoClient.getDatabase("agg_tutorials_db")
        // Get a reference to relevant collections.
        // ... val someColl = ...
        // Delete any existing documents in collections if needed.
        // ... someColl.deleteMany(empty())
        // Insert sample data into the collection or collections.
        // ... someColl.insertMany( ... )
        // Create an empty pipeline.
        val pipeline = mutableListOf<Bson>()
        // Add code to create pipeline stages.
        // ... pipeline.add(...)
        // Run the aggregation.
        // ... val aggregationResult = someColl.aggregate<Document>(pipeline)
        // Print the aggregation results.
        aggregationResult.collect { println(it) }
    }
}

@Serializable
data class Order(
    val customerID: String,
    @Contextual val orderDate: LocalDateTime,
    val productID: String,
    val value: Double
)
@Serializable
data class Product(
    val ID: String,
    val name: String,
    val category: String,
    val description: String
)

val orders = aggDB.getCollection<Order>("orders")
val products = aggDB.getCollection<Product>("products")
orders.deleteMany(Filters.empty());
products.deleteMany(Filters.empty());
orders.insertMany(
    listOf(
        Order("elise_smith@myemail.com", LocalDateTime.parse("2020-05-30T08:35:52"), "a1b2c3d4", 431.43),
        Order("tj@wheresmyemail.com", LocalDateTime.parse("2019-05-28T19:13:32"), "z9y8x7w6", 5.01),
        Order("oranieri@warmmail.com", LocalDateTime.parse("2020-01-01T08:25:37"), "ff11gg22hh33", 63.13),
        Order("jjones@tepidmail.com", LocalDateTime.parse("2020-12-26T08:55:46"), "a1b2c3d4", 429.65)
    )
)
products.insertMany(
    listOf(
        Product("a1b2c3d4", "Asus Laptop", "ELECTRONICS", "Good value laptop for students"),
        Product("z9y8x7w6", "The Day Of The Triffids", "BOOKS", "Classic post-apocalyptic novel"),
        Product(
            "ff11gg22hh33",
            "Morphy Richardds Food Mixer",
            "KITCHENWARE",
            "Luxury mixer turning good cakes into great"
        ),
        Product("pqr678st", "Karcher Hose Set", "GARDEN", "Hose + nosels + winder for tidy storage")
    )
)

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

const orders = aggDB.collection("orders");
const products = aggDB.collection("products");
await orders.deleteMany({});
await products.deleteMany({});
await orders.insertMany([
  {
    customer_id: "elise_smith@myemail.com",
    orderdate: new Date("2020-05-30T08:35:52Z"),
    product_id: "a1b2c3d4",
    value: 431.43,
  },
  {
    customer_id: "tj@wheresmyemail.com",
    orderdate: new Date("2019-05-28T19:13:32Z"),
    product_id: "z9y8x7w6",
    value: 5.01,
  },
  {
    customer_id: "oranieri@warmmail.com",
    orderdate: new Date("2020-01-01T08:25:37Z"),
    product_id: "ff11gg22hh33",
    value: 63.13,
  },
  {
    customer_id: "jjones@tepidmail.com",
    orderdate: new Date("2020-12-26T08:55:46Z"),
    product_id: "a1b2c3d4",
    value: 429.65,
  },
]);
await products.insertMany([
  {
    id: "a1b2c3d4",
    name: "Asus Laptop",
    category: "ELECTRONICS",
    description: "Good value laptop for students",
  },
  {
    id: "z9y8x7w6",
    name: "The Day Of The Triffids",
    category: "BOOKS",
    description: "Classic post-apocalyptic novel",
  },
  {
    id: "ff11gg22hh33",
    name: "Morphy Richardds Food Mixer",
    category: "KITCHENWARE",
    description: "Luxury mixer turning good cakes into great",
  },
  {
    id: "pqr678st",
    name: "Karcher Hose Set",
    category: "GARDEN",
    description: "Hose + nosels + winder for tidy storage",
  },
]);

<?php
require 'vendor/autoload.php';
// Modify imports for each tutorial as needed.
use MongoDB\Client;
use MongoDB\BSON\UTCDateTime;
use MongoDB\Builder\Pipeline;
use MongoDB\Builder\Stage;
use MongoDB\Builder\Type\Sort;
use MongoDB\Builder\Query;
use MongoDB\Builder\Expression;
use MongoDB\Builder\Accumulator;
use function MongoDB\object;
// Replace the placeholder with your connection string.
$uri = '<connection string>';
$client = new Client($uri);
// Get a reference to relevant collections.
// ... $someColl = $client->agg_tutorials_db->someColl;
// ... $anotherColl = $client->agg_tutorials_db->anotherColl;
// Delete any existing documents in collections if needed.
// ... $someColl->deleteMany([]);
// Insert sample data into the collection or collections.
// ... $someColl->insertMany(...);
// Add code to create pipeline stages within the Pipeline instance.
// ... $pipeline = new Pipeline(...);
// Run the aggregation.
// ... $cursor = $someColl->aggregate($pipeline);
// Print the aggregation results.
foreach ($cursor as $doc) {
    echo json_encode($doc, JSON_PRETTY_PRINT), PHP_EOL;
}

$orders = $client->agg_tutorials_db->orders;
$products = $client->agg_tutorials_db->products;
$orders->deleteMany([]);
$products->deleteMany([]);
$orders->insertMany(
    [
        [
            'customer_id' => 'elise_smith@myemail.com',
            'orderdate' => new UTCDateTime(new DateTimeImmutable('2020-05-30T08:35:52')),
            'product_id' => 'a1b2c3d4',
            'value' => 431.43
        ],
        [
            'customer_id' => 'tj@wheresmyemail.com',
            'orderdate' => new UTCDateTime(new DateTimeImmutable('2019-05-28T19:13:32')),
            'product_id' => 'z9y8x7w6',
            'value' => 5.01
        ],
        [
            'customer_id' => 'oranieri@warmmail.com',
            'orderdate' => new UTCDateTime(new DateTimeImmutable('2020-01-01T08:25:37')),
            'product_id' => 'ff11gg22hh33',
            'value' => 63.13,
        ],
        [
            'customer_id' => 'jjones@tepidmail.com',
            'orderdate' => new UTCDateTime(new DateTimeImmutable('2020-12-26T08:55:46')),
            'product_id' => 'a1b2c3d4',
            'value' => 429.65
        ],
    ]
);
$products->insertMany(
    [
        [
            'id' => 'a1b2c3d4',
            'name' => 'Asus Laptop',
            'category' => 'ELECTRONICS',
            'description' => 'Good value laptop for students',
        ],
        [
            'id' => 'z9y8x7w6',
            'name' => 'The Day Of The Triffids',
            'category' => 'BOOKS',
            'description' => 'Classic post-apocalyptic novel',
        ],
        [
            'id' => 'ff11gg22hh33',
            'name' => 'Morphy Richardds Food Mixer',
            'category' => 'KITCHENWARE',
            'description' => 'Luxury mixer turning good cakes into great',
        ],
        [
            'id' => 'pqr678st',
            'name' => 'Karcher Hose Set',
            'category' => 'GARDEN',
            'description' => 'Hose + nosels + winder for tidy storage',
        ],
    ]
);

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

orders_coll = agg_db["orders"]
products_coll = agg_db["products"]
orders_coll.delete_many({})
products_coll.delete_many({})
order_data = [
    {
        "customer_id": "elise_smith@myemail.com",
        "orderdate": datetime(2020, 5, 30, 8, 35, 52),
        "product_id": "a1b2c3d4",
        "value": 431.43,
    },
    {
        "customer_id": "tj@wheresmyemail.com",
        "orderdate": datetime(2019, 5, 28, 19, 13, 32),
        "product_id": "z9y8x7w6",
        "value": 5.01,
    },
    {
        "customer_id": "oranieri@warmmail.com",
        "orderdate": datetime(2020, 1, 1, 8, 25, 37),
        "product_id": "ff11gg22hh33",
        "value": 63.13,
    },
    {
        "customer_id": "jjones@tepidmail.com",
        "orderdate": datetime(2020, 12, 26, 8, 55, 46),
        "product_id": "a1b2c3d4",
        "value": 429.65,
    },
]
orders_coll.insert_many(order_data)
product_data = [
    {
        "id": "a1b2c3d4",
        "name": "Asus Laptop",
        "category": "ELECTRONICS",
        "description": "Good value laptop for students",
    },
    {
        "id": "z9y8x7w6",
        "name": "The Day Of The Triffids",
        "category": "BOOKS",
        "description": "Classic post-apocalyptic novel",
    },
    {
        "id": "ff11gg22hh33",
        "name": "Morphy Richardds Food Mixer",
        "category": "KITCHENWARE",
        "description": "Luxury mixer turning good cakes into great",
    },
    {
        "id": "pqr678st",
        "name": "Karcher Hose Set",
        "category": "GARDEN",
        "description": "Hose + nosels + winder for tidy storage",
    },
]
products_coll.insert_many(product_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

orders = agg_db[:orders]
products = agg_db[:products]
orders.delete_many({})
products.delete_many({})
orders.insert_many(
  [
    {
      customer_id: "elise_smith@myemail.com",
      orderdate: DateTime.parse("2020-05-30T08:35:52Z"),
      product_id: "a1b2c3d4",
      value: 431.43,
    },
    {
      customer_id: "tj@wheresmyemail.com",
      orderdate: DateTime.parse("2019-05-28T19:13:32Z"),
      product_id: "z9y8x7w6",
      value: 5.01,
    },
    {
      customer_id: "oranieri@warmmail.com",
      orderdate: DateTime.parse("2020-01-01T08:25:37Z"),
      product_id: "ff11gg22hh33",
      value: 63.13,
    },
    {
      customer_id: "jjones@tepidmail.com",
      orderdate: DateTime.parse("2020-12-26T08:55:46Z"),
      product_id: "a1b2c3d4",
      value: 429.65,
    },
  ]
)
products.insert_many(
  [
    {
      id: "a1b2c3d4",
      name: "Asus Laptop",
      category: "ELECTRONICS",
      description: "Good value laptop for students",
    },
    {
      id: "z9y8x7w6",
      name: "The Day Of The Triffids",
      category: "BOOKS",
      description: "Classic post-apocalyptic novel",
    },
    {
      id: "ff11gg22hh33",
      name: "Morphy Richardds Food Mixer",
      category: "KITCHENWARE",
      description: "Luxury mixer turning good cakes into great",
    },
    {
      id: "pqr678st",
      name: "Karcher Hose Set",
      category: "GARDEN",
      description: "Hose + nosels + winder for tidy storage",
    },
  ]
)

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 Order {
    customer_id: String,
    order_date: DateTime,
    product_id: String,
    value: f32,
}
#[derive(Debug, Serialize, Deserialize)]
struct Product {
    id: String,
    name: String,
    category: String,
    description: String,
}

let orders: Collection<Order> = agg_db.collection("orders");
let products: Collection<Product> = agg_db.collection("products");
orders.delete_many(doc! {}).await?;
products.delete_many(doc! {}).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_id: "a1b2c3d4".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_id: "z9y8x7w6".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_id: "ff11gg22hh33".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_id: "a1b2c3d4".to_string(),
        value: 429.65,
    },
];
orders.insert_many(order_docs).await?;
let product_docs = vec![
    Product {
        id: "a1b2c3d4".to_string(),
        name: "Asus Laptop".to_string(),
        category: "ELECTRONICS".to_string(),
        description: "Good value laptop for students".to_string(),
    },
    Product {
        id: "z9y8x7w6".to_string(),
        name: "The Day Of The Triffids".to_string(),
        category: "BOOKS".to_string(),
        description: "Classic post-apocalyptic novel".to_string(),
    },
    Product {
        id: "ff11gg22hh33".to_string(),
        name: "Morphy Richardds Food Mixer".to_string(),
        category: "KITCHENWARE".to_string(),
        description: "Luxury mixer turning good cakes into great".to_string(),
    },
    Product {
        id: "pqr678st".to_string(),
        name: "Karcher Hose Set".to_string(),
        category: "GARDEN".to_string(),
        description: "Hose + nosels + winder for tidy storage".to_string(),
    },
];
products.insert_many(product_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 orders = aggDB.getCollection("orders")
val products = aggDB.getCollection("products")
orders.deleteMany(Filters.empty()).subscribe(
  _ => {},
  e => println("Error: " + e.getMessage),
)
products.deleteMany(Filters.empty()).subscribe(
  _ => {},
  e => println("Error: " + e.getMessage),
)
val dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss")
orders.insertMany(
  Seq(
    Document(
      "customer_id" -> "elise_smith@myemail.com",
      "orderdate" -> dateFormat.parse("2020-05-30T08:35:52"),
      "product_id" -> "a1b2c3d4",
      "value" -> 431.43
    ),
    Document(
      "customer_id" -> "tj@wheresmyemail.com",
      "orderdate" -> dateFormat.parse("2019-05-28T19:13:32"),
      "product_id" -> "z9y8x7w6",
      "value" -> 5.01
    ),
    Document(
      "customer_id" -> "oranieri@warmmail.com",
      "orderdate" -> dateFormat.parse("2020-01-01T08:25:37"),
      "product_id" -> "ff11gg22hh33",
      "value" -> 63.13
    ),
    Document(
      "customer_id" -> "jjones@tepidmail.com",
      "orderdate" -> dateFormat.parse("2020-12-26T08:55:46"),
      "product_id" -> "a1b2c3d4",
      "value" -> 429.65
    )
  )
).subscribe(
  _ => {},
  e => println("Error: " + e.getMessage),
)
products.insertMany(
  Seq(
    Document(
      "id" -> "a1b2c3d4",
      "name" -> "Asus Laptop",
      "category" -> "ELECTRONICS",
      "description" -> "Good value laptop for students"
    ),
    Document(
      "id" -> "z9y8x7w6",
      "name" -> "The Day Of The Triffids",
      "category" -> "BOOKS",
      "description" -> "Classic post-apocalyptic novel"
    ),
    Document(
      "id" -> "ff11gg22hh33",
      "name" -> "Morphy Richardds Food Mixer",
      "category" -> "KITCHENWARE",
      "description" -> "Luxury mixer turning good cakes into great"
    ),
    Document(
      "id" -> "pqr678st",
      "name" -> "Karcher Hose Set",
      "category" -> "GARDEN",
      "description" -> "Hose + nosels + winder for tidy storage"
    )
  )
).subscribe(
  _ => {},
  e => println("Error: " + e.getMessage),
)