Docs: https://www.mongodb.com/docs/manual/aggregation/

MongoDB Aggregation là một trong những tính năng mạnh mẽ nhất của MongoDB.

Hiểu một cách đơn giản, đây là một framework (khuôn khổ) dùng để xử lý và biến đổi dữ liệu ngay trên máy chủ cơ sở dữ liệu (database server) trước khi trả về cho ứng dụng của bạn.

Thay vì bạn phải lấy một tập dữ liệu lớn về ứng dụng rồi dùng code (như JavaScript, Python) để lặp, lọc, tính toán, thì Aggregation cho phép bạn thực hiện tất cả những việc đó ngay trong database.

🚀 Khái niệm cốt lõi: Đường ống (Pipeline)

Cách thức hoạt động chính của Aggregation là thông qua một "Đường ống" (Pipeline).

Bạn có thể tưởng tượng nó giống như một dây chuyền sản xuất trong nhà máy:

Đầu vào: Toàn bộ các tài liệu (documents) trong một collection của bạn.
Các Giai đoạn (Stages): Dữ liệu được đẩy qua một chuỗi các "giai đoạn". Mỗi giai đoạn thực hiện một hành động cụ thể (lọc, nhóm, sắp xếp, v.v.).
Đầu ra: Dữ liệu (output) của giai đoạn này sẽ là đầu vào (input) cho giai đoạn tiếp theo.
Kết quả: Dữ liệu cuối cùng sau khi đi qua tất cả các giai đoạn là kết quả bạn nhận được.

🔧 Các Giai Đoạn (Stages) Phổ Biến

Đây là một số "máy" (giai đoạn) thông dụng nhất trong dây chuyền sản xuất của bạn:

$match:
- Công dụng: Lọc tài liệu. Nó hoạt động tương tự như lệnh find().
- Ví dụ: Chỉ chọn các đơn hàng có trạng thái là "completed".
$group:
- Công dụng: Đây là "trái tim" của aggregation. Nó dùng để nhóm các tài liệu lại dựa trên một (hoặc nhiều) trường.
- Tương đương SQL: Giống hệt như GROUP BY.
- Toán tử tích lũy: Thường được sử dụng với các toán tử như $sum (tính tổng), $avg (tính trung bình), $max (tìm lớn nhất), $push (gom vào mảng), v.v.
$project:
- Công dụng: Định hình lại cấu trúc của tài liệu đầu ra.
- Ví dụ: Bạn có thể chọn chỉ giữ lại một số trường, đổi tên trường, hoặc tạo ra trường mới (ví dụ: fullName = firstName + lastName).
$sort:
- Công dụng: Sắp xếp tài liệu (tăng dần hoặc giảm dần).
- Tương đương SQL: Giống ORDER BY.
$lookup:
- Công dụng: Thực hiện một phép "JOIN" (giống như trong SQL) để kết hợp dữ liệu từ một collection khác.
- Ví dụ: Lấy thông tin chi tiết của người dùng (users collection) cho các đơn hàng (orders collection).
$limit và $skip:
- Công dụng: Dùng để phân trang (pagination). $limit giới hạn số lượng tài liệu trả về, $skip bỏ qua một số tài liệu.

📝 Ví dụ Đơn Giản

Giả sử bạn có một collection orders (đơn hàng) như sau:

[{
  "_id": 1,
  "customer_id": "A",
  "item": "Áo thun",
  "price": 300000
}, {
  "_id": 2,
  "customer_id": "B",
  "item": "Quần jean",
  "price": 500000
}, {
  "_id": 3,
  "customer_id": "A",
  "item": "Giày",
  "price": 700000
}, {
  "_id": 4,
  "customer_id": "C",
  "item": "Mũ",
  "price": 150000
}, {
  "_id": 5,
  "customer_id": "B",
  "item": "Tất",
  "price": 50000
}]

Yêu cầu: Tính tổng số tiền mỗi khách hàng đã chi tiêu và sắp xếp theo thứ tự giảm dần.

Aggregation Pipeline:

db.orders.aggregate([
  // Giai đoạn 1: Nhóm (group) các đơn hàng theo "customer_id"
  {
    $group: {
      "_id": "$customer_id", // Nhóm theo trường customer_id
      "totalSpent": { $sum: "$price" } // Tính tổng của trường "price" cho mỗi nhóm
    }
  },
  
  // Giai đoạn 2: Sắp xếp (sort) kết quả
  {
    $sort: { "totalSpent": -1 } // Sắp xếp giảm dần (-1) theo tổng tiền
  }
])

Kết quả trả về:

[
  { "_id": "A", "totalSpent": 1000000 }, // Khách A (300k + 700k)
  { "_id": "B", "totalSpent": 550000 },  // Khách B (500k + 50k)
  { "_id": "C", "totalSpent": 150000 }   // Khách C (150k)
]

💡 Tại sao nên dùng Aggregation?

Hiệu năng: Xử lý dữ liệu ngay trên server database luôn nhanh hơn là tải hàng GB dữ liệu về ứng dụng rồi mới xử lý.
Giảm tải mạng: Bạn chỉ nhận về kết quả cuối cùng (đã được tổng hợp) thay vì toàn bộ dữ liệu thô.
Mạnh mẽ & Linh hoạt: Cho phép bạn thực hiện các phân tích, thống kê phức tạp mà find() đơn giản không thể làm được.

.

.

Hai giai đoạn (stages) quan trọng và mạnh mẽ nhất trong Aggregation Pipeline. Chúng ta sẽ đi sâu vào từng cái một.

🗃️ 1. Giai đoạn `$group` (Gom nhóm)

Mục đích chính: Gom các tài liệu (documents) có cùng một giá trị lại thành một nhóm duy nhất để thực hiện các phép tính toán (như SUM, COUNT, AVG).

Đây chính là GROUP BY trong SQL.

Cú pháp cốt lõi:

{
  $group: {
    "_id": <biểu thức nhóm>, // Dựa vào đây để nhóm
    "ten_truong_moi_1": { <toán tử tích lũy 1>: <biểu thức> },
    "ten_truong_moi_2": { <toán tử tích lũy 2>: <biểu thức> },
    ...
  }
}

_id (BẮT BUỘC): Đây là "khóa" (key) mà bạn muốn nhóm theo.
- Ví dụ: _id: "$category" sẽ nhóm tất cả tài liệu có cùng category lại.
- Ví dụ: _id: null sẽ nhóm tất cả tài liệu trong collection thành một nhóm duy nhất (dùng để tính tổng toàn bộ).
Các toán tử tích lũy (Accumulators): Đây là các phép tính bạn thực hiện trên mỗi nhóm. Các toán tử phổ biến nhất:
- $sum: Tính tổng.
- $avg: Tính trung bình.
- $max: Tìm giá trị lớn nhất.
- $min: Tìm giá trị nhỏ nhất.
- $count: Đếm số lượng tài liệu trong nhóm (cách mới từ v5.0).
- $push: Gom tất cả các giá trị của một trường vào một mảng (array).

Ví dụ với `$group`

Giả sử chúng ta có collection products (sản phẩm):

[
  { "_id": 1, "name": "Áo thun", "category": "Quần áo", "price": 300000 },
  { "_id": 2, "name": "Quần jean", "category": "Quần áo", "price": 500000 },
  { "_id": 3, "name": "Laptop", "category": "Điện tử", "price": 20000000 },
  { "_id": 4, "name": "Chuột", "category": "Điện tử", "price": 400000 }
]

Yêu cầu: Đếm số lượng sản phẩm và tính giá trung bình cho mỗi danh mục (category).

Pipeline:

db.products.aggregate([
  // Giai đoạn $group
  {
    $group: {
      "_id": "$category", // 1. Nhóm theo trường "category"
      
      // 2. Tạo các trường tính toán cho mỗi nhóm
      "soLuongSanPham": { $count: {} }, // Đếm số tài liệu trong nhóm
      "giaTrungBinh": { $avg: "$price" } // Tính trung bình trường "price"
    }
  }
])

Kết quả:

[
  { 
    "_id": "Quần áo", // Nhóm 1
    "soLuongSanPham": 2, 
    "giaTrungBinh": 400000 // (300k + 500k) / 2
  },
  { 
    "_id": "Điện tử", // Nhóm 2
    "soLuongSanPham": 2, 
    "giaTrungBinh": 10200000 // (20M + 400k) / 2
  }
]

🔗 2. Giai đoạn `$lookup` (JOIN)

Mục đích chính: Thực hiện một phép "JOIN" (giống SQL) để lấy dữ liệu từ một collection khác và đính kèm vào tài liệu hiện tại.

Cú pháp cốt lõi:

{
  $lookup: {
    "from": <collection_can_join>, // Tên collection BẠN MUỐN JOIN VÀO
    "localField": <truong_cua_collection_HIEN_TAI>, // Khóa ngoại (VD: "user_id")
    "foreignField": <truong_cua_collection_from>, // Khóa chính (VD: "_id")
    "as": <ten_truong_moi_chua_ket_qua> // Tên mảng (array) mới
  }
}

Quan trọng: $lookup luôn luôn trả về kết quả trong một mảng (array) (trường as), ngay cả khi nó chỉ tìm thấy 1 hoặc 0 tài liệu khớp.

Ví dụ với `$lookup`

Giả sử chúng ta có 2 collection:

orders (Đơn hàng):

[
  { "_id": 101, "item": "item_A", "user_id": 1 },
  { "_id": 102, "item": "item_B", "user_id": 2 },
  { "_id": 103, "item": "item_C", "user_id": 1 }
]

users (Người dùng):

[
  { "_id": 1, "name": "Văn A", "email": "a@example.com" },
  { "_id": 2, "name": "Thị B", "email": "b@example.com" }
]

Yêu cầu: Lấy tất cả các đơn hàng, nhưng kèm theo thông tin chi tiết của người dùng đã đặt hàng đó.

Pipeline: (Chúng ta sẽ aggregate trên orders)

db.orders.aggregate([
  // Giai đoạn $lookup
  {
    $lookup: {
      "from": "users",             // 1. JOIN với collection "users"
      "localField": "user_id",     // 2. Dùng trường "user_id" của 'orders'
      "foreignField": "_id",       // 3. Khớp với trường "_id" của 'users'
      "as": "thongTinNguoiDung"     // 4. Lưu kết quả vào mảng tên là "thongTinNguoiDung"
    }
  }
])

Kết quả:

Kết quả trả về là các tài liệu orders GỐC, cộng thêm một trường mảng as mới.

[
  { 
    "_id": 101, "item": "item_A", "user_id": 1,
    "thongTinNguoiDung": [ // Mảng kết quả
      { "_id": 1, "name": "Văn A", "email": "a@example.com" } 
    ]
  },
  { 
    "_id": 102, "item": "item_B", "user_id": 2,
    "thongTinNguoiDung": [
      { "_id": 2, "name": "Thị B", "email": "b@example.com" }
    ]
  },
  { 
    "_id": 103, "item": "item_C", "user_id": 1,
    "thongTinNguoiDung": [
      { "_id": 1, "name": "Văn A", "email": "a@example.com" }
    ]
  }
]

MongoDB Aggregation về cơ bản là một "dây chuyền xử lý dữ liệu" (pipeline) mạnh mẽ, chạy trực tiếp bên trong cơ sở dữ liệu của bạn.

Thay vì kéo hàng ngàn bản ghi thô về ứng dụng rồi mới xử lý, bạn ra lệnh cho MongoDB tự biến đổi dữ liệu đó qua một loạt các "giai đoạn" (stages). Hai giai đoạn quan trọng nhất chúng ta vừa tìm hiểu là:

$group (Gom nhóm): Đây là "bộ não" tính toán. Nó hoạt động giống hệt GROUP BY trong SQL, cho phép bạn gom nhóm các tài liệu lại (ví dụ: nhóm theo danh mục, theo người dùng) và thực hiện các phép tính toán trên từng nhóm (như tính tổng, đếm, lấy trung bình).
$lookup (Tham chiếu): Đây là "cánh tay" kết nối. Nó hoạt động giống như JOIN trong SQL, cho phép bạn kết nối và lấy thông tin từ một collection khác đính kèm vào kết quả (ví dụ: lấy thông tin user gắn vào order của họ).

Kết hợp các giai đoạn này, bạn có thể biến dữ liệu thô thành các báo cáo và thống kê phức tạp chỉ trong một truy vấn duy nhất.

Tìm hiểu về MongoDB Aggregate