데이터 그룹화 및 합계

이 튜토리얼에서는 집계 파이프라인 구성하고, 컬렉션 에서 집계 수행하고, 선택한 언어 사용하여 결과를 표시하는 방법을 보여 줍니다.

이 작업에 관한 정보

이 튜토리얼에서는 고객 주문 데이터를 그룹 하고 분석 방법을 보여줍니다. 결과에는 2020 에서 품목을 구매한 고객 목록이 표시되고 2020에 대한 각 고객의 주문 내역이 포함됩니다.

집계 파이프라인 다음 작업을 수행합니다.

문서의 하위 집합을 필드 값으로 일치
공통 필드 값을 기준으로 문서 그룹화
각 결과 문서 에 계산된 필드를 추가합니다.

시작하기 전에

오른쪽 상단의 언어 선택 드롭다운 메뉴를 사용하여 다음 예제의 언어 설정하다 하거나 MongoDB Shell 선택합니다.

이 예시 개별 제품 주문을 설명하는 문서가 포함된 orders 컬렉션 사용합니다. 각 주문은 한 명의 고객에만 해당하므로 집계 게이션은 고객 이메일 주소가 포함된 customer_id 필드 기준으로 문서를 정렬합니다.

컬렉션 만들려면 메서드를 사용합니다.orders insertMany()

db.orders.deleteMany({})
db.orders.insertMany( [
   {
      customer_id: "[email protected]",
      orderdate: new Date("2020-05-30T08:35:52Z"),
      value: 231,
   },
   {
      customer_id: "[email protected]",
      orderdate: new Date("2020-01-13T09:32:07Z"),
      value: 99,
   },
   {
      customer_id: "[email protected]",
      orderdate: new Date("2020-01-01T08:25:37Z"),
      value: 63,
   },
   {
      customer_id: "[email protected]",
      orderdate: new Date("2019-05-28T19:13:32Z"),
      value: 2,
   },
   {
      customer_id: "[email protected]",
      orderdate: new Date("2020-11-23T22:56:53Z"),
      value: 187,
   },
   {
      customer_id: "[email protected]",
      orderdate: new Date("2020-08-18T23:04:48Z"),
      value: 4,
   },
   {
      customer_id: "[email protected]",
      orderdate: new Date("2020-12-26T08:55:46Z"),
      value: 4,
   },
   {
      customer_id: "[email protected]",
      orderdate: new Date("2021-02-29T07:49:32Z"),
      value: 1024,
   },
   {
      customer_id: "[email protected]",
      orderdate: new Date("2020-10-03T13:49:44Z"),
      value: 102,
   }
] )

템플릿 앱 만들기

이 집계 튜토리얼을 시작하기 전에 새 C 앱 설정하다 해야 합니다. 이 앱 사용하여 MongoDB deployment 에 연결하고, 샘플 데이터를 MongoDB 에 삽입하고, 집계 파이프라인 실행 .

팁

운전자 설치하고 MongoDB 에 연결하는 방법을 학습 C 드라이버 시작하기 가이드 참조하세요.

C 드라이버 에서 애그리게이션을 수행하는 방법에 대해 자세히 학습 애그리게이션 가이드 참조하세요.

운전자 설치한 후 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;
}

모든 튜토리얼에서는 연결 문자열 자리 표시자를 반드시 배포서버의 연결 문자열로 바꿔야 합니다.

팁

배포의 연결 문자열 찾는 방법을 학습 C 시작하기 가이드 의 연결 문자열 만들기 단계를 참조하세요.

예를 들어 연결 문자열이 "mongodb+srv://mongodb-example:27017" 인 경우 연결 문자열 할당은 다음과 유사합니다.

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

컬렉션 생성

이 예시 개별 제품 주문을 설명하는 문서가 포함된 orders 컬렉션 사용합니다. 각 주문은 한 명의 고객에게만 해당하므로 집계 게이션은 고객 이메일 주소가 포함된 customer_id 필드 기준으로 문서를 정렬합니다.

orders 컬렉션 만들고 샘플 데이터를 삽입하려면 애플리케이션 에 다음 코드를 추가합니다.

mongoc_collection_t *orders = mongoc_client_get_collection(client, "agg_tutorials_db", "orders");
{
    bson_t *filter = bson_new();
    bson_error_t error;
    if (!mongoc_collection_delete_many(orders, filter, NULL, NULL, &error))
    {
        fprintf(stderr, "Delete error: %s\n", error.message);
    }
    bson_destroy(filter);
}
{
    size_t num_docs = 9;
    bson_t *docs[num_docs];
    docs[0] = BCON_NEW(
        "customer_id", BCON_UTF8("[email protected]"),
        "orderdate", BCON_DATE_TIME(1590825352000UL), // 2020-05-30T08:35:52Z
        "value", BCON_INT32(231));
    docs[1] = BCON_NEW(
        "customer_id", BCON_UTF8("[email protected]"),
        "orderdate", BCON_DATE_TIME(1578904327000UL), // 2020-01-13T09:32:07Z
        "value", BCON_INT32(99));
    docs[2] = BCON_NEW(
        "customer_id", BCON_UTF8("[email protected]"),
        "orderdate", BCON_DATE_TIME(1577865937000UL), // 2020-01-01T08:25:37Z
        "value", BCON_INT32(63));
    docs[3] = BCON_NEW(
        "customer_id", BCON_UTF8("[email protected]"),
        "orderdate", BCON_DATE_TIME(1559061212000UL), // 2019-05-28T19:13:32Z
        "value", BCON_INT32(2));
    docs[4] = BCON_NEW(
        "customer_id", BCON_UTF8("[email protected]"),
        "orderdate", BCON_DATE_TIME(1606171013000UL), // 2020-11-23T22:56:53Z
        "value", BCON_INT32(187));
    docs[5] = BCON_NEW(
        "customer_id", BCON_UTF8("[email protected]"),
        "orderdate", BCON_DATE_TIME(1597793088000UL), // 2020-08-18T23:04:48Z
        "value", BCON_INT32(4));
    docs[6] = BCON_NEW(
        "customer_id", BCON_UTF8("[email protected]"),
        "orderdate", BCON_DATE_TIME(1608963346000UL), // 2020-12-26T08:55:46Z
        "value", BCON_INT32(4));
    docs[7] = BCON_NEW(
        "customer_id", BCON_UTF8("[email protected]"),
        "orderdate", BCON_DATE_TIME(1614496172000UL), // 2021-02-28T07:49:32Z
        "value", BCON_INT32(1024));
    docs[8] = BCON_NEW(
        "customer_id", BCON_UTF8("[email protected]"),
        "orderdate", BCON_DATE_TIME(1601722184000UL), // 2020-10-03T13:49:44Z
        "value", BCON_INT32(102));
    bson_error_t error;
    if (!mongoc_collection_insert_many(orders, (const bson_t **)docs, num_docs, NULL, NULL, &error))
    {
        fprintf(stderr, "Insert error: %s\n", error.message);
    }
    for (int i = 0; i < num_docs; i++)
    {
        bson_destroy(docs[i]);
    }
}

템플릿 앱 만들기

집계 튜토리얼을 따라 하기 전에 새 C++ 앱 설정하다 해야 합니다. 이 앱 사용하여 MongoDB deployment 에 연결하고, 샘플 데이터를 MongoDB 에 삽입하고, 집계 파이프라인 실행 .

팁

운전자 설치하고 MongoDB 에 연결하는 방법을 학습 C++ 시작하기 튜토리얼을 참조하세요.

C++ 운전자 사용에 대해 자세히 학습 API 설명서를 참조하세요.

C++ 드라이버 에서 애그리게이션을 수행하는 방법에 대해 자세히 학습 애그리게이션 가이드 참조하세요.

운전자 설치한 후 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;
   }
}

모든 튜토리얼에서는 연결 문자열 자리 표시자를 반드시 배포서버의 연결 문자열로 바꿔야 합니다.

팁

배포의 연결 문자열 찾는 방법을 학습 C++ 시작하기 튜토리얼의 연결 문자열 만들기 단계를 참조하세요.

예를 들어 연결 문자열이 "mongodb+srv://mongodb-example:27017" 인 경우 연결 문자열 할당은 다음과 유사합니다.

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

컬렉션 생성

orders 컬렉션 만들고 샘플 데이터를 삽입하려면 애플리케이션 에 다음 코드를 추가합니다.

auto orders = db["orders"];
std::vector<bsoncxx::document::value> docs = {
    bsoncxx::from_json(R"({
        "customer_id": "[email protected]",
        "orderdate": {"$date": 1590821752000},
        "value": 231
    })"),
    bsoncxx::from_json(R"({
        "customer_id": "[email protected]",
        "orderdate": {"$date": 1578901927},
        "value": 99
    })"),
    bsoncxx::from_json(R"({
        "customer_id": "[email protected]",
        "orderdate": {"$date": 1577861137},
        "value": 63
    })"),
    bsoncxx::from_json(R"({
        "customer_id": "[email protected]",
        "orderdate": {"$date": 1559076812},
        "value": 2
    })"),
    bsoncxx::from_json(R"({
        "customer_id": "[email protected]",
        "orderdate": {"$date": 1606172213},
        "value": 187
    })"),
    bsoncxx::from_json(R"({
        "customer_id": "[email protected]",
        "orderdate": {"$date": 1597794288},
        "value": 4
    })"),
    bsoncxx::from_json(R"({
        "customer_id": "[email protected]",
        "orderdate": {"$date": 1608972946000},
        "value": 4
    })"),
    bsoncxx::from_json(R"({
        "customer_id": "[email protected]",
        "orderdate": {"$date": 1614570572},
        "value": 1024
    })"),
    bsoncxx::from_json(R"({
        "customer_id": "[email protected]",
        "orderdate": {"$date": 1601722184000},
        "value": 102
    })")
};
auto result = orders.insert_many(docs); // Might throw an exception

템플릿 앱 만들기

이 집계 튜토리얼을 시작하기 전에 새 C#/ .NET 앱 설정하다 해야 합니다. 이 앱 사용하여 MongoDB deployment 에 연결하고, 샘플 데이터를 MongoDB 에 삽입하고, 집계 파이프라인 실행 .

팁

운전자 설치하고 MongoDB 에 연결하는 방법을 학습 C#/ .NET 드라이버 빠른 시작 가이드 참조하세요.

C#/ .NET 드라이버 에서 애그리게이션을 수행하는 방법에 대해 자세히 학습 애그리게이션 가이드 참조하세요.

운전자 설치한 후 다음 코드를 Program.cs 파일 에 붙여넣어 집계 튜토리얼을 위한 앱 템플릿을 만듭니다.

중요

다음 코드에서 코드 주석을 읽고 팔로우 중인 튜토리얼에 대해 수정해야 하는 코드 섹션을 찾습니다.

변경하지 않고 코드를 실행하려고 하면 연결 오류가 발생합니다.

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

모든 튜토리얼에서는 연결 문자열 자리 표시자를 반드시 배포서버의 연결 문자열로 바꿔야 합니다.

팁

배포의 연결 문자열 찾는 방법을 학습 C# 빠른 시작 가이드 의 Atlas 에서 무료 계층 클러스터 설정 단계를 참조하세요.

예를 들어 연결 문자열이 "mongodb+srv://mongodb-example:27017" 인 경우 연결 문자열 할당은 다음과 유사합니다.

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

컬렉션 생성

이 예시 개별 제품 주문을 설명하는 문서가 포함된 orders 컬렉션 사용합니다. 각 주문은 한 명의 고객에게만 해당하므로 집계 게이션은 고객 이메일 주소가 포함된 CustomerId 필드 기준으로 문서를 정렬합니다.

먼저 C# 클래스를 만들어 orders 컬렉션 의 데이터를 모델링합니다.

public class Order
{
  [BsonId]
  public ObjectId Id { get; set; }
  public string CustomerId { get; set; }
  public DateTime OrderDate { get; set; }
  public int Value { get; set; }
}

orders 컬렉션 만들고 샘플 데이터를 삽입하려면 애플리케이션 에 다음 코드를 추가합니다.

var orders = aggDB.GetCollection<Order>("orders");
orders.DeleteMany(Builders<Order>.Filter.Empty);
orders.InsertMany(new List<Order>
    {
        new Order
        {
            CustomerId = "[email protected]",
            OrderDate = DateTime.Parse("2020-05-30T08:35:52Z"),
            Value = 231
        },
        new Order
        {
            CustomerId = "[email protected]",
            OrderDate = DateTime.Parse("2020-01-13T09:32:07Z"),
            Value = 99
        },
        new Order
        {
            CustomerId = "[email protected]",
            OrderDate = DateTime.Parse("2020-01-01T08:25:37Z"),
            Value = 63
        },
        new Order
        {
            CustomerId = "[email protected]",
            OrderDate = DateTime.Parse("2019-05-28T19:13:32Z"),
            Value = 2
        },
        new Order
        {
            CustomerId = "[email protected]",
            OrderDate = DateTime.Parse("2020-11-23T22:56:53Z"),
            Value = 187
        },
        new Order
        {
            CustomerId = "[email protected]",
            OrderDate = DateTime.Parse("2020-08-18T23:04:48Z"),
            Value = 4
        },
        new Order
        {
            CustomerId = "[email protected]",
            OrderDate = DateTime.Parse("2020-12-26T08:55:46Z"),
            Value = 4
        },
        new Order
        {
            CustomerId = "[email protected]",
            OrderDate = DateTime.Parse("2021-02-28T07:49:32Z"),
            Value = 1024
        },
        new Order
        {
            CustomerId = "[email protected]",
            OrderDate = DateTime.Parse("2020-10-03T13:49:44Z"),
            Value = 102
        }
    });

템플릿 앱 만들기

이 집계 튜토리얼을 시작하기 전에 새 고 (Go) 앱 설정하다 해야 합니다. 이 앱 사용하여 MongoDB deployment 에 연결하고, 샘플 데이터를 MongoDB 에 삽입하고, 집계 파이프라인 실행 .

팁

운전자 설치하고 MongoDB 에 연결하는 방법을 학습 고 (Go) 드라이버 빠른 시작 가이드 참조하세요.

고 (Go) 드라이버 에서 애그리게이션을 수행하는 방법에 대해 자세히 학습 애그리게이션 가이드 참조하세요.

운전자 설치한 후 agg_tutorial.go라는 파일 만듭니다. 이 파일 에 다음 코드를 붙여넣어 집계 튜토리얼을 위한 앱 템플릿을 만듭니다.

중요

다음 코드에서 코드 주석을 읽고 팔로우 중인 튜토리얼에 대해 수정해야 하는 코드 섹션을 찾습니다.

변경하지 않고 코드를 실행하려고 하면 연결 오류가 발생합니다.

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

모든 튜토리얼에서는 연결 문자열 자리 표시자를 반드시 배포서버의 연결 문자열로 바꿔야 합니다.

팁

배포서버의 연결 문자열 찾는 방법을 학습 고 (Go) 빠른 시작 가이드 의 MongoDB 클러스터 만들기 단계를 참조하세요.

예를 들어 연결 문자열이 "mongodb+srv://mongodb-example:27017" 인 경우 연결 문자열 할당은 다음과 유사합니다.

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

컬렉션 생성

먼저 고 (Go) 구조체를 만들어 orders 컬렉션 의 데이터를 모델링합니다.

type Order struct {
	CustomerID string        `bson:"customer_id,omitempty"`
	OrderDate  bson.DateTime `bson:"orderdate"`
	Value      int           `bson:"value"`
}

orders 컬렉션 만들고 샘플 데이터를 삽입하려면 애플리케이션 에 다음 코드를 추가합니다.

orders := aggDB.Collection("orders")
orders.DeleteMany(context.TODO(), bson.D{})
_, err = orders.InsertMany(context.TODO(), []interface{}{
	Order{
		CustomerID: "[email protected]",
		OrderDate:  bson.NewDateTimeFromTime(time.Date(2020, 5, 30, 8, 35, 53, 0, time.UTC)),
		Value:      231,
	},
	Order{
		CustomerID: "[email protected]",
		OrderDate:  bson.NewDateTimeFromTime(time.Date(2020, 1, 13, 9, 32, 7, 0, time.UTC)),
		Value:      99,
	},
	Order{
		CustomerID: "[email protected]",
		OrderDate:  bson.NewDateTimeFromTime(time.Date(2020, 1, 01, 8, 25, 37, 0, time.UTC)),
		Value:      63,
	},
	Order{
		CustomerID: "[email protected]",
		OrderDate:  bson.NewDateTimeFromTime(time.Date(2019, 5, 28, 19, 13, 32, 0, time.UTC)),
		Value:      2,
	},
	Order{
		CustomerID: "[email protected]",
		OrderDate:  bson.NewDateTimeFromTime(time.Date(2020, 11, 23, 22, 56, 53, 0, time.UTC)),
		Value:      187,
	},
	Order{
		CustomerID: "[email protected]",
		OrderDate:  bson.NewDateTimeFromTime(time.Date(2020, 8, 18, 23, 4, 48, 0, time.UTC)),
		Value:      4,
	},
	Order{
		CustomerID: "[email protected]",
		OrderDate:  bson.NewDateTimeFromTime(time.Date(2020, 12, 26, 8, 55, 46, 0, time.UTC)),
		Value:      4,
	},
	Order{
		CustomerID: "[email protected]",
		OrderDate:  bson.NewDateTimeFromTime(time.Date(2021, 2, 29, 7, 49, 32, 0, time.UTC)),
		Value:      1024,
	},
	Order{
		CustomerID: "[email protected]",
		OrderDate:  bson.NewDateTimeFromTime(time.Date(2020, 10, 3, 13, 49, 44, 0, time.UTC)),
		Value:      102,
	},
})
if err != nil {
	log.Fatal(err)
}

템플릿 앱 만들기

집계 튜토리얼을 시작하기 전에 새 Java 앱 설정하다 해야 합니다. 이 앱 사용하여 MongoDB deployment 에 연결하고, 샘플 데이터를 MongoDB 에 삽입하고, 집계 파이프라인 실행 .

팁

운전자 설치하고 MongoDB 에 연결하는 방법을 학습 Java 드라이버 시작하기 가이드 참조하세요.

Java Sync 드라이버 에서 애그리게이션을 수행하는 방법에 대해 자세히 학습 애그리게이션 가이드 참조하세요.

운전자 설치한 후 AggTutorial.java라는 파일 만듭니다. 이 파일 에 다음 코드를 붙여넣어 집계 튜토리얼을 위한 앱 템플릿을 만듭니다.

중요

다음 코드에서 코드 주석을 읽고 팔로우 중인 튜토리얼에 대해 수정해야 하는 코드 섹션을 찾습니다.

변경하지 않고 코드를 실행하려고 하면 연결 오류가 발생합니다.

package org.example;
// Modify imports for each tutorial as needed.
import com.mongodb.client.*;
import com.mongodb.client.model.Aggregates;
import com.mongodb.client.model.Filters;
import com.mongodb.client.model.Sorts;
import org.bson.Document;
import org.bson.conversions.Bson;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class AggTutorial {
    public static void main( String[] args ) {
        // Replace the placeholder with your connection string.
        String uri = "<connection string>";
        try (MongoClient mongoClient = MongoClients.create(uri)) {
            MongoDatabase aggDB = mongoClient.getDatabase("agg_tutorials_db");
            // Get a reference to relevant collections.
            // ... MongoCollection<Document> someColl = ...
            // ... MongoCollection<Document> anotherColl = ...
            // Delete any existing documents in collections if needed.
            // ... someColl.deleteMany(Filters.empty());
            // Insert sample data into the collection or collections.
            // ... someColl.insertMany(...);
            // Create an empty pipeline array.
            List<Bson> pipeline = new ArrayList<>();
            // Add code to create pipeline stages.
            // ... pipeline.add(...);
            // Run the aggregation.
            // ... AggregateIterable<Document> aggregationResult = someColl.aggregate(pipeline);
            // Print the aggregation results.
            for (Document document : aggregationResult) {
                System.out.println(document.toJson());
            }
        }
    }
}

모든 튜토리얼에서는 연결 문자열 자리 표시자를 반드시 배포서버의 연결 문자열로 바꿔야 합니다.

팁

배포의 연결 문자열 찾는 방법을 학습 Java Sync 빠른 시작 가이드 의 연결 문자열 만들기 단계를 참조하세요.

예를 들어 연결 문자열이 "mongodb+srv://mongodb-example:27017" 인 경우 연결 문자열 할당은 다음과 유사합니다.

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

컬렉션 생성

orders 컬렉션 만들고 샘플 데이터를 삽입하려면 애플리케이션 에 다음 코드를 추가합니다.

MongoCollection<Document> orders = aggDB.getCollection("orders");
orders.deleteMany(Filters.empty());
orders.insertMany(
        Arrays.asList(
                new Document("customer_id", "[email protected]")
                        .append("orderdate", LocalDateTime.parse("2020-05-30T08:35:52"))
                        .append("value", 231),
                new Document("customer_id", "[email protected]")
                        .append("orderdate", LocalDateTime.parse("2020-01-13T09:32:07"))
                        .append("value", 99),
                new Document("customer_id", "[email protected]")
                        .append("orderdate", LocalDateTime.parse("2020-01-01T08:25:37"))
                        .append("value", 63),
                new Document("customer_id", "[email protected]")
                        .append("orderdate", LocalDateTime.parse("2019-05-28T19:13:32"))
                        .append("value", 2),
                new Document("customer_id", "[email protected]")
                        .append("orderdate", LocalDateTime.parse("2020-11-23T22:56:53"))
                        .append("value", 187),
                new Document("customer_id", "[email protected]")
                        .append("orderdate", LocalDateTime.parse("2020-08-18T23:04:48"))
                        .append("value", 4),
                new Document("customer_id", "[email protected]")
                        .append("orderdate", LocalDateTime.parse("2020-12-26T08:55:46"))
                        .append("value", 4),
                new Document("customer_id", "[email protected]")
                        .append("orderdate", LocalDateTime.parse("2021-02-28T07:49:32"))
                        .append("value", 1024),
                new Document("customer_id", "[email protected]")
                        .append("orderdate", LocalDateTime.parse("2020-10-03T13:49:44"))
                        .append("value", 102)
        )
);

템플릿 앱 만들기

집계 튜토리얼을 시작하기 전에 새 코틀린 (Kotlin) 앱 설정하다 해야 합니다. 이 앱 사용하여 MongoDB deployment 에 연결하고, 샘플 데이터를 MongoDB 에 삽입하고, 집계 파이프라인 실행 .

팁

운전자 설치하고 MongoDB 에 연결하는 방법을 학습 코틀린 (Kotlin) ) 드라이버 빠른 시작 가이드 참조하세요.

코틀린 (Kotlin) ) 드라이버 에서 애그리게이션을 수행하는 방법에 대해 자세히 학습 애그리게이션 가이드 참조하세요.

운전자 외에도 build.gradle.kts 파일 에 다음 종속성을 추가하고 프로젝트 다시 로드해야 합니다.

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

운전자 설치한 후 AggTutorial.kt라는 파일 만듭니다. 이 파일 에 다음 코드를 붙여넣어 집계 튜토리얼을 위한 앱 템플릿을 만듭니다.

중요

다음 코드에서 코드 주석을 읽고 팔로우 중인 튜토리얼에 대해 수정해야 하는 코드 섹션을 찾습니다.

변경하지 않고 코드를 실행하려고 하면 연결 오류가 발생합니다.

package org.example
// Modify imports for each tutorial as needed.
import com.mongodb.client.model.*
import com.mongodb.kotlin.client.coroutine.MongoClient
import kotlinx.coroutines.runBlocking
import kotlinx.datetime.LocalDateTime
import kotlinx.datetime.toJavaLocalDateTime
import kotlinx.serialization.Contextual
import kotlinx.serialization.Serializable
import org.bson.Document
import org.bson.conversions.Bson
// Define data classes.
@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) }
    }
}

모든 튜토리얼에서는 연결 문자열 자리 표시자를 반드시 배포서버의 연결 문자열로 바꿔야 합니다.

팁

배포의 연결 문자열 찾는 방법을 학습 코틀린 (Kotlin) 드라이버 빠른 시작 가이드 의 클러스터에 연결 단계를 참조하세요.

예를 들어 연결 문자열이 "mongodb+srv://mongodb-example:27017" 인 경우 연결 문자열 할당은 다음과 유사합니다.

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

컬렉션 생성

먼저 코틀린 (Kotlin) 데이터 클래스를 만들어 orders 컬렉션 의 데이터를 모델링합니다.

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

orders 컬렉션 만들고 샘플 데이터를 삽입하려면 애플리케이션 에 다음 코드를 추가합니다.

val orders = aggDB.getCollection<Order>("orders")
orders.deleteMany(Filters.empty())
orders.insertMany(
    listOf(
        Order("[email protected]", LocalDateTime.parse("2020-05-30T08:35:52"), 231),
        Order("[email protected]", LocalDateTime.parse("2020-01-13T09:32:07"), 99),
        Order("[email protected]", LocalDateTime.parse("2020-01-01T08:25:37"), 63),
        Order("[email protected]", LocalDateTime.parse("2019-05-28T19:13:32"), 2),
        Order("[email protected]", LocalDateTime.parse("2020-11-23T22:56:53"), 187),
        Order("[email protected]", LocalDateTime.parse("2020-08-18T23:04:48"), 4),
        Order("[email protected]", LocalDateTime.parse("2020-12-26T08:55:46"), 4),
        Order("[email protected]", LocalDateTime.parse("2021-02-28T07:49:32"), 1024),
        Order("[email protected]", LocalDateTime.parse("2020-10-03T13:49:44"), 102)
    )
)

템플릿 앱 만들기

이 집계 튜토리얼을 따라 시작하기 전에 새 Node.js 앱 설정하다 해야 합니다. 이 앱 사용하여 MongoDB deployment 에 연결하고, 샘플 데이터를 MongoDB 에 삽입하고, 집계 파이프라인 실행 .

팁

운전자 설치하고 MongoDB 에 연결하는 방법을 학습 Node.js 드라이버 빠른 시작 가이드 참조하세요.

Node.js 드라이버 에서 애그리게이션을 수행하는 방법에 대해 자세히 학습 애그리게이션 가이드 참조하세요.

운전자 설치한 후 agg_tutorial.js라는 파일 만듭니다. 이 파일 에 다음 코드를 붙여넣어 집계 튜토리얼을 위한 앱 템플릿을 만듭니다.

중요

다음 코드에서 코드 주석을 읽고 팔로우 중인 튜토리얼에 대해 수정해야 하는 코드 섹션을 찾습니다.

변경하지 않고 코드를 실행하려고 하면 연결 오류가 발생합니다.

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

모든 튜토리얼에서는 연결 문자열 자리 표시자를 반드시 배포서버의 연결 문자열로 바꿔야 합니다.

팁

배포의 연결 문자열 찾는 방법을 학습 Node.js 빠른 시작 가이드 의 연결 문자열 만들기 단계를 참조하세요.

예를 들어 연결 문자열이 "mongodb+srv://mongodb-example:27017" 인 경우 연결 문자열 할당은 다음과 유사합니다.

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

컬렉션 생성

orders 컬렉션 만들고 샘플 데이터를 삽입하려면 애플리케이션 에 다음 코드를 추가합니다.

const orders = aggDB.collection("orders");
await orders.deleteMany({});
await orders.insertMany([
  {
    customer_id: "[email protected]",
    orderdate: new Date("2020-05-30T08:35:52Z"),
    value: 231,
  },
  {
    customer_id: "[email protected]",
    orderdate: new Date("2020-01-13T09:32:07Z"),
    value: 99,
  },
  {
    customer_id: "[email protected]",
    orderdate: new Date("2020-01-01T08:25:37Z"),
    value: 63,
  },
  {
    customer_id: "[email protected]",
    orderdate: new Date("2019-05-28T19:13:32Z"),
    value: 2,
  },
  {
    customer_id: "[email protected]",
    orderdate: new Date("2020-11-23T22:56:53Z"),
    value: 187,
  },
  {
    customer_id: "[email protected]",
    orderdate: new Date("2020-08-18T23:04:48Z"),
    value: 4,
  },
  {
    customer_id: "[email protected]",
    orderdate: new Date("2020-12-26T08:55:46Z"),
    value: 4,
  },
  {
    customer_id: "[email protected]",
    orderdate: new Date("2021-02-29T07:49:32Z"),
    value: 1024,
  },
  {
    customer_id: "[email protected]",
    orderdate: new Date("2020-10-03T13:49:44Z"),
    value: 102,
  },
]);

템플릿 앱 만들기

이 집계 튜토리얼을 시작하기 전에 새 PHP 앱 설정하다 해야 합니다. 이 앱 사용하여 MongoDB deployment 에 연결하고, 샘플 데이터를 MongoDB 에 삽입하고, 집계 파이프라인 실행 .

팁

PHP 라이브러리를 설치하고 MongoDB 에 연결하는 방법을 학습 PHP 라이브러리 시작하기 튜토리얼을 참조하세요.

PHP 라이브러리에서 애그리게이션을 수행하는 방법에 대해 자세히 학습 애그리게이션 가이드 참조하세요.

라이브러리를 설치한 후 agg_tutorial.php라는 파일 만듭니다. 이 파일 에 다음 코드를 붙여넣어 집계 튜토리얼을 위한 앱 템플릿을 만듭니다.

중요

다음 코드에서 코드 주석을 읽고 팔로우 중인 튜토리얼에 대해 수정해야 하는 코드 섹션을 찾습니다.

변경하지 않고 코드를 실행하려고 하면 연결 오류가 발생합니다.

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

모든 튜토리얼에서는 연결 문자열 자리 표시자를 반드시 배포서버의 연결 문자열로 바꿔야 합니다.

팁

배포의 연결 문자열 찾는 방법을 학습 PHP 라이브러리 시작하기 튜토리얼의 연결 문자열 만들기 단계를 참조하세요.

예를 들어 연결 문자열이 "mongodb+srv://mongodb-example:27017" 인 경우 연결 문자열 할당은 다음과 유사합니다.

$uri = 'mongodb+srv://mongodb-example:27017';

컬렉션 생성

orders 컬렉션 만들고 샘플 데이터를 삽입하려면 애플리케이션 에 다음 코드를 추가합니다.

$orders = $client->agg_tutorials_db->orders;
$orders->deleteMany([]);
$orders->insertMany(
    [
        [
            'customer_id' => '[email protected]',
            'orderdate' => new UTCDateTime(new DateTimeImmutable('2020-05-30T08:35:52')),
            'value' => 231
        ],
        [
            'customer_id' => '[email protected]',
            'orderdate' => new UTCDateTime(new DateTimeImmutable('2020-01-13T09:32:07')),
            'value' => 99
        ],
        [
            'customer_id' => '[email protected]',
            'orderdate' => new UTCDateTime(new DateTimeImmutable('2020-01-01T08:25:37')),
            'value' => 63
        ],
        [
            'customer_id' => '[email protected]',
            'orderdate' => new UTCDateTime(new DateTimeImmutable('2019-05-28T19:13:32')),
            'value' => 2
        ],
        [
            'customer_id' => '[email protected]',
            'orderdate' => new UTCDateTime(new DateTimeImmutable('2020-11-23T22:56:53')),
            'value' => 187
        ],
        [
            'customer_id' => '[email protected]',
            'orderdate' => new UTCDateTime(new DateTimeImmutable('2020-08-18T23:04:48')),
            'value' => 4
        ],
        [
            'customer_id' => '[email protected]',
            'orderdate' => new UTCDateTime(new DateTimeImmutable('2020-12-26T08:55:46')),
            'value' => 4
        ],
        [
            'customer_id' => '[email protected]',
            'orderdate' => new UTCDateTime(new DateTimeImmutable('2021-02-28T07:49:32')),
            'value' => 1024
        ],
        [
            'customer_id' => '[email protected]',
            'orderdate' => new UTCDateTime(new DateTimeImmutable('2020-10-03T13:49:44')),
            'value' => 102
        ]
    ]
);

템플릿 앱 만들기

이 집계 튜토리얼을 따라 시작하기 전에 새 Python 앱 설정하다 해야 합니다. 이 앱 사용하여 MongoDB deployment 에 연결하고, 샘플 데이터를 MongoDB 에 삽입하고, 집계 파이프라인 실행 .

팁

PyMongo 설치하고 MongoDB 에 연결하는 방법을 학습 PyMongo 시작하기 튜토리얼을 참조하세요.

PyMongo 에서 애그리게이션을 수행하는 방법에 대해 자세히 학습 애그리게이션 가이드 참조하세요.

라이브러리를 설치한 후 agg_tutorial.py라는 파일 만듭니다. 이 파일 에 다음 코드를 붙여넣어 집계 튜토리얼을 위한 앱 템플릿을 만듭니다.

중요

다음 코드에서 코드 주석을 읽고 팔로우 중인 튜토리얼에 대해 수정해야 하는 코드 섹션을 찾습니다.

변경하지 않고 코드를 실행하려고 하면 연결 오류가 발생합니다.

# Modify imports for each tutorial as needed.
from pymongo import MongoClient
# Replace the placeholder with your connection string.
uri = "<connection string>"
client = MongoClient(uri)
try:
    agg_db = client["agg_tutorials_db"]
    # Get a reference to relevant collections.
    # ... some_coll = agg_db["some_coll"]
    # ... another_coll = agg_db["another_coll"]
    # Delete any existing documents in collections if needed.
    # ... some_coll.delete_many({})
    # Insert sample data into the collection or collections.
    # ... some_coll.insert_many(...)
    # Create an empty pipeline array.
    pipeline = []
    # Add code to create pipeline stages.
    # ... pipeline.append({...})
    # Run the aggregation.
    # ... aggregation_result = ...
    # Print the aggregation results.
    for document in aggregation_result:
        print(document)
finally:
    client.close()

모든 튜토리얼에서는 연결 문자열 자리 표시자를 반드시 배포서버의 연결 문자열로 바꿔야 합니다.

팁

배포의 연결 문자열 찾는 방법을 학습 PHP 라이브러리 시작하기 튜토리얼의 연결 문자열 만들기 단계를 참조하세요.

예를 들어 연결 문자열이 "mongodb+srv://mongodb-example:27017" 인 경우 연결 문자열 할당은 다음과 유사합니다.

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

컬렉션 생성

orders 컬렉션 만들고 샘플 데이터를 삽입하려면 애플리케이션 에 다음 코드를 추가합니다.

orders_coll = agg_db["orders"]
orders_coll.delete_many({})
order_data = [
    {
        "customer_id": "[email protected]",
        "orderdate": datetime(2020, 5, 30, 8, 35, 52),
        "value": 231,
    },
    {
        "customer_id": "[email protected]",
        "orderdate": datetime(2020, 1, 13, 9, 32, 7),
        "value": 99,
    },
    {
        "customer_id": "[email protected]",
        "orderdate": datetime(2020, 1, 1, 8, 25, 37),
        "value": 63,
    },
    {
        "customer_id": "[email protected]",
        "orderdate": datetime(2019, 5, 28, 19, 13, 32),
        "value": 2,
    },
    {
        "customer_id": "[email protected]",
        "orderdate": datetime(2020, 11, 23, 22, 56, 53),
        "value": 187,
    },
    {
        "customer_id": "[email protected]",
        "orderdate": datetime(2020, 8, 18, 23, 4, 48),
        "value": 4,
    },
    {
        "customer_id": "[email protected]",
        "orderdate": datetime(2020, 12, 26, 8, 55, 46),
        "value": 4,
    },
    {
        "customer_id": "[email protected]",
        "orderdate": datetime(2021, 2, 28, 7, 49, 32),
        "value": 1024,
    },
    {
        "customer_id": "[email protected]",
        "orderdate": datetime(2020, 10, 3, 13, 49, 44),
        "value": 102,
    },
]
orders_coll.insert_many(order_data)

템플릿 앱 만들기

이 집계 튜토리얼을 따라 시작하기 전에 새 Ruby 앱 설정하다 해야 합니다. 이 앱 사용하여 MongoDB deployment 에 연결하고, 샘플 데이터를 MongoDB 에 삽입하고, 집계 파이프라인 실행 .

팁

Ruby 드라이버 설치하고 MongoDB 에 연결하는 방법을 학습 Ruby 드라이버 시작하기 가이드 참조하세요.

Ruby 드라이버 에서 애그리게이션을 수행하는 방법에 대해 자세히 학습 애그리게이션 가이드 참조하세요.

운전자 설치한 후 agg_tutorial.rb라는 파일 만듭니다. 이 파일 에 다음 코드를 붙여넣어 집계 튜토리얼을 위한 앱 템플릿을 만듭니다.

중요

다음 코드에서 코드 주석을 읽고 팔로우 중인 튜토리얼에 대해 수정해야 하는 코드 섹션을 찾습니다.

변경하지 않고 코드를 실행하려고 하면 연결 오류가 발생합니다.

# typed: strict
require 'mongo'
require 'bson'
# Replace the placeholder with your connection string.
uri = "<connection string>"
Mongo::Client.new(uri) do |client|
  agg_db = client.use('agg_tutorials_db')
  # Get a reference to relevant collections.
  # ... some_coll = agg_db[:some_coll]
  # Delete any existing documents in collections if needed.
  # ... some_coll.delete_many({})
  # Insert sample data into the collection or collections.
  # ... some_coll.insert_many( ... )
  # Add code to create pipeline stages within the array.
  # ... pipeline = [ ... ]
  # Run the aggregation.
  # ... aggregation_result = some_coll.aggregate(pipeline)
  # Print the aggregation results.
  aggregation_result.each do |doc|
    puts doc
  end
end

모든 튜토리얼에서는 연결 문자열 자리 표시자를 반드시 배포서버의 연결 문자열로 바꿔야 합니다.

팁

배포의 연결 문자열 찾는 방법을 학습 Ruby 시작하기 가이드 의 연결 문자열 만들기 단계를 참조하세요.

예를 들어 연결 문자열이 "mongodb+srv://mongodb-example:27017" 인 경우 연결 문자열 할당은 다음과 유사합니다.

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

컬렉션 생성

orders 컬렉션 만들고 샘플 데이터를 삽입하려면 애플리케이션 에 다음 코드를 추가합니다.

orders = agg_db[:orders]
orders.delete_many({})
orders.insert_many(
  [
    {
      customer_id: "[email protected]",
      orderdate: DateTime.parse("2020-05-30T08:35:52Z"),
      value: 231,
    },
    {
      customer_id: "[email protected]",
      orderdate: DateTime.parse("2020-01-13T09:32:07Z"),
      value: 99,
    },
    {
      customer_id: "[email protected]",
      orderdate: DateTime.parse("2020-01-01T08:25:37Z"),
      value: 63,
    },
    {
      customer_id: "[email protected]",
      orderdate: DateTime.parse("2019-05-28T19:13:32Z"),
      value: 2,
    },
    {
      customer_id: "[email protected]",
      orderdate: DateTime.parse("2020-11-23T22:56:53Z"),
      value: 187,
    },
    {
      customer_id: "[email protected]",
      orderdate: DateTime.parse("2020-08-18T23:04:48Z"),
      value: 4,
    },
    {
      customer_id: "[email protected]",
      orderdate: DateTime.parse("2020-12-26T08:55:46Z"),
      value: 4,
    },
    {
      customer_id: "[email protected]",
      orderdate: DateTime.parse("2021-02-28T07:49:32Z"),
      value: 1024,
    },
    {
      customer_id: "[email protected]",
      orderdate: DateTime.parse("2020-10-03T13:49:44Z"),
      value: 102,
    },
  ]
)

템플릿 앱 만들기

이 집계 튜토리얼을 시작하기 전에 새 Rust 앱 설정하다 해야 합니다. 이 앱 사용하여 MongoDB deployment 에 연결하고, 샘플 데이터를 MongoDB 에 삽입하고, 집계 파이프라인 실행 .

팁

운전자 설치하고 MongoDB 에 연결하는 방법을 학습 Rust 드라이버 빠른 시작 가이드 참조하세요.

Rust 드라이버 에서 애그리게이션을 수행하는 방법에 대해 자세히 학습 애그리게이션 가이드 참조하세요.

운전자 설치한 후 agg-tutorial.rs라는 파일 만듭니다. 이 파일 에 다음 코드를 붙여넣어 집계 튜토리얼을 위한 앱 템플릿을 만듭니다.

중요

다음 코드에서 코드 주석을 읽고 팔로우 중인 튜토리얼에 대해 수정해야 하는 코드 섹션을 찾습니다.

변경하지 않고 코드를 실행하려고 하면 연결 오류가 발생합니다.

use mongodb::{
    bson::{doc, Document},
    options::ClientOptions,
    Client,
};
use futures::stream::TryStreamExt;
use std::error::Error;
// Define structs.
// #[derive(Debug, Serialize, Deserialize)]
// struct MyStruct { ... }
#[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(())
}

모든 튜토리얼에서는 연결 문자열 자리 표시자를 반드시 배포서버의 연결 문자열로 바꿔야 합니다.

팁

배포서버의 연결 문자열 찾는 방법을 학습 Rust 빠른 시작 가이드 의 연결 문자열 만들기 단계를 참조하세요.

예를 들어 연결 문자열이 "mongodb+srv://mongodb-example:27017" 인 경우 연결 문자열 할당은 다음과 유사합니다.

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

컬렉션 생성

먼저 orders 컬렉션 의 데이터를 모델링하는 Rust 구조체를 만듭니다.

#[derive(Debug, Serialize, Deserialize)]
struct Order {
    customer_id: String,
    orderdate: DateTime,
    value: i32,
}

orders 컬렉션 만들고 샘플 데이터를 삽입하려면 애플리케이션 에 다음 코드를 추가합니다.

let orders: Collection<Order> = agg_db.collection("orders");
orders.delete_many(doc! {}).await?;
let docs = vec![
    Order {
        customer_id: "[email protected]".to_string(),
        orderdate: DateTime::builder().year(2020).month(5).day(30).hour(8).minute(35).second(53).build().unwrap(),
        value: 231,
    },
    Order {
        customer_id: "[email protected]".to_string(),
        orderdate: DateTime::builder().year(2020).month(1).day(13).hour(9).minute(32).second(7).build().unwrap(),
        value: 99,
    },
    Order {
        customer_id: "[email protected]".to_string(),
        orderdate: DateTime::builder().year(2020).month(1).day(1).hour(8).minute(25).second(37).build().unwrap(),
        value: 63,
    },
    Order {
        customer_id: "[email protected]".to_string(),
        orderdate: DateTime::builder().year(2019).month(5).day(28).hour(19).minute(13).second(32).build().unwrap(),
        value: 2,
    },
    Order {
        customer_id: "[email protected]".to_string(),
        orderdate: DateTime::builder().year(2020).month(11).day(23).hour(22).minute(56).second(53).build().unwrap(),
        value: 187,
    },
    Order {
        customer_id: "[email protected]".to_string(),
        orderdate: DateTime::builder().year(2020).month(8).day(18).hour(23).minute(4).second(48).build().unwrap(),
        value: 4,
    },
    Order {
        customer_id: "[email protected]".to_string(),
        orderdate: DateTime::builder().year(2020).month(12).day(26).hour(8).minute(55).second(46).build().unwrap(),
        value: 4,
    },
    Order {
        customer_id: "[email protected]".to_string(),
        orderdate: DateTime::builder().year(2021).month(2).day(28).hour(7).minute(49).second(32).build().unwrap(),
        value: 1024,
    },
    Order {
        customer_id: "[email protected]".to_string(),
        orderdate: DateTime::builder().year(2020).month(10).day(3).hour(13).minute(49).second(44).build().unwrap(),
        value: 102,
    },
];
orders.insert_many(docs).await?;

템플릿 앱 만들기

집계 튜토리얼을 시작하기 전에 새 스칼라 앱 설정하다 해야 합니다. 이 앱 사용하여 MongoDB deployment 에 연결하고, 샘플 데이터를 MongoDB 에 삽입하고, 집계 파이프라인 실행 .

팁

운전자 설치하고 MongoDB 에 연결하는 방법을 학습 스칼라 드라이버 시작하기 가이드 참조하세요.

스칼라 드라이버 에서 애그리게이션을 수행하는 방법에 대해 자세히 학습 애그리게이션 가이드 참조하세요.

운전자 설치한 후 AggTutorial.scala라는 파일 만듭니다. 이 파일 에 다음 코드를 붙여넣어 집계 튜토리얼을 위한 앱 템플릿을 만듭니다.

중요

다음 코드에서 코드 주석을 읽고 팔로우 중인 튜토리얼에 대해 수정해야 하는 코드 섹션을 찾습니다.

변경하지 않고 코드를 실행하려고 하면 연결 오류가 발생합니다.

package org.example;
// Modify imports for each tutorial as needed.
import org.mongodb.scala.MongoClient
import org.mongodb.scala.bson.Document
import org.mongodb.scala.model.{Accumulators, Aggregates, Field, Filters, Variable}
import java.text.SimpleDateFormat
object FilteredSubset {
  def main(args: Array[String]): Unit = {
    // Replace the placeholder with your connection string.
    val uri = "<connection string>"
    val mongoClient = MongoClient(uri)
    Thread.sleep(1000)
    val aggDB = mongoClient.getDatabase("agg_tutorials_db")
    // Get a reference to relevant collections.
    // ... val someColl = aggDB.getCollection("someColl")
    // ... val anotherColl = aggDB.getCollection("anotherColl")
    // Delete any existing documents in collections if needed.
    // ... someColl.deleteMany(Filters.empty()).subscribe(...)
    // If needed, create the date format template.
    val dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss")
    // Insert sample data into the collection or collections.
    // ... someColl.insertMany(...).subscribe(...)
    Thread.sleep(1000)
    // Add code to create pipeline stages within the Seq.
    // ... val pipeline = Seq(...)
    // Run the aggregation and print the results.
    // ... someColl.aggregate(pipeline).subscribe(...)
    Thread.sleep(1000)
    mongoClient.close()
  }
}

모든 튜토리얼에서는 연결 문자열 자리 표시자를 반드시 배포서버의 연결 문자열로 바꿔야 합니다.

팁

배포의 연결 문자열 찾는 방법을 학습 스칼라 드라이버 시작하기 가이드 의 연결 문자열 만들기 단계를 참조하세요.

예를 들어 연결 문자열이 "mongodb+srv://mongodb-example:27017" 인 경우 연결 문자열 할당은 다음과 유사합니다.

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

컬렉션 생성

orders 컬렉션 만들고 샘플 데이터를 삽입하려면 애플리케이션 에 다음 코드를 추가합니다.

val orders = aggDB.getCollection("orders")
orders.deleteMany(Filters.empty()).subscribe(
  _ => {},
  e => println("Error: " + e.getMessage),
)
val dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss")
orders.insertMany(Seq(
  Document("customer_id" -> "[email protected]",
    "orderdate" -> dateFormat.parse("2020-05-30T08:35:52"),
    "value" -> 231),
  Document("customer_id" -> "[email protected]",
    "orderdate" -> dateFormat.parse("2020-01-13T09:32:07"),
    "value" -> 99),
  Document("customer_id" -> "[email protected]",
    "orderdate" -> dateFormat.parse("2020-01-01T08:25:37"),
    "value" -> 63),
  Document("customer_id" -> "[email protected]",
    "orderdate" -> dateFormat.parse("2019-05-28T19:13:32"),
    "value" -> 2),
  Document("customer_id" -> "[email protected]",
    "orderdate" -> dateFormat.parse("2020-11-23T22:56:53"),
    "value" -> 187),
  Document("customer_id" -> "[email protected]",
    "orderdate" -> dateFormat.parse("2020-08-18T23:04:48"),
    "value" -> 4),
  Document("customer_id" -> "[email protected]",
    "orderdate" -> dateFormat.parse("2020-12-26T08:55:46"),
    "value" -> 4),
  Document("customer_id" -> "[email protected]",
    "orderdate" -> dateFormat.parse("2021-02-28T07:49:32"),
    "value" -> 1024),
  Document("customer_id" -> "[email protected]",
    "orderdate" -> dateFormat.parse("2020-10-03T13:49:44"),
    "value" -> 102)
)).subscribe(
  _ => {},
  e => println("Error: " + e.getMessage),
)

단계

다음 단계에서는 집계 파이프라인 만들고 실행 문서를 그룹 하고 새 필드를 계산하는 방법을 보여 줍니다.

집계 파이프라인 실행합니다.

db.orders.aggregate( [
   // Stage 1: Match orders in 2020
   { $match: {
      orderdate: {
         $gte: new Date("2020-01-01T00:00:00Z"),
         $lt: new Date("2021-01-01T00:00:00Z"),
      }
   } },
   // Stage 2: Sort orders by date
   { $sort: { orderdate: 1 } },
   // Stage 3: Group orders by email address
   { $group: {
      _id: "$customer_id",
      first_purchase_date: { $first: "$orderdate" },
      total_value: { $sum: "$value" },
      total_orders: { $sum: 1 },
      orders: { $push:
         {
            orderdate: "$orderdate",
            value: "$value"
         }
      }
   } },
   // Stage 4: Sort orders by first order date
   { $sort: { first_purchase_date: 1 } },
   // Stage 5: Display the customers' email addresses
   { $set: { customer_id: "$_id" } },
   // Stage 6: Remove unneeded fields
   { $unset: ["_id"] }
] )

집계 결과를 해석합니다.

이 집계 2020의 고객 주문에 대한 다음 요약을 반환합니다. 결과 문서에는 특정 고객이 주문한 모든 주문에 대한 세부 정보가 고객의 이메일 주소 별로 그룹화되어 포함됩니다.

{
   first_purchase_date: ISODate("2020-01-01T08:25:37.000Z"),
   total_value: 63,
   total_orders: 1,
   orders: [ { orderdate: ISODate("2020-01-01T08:25:37.000Z"), value: 63 } ],
   customer_id: '[email protected]'
}
{
   first_purchase_date: ISODate("2020-01-13T09:32:07.000Z"),
   total_value: 436,
   total_orders: 4,
   orders: [
      { orderdate: ISODate("2020-01-13T09:32:07.000Z"), value: 99 },
      { orderdate: ISODate("2020-05-30T08:35:52.000Z"), value: 231 },
      { orderdate: ISODate("2020-10-03T13:49:44.000Z"), value: 102 },
      { orderdate: ISODate("2020-12-26T08:55:46.000Z"), value: 4 }
   ],
   customer_id: '[email protected]'
}
{
   first_purchase_date: ISODate("2020-08-18T23:04:48.000Z"),
   total_value: 191,
   total_orders: 2,
   orders: [
      { orderdate: ISODate("2020-08-18T23:04:48.000Z"), value: 4 },
      { orderdate: ISODate("2020-11-23T22:56:53.000Z"), value: 187 }
   ],
   customer_id: '[email protected]'
}

2020의 주문에 대한 매치 단계를 추가합니다.

먼저 에 접수된 $match 주문과 일치하는 단계를 2020 추가합니다.

"{", "$match", "{",
"orderdate", "{",
"$gte", BCON_DATE_TIME(1577836800000UL), // Represents 2020-01-01T00:00:00Z
"$lt", BCON_DATE_TIME(1609459200000UL),  // Represents 2021-01-01T00:00:00Z
"}",
"}", "}",

정렬 단계를 추가하여 주문 날짜별로 정렬합니다.

다음으로, 단계를 추가하여 필드 에 오름차순 $sort 정렬을 orderdate 설정하다 2020 다음 단계에서 각 고객의 가장 이른 구매를 조회 .

"{", "$sort", "{", "orderdate", BCON_INT32(1), "}", "}",

이메일 주소 별로 그룹 하려면 그룹 단계를 추가합니다.

단계를 추가하여 필드 $group 값으로 주문 문서를 수집합니다. 이 단계에서는 결과 문서에 다음 필드를 생성하는 집계 작업을 추가합니다.customer_id

first_purchase_date: 고객의 첫 구매 날짜
total_value: 고객의 모든 구매 총액
total_orders: 고객의 총 구매 횟수
orders: 각 구매의 날짜 및 금액을 포함한 고객의 모든 구매 목록

"{", "$group", "{",
"_id", BCON_UTF8("$customer_id"),
"first_purchase_date", "{", "$first", BCON_UTF8("$orderdate"), "}",
"total_value", "{", "$sum", BCON_UTF8("$value"), "}",
"total_orders", "{", "$sum", BCON_INT32(1), "}",
"orders", "{", "$push", "{",
"orderdate", BCON_UTF8("$orderdate"),
"value", BCON_UTF8("$value"),
"}", "}",
"}", "}",

정렬 단계를 추가하여 첫 번째 주문 날짜별로 정렬합니다.

다음으로, 다른 $sort 단계를 추가하여 필드 에 오름차순 정렬을 설정하다 first_purchase_date .

"{", "$sort", "{", "first_purchase_date", BCON_INT32(1), "}", "}",

이메일 주소 표시하는 설정하다 단계를 추가합니다.

단계를 $set 추가하여 단계에서 설정하다 필드 의 값으로 customer_id _id 필드 다시 $group 만듭니다.

"{", "$set", "{", "customer_id", BCON_UTF8("$_id"), "}", "}",

불필요한 필드를 제거 하려면 설정되지 않은 단계를 추가합니다.

마지막으로 단계를 $unset 추가합니다.$unset 단계는 _id 결과 문서에서 필드 제거합니다.

"{", "$unset", "[", BCON_UTF8("_id"), "]", "}",

집계 파이프라인 실행합니다.

orders collection에서 애그리게이션을 수행하려면 애플리케이션 끝에 다음 코드를 추가하세요.

mongoc_cursor_t *results =
    mongoc_collection_aggregate(orders, MONGOC_QUERY_NONE, pipeline, NULL, NULL);
bson_destroy(pipeline);

정리 문에 다음 줄을 추가하여 컬렉션 리소스를 정리해야 합니다.

mongoc_collection_destroy(orders);

마지막으로 셸 에서 다음 명령을 실행 실행 파일을 생성하고 실행 .

gcc -o aggc agg-tutorial.c $(pkg-config --libs --cflags libmongoc-1.0)
./aggc

팁

한 번의 호출에서 앞의 명령을 실행 데 연결 오류가 발생하는 경우 별도로 실행 수 있습니다.

집계 결과를 해석합니다.

이 애그리게이션은 2020년의 고객 주문에 대한 다음과 같은 요약을 반환합니다.

{ "first_purchase_date" : { "$date" : { "$numberLong" : "1577865937000" } }, "total_value" : { "$numberInt" : "63" }, "total_orders" : { "$numberInt" : "1" }, "orders" : [ { "orderdate" : { "$date" : { "$numberLong" : "1577865937000" } }, "value" : { "$numberInt" : "63" } } ], "customer_id" : "[email protected]" }
{ "first_purchase_date" : { "$date" : { "$numberLong" : "1578904327000" } }, "total_value" : { "$numberInt" : "436" }, "total_orders" : { "$numberInt" : "4" }, "orders" : [ { "orderdate" : { "$date" : { "$numberLong" : "1578904327000" } }, "value" : { "$numberInt" : "99" } }, { "orderdate" : { "$date" : { "$numberLong" : "1590825352000" } }, "value" : { "$numberInt" : "231" } }, { "orderdate" : { "$date" : { "$numberLong" : "1601722184000" } }, "value" : { "$numberInt" : "102" } }, { "orderdate" : { "$date" : { "$numberLong" : "1608963346000" } }, "value" : { "$numberInt" : "4" } } ], "customer_id" : "[email protected]" }
{ "first_purchase_date" : { "$date" : { "$numberLong" : "1597793088000" } }, "total_value" : { "$numberInt" : "191" }, "total_orders" : { "$numberInt" : "2" }, "orders" : [ { "orderdate" : { "$date" : { "$numberLong" : "1597793088000" } }, "value" : { "$numberInt" : "4" } }, { "orderdate" : { "$date" : { "$numberLong" : "1606171013000" } }, "value" : { "$numberInt" : "187" } } ], "customer_id" : "[email protected]" }

결과 문서에는 특정 고객의 모든 주문에 대한 세부 정보가 고객의 이메일 주소별로 그룹화되어 포함되어 있습니다.

2020의 주문에 대한 매치 단계를 추가합니다.

먼저 에 접수된 $match 주문과 일치하는 단계를 2020 추가합니다.

pipeline.match(bsoncxx::from_json(R"({
    "orderdate": {
        "$gte": {"$date": 1577836800},
        "$lt": {"$date": 1609459200000}
    }
})"));

정렬 단계를 추가하여 주문 날짜별로 정렬합니다.

다음으로, 단계를 추가하여 필드 에 오름차순 $sort 정렬을 orderdate 설정하다 2020 다음 단계에서 각 고객의 가장 이른 구매를 조회 .

pipeline.sort(bsoncxx::from_json(R"({
    "orderdate": 1
})"));

이메일 주소 별로 그룹 하려면 그룹 단계를 추가합니다.

단계를 추가하여 필드 $group 값으로 주문 문서를 수집합니다. 이 단계에서는 결과 문서에 다음 필드를 생성하는 집계 작업을 추가합니다.customer_id

first_purchase_date: 고객의 첫 구매 날짜
total_value: 고객의 모든 구매 총액
total_orders: 고객의 총 구매 횟수
orders: 각 구매의 날짜 및 금액을 포함한 고객의 모든 구매 목록

pipeline.group(bsoncxx::from_json(R"({
    "_id": "$customer_id",
    "first_purchase_date": {"$first": "$orderdate"},
    "total_value": {"$sum": "$value"},
    "total_orders": {"$sum": 1},
    "orders": {"$push": {
        "orderdate": "$orderdate",
        "value": "$value"
    }}
})"));

정렬 단계를 추가하여 첫 번째 주문 날짜별로 정렬합니다.

다음으로, 다른 $sort 단계를 추가하여 필드 에 오름차순 정렬을 설정하다 first_purchase_date .

pipeline.sort(bsoncxx::from_json(R"({
    "first_purchase_date": 1
})"));

addFields 단계를 추가하여 이메일 주소 표시합니다.

$addFields $set 단계의 별칭인 customer_id 단계를 추가하여 단계에서 설정하다 필드 의 값에서 필드 _id $group 다시 만듭니다.

pipeline.add_fields(bsoncxx::from_json(R"({
    "customer_id": "$_id"
})"));

불필요한 필드를 제거 하려면 설정되지 않은 단계를 추가합니다.

마지막으로 단계를 $unset 추가합니다.$unset 단계는 _id 결과 문서에서 필드 제거합니다.

pipeline.append_stage(bsoncxx::from_json(R"({
    "$unset": ["_id"]
})"));

집계 파이프라인 실행합니다.

orders collection에서 애그리게이션을 수행하려면 애플리케이션 끝에 다음 코드를 추가하세요.

auto cursor = orders.aggregate(pipeline);

마지막으로 shell에서 다음 명령을 실행하여 애플리케이션을 시작합니다.

c++ --std=c++17 agg-tutorial.cpp $(pkg-config --cflags --libs libmongocxx) -o ./app.out
./app.out

집계 결과를 해석합니다.

이 애그리게이션은 2020년의 고객 주문에 대한 다음과 같은 요약을 반환합니다.

{ "first_purchase_date" : { "$date" : "1970-01-19T06:17:41.137Z" }, "total_value" : 63,
"total_orders" : 1, "orders" : [ { "orderdate" : { "$date" : "1970-01-19T06:17:41.137Z" },
"value" : 63 } ], "customer_id" : "[email protected]" }
{ "first_purchase_date" : { "$date" : "1970-01-19T06:35:01.927Z" }, "total_value" : 436,
"total_orders" : 4, "orders" : [ { "orderdate" : { "$date" : "1970-01-19T06:35:01.927Z" },
"value" : 99 }, { "orderdate" : { "$date" : "2020-05-30T06:55:52Z" }, "value" : 231 },
{ "orderdate" : { "$date" : "2020-10-03T10:49:44Z" }, "value" : 102 }, { "orderdate" :
{ "$date" : "2020-12-26T08:55:46Z" }, "value" : 4 } ], "customer_id" : "[email protected]" }
{ "first_purchase_date" : { "$date" : "1970-01-19T11:49:54.288Z" }, "total_value" : 1215,
"total_orders" : 3, "orders" : [ { "orderdate" : { "$date" : "1970-01-19T11:49:54.288Z" },
"value" : 4 }, { "orderdate" : { "$date" : "1970-01-19T14:09:32.213Z" }, "value" : 187 },
{ "orderdate" : { "$date" : "1970-01-19T16:29:30.572Z" }, "value" : 1024 } ], "customer_id" : "[email protected]" }

결과 문서에는 특정 고객의 모든 주문에 대한 세부 정보가 고객의 이메일 주소별로 그룹화되어 포함되어 있습니다.

2020의 주문에 대한 매치 단계를 추가합니다.

먼저 컬렉션 에서 집계 시작하고 에 접수된 orders 주문과 $match 일치하는 단계를 2020 연결합니다.

var results = orders.Aggregate()
    .Match(o => o.OrderDate >= DateTime.Parse("2020-01-01T00:00:00Z") &&
                o.OrderDate < DateTime.Parse("2021-01-01T00:00:00Z"))

정렬 단계를 추가하여 주문 날짜별로 정렬합니다.

다음으로, 단계를 추가하여 필드 에 오름차순 $sort 정렬을 OrderDate 설정하다 2020 다음 단계에서 각 고객의 가장 이른 구매를 조회 .

.SortBy(o => o.OrderDate)

이메일 주소 별로 그룹 하려면 그룹 단계를 추가합니다.

단계를 추가하여 필드 $group 값으로 주문 문서를 수집합니다. 이 단계에서는 결과 문서에 다음 필드를 생성하는 집계 작업을 추가합니다.CustomerId

CustomerId: 고객의 이메일 주소 (그룹화 키)
FirstPurchaseDate: 고객의 첫 구매 날짜
TotalValue: 고객의 모든 구매 총액
TotalOrders: 고객의 총 구매 횟수
Orders: 각 구매의 날짜 및 금액을 포함한 고객의 모든 구매 목록

.Group(
    o => o.CustomerId,
    g => new
    {
      CustomerId = g.Key,
      FirstPurchaseDate = g.First().OrderDate,
      TotalValue = g.Sum(i => i.Value),
      TotalOrders = g.Count(),
      Orders = g.Select(i => new { i.OrderDate, i.Value }).ToList()
    }
)

정렬 단계를 추가하여 첫 번째 주문 날짜별로 정렬합니다.

다음으로, 다른 $sort 단계를 추가하여 필드 에 오름차순 정렬을 설정하다 FirstPurchaseDate .

.SortBy(c => c.FirstPurchaseDate)
.As<BsonDocument>();

또한 앞의 코드는 출력 문서를 BsonDocument 인스턴스로 변환하여 인쇄합니다.

집계 실행하고 결과를 해석합니다.

마지막으로 IDE에서 애플리케이션 실행 하고 결과를 검사합니다.

이 애그리게이션은 2020년의 고객 주문에 대한 다음과 같은 요약을 반환합니다.

{ "CustomerId" : "[email protected]", "FirstPurchaseDate" : { "$date" : "2020-01-01T08:25:37Z" }, "TotalValue" : 63, "TotalOrders" : 1, "Orders" : [{ "OrderDate" : { "$date" : "2020-01-01T08:25:37Z" }, "Value" : 63 }] }
{ "CustomerId" : "[email protected]", "FirstPurchaseDate" : { "$date" : "2020-01-13T09:32:07Z" }, "TotalValue" : 436, "TotalOrders" : 4, "Orders" : [{ "OrderDate" : { "$date" : "2020-01-13T09:32:07Z" }, "Value" : 99 }, { "OrderDate" : { "$date" : "2020-05-30T08:35:52Z" }, "Value" : 231 }, { "OrderDate" : { "$date" : "2020-10-03T13:49:44Z" }, "Value" : 102 }, { "OrderDate" : { "$date" : "2020-12-26T08:55:46Z" }, "Value" : 4 }] }
{ "CustomerId" : "[email protected]", "FirstPurchaseDate" : { "$date" : "2020-08-18T23:04:48Z" }, "TotalValue" : 191, "TotalOrders" : 2, "Orders" : [{ "OrderDate" : { "$date" : "2020-08-18T23:04:48Z" }, "Value" : 4 }, { "OrderDate" : { "$date" : "2020-11-23T22:56:53Z" }, "Value" : 187 }] }

결과 문서에는 특정 고객의 모든 주문에 대한 세부 정보가 고객의 이메일 주소별로 그룹화되어 포함되어 있습니다.

2020의 주문에 대한 매치 단계를 추가합니다.

먼저 에 접수된 $match 주문과 일치하는 단계를 2020 추가합니다.

matchStage := bson.D{{Key: "$match", Value: bson.D{
	{Key: "orderdate", Value: bson.D{
		{Key: "$gte", Value: time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)},
		{Key: "$lt", Value: time.Date(2021, 1, 1, 0, 0, 0, 0, time.UTC)},
	}},
}}}

정렬 단계를 추가하여 주문 날짜별로 정렬합니다.

다음으로, 단계를 추가하여 필드 에 오름차순 $sort 정렬을 orderdate 설정하다 2020 다음 단계에서 각 고객의 가장 이른 구매를 조회 .

sortStage1 := bson.D{{Key: "$sort", Value: bson.D{
	{Key: "orderdate", Value: 1},
}}}

이메일 주소 별로 그룹 하려면 그룹 단계를 추가합니다.

단계를 추가하여 필드 $group 값으로 주문 문서를 수집합니다. 이 단계에서는 결과 문서에 다음 필드를 생성하는 집계 작업을 추가합니다.customer_id

first_purchase_date: 고객의 첫 구매 날짜
total_value: 고객의 모든 구매 총액
total_orders: 고객의 총 구매 횟수
orders: 각 구매의 날짜 및 금액을 포함한 고객의 모든 구매 목록

groupStage := bson.D{{Key: "$group", Value: bson.D{
	{Key: "_id", Value: "$customer_id"},
	{Key: "first_purchase_date", Value: bson.D{{Key: "$first", Value: "$orderdate"}}},
	{Key: "total_value", Value: bson.D{{Key: "$sum", Value: "$value"}}},
	{Key: "total_orders", Value: bson.D{{Key: "$sum", Value: 1}}},
	{Key: "orders", Value: bson.D{{Key: "$push", Value: bson.D{
		{Key: "orderdate", Value: "$orderdate"},
		{Key: "value", Value: "$value"},
	}}}},
}}}

정렬 단계를 추가하여 첫 번째 주문 날짜별로 정렬합니다.

다음으로, 다른 $sort 단계를 추가하여 필드 에 오름차순 정렬을 설정하다 first_purchase_date .

sortStage2 := bson.D{{Key: "$sort", Value: bson.D{
	{Key: "first_purchase_date", Value: 1},
}}}

이메일 주소 표시하는 설정하다 단계를 추가합니다.

단계를 $set 추가하여 단계에서 설정하다 필드 의 값으로 customer_id _id 필드 다시 $group 만듭니다.

setStage := bson.D{{Key: "$set", Value: bson.D{
	{Key: "customer_id", Value: "$_id"},
}}}

불필요한 필드를 제거 하려면 설정되지 않은 단계를 추가합니다.

마지막으로 단계를 $unset 추가합니다.$unset 단계는 _id 결과 문서에서 필드 제거합니다.

unsetStage := bson.D{{Key: "$unset", Value: bson.A{"_id"}}}

집계 파이프라인 실행합니다.

orders collection에서 애그리게이션을 수행하려면 애플리케이션 끝에 다음 코드를 추가하세요.

pipeline := mongo.Pipeline{matchStage, sortStage1, groupStage, setStage, sortStage2, unsetStage}
cursor, err := orders.Aggregate(context.TODO(), pipeline)

마지막으로 shell에서 다음 명령을 실행하여 애플리케이션을 시작합니다.

go run agg_tutorial.go

집계 결과를 해석합니다.

이 애그리게이션은 2020년의 고객 주문에 대한 다음과 같은 요약을 반환합니다.

{"first_purchase_date":{"$date":"2020-01-01T08:25:37Z"},"total_value":63,"total_orders":1,"orders":[{"orderdate":{"$date":"2020-01-01T08:25:37Z"},"value":63}],"customer_id":"[email protected]"}
{"first_purchase_date":{"$date":"2020-01-13T09:32:07Z"},"total_value":436,"total_orders":4,"orders":[{"orderdate":{"$date":"2020-01-13T09:32:07Z"},"value":99},{"orderdate":{"$date":"2020-05-30T08:35:53Z"},"value":231},{"orderdate":{"$date":"2020-10-03T13:49:44Z"},"value":102},{"orderdate":{"$date":"2020-12-26T08:55:46Z"},"value":4}],"customer_id":"[email protected]"}
{"first_purchase_date":{"$date":"2020-08-18T23:04:48Z"},"total_value":191,"total_orders":2,"orders":[{"orderdate":{"$date":"2020-08-18T23:04:48Z"},"value":4},{"orderdate":{"$date":"2020-11-23T22:56:53Z"},"value":187}],"customer_id":"[email protected]"}

결과 문서에는 특정 고객의 모든 주문에 대한 세부 정보가 고객의 이메일 주소별로 그룹화되어 포함되어 있습니다.

2020의 주문에 대한 매치 단계를 추가합니다.

먼저 에 접수된 $match 주문과 일치하는 단계를 2020 추가합니다.

pipeline.add(Aggregates.match(Filters.and(
        Filters.gte("orderdate", LocalDateTime.parse("2020-01-01T00:00:00")),
        Filters.lt("orderdate", LocalDateTime.parse("2021-01-01T00:00:00"))
)));

정렬 단계를 추가하여 주문 날짜별로 정렬합니다.

다음으로, 단계를 추가하여 필드 에 오름차순 $sort 정렬을 orderdate 설정하다 2020 다음 단계에서 각 고객의 가장 이른 구매를 조회 .

pipeline.add(Aggregates.sort(Sorts.ascending("orderdate")));

이메일 주소 별로 그룹 하려면 그룹 단계를 추가합니다.

단계를 추가하여 필드 $group 값으로 주문 문서를 수집합니다. 이 단계에서는 결과 문서에 다음 필드를 생성하는 집계 작업을 추가합니다.customer_id

first_purchase_date: 고객의 첫 구매 날짜
total_value: 고객의 모든 구매 총액
total_orders: 고객의 총 구매 횟수
orders: 각 구매의 날짜 및 금액을 포함한 고객의 모든 구매 목록

pipeline.add(Aggregates.group(
        "$customer_id",
        Accumulators.first("first_purchase_date", "$orderdate"),
        Accumulators.sum("total_value", "$value"),
        Accumulators.sum("total_orders", 1),
        Accumulators.push("orders",
                new Document("orderdate", "$orderdate")
                        .append("value", "$value")
        )
));

정렬 단계를 추가하여 첫 번째 주문 날짜별로 정렬합니다.

다음으로, 다른 $sort 단계를 추가하여 필드 에 오름차순 정렬을 설정하다 first_purchase_date .

pipeline.add(Aggregates.sort(Sorts.ascending("first_purchase_date")));

이메일 주소 표시하는 설정하다 단계를 추가합니다.

단계를 $set 추가하여 단계에서 설정하다 필드 의 값으로 customer_id _id 필드 다시 $group 만듭니다.

pipeline.add(Aggregates.set(new Field<>("customer_id", "$_id")));

불필요한 필드를 제거 하려면 설정되지 않은 단계를 추가합니다.

마지막으로 단계를 $unset 추가합니다.$unset 단계는 _id 결과 문서에서 필드 제거합니다.

pipeline.add(Aggregates.unset("_id"));

집계 파이프라인 실행합니다.

orders collection에서 애그리게이션을 수행하려면 애플리케이션 끝에 다음 코드를 추가하세요.

AggregateIterable<Document> aggregationResult = orders.aggregate(pipeline);

마지막으로 IDE에서 애플리케이션 실행 .

집계 결과를 해석합니다.

이 애그리게이션은 2020년의 고객 주문에 대한 다음과 같은 요약을 반환합니다.

{"first_purchase_date": {"$date": "2020-01-01T08:25:37Z"}, "total_value": 63, "total_orders": 1, "orders": [{"orderdate": {"$date": "2020-01-01T08:25:37Z"}, "value": 63}], "customer_id": "[email protected]"}
{"first_purchase_date": {"$date": "2020-01-13T09:32:07Z"}, "total_value": 436, "total_orders": 4, "orders": [{"orderdate": {"$date": "2020-01-13T09:32:07Z"}, "value": 99}, {"orderdate": {"$date": "2020-05-30T08:35:52Z"}, "value": 231}, {"orderdate": {"$date": "2020-10-03T13:49:44Z"}, "value": 102}, {"orderdate": {"$date": "2020-12-26T08:55:46Z"}, "value": 4}], "customer_id": "[email protected]"}
{"first_purchase_date": {"$date": "2020-08-18T23:04:48Z"}, "total_value": 191, "total_orders": 2, "orders": [{"orderdate": {"$date": "2020-08-18T23:04:48Z"}, "value": 4}, {"orderdate": {"$date": "2020-11-23T22:56:53Z"}, "value": 187}], "customer_id": "[email protected]"}

결과 문서에는 특정 고객의 모든 주문에 대한 세부 정보가 고객의 이메일 주소별로 그룹화되어 포함되어 있습니다.

2020의 주문에 대한 매치 단계를 추가합니다.

먼저 에 접수된 $match 주문과 일치하는 단계를 2020 추가합니다.

pipeline.add(
    Aggregates.match(
        Filters.and(
            Filters.gte(Order::orderDate.name, LocalDateTime.parse("2020-01-01T00:00:00").toJavaLocalDateTime()),
            Filters.lt(Order::orderDate.name, LocalDateTime.parse("2021-01-01T00:00:00").toJavaLocalDateTime())
        )
    )
)

정렬 단계를 추가하여 주문 날짜별로 정렬합니다.

다음으로, 단계를 추가하여 필드 에 오름차순 $sort 정렬을 orderDate 설정하다 2020 다음 단계에서 각 고객의 가장 이른 구매를 조회 .

pipeline.add(Aggregates.sort(Sorts.ascending(Order::orderDate.name)))

이메일 주소 별로 그룹 하려면 그룹 단계를 추가합니다.

단계를 추가하여 필드 $group 값으로 주문 문서를 수집합니다. 이 단계에서는 결과 문서에 다음 필드를 생성하는 집계 작업을 추가합니다.customer_id

first_purchase_date: 고객의 첫 구매 날짜
total_value: 고객의 모든 구매 총액
total_orders: 고객의 총 구매 횟수
orders: 각 구매의 날짜 및 금액을 포함한 고객의 모든 구매 목록

pipeline.add(
    Aggregates.group(
        "\$${Order::customerID.name}",
        Accumulators.first("first_purchase_date", "\$${Order::orderDate.name}"),
        Accumulators.sum("total_value", "\$${Order::value.name}"),
        Accumulators.sum("total_orders", 1),
        Accumulators.push(
            "orders",
            Document("orderdate", "\$${Order::orderDate.name}")
                .append("value", "\$${Order::value.name}")
        )
    )
)

정렬 단계를 추가하여 첫 번째 주문 날짜별로 정렬합니다.

다음으로, 다른 $sort 단계를 추가하여 필드 에 오름차순 정렬을 설정하다 first_purchase_date .

pipeline.add(Aggregates.sort(Sorts.ascending("first_purchase_date")))

이메일 주소 표시하는 설정하다 단계를 추가합니다.

단계를 $set 추가하여 단계에서 설정하다 필드 의 값으로 customer_id _id 필드 다시 $group 만듭니다.

pipeline.add(Aggregates.set(Field("customer_id", "\$_id")))

불필요한 필드를 제거 하려면 설정되지 않은 단계를 추가합니다.

마지막으로 단계를 $unset 추가합니다.$unset 단계는 _id 결과 문서에서 필드 제거합니다.

pipeline.add(Aggregates.unset("_id"))

집계 파이프라인 실행합니다.

orders collection에서 애그리게이션을 수행하려면 애플리케이션 끝에 다음 코드를 추가하세요.

val aggregationResult = orders.aggregate<Document>(pipeline)

마지막으로 IDE에서 애플리케이션 실행 .

집계 결과를 해석합니다.

이 애그리게이션은 2020년의 고객 주문에 대한 다음과 같은 요약을 반환합니다.

Document{{first_purchase_date=Wed Jan 01 03:25:37 EST 2020, total_value=63, total_orders=1, orders=[Document{{orderdate=Wed Jan 01 03:25:37 EST 2020, value=63}}], [email protected]}}
Document{{first_purchase_date=Mon Jan 13 04:32:07 EST 2020, total_value=436, total_orders=4, orders=[Document{{orderdate=Mon Jan 13 04:32:07 EST 2020, value=99}}, Document{{orderdate=Sat May 30 04:35:52 EDT 2020, value=231}}, Document{{orderdate=Sat Oct 03 09:49:44 EDT 2020, value=102}}, Document{{orderdate=Sat Dec 26 03:55:46 EST 2020, value=4}}], [email protected]}}
Document{{first_purchase_date=Tue Aug 18 19:04:48 EDT 2020, total_value=191, total_orders=2, orders=[Document{{orderdate=Tue Aug 18 19:04:48 EDT 2020, value=4}}, Document{{orderdate=Mon Nov 23 17:56:53 EST 2020, value=187}}], [email protected]}}

결과 문서에는 특정 고객의 모든 주문에 대한 세부 정보가 고객의 이메일 주소별로 그룹화되어 포함되어 있습니다.

2020의 주문에 대한 매치 단계를 추가합니다.

먼저 에 접수된 $match 주문과 일치하는 단계를 2020 추가합니다.

pipeline.push({
  $match: {
    orderdate: {
      $gte: new Date("2020-01-01T00:00:00Z"),
      $lt: new Date("2021-01-01T00:00:00Z"),
    },
  },
});

정렬 단계를 추가하여 주문 날짜별로 정렬합니다.

다음으로, 단계를 추가하여 필드 에 오름차순 $sort 정렬을 orderdate 설정하다 2020 다음 단계에서 각 고객의 가장 이른 구매를 조회 .

pipeline.push({
  $sort: {
    orderdate: 1,
  },
});

이메일 주소 별로 그룹 하려면 그룹 단계를 추가합니다.

단계를 추가하여 필드 값을 기준으로 주문을 그룹 . 이 단계에서는 결과 문서에 다음 필드를 생성하는 집계 작업을 추가합니다.$group customer_id

first_purchase_date: 고객의 첫 구매 날짜
total_value: 고객의 모든 구매 총액
total_orders: 고객의 총 구매 횟수
orders: 각 구매의 날짜 및 금액을 포함한 고객의 모든 구매 목록

pipeline.push({
  $group: {
    _id: "$customer_id",
    first_purchase_date: { $first: "$orderdate" },
    total_value: { $sum: "$value" },
    total_orders: { $sum: 1 },
    orders: {
      $push: {
        orderdate: "$orderdate",
        value: "$value",
      },
    },
  },
});

정렬 단계를 추가하여 첫 번째 주문 날짜별로 정렬합니다.

다음으로, 다른 $sort 단계를 추가하여 필드 에 오름차순 정렬을 설정하다 first_purchase_date .

pipeline.push({
  $sort: {
    first_purchase_date: 1,
  },
});

이메일 주소 표시하는 설정하다 단계를 추가합니다.

단계를 $set 추가하여 단계에서 설정하다 필드 의 값으로 customer_id _id 필드 다시 $group 만듭니다.

pipeline.push({
  $set: {
    customer_id: "$_id",
  },
});

불필요한 필드를 제거 하려면 설정되지 않은 단계를 추가합니다.

마지막으로 단계를 $unset 추가합니다.$unset 단계는 _id 결과 문서에서 필드 제거합니다.

pipeline.push({ $unset: ["_id"] });

집계 파이프라인 실행합니다.

orders collection에서 애그리게이션을 수행하려면 애플리케이션 끝에 다음 코드를 추가하세요.

const aggregationResult = await orders.aggregate(pipeline);

마지막으로 shell에서 다음 명령을 실행하여 애플리케이션을 시작합니다.

node agg_tutorial.js

집계 결과를 해석합니다.

이 애그리게이션은 2020년의 고객 주문에 대한 다음과 같은 요약을 반환합니다.

{
  first_purchase_date: 2020-01-01T08:25:37.000Z,
  total_value: 63,
  total_orders: 1,
  orders: [ { orderdate: 2020-01-01T08:25:37.000Z, value: 63 } ],
  customer_id: '[email protected]'
}
{
  first_purchase_date: 2020-01-13T09:32:07.000Z,
  total_value: 436,
  total_orders: 4,
  orders: [
    { orderdate: 2020-01-13T09:32:07.000Z, value: 99 },
    { orderdate: 2020-05-30T08:35:52.000Z, value: 231 },
    { orderdate: 2020-10-03T13:49:44.000Z, value: 102 },
    { orderdate: 2020-12-26T08:55:46.000Z, value: 4 }
  ],
  customer_id: '[email protected]'
}
{
  first_purchase_date: 2020-08-18T23:04:48.000Z,
  total_value: 191,
  total_orders: 2,
  orders: [
    { orderdate: 2020-08-18T23:04:48.000Z, value: 4 },
    { orderdate: 2020-11-23T22:56:53.000Z, value: 187 }
  ],
  customer_id: '[email protected]'
}

결과 문서에는 특정 고객의 모든 주문에 대한 세부 정보가 고객의 이메일 주소별로 그룹화되어 포함되어 있습니다.

2020의 주문에 대한 매치 단계를 추가합니다.

인스턴스 에서 에 Pipeline 접수된 $match 주문과 일치하는 단계를 추가합니다.2020

Stage::match(
    orderdate: [
        Query::gte(new UTCDateTime(new DateTimeImmutable('2020-01-01T00:00:00'))),
        Query::lt(new UTCDateTime(new DateTimeImmutable('2021-01-01T00:00:00'))),
    ]
),

정렬 단계를 추가하여 주문 날짜별로 정렬합니다.

다음으로, 단계를 추가하여 필드 에 오름차순 $sort 정렬을 orderdate 설정하다 2020 다음 단계에서 각 고객의 가장 이른 구매를 조회 .

Stage::sort(orderdate: Sort::Asc),

이메일 주소 별로 그룹 하려면 그룹 단계를 추가합니다.

인스턴스 외부 Pipeline 에 필드 값으로 주문 문서 를 수집 $group 하는 팩토리 함수 에 단계 를 만듭니다 customer_id . 이 단계에서는 결과 문서에 다음 필드를 생성하는 집계 작업을 추가합니다.

first_purchase_date: 고객의 첫 구매 날짜
total_value: 고객의 모든 구매 총액
total_orders: 고객의 총 구매 횟수
orders: 각 구매의 날짜 및 금액을 포함한 고객의 모든 구매 목록

function groupByCustomerStage()
{
    return Stage::group(
        _id: Expression::stringFieldPath('customer_id'),
        first_purchase_date: Accumulator::first(
            Expression::arrayFieldPath('orderdate')
        ),
        total_value: Accumulator::sum(
            Expression::numberFieldPath('value'),
        ),
        total_orders: Accumulator::sum(1),
        orders: Accumulator::push(
            object(
                orderdate: Expression::dateFieldPath('orderdate'),
                value: Expression::numberFieldPath('value'),
            ),
        ),
    );
}

그런 다음 Pipeline 인스턴스 에서 groupByCustomerStage() 함수를 호출합니다.

groupByCustomerStage(),

정렬 단계를 추가하여 첫 번째 주문 날짜별로 정렬합니다.

다음으로, 다른 $sort 단계를 만들어 필드 에 오름차순 정렬을 설정하다 first_purchase_date .

Stage::sort(first_purchase_date: Sort::Asc),

이메일 주소 표시하는 설정하다 단계를 추가합니다.

단계를 $set 추가하여 단계에서 설정하다 필드 의 값으로 customer_id _id 필드 다시 $group 만듭니다.

Stage::set(customer_id: Expression::stringFieldPath('_id')),

불필요한 필드를 제거 하려면 설정되지 않은 단계를 추가합니다.

마지막으로 단계를 $unset 추가합니다.$unset 단계는 _id 결과 문서에서 필드 제거합니다.

Stage::unset('_id')

집계 파이프라인 실행합니다.

orders collection에서 애그리게이션을 수행하려면 애플리케이션 끝에 다음 코드를 추가하세요.

$cursor = $orders->aggregate($pipeline);

마지막으로 shell에서 다음 명령을 실행하여 애플리케이션을 시작합니다.

php agg_tutorial.php

집계 결과를 해석합니다.

이 애그리게이션은 2020년의 고객 주문에 대한 다음과 같은 요약을 반환합니다.

{
    "first_purchase_date": {
        "$date": {
            "$numberLong": "1577867137000"
        }
    },
    "total_value": 63,
    "total_orders": 1,
    "orders": [
        {
            "orderdate": {
                "$date": {
                    "$numberLong": "1577867137000"
                }
            },
            "value": 63
        }
    ],
    "customer_id": "[email protected]"
}
{
    "first_purchase_date": {
        "$date": {
            "$numberLong": "1578907927000"
        }
    },
    "total_value": 436,
    "total_orders": 4,
    "orders": [
        {
            "orderdate": {
                "$date": {
                    "$numberLong": "1578907927000"
                }
            },
            "value": 99
        },
        {
            "orderdate": {
                "$date": {
                    "$numberLong": "1590827752000"
                }
            },
            "value": 231
        },
        {
            "orderdate": {
                "$date": {
                    "$numberLong": "1601732984000"
                }
            },
            "value": 102
        },
        {
            "orderdate": {
                "$date": {
                    "$numberLong": "1608972946000"
                }
            },
            "value": 4
        }
    ],
    "customer_id": "[email protected]"
}
{
    "first_purchase_date": {
        "$date": {
            "$numberLong": "1597791888000"
        }
    },
    "total_value": 191,
    "total_orders": 2,
    "orders": [
        {
            "orderdate": {
                "$date": {
                    "$numberLong": "1597791888000"
                }
            },
            "value": 4
        },
        {
            "orderdate": {
                "$date": {
                    "$numberLong": "1606172213000"
                }
            },
            "value": 187
        }
    ],
    "customer_id": "[email protected]"
}

결과 문서에는 특정 고객의 모든 주문에 대한 세부 정보가 고객의 이메일 주소별로 그룹화되어 포함되어 있습니다.

2020의 주문에 대한 매치 단계를 추가합니다.

인스턴스 에서 에 Pipeline 접수된 $match 주문과 일치하는 단계를 추가합니다.2020

pipeline.append(
    {
        "$match": {
            "orderdate": {
                "$gte": datetime(2020, 1, 1, 0, 0, 0),
                "$lt": datetime(2021, 1, 1, 0, 0, 0),
            }
        }
    }
)

정렬 단계를 추가하여 주문 날짜별로 정렬합니다.

다음으로, 단계를 추가하여 필드 에 오름차순 $sort 정렬을 orderdate 설정하다 2020 다음 단계에서 각 고객의 가장 이른 구매를 조회 .

pipeline.append({"$sort": {"orderdate": 1}})

이메일 주소 별로 그룹 하려면 그룹 단계를 추가합니다.

단계를 추가하여 필드 값을 기준으로 주문을 그룹 . 이 단계에서는 결과 문서에 다음 필드를 생성하는 집계 작업을 추가합니다.$group customer_id

first_purchase_date: 고객의 첫 구매 날짜
total_value: 고객의 모든 구매 총액
total_orders: 고객의 총 구매 횟수
orders: 각 구매의 날짜 및 금액을 포함한 고객의 모든 구매 목록

pipeline.append(
    {
        "$group": {
            "_id": "$customer_id",
            "first_purchase_date": {"$first": "$orderdate"},
            "total_value": {"$sum": "$value"},
            "total_orders": {"$sum": 1},
            "orders": {"$push": {"orderdate": "$orderdate", "value": "$value"}},
        }
    }
)

정렬 단계를 추가하여 첫 번째 주문 날짜별로 정렬합니다.

다음으로, 다른 $sort 단계를 만들어 필드 에 오름차순 정렬을 설정하다 first_purchase_date .

pipeline.append({"$sort": {"first_purchase_date": 1}})

이메일 주소 표시하는 설정하다 단계를 추가합니다.

단계를 $set 추가하여 단계에서 설정하다 필드 의 값으로 customer_id _id 필드 다시 $group 만듭니다.

pipeline.append({"$set": {"customer_id": "$_id"}})

불필요한 필드를 제거 하려면 설정되지 않은 단계를 추가합니다.

마지막으로 단계를 $unset 추가합니다.$unset 단계는 _id 결과 문서에서 필드 제거합니다.

pipeline.append({"$unset": ["_id"]})

집계 파이프라인 실행합니다.

orders collection에서 애그리게이션을 수행하려면 애플리케이션 끝에 다음 코드를 추가하세요.

aggregation_result = orders_coll.aggregate(pipeline)

마지막으로 shell에서 다음 명령을 실행하여 애플리케이션을 시작합니다.

python3 agg_tutorial.py

집계 결과를 해석합니다.

이 애그리게이션은 2020년의 고객 주문에 대한 다음과 같은 요약을 반환합니다.

{'first_purchase_date': datetime.datetime(2020, 1, 1, 8, 25, 37), 'total_value': 63, 'total_orders': 1, 'orders': [{'orderdate': datetime.datetime(2020, 1, 1, 8, 25, 37), 'value': 63}], 'customer_id': '[email protected]'}
{'first_purchase_date': datetime.datetime(2020, 1, 13, 9, 32, 7), 'total_value': 436, 'total_orders': 4, 'orders': [{'orderdate': datetime.datetime(2020, 1, 13, 9, 32, 7), 'value': 99}, {'orderdate': datetime.datetime(2020, 5, 30, 8, 35, 52), 'value': 231}, {'orderdate': datetime.datetime(2020, 10, 3, 13, 49, 44), 'value': 102}, {'orderdate': datetime.datetime(2020, 12, 26, 8, 55, 46), 'value': 4}], 'customer_id': '[email protected]'}
{'first_purchase_date': datetime.datetime(2020, 8, 18, 23, 4, 48), 'total_value': 191, 'total_orders': 2, 'orders': [{'orderdate': datetime.datetime(2020, 8, 18, 23, 4, 48), 'value': 4}, {'orderdate': datetime.datetime(2020, 11, 23, 22, 56, 53), 'value': 187}], 'customer_id': '[email protected]'}

결과 문서에는 특정 고객의 모든 주문에 대한 세부 정보가 고객의 이메일 주소별로 그룹화되어 포함되어 있습니다.

2020의 주문에 대한 매치 단계를 추가합니다.

먼저 에 접수된 $match 주문과 일치하는 단계를 2020 추가합니다.

{
  "$match": {
    orderdate: {
      "$gte": DateTime.parse("2020-01-01T00:00:00Z"),
      "$lt": DateTime.parse("2021-01-01T00:00:00Z"),
    },
  },
},

정렬 단계를 추가하여 주문 날짜별로 정렬합니다.

다음으로, 단계를 추가하여 필드 에 오름차순 $sort 정렬을 orderdate 설정하다 2020 다음 단계에서 각 고객의 가장 이른 구매를 조회 .

{
  "$sort": {
    orderdate: 1,
  },
},

이메일 주소 별로 그룹 하려면 그룹 단계를 추가합니다.

단계를 추가하여 필드 $group 값으로 주문 문서를 수집합니다. 이 단계에서는 결과 문서에 다음 필드를 생성하는 집계 작업을 추가합니다.customer_id

first_purchase_date: 고객의 첫 구매 날짜
total_value: 고객의 모든 구매 총액
total_orders: 고객의 총 구매 횟수
orders: 각 구매의 날짜 및 금액을 포함한 고객의 모든 구매 목록

{
  "$group": {
    _id: "$customer_id",
    first_purchase_date: { "$first": "$orderdate" },
    total_value: { "$sum": "$value" },
    total_orders: { "$sum": 1 },
    orders: { "$push": {
      orderdate: "$orderdate",
      value: "$value",
    } },
  },
},

정렬 단계를 추가하여 첫 번째 주문 날짜별로 정렬합니다.

다음으로, 다른 $sort 단계를 추가하여 필드 에 오름차순 정렬을 설정하다 first_purchase_date .

{
  "$sort": {
    first_purchase_date: 1,
  },
},

이메일 주소 표시하는 설정하다 단계를 추가합니다.

단계를 $set 추가하여 단계에서 설정하다 필드 의 값으로 customer_id _id 필드 다시 $group 만듭니다.

{
  "$set": {
    customer_id: "$_id",
  },
},

불필요한 필드를 제거 하려면 설정되지 않은 단계를 추가합니다.

마지막으로 단계를 $unset 추가합니다.$unset 단계는 _id 결과 문서에서 필드 제거합니다.

{ "$unset": ["_id"] },

집계 파이프라인 실행합니다.

orders collection에서 애그리게이션을 수행하려면 애플리케이션 끝에 다음 코드를 추가하세요.

aggregation_result = orders.aggregate(pipeline)

마지막으로 shell에서 다음 명령을 실행하여 애플리케이션을 시작합니다.

ruby agg_tutorial.rb

집계 결과를 해석합니다.

이 애그리게이션은 2020년의 고객 주문에 대한 다음과 같은 요약을 반환합니다.

{"first_purchase_date"=>2020-01-01 08:25:37 UTC, "total_value"=>63, "total_orders"=>1, "orders"=>[{"orderdate"=>2020-01-01 08:25:37 UTC, "value"=>63}], "customer_id"=>"[email protected]"}
{"first_purchase_date"=>2020-01-13 09:32:07 UTC, "total_value"=>436, "total_orders"=>4, "orders"=>[{"orderdate"=>2020-01-13 09:32:07 UTC, "value"=>99}, {"orderdate"=>2020-05-30 08:35:52 UTC, "value"=>231}, {"orderdate"=>2020-10-03 13:49:44 UTC, "value"=>102}, {"orderdate"=>2020-12-26 08:55:46 UTC, "value"=>4}], "customer_id"=>"[email protected]"}
{"first_purchase_date"=>2020-08-18 23:04:48 UTC, "total_value"=>191, "total_orders"=>2, "orders"=>[{"orderdate"=>2020-08-18 23:04:48 UTC, "value"=>4}, {"orderdate"=>2020-11-23 22:56:53 UTC, "value"=>187}], "customer_id"=>"[email protected]"}

결과 문서에는 특정 고객의 모든 주문에 대한 세부 정보가 고객의 이메일 주소별로 그룹화되어 포함되어 있습니다.

2020의 주문에 대한 매치 단계를 추가합니다.

먼저 에 접수된 $match 주문과 일치하는 단계를 2020 추가합니다.

pipeline.push(doc! {
    "$match": {
        "orderdate": {
            "$gte": DateTime::builder().year(2020).month(1).day(1).build().unwrap(),
            "$lt": DateTime::builder().year(2021).month(1).day(1).build().unwrap(),
        }
    }
});

정렬 단계를 추가하여 주문 날짜별로 정렬합니다.

다음으로, 단계를 추가하여 필드 에 오름차순 $sort 정렬을 orderdate 설정하다 2020 다음 단계에서 각 고객의 가장 이른 구매를 조회 .

pipeline.push(doc! {
    "$sort": {
        "orderdate": 1
    }
});

이메일 주소 별로 그룹 하려면 그룹 단계를 추가합니다.

단계를 추가하여 필드 $group 값으로 주문 문서를 수집합니다. 이 단계에서는 결과 문서에 다음 필드를 생성하는 집계 작업을 추가합니다.customer_id

first_purchase_date: 고객의 첫 구매 날짜
total_value: 고객의 모든 구매 총액
total_orders: 고객의 총 구매 횟수
orders: 각 구매의 날짜 및 금액을 포함한 고객의 모든 구매 목록

pipeline.push(doc! {
    "$group": {
        "_id": "$customer_id",
        "first_purchase_date": { "$first": "$orderdate" },
        "total_value": { "$sum": "$value" },
        "total_orders": { "$sum": 1 },
        "orders": {
            "$push": {
                "orderdate": "$orderdate",
                "value": "$value"
            }
        }
    }
});

정렬 단계를 추가하여 첫 번째 주문 날짜별로 정렬합니다.

다음으로, 다른 $sort 단계를 추가하여 필드 에 오름차순 정렬을 설정하다 first_purchase_date .

pipeline.push(doc! {
    "$sort": {
        "first_purchase_date": 1
    }
});

이메일 주소 표시하는 설정하다 단계를 추가합니다.

단계를 $set 추가하여 단계에서 설정하다 필드 의 값으로 customer_id _id 필드 다시 $group 만듭니다.

pipeline.push(doc! {
    "$set": {
        "customer_id": "$_id"
    }
});

불필요한 필드를 제거 하려면 설정되지 않은 단계를 추가합니다.

마지막으로 단계를 $unset 추가합니다.$unset 단계는 _id 결과 문서에서 필드 제거합니다.

pipeline.push(doc! {"$unset": ["_id"] });

집계 파이프라인 실행합니다.

orders collection에서 애그리게이션을 수행하려면 애플리케이션 끝에 다음 코드를 추가하세요.

let mut cursor = orders.aggregate(pipeline).await?;

마지막으로 shell에서 다음 명령을 실행하여 애플리케이션을 시작합니다.

cargo run

집계 결과를 해석합니다.

이 애그리게이션은 2020년의 고객 주문에 대한 다음과 같은 요약을 반환합니다.

Document({"first_purchase_date": DateTime(2020-01-01 8:25:37.0 +00:00:00), "total_value": Int32(63), "total_orders": Int32(1),
"orders": Array([Document({"orderdate": DateTime(2020-01-01 8:25:37.0 +00:00:00), "value": Int32(63)})]), "customer_id": String("[email protected]")})
Document({"first_purchase_date": DateTime(2020-01-13 9:32:07.0 +00:00:00), "total_value": Int32(436), "total_orders": Int32(4),
"orders": Array([Document({"orderdate": DateTime(2020-01-13 9:32:07.0 +00:00:00), "value": Int32(99)}), Document({"orderdate":
DateTime(2020-05-30 8:35:53.0 +00:00:00), "value": Int32(231)}), Document({"orderdate": DateTime(2020-10-03 13:49:44.0 +00:00:00),
"value": Int32(102)}), Document({"orderdate": DateTime(2020-12-26 8:55:46.0 +00:00:00), "value": Int32(4)})]), "customer_id": String("[email protected]")})
Document({"first_purchase_date": DateTime(2020-08-18 23:04:48.0 +00:00:00), "total_value": Int32(191), "total_orders": Int32(2),
"orders": Array([Document({"orderdate": DateTime(2020-08-18 23:04:48.0 +00:00:00), "value": Int32(4)}), Document({"orderdate":
DateTime(2020-11-23 22:56:53.0 +00:00:00), "value": Int32(187)})]), "customer_id": String("[email protected]")})

결과 문서에는 특정 고객의 모든 주문에 대한 세부 정보가 고객의 이메일 주소별로 그룹화되어 포함되어 있습니다.

2020의 주문에 대한 매치 단계를 추가합니다.

먼저 에 접수된 $match 주문과 일치하는 단계를 2020 추가합니다.

Aggregates.filter(Filters.and(
  Filters.gte("orderdate", dateFormat.parse("2020-01-01T00:00:00")),
  Filters.lt("orderdate", dateFormat.parse("2021-01-01T00:00:00"))
)),

정렬 단계를 추가하여 주문 날짜별로 정렬합니다.

다음으로, 단계를 추가하여 필드 에 오름차순 $sort 정렬을 orderdate 설정하다 2020 다음 단계에서 각 고객의 가장 이른 구매를 조회 .

Aggregates.sort(Sorts.ascending("orderdate")),

이메일 주소 별로 그룹 하려면 그룹 단계를 추가합니다.

단계를 추가하여 필드 $group 값으로 주문 문서를 수집합니다. 이 단계에서는 결과 문서에 다음 필드를 생성하는 집계 작업을 추가합니다.customer_id

first_purchase_date: 고객의 첫 구매 날짜
total_value: 고객의 모든 구매 총액
total_orders: 고객의 총 구매 횟수
orders: 각 구매의 날짜 및 금액을 포함한 고객의 모든 구매 목록

Aggregates.group(
  "$customer_id",
  Accumulators.first("first_purchase_date", "$orderdate"),
  Accumulators.sum("total_value", "$value"),
  Accumulators.sum("total_orders", 1),
  Accumulators.push("orders", Document("orderdate" -> "$orderdate", "value" -> "$value"))
),

정렬 단계를 추가하여 첫 번째 주문 날짜별로 정렬합니다.

다음으로, 다른 $sort 단계를 추가하여 필드 에 오름차순 정렬을 설정하다 first_purchase_date .

Aggregates.sort(Sorts.ascending("first_purchase_date")),

이메일 주소 표시하는 설정하다 단계를 추가합니다.

단계를 $set 추가하여 단계에서 설정하다 필드 의 값으로 customer_id _id 필드 다시 $group 만듭니다.

Aggregates.set(Field("customer_id", "$_id")),

불필요한 필드를 제거 하려면 설정되지 않은 단계를 추가합니다.

마지막으로 단계를 $unset 추가합니다.$unset 단계는 _id 결과 문서에서 필드 제거합니다.

Aggregates.unset("_id")

집계 파이프라인 실행합니다.

orders collection에서 애그리게이션을 수행하려면 애플리케이션 끝에 다음 코드를 추가하세요.

orders.aggregate(pipeline)
  .subscribe((doc: Document) => println(doc.toJson()),
    (e: Throwable) => println(s"Error: $e"))

마지막으로 IDE에서 애플리케이션 실행 .

집계 결과를 해석합니다.

이 애그리게이션은 2020년의 고객 주문에 대한 다음과 같은 요약을 반환합니다.

{"first_purchase_date": {"$date": "2020-01-01T13:25:37Z"}, "total_value": 63, "total_orders": 1, "orders": [{"orderdate": {"$date": "2020-01-01T13:25:37Z"}, "value": 63}], "customer_id": "[email protected]"}
{"first_purchase_date": {"$date": "2020-01-13T14:32:07Z"}, "total_value": 436, "total_orders": 4, "orders": [{"orderdate": {"$date": "2020-01-13T14:32:07Z"}, "value": 99}, {"orderdate": {"$date": "2020-05-30T12:35:52Z"}, "value": 231}, {"orderdate": {"$date": "2020-10-03T17:49:44Z"}, "value": 102}, {"orderdate": {"$date": "2020-12-26T13:55:46Z"}, "value": 4}], "customer_id": "[email protected]"}
{"first_purchase_date": {"$date": "2020-08-19T03:04:48Z"}, "total_value": 191, "total_orders": 2, "orders": [{"orderdate": {"$date": "2020-08-19T03:04:48Z"}, "value": 4}, {"orderdate": {"$date": "2020-11-24T03:56:53Z"}, "value": 187}], "customer_id": "[email protected]"}

결과 문서에는 특정 고객의 모든 주문에 대한 세부 정보가 고객의 이메일 주소별로 그룹화되어 포함되어 있습니다.

돌아가기

필터 및 하위 집합

배열 풀기