Aggregate trong MongoDB: Cách cải thiện hiệu suất truy vấn

Nội dung bài viết

Hiện nay, với sự gia tăng của dữ liệu và yêu cầu về tốc độ xử lý, các công cụ cơ sở dữ liệu như MongoDB ngày càng trở nên quan trọng. Nhưng chỉ lưu trữ tốt thôi chưa đủ, việc tối ưu hóa các truy vấn mới là yếu tố then chốt để đảm bảo hiệu suất cao nhất khi làm việc với dữ liệu lớn. Aggregation trong MongoDB là công cụ quan trọng giúp bạn cải thiện hiệu năng truy vấn một cách rõ rệt.

Đọc bài viết này để hiểu rõ hơn về:

Khái niệm aggregation trong DBSM là gì
Aggregate pipeline
Cách thực thi một Aggregate với MongoDB
Một số cách tối ưu hoá aggregate

Tổng quan về MongoDB

MongoDB là một hệ quản trị cơ sở dữ liệu NoSQL hướng document, được thiết kế để lưu trữ dữ liệu dưới dạng BSON (Binary JSON) – một phiên bản mở rộng của JSON cho phép lưu trữ nhiều kiểu dữ liệu hơn JSON thuần như Date, ObjectId, Binary data, và hỗ trợ kích thước document lớn hơn. Thay vì lưu trữ trong các bảng, hàng và cột như cơ sở dữ liệu quan hệ (SQL), MongoDB tổ chức dữ liệu theo mô hình collection và document, giúp việc mở rộng và thay đổi cấu trúc dữ liệu dễ dàng hơn để thích ứng với yêu cầu thực tế.

Nhờ khả năng mở rộng theo chiều ngang (horizontal scaling) thông qua sharding và cơ chế replica set đảm bảo tính sẵn sàng cao, MongoDB trở thành lựa chọn phổ biến trong các ứng dụng hiện đại từ nền tảng web, phân tích dữ liệu, đến hệ thống IoT hay trí tuệ nhân tạo.

Không chỉ dừng lại ở các thao tác CRUD cơ bản (Create, Read, Update, Delete), MongoDB còn nổi bật với Aggregation Framework, một công cụ mạnh mẽ cho phép bạn phân tích, tổng hợp và biến đổi dữ liệu ngay trong database, mà không cần phụ thuộc vào công cụ xử lý bên ngoài.

Đọc chi tiết: MongoDB là gì? Định nghĩa và Hiểu rõ A-Z về MongoDB

Khái niệm Aggregation trong DBMS và Aggregation trong MongoDB

Trong các hệ quản trị cơ sở dữ liệu (DBMS): Aggregation được hiểu là quá trình tổng hợp, phân tích và trích xuất thông tin có ý nghĩa từ một tập dữ liệu lớn. Chẳng hạn, khi bạn muốn thống kê tổng doanh thu theo tháng, tính trung bình số lượng sản phẩm bán ra, hay nhóm dữ liệu theo danh mục, thì đó chính là các dạng của phép tổng hợp (aggregation).

Trong MongoDB:

Aggregation Pipeline

Aggregation Pipeline trong MongoDB là một cơ chế xử lý dữ liệu theo chuỗi các giai đoạn (stages), mỗi stage thực hiện một phép biến đổi cụ thể và kết quả của stage trước sẽ được truyền tiếp cho stage sau.

Cách tiếp cận theo pipeline này giúp việc xử lý trở nên trực quan, linh hoạt và hiệu quả, đặc biệt khi bạn cần thực hiện những phép tính hoặc thống kê phức tạp ngay trong cơ sở dữ liệu mà vẫn đảm bảo tốc độ và khả năng mở rộng.

Single-purpose aggregation

Bên cạnh Aggregation Pipeline với nhiều giai đoạn xử lý phức tạp, MongoDB còn cung cấp một nhóm Single-purpose Aggregation operations – tức là những phép tổng hợp đơn giản, được thiết kế cho các tác vụ thống kê cơ bản và cho phép người dùng nhanh chóng lấy ra kết quả tổng hợp mà không cần xây dựng pipeline nhiều bước.

Các hàm phổ biến trong nhóm này gồm có:

countDocuments(): đếm số lượng document trong collection hoặc theo điều kiện cụ thể.
distinct(): trả về danh sách các giá trị duy nhất của một trường.
estimatedDocumentCount(): đếm nhanh số lượng document trong collection (sử dụng metadata, không scan toàn bộ collection nên hiệu năng cao nhưng kết quả là ước lượng, không hỗ trợ filter điều kiện).

Các trường hợp sử dụng

Single-purpose aggregation đặc biệt hữu ích khi bạn chỉ cần thực hiện thống kê nhỏ, nhanh chóng như kiểm tra tổng số bản ghi, đếm số người dùng hay liệt kê các danh mục sản phẩm khác nhau. So với pipeline, chúng đơn giản hơn, dễ viết hơn và chạy nhanh hơn trong các trường hợp không yêu cầu xử lý phức tạp.

Tuy nhiên, khi bài toán cần phân tích dữ liệu nhiều bước hoặc tính toán nâng cao, bạn nên chuyển sang sử dụng Aggregation Pipeline để tận dụng tối đa sức mạnh của MongoDB.

Aggregate pipeline trong MongoDB

Cấu trúc cơ bản và cách hoạt động

Cách vận hành Aggregate pipeline trong MongoDB tương tự như pipeline trong hệ thống xử lý dữ liệu giúp thao tác, lọc, tính toán và tổng hợp dữ liệu một cách có trật tự và hiệu quả.

Mỗi stage trong pipeline sẽ sử dụng một toán tử bắt đầu bằng dấu $, thực hiện một nhiệm vụ cụ thể ví dụ như lọc dữ liệu ($match), nhóm dữ liệu ($group), chọn trường hiển thị ($project) hay sắp xếp kết quả ($sort).
Dữ liệu output của một stage sẽ trở thành input của stage tiếp theo, tạo thành một luồng xử lý liên tục (data flow).

Cú pháp cơ bản của một pipeline như sau:

db.collection.aggregate([
  { <stage1>: { <expression> } },
  { <stage2>: { <expression> } },
  ...
])

Việc xâu chuỗi nhiều stage lại với nhau cho phép bạn xây dựng các luồng xử lý dữ liệu phức tạp mà vẫn đảm bảo hiệu năng cao, vì MongoDB thực thi pipeline trực tiếp trên server thay vì phải trả dữ liệu về client để xử lý.

Các stage phổ biến trong Aggregate

Stage	Chức năng chính	Cách sử dụng
`$match`	Lọc document theo điều kiện, tương tự `WHERE` trong SQL. Nên đặt sớm nhất có thể trong pipeline để giảm lượng dữ liệu xử lý	Ví dụ để lọc người dùng đang hoạt động và trên 18 tuổi: `{ $match: { status: "active", age: { $gte: 18 } } }`
`$group`	Nhóm dữ liệu theo một khóa _id và áp dụng các phép tổng hợp như `$sum`, `$avg`, `$min`, `$max`.	Ví dụ để tính tổng giá theo từng loại sản phẩm: `{ $group: { _id: "$category", total: { $sum: "$price" } } }`
`$project`	Chọn trường cần hiển thị (1 để include, 0 để exclude) hoặc tạo trường mới dựa trên phép tính.	Ví dụ để hiển thị tên, tổng và tính thêm trường giảm giá: `{ $project: { name: 1, total: 1, discount: { $multiply: ["$total", 0.1] } } }`
`$sort`	Sắp xếp kết quả theo thứ tự tăng/giảm (1 cho tăng dần, -1 cho giảm dần).	Ví dụ để sắp xếp giảm dần theo trường total: `{ $sort: { total: -1 } }`
`$limit`	Giới hạn số lượng document được trả về.	Ví dụ để lấy 5 kết quả đầu tiên sau khi sắp xếp. `{ $limit: 5 }`
`$skip`	Bỏ qua một số lượng document đầu tiên, thường dùng để phân trang. Tuy nhiên lưu ý là sẽ tốn tài nguyên với offset lớn.	Ví dụ để bỏ qua 10 bản ghi đầu tiên: `{ $skip: 10 }`
`$unwind`	Tách mảng (array) thành nhiều document riêng lẻ, mỗi phần tử trong mảng tương ứng với một document. Có thể dùng `preserveNullAndEmptyArrays: true` để giữ document không có array	Để tách mỗi phần tử trong mảng items thành dòng riêng: `{ $unwind: "$items" }`
`$lookup`	Thực hiện “join” giữa hai collection (giống `LEFT OUTER JOIN` trong SQL).	Để gộp dữ liệu người dùng và đơn hàng: `{ $lookup: { from: "orders", localField: "user_id", foreignField: "_id", as: "userOrders" } }`
`$count`	Đếm tổng số document trong pipeline (sau các stage trước đó).	Để trả về tổng số bản ghi trong kết quả: `{ $count: "totalDocs" }`
`$addFields`	Thêm trường mới hoặc cập nhật giá trị trường hiện có mà không loại bỏ các trường khác.	Để thêm trường revenue bằng hiệu sales – cost: `{ $addFields: { revenue: { $subtract: ["$sales", "$cost"] } } }`

Cách thực thi một Aggregate bằng MongoDB

Để thực thi một Aggregate trong MongoDB, bạn sẽ sử dụng phương thức aggregate() trên đối tượng collection.

Các bước thực hiện một aggregate như sau:

Xác định collection: Đầu tiên, bạn phải xác định collection mà bạn muốn thực thi aggregate, ví dụ db.orders hoặc db.products.
Xây dựng pipeline: Tiếp theo, xây dựng pipeline bằng cách kết hợp các stage phù hợp như $match, $group, $sort, $limit,… tùy thuộc vào mục tiêu phân tích của bạn.
Gọi phương thức aggregate(): Sau khi pipeline được xây dựng, bạn gọi phương thức aggregate() để thực thi các thao tác. MongoDB sẽ trả về một cursor, không phải mảng trực tiếp.
Lọc và hiển thị kết quả: Bạn có thể sử dụng phương thức toArray() để lấy kết quả dưới dạng mảng hoặc forEach()để duyệt qua từng document hoặc sử dụng iterator pattern với hasNext() và next().

Ví dụ: Giả sử bạn có một collection orders và muốn tổng hợp tổng số đơn hàng theo từng customer_id ta thực hiện như sau:

db.orders.aggregate([
  { $match: { status: "completed" } },  // Chỉ lấy các đơn hàng đã hoàn thành
  { $group: { _id: "$customer_id", totalAmount: { $sum: "$amount" } } },  // Nhóm theo customer_id và tính tổng tiền
  { $sort: { totalAmount: -1 } },        // Sắp xếp theo tổng tiền giảm dần
  { $limit: 10 }                         // Lấy 10 khách hàng có tổng tiền cao nhất
]).forEach(printjson);

Kết quả sẽ là một danh sách các khách hàng với tổng số tiền đã chi tiêu trong các đơn hàng hoàn thành, được sắp xếp từ cao xuống thấp, giới hạn trong 10 khách hàng đầu tiên.

Tối ưu hóa Aggregation Pipeline trong MongoDB

Sử dụng $match sớm trong pipeline

Khi thực hiện một pipeline, giai đoạn $match thường được sử dụng để lọc dữ liệu dựa trên điều kiện nhất định. Đặt $match ở giai đoạn đầu tiên của pipeline sẽ giúp giảm số lượng document cần phải xử lý trong các giai đoạn sau.

Việc lọc dữ liệu sớm giúp tiết kiệm tài nguyên và làm giảm độ phức tạp của các thao tác sau này. Quan trọng hơn, MongoDB có thể tận dụng indexes cho $match khi nó được đặt ở đầu pipeline.

Ví dụ để lọc các đơn hàng đã hoàn thành và tính tổng số tiền mà mỗi khách hàng đã chi tiêu ta có cú pháp như sau:

db.orders.aggregate([
  { $match: { status: "completed" } },  // Lọc dữ liệu ngay từ đầu
  { $group: { _id: "$customer_id", totalAmount: { $sum: "$amount" } } },
  { $sort: { totalAmount: -1 } },
  { $limit: 10 }
])

Trong đó:

$match ở đầu pipeline giúp lọc các đơn hàng có trạng thái “completed”. Việc này giúp giảm số lượng dữ liệu cần phải xử lý trong các bước tiếp theo như $group và $sort, từ đó tăng tốc độ truy vấn.
Nếu $match được đặt sau giai đoạn $group hoặc $sort, MongoDB sẽ phải xử lý toàn bộ collection trước khi lọc, làm giảm hiệu suất đáng kể.

Dùng $project sau khi nhóm dữ liệu

Khi sử dụng $group, có thể tạo thêm trường bằng $project để lọc và tính toán các trường cần thiết sau khi đã nhóm dữ liệu. Việc sử dụng $project sau giai đoạn $group giúp lọc các trường không cần thiết và tính toán các trường mới mà không làm phức tạp dữ liệu quá nhiều.

Tuy nhiên, cần lưu ý rằng việc project sớm trước $group cũng có thể tối ưu bằng cách giảm dữ liệu cần xử lý.

Ví dụ để loại bỏ các trường không cần thiết và chỉ giữ lại những thông tin quan trọng như sau:

db.orders.aggregate([
  { $match: { status: "completed" } },
  { $group: { _id: "$customer_id", totalAmount: { $sum: "$amount" } } },
  { $project: { totalAmount: 1, _id: 0 } },  // Chỉ giữ lại trường totalAmount
  { $sort: { totalAmount: -1 } },
  { $limit: 10 }
])

Ở ví dụ này, sau khi nhóm các đơn hàng theo customer_id và tính tổng số tiền (totalAmount), chúng ta sử dụng $project để đổi tên trường _id thành customer cho dễ hiểu và chỉ giữ lại trường totalAmount và loại bỏ trường _id.

Điều này giúp giảm kích thước dữ liệu mà MongoDB phải xử lý và truyền qua các giai đoạn tiếp theo. Khi bạn chỉ giữ lại những trường cần thiết, bạn sẽ tiết kiệm tài nguyên bộ nhớ và giúp pipeline chạy nhanh hơn.

Tối ưu hóa $sort và $limit

MongoDB tự động tối ưu khi $sort và $limit liền kề nhau. Khi hai stage này đứng cạnh nhau, MongoDB sẽ chỉ giữ trong bộ nhớ số lượng document bằng với giới hạn của $limit, giúp tiết kiệm tài nguyên đáng kể.

db.orders.aggregate([
  { $match: { status: "completed" } },
  { $sort: { amount: -1 } },  // Sort trước
  { $limit: 1000 },           // Limit sau - MongoDB tự động tối ưu
  { $group: { _id: "$customer_id", totalAmount: { $sum: "$amount" } } }
])

Ở ví dụ này, trước khi thực hiện $sort, chúng ta giới hạn số lượng document với $limit để chỉ sắp xếp một phần dữ liệu thay vì toàn bộ collection. Nếu không giới hạn dữ liệu, MongoDB sẽ phải sắp xếp tất cả các document, làm giảm hiệu suất và tốn nhiều tài nguyên.

Bằng cách giới hạn dữ liệu trước khi sắp xếp, chúng ta giảm được số lượng document cần xử lý trong giai đoạn $sort, giúp pipeline thực thi nhanh hơn.

Tận dụng Indexes

MongoDB có thể sử dụng indexes để tăng tốc các truy vấn. Đảm bảo rằng các trường mà bạn sử dụng trong $match, $sort hay $group đều được index hóa đúng cách. Đặc biệt, các trường được sử dụng trong $match và $sort sẽ giúp MongoDB tìm kiếm và truy xuất dữ liệu nhanh chóng, giảm thời gian xử lý.

Lưu ý quan trọng về indexes:

$match có thể sử dụng index khi ở đầu pipeline
$sort có thể sử dụng index nếu nó đứng ngay sau $match đầu tiên Compound index phải khớp với thứ tự các trường trong query

Ví dụ về ứng dụng sử dụng index cho truy vấn nhanh hơn như sau:

db.orders.createIndex({ status: 1, amount: -1 })  // Tạo index cho các trường status và amount

db.orders.aggregate([
  { $match: { status: "completed" } },
  { $sort: { amount: -1 } },
  { $group: { _id: "$customer_id", totalAmount: { $sum: "$amount" } } }
])

Trong ví dụ này, chúng ta tạo một compound index cho các trường status và amount. MongoDB có thể sử dụng index này để tìm kiếm và sắp xếp dữ liệu nhanh chóng, thay vì phải quét toàn bộ collection, giúp giảm đáng kể thời gian truy vấn và tăng hiệu suất, đặc biệt khi làm việc với dữ liệu lớn.

$facet cho phép bạn thực hiện nhiều pipeline song song trong một truy vấn duy nhất, giúp phân tích nhiều khía cạnh của dữ liệu cùng lúc mà không cần phải viết nhiều truy vấn riêng biệt.

Tuy nhiên, cần lưu ý $facet có giới hạn 16MB cho output và không thể sử dụng indexes cho các stage bên trong.

Ví dụ để phân tích đồng thời với $facet:

db.orders.aggregate([
  { $match: { status: "completed" } },
  { $facet: {
      totalRevenue: [{ $group: { _id: null, total: { $sum: "$amount" } } }],
      averageOrder: [{ $group: { _id: null, avg: { $avg: "$amount" } } }]
    }
  }
])

Ở ví dụ này, chúng ta sử dụng $facet để thực hiện hai phép phân tích đồng thời: tính tổng doanh thu (totalRevenue) và tính giá trị trung bình của đơn hàng (averageOrder). Việc này giúp tăng hiệu suất vì bạn chỉ cần thực hiện một truy vấn duy nhất thay vì hai truy vấn riêng biệt.

Tuy nhiên, với dữ liệu rất lớn, việc chạy các query riêng có thể hiệu quả hơn do có thể tận dụng indexes.

Các câu hỏi thường gặp về Aggregate trong MongoDB

Aggregation có nhanh hơn truy vấn thông thường không?

Aggregation có thể nhanh hơn hoặc chậm hơn so với các truy vấn thông thường tùy thuộc vào các yếu tố như loại truy vấn, kích thước dữ liệu và cấu trúc index.

Khi nào Aggregation nhanh hơn?

Aggregation rất mạnh trong các tác vụ tính toán, nhóm dữ liệu và phân tích phức tạp mà không cần phải xuất dữ liệu ra ngoài. Nó có thể thực hiện các phép toán phức tạp ngay trong cơ sở dữ liệu mà không phải chuyển dữ liệu qua ứng dụng, điều này giúp giảm độ trễ network I/O và tài nguyên CPU phía client khi bạn thực hiện các phép tính phức tạp như tính tổng, nhóm, hoặc sắp xếp.
Aggregation tận dụng được các tối ưu hóa nội bộ của MongoDB như pipeline optimization, index usage, và có thể sử dụng disk khi cần với option allowDiskUse: true

Khi nào Aggregation chậm hơn?

Aggregation có thể chậm hơn so với truy vấn thông thường nếu không được tối ưu hóa đúng cách, đặc biệt là nếu không sử dụng index phù hợp trong các giai đoạn như $match, $sort hoặc $group.
Với các truy vấn đơn giản chỉ cần lọc và lấy dữ liệu thì find() thường nhanh hơn vì có overhead ít hơn.
Các pipeline phức tạp với nhiều giai đoạn hoặc khi xử lý dữ liệu không được phân tán hợp lý sẽ làm giảm hiệu suất.
Khi pipeline vượt quá giới hạn bộ nhớ 100MB mà không sử dụng allowDiskUse: true

Đọc chi tiết: MongoDB find(): Chiếc chìa khóa “vạn năng” trong MongoDB

Aggregation có hỗ trợ song song (parallel processing) không?

Aggregation trong MongoDB có hỗ trợ song song (parallel processing) thông qua tính năng sharding và parallelism trong một số stages nhất định.

Sharded Clusters: Khi sử dụng MongoDB sharded clusters, MongoDB có thể phân tán việc thực thi aggregation qua các shard khác nhau trong cluster, giúp xử lý song song các phần dữ liệu.

Các stage như $match, $project, $limit có thể được thực thi trên từng shard.
Các stage như $group, $sort có thể được thực thi một phần trên shard (partial aggregation) và merge kết quả trên mongosh.
Mỗi shard sẽ thực hiện các phép toán trên phần dữ liệu của nó, và MongoDB sẽ gộp kết quả lại để trả về cho người dùng.

Parallel Execution: Trong một số trường hợp, MongoDB có thể thực hiện parallel execution ngay cả trong các stages như $group hoặc $sort nếu dữ liệu được chia đều qua các shard. Điều này giúp MongoDB tăng hiệu suất khi làm việc với các tập dữ liệu lớn.

Khi nào nên cân nhắc chia nhỏ pipeline hoặc dùng MapReduce?

Chia nhỏ pipeline khi:

Khi pipeline quá phức tạp hoặc quá dài: Nếu pipeline của bạn có quá nhiều giai đoạn (thường > 20-30 stages) hoặc các giai đoạn quá phức tạp, MongoDB có thể gặp khó khăn trong việc thực thi hiệu quả. Bạn có thể chia nhỏ pipeline thành các phần xử lý độc lập và sử dụng $out hoặc $merge để lưu kết quả trung gian..
Khi cần tối ưu hóa bộ nhớ và tài nguyên: Nếu dữ liệu quá lớn và không thể xử lý hết trong bộ nhớ, bạn có thể chia nhỏ pipeline để xử lý từng phần dữ liệu một cách hiệu quả hơn.

Sử dụng MapReduce khi:

Khi cần xử lý dữ liệu phức tạp hơn không hỗ trợ trong pipeline aggregation: MapReduce có thể được sử dụng khi bạn cần thực hiện các phép toán phức tạp không thể thực hiện được qua Aggregation Pipeline, chẳng hạn như khi cần sự linh hoạt cao hơn trong việc xử lý dữ liệu.
Khi dữ liệu không thể được phân tán hiệu quả: Trong các trường hợp dữ liệu không dễ dàng chia thành các phần nhỏ (shards), MapReduce có thể xử lý được những tình huống này, mặc dù nó ít hiệu quả hơn so với Aggregation khi làm việc với dữ liệu đã được phân tán (sharded).

LƯU Ý: MapReduce đã bị ngừng hỗ trợ từ MongoDB phiên bản 5.0 trở đi và không còn được khuyến nghị sử dụng.

Nếu MapReduce đã bị loại bỏ, nên dùng gì thay thế?

Aggregation Pipeline với $accumulator và $function (từ MongoDB 4.4+) cho các logic phức tạp cần JavaScript.
$merge và $out để ghi kết quả vào collection hoặc xử lý dữ liệu theo batch.
MongoDB Spark Connector hoặc các ETL tools cho xử lý các khối dữ liệu cực lớn.
Change Streams kết hợp với application logic để xử lý dữ liệu real-time.

Ví dụ cách dùng Aggregation Pipeline kết hợp với $function để viết logic tính toán tùy chỉnh bằng JavaScript như sau:

db.collection.aggregate([
  {
    $group: {
      _id: "$category",
      values: { $push: "$value" }
    }
  },
  {
    $addFields: {
      customCalc: {
        $function: {
          body: function(values) {
            // Custom JavaScript logic here
            return values.reduce((a, b) => a + b * 2, 0);
          },
          args: ["$values"],
          lang: "js"
        }
      }
    }
  }
])

Trong đó ví dụ trên thực hiện 2 bước chính:

$group: gom các document theo category, tạo mảng values chứa toàn bộ giá trị value.
$function: chạy đoạn JavaScript để xử lý mảng đó, ở đây là nhân đôi từng giá trị rồi cộng lại.
Kết quả: mỗi nhóm có thêm trường customCalc thể hiện tổng đã tính.

Các giới hạn quan trọng của Aggregation Pipeline:

Giới hạn	Mô tả	Gợi ý khắc phục
Document size limit	Mỗi document tối đa 16MB	Chia nhỏ dữ liệu hoặc dùng $merge để ghi từng phần
Pipeline stage limit	Tối đa 1000 stages trong một pipeline	Gộp logic hoặc chia pipeline thành nhiều bước nhỏ
Memory limit	Mỗi stage chỉ dùng tối đa 100MB RAM	Dùng tùy chọn allowDiskUse: true để cho phép ghi tạm ra đĩa
Time limit	Pipeline có thể bị giới hạn thời gian chạy	Dùng maxTimeMS để đặt giới hạn tùy ý

Tổng kết

Aggregation Pipeline là một phần không thể thiếu trong MongoDB khi làm việc với các truy vấn phức tạp và dữ liệu lớn. Từ lọc dữ liệu đến tính toán tổng hợp, khả năng của Aggregation giúp giải quyết nhiều bài toán mà không cần phải sử dụng đến ứng dụng bên ngoài. Hiểu rõ cách thức hoạt động của Aggregation Pipeline không chỉ giúp bạn tận dụng sức mạnh của MongoDB mà còn mở ra nhiều khả năng xử lý dữ liệu trực tiếp trong cơ sở dữ liệu, giảm thiểu thời gian và tài nguyên cho các phép toán phức tạp.