Các aggregation pipeline operators xây dựng các biểu thức để sử dụng trong các giai đoạn Aggregation Pipeline. Sau đây là danh sách các Aggregation Pipeline Operators.
Giới thiệu về Aggregation Pipeline Operators trong MongoDB
Aggregation Pipeline Operators là một tập hợp các toán tử được cung cấp bởi MongoDB để thực hiện các phép tính phức tạp trên dữ liệu trong các truy vấn Aggregation. Trong MongoDB, Aggregation được sử dụng để thực hiện các phép tính như nhóm, sắp xếp, lọc, tính tổng, tính trung bình, … trên dữ liệu trong một collection.
Aggregation Pipeline Operators cho phép người dùng sử dụng các toán tử khác nhau để thực hiện các phép tính trên dữ liệu. Chúng được sử dụng để phân tích và xử lý dữ liệu phức tạp, thường được sử dụng trong các báo cáo và hệ thống Business Intelligence.
Một số Aggregation Pipeline Operators phổ biến trong MongoDB bao gồm: $match, $group, $sort, $limit, $skip, $project, $unwind, $lookup, $replaceRoot, $count, $addFields, $facet.
Toán tử Arithmetic Expression
Nó được sử dụng để thực hiện các phép tính số học trên các con số. Một số biểu thức số học cũng hỗ trợ số học dữ liệu.
- $ abs
Toán tử abs trả về giá trị tuyệt đối của một số.
Cú pháp:
{$ abs: <number>}Ví dụ:
db.score.aggregate([
{
$school: { marks: { $abs: { $subtract: [ "$max", "$min" ] } } }
}
]) - $ add
Nó thêm hai hoặc nhiều số và ngày tháng. Nếu một trong các đối số là ngày, thì ngày sẽ coi đối số kia là mili giây để thêm vào ngày.
Cú pháp:
{$ add: [<expression1>, <expression2>, ...]}Ví dụ:
db.books.aggregate(
[
{ $project: { item: 1, total: { $add: [ "$price", "$tax" ] } } }
]
) - $ ceil
Toán tử ceil trả về số nguyên nhỏ nhất lớn hơn hoặc bằng số được chỉ định.
Cú pháp:
{$ ceil: <number>}Ví dụ:
db.samples.aggregate ([{$ project: {value: 1, bareValue: {$ ceil: "$ value"}}}])- $ divide
Nó chia một hoặc nhiều số cho một số khác và trả về kết quả.
Cú pháp:
{$ divide: [<expression1>, <expression2>]}Ví dụ:
db.planning.aggregate( [ { $project: { name: 1, workdays: { $divide: [ "$hours", 8 ] } } } ] ) - $ exp
Toán tử exp được sử dụng để nâng số của Euler lên thành số mũ được chỉ định và trả về kết quả.
Cú pháp:
{$ exp: <exponent>}Ví dụ:
db.accounts.aggregate ([{$ project: {effectRate: {$ subtract: [{$ exp: "$ rate"}, 1]}}}])- $ floor
Toán tử tầng trả về số nguyên lớn nhất nhỏ hơn hoặc bằng số được chỉ định.
Cú pháp:
{$ floor: <number>}Ví dụ:
db.samples.aggregate ([{$ project: {value: 1, floorValue: {$ floor: "$ value"}}}])- $ ln
Toán tử ln tính toán lôgarit tự nhiên của một số và trả về kết quả là một nhân đôi.
Cú pháp:
{$ ln: <number>}Ví dụ:
db.sales.aggregate ([{$ project: {x: "$ year", y: {$ ln: "$ sales"}}}])- $ log
Toán tử nhật ký tính toán nhật ký của một số cho cơ số được chỉ định và trả về kết quả là kép.
Cú pháp:
{$ log: [<number>, <base>]}Ví dụ:
db.examples.aggregate([
{ $project: { bitsNeeded:
{
$floor: { $add: [ 1, { $log: [ "$positiveInt", 2 ] } ] } } }
}
]) - $ log10
Toán tử log10 tính toán cơ số 10 của một số và trả về kết quả là một nhân đôi.
Cú pháp:
{$ log10: <number>}Ví dụ:
db.samples.aggregate( [ { $project: { pH: { $multiply: [ -1, { $log10: "$H3O" } ] } } } ] ) - $ mod
Toán tử mod chia một số với một số khác và trả về phần còn lại.
Cú pháp:
{$ mod: [<expression1>, <expression2>]}Ví dụ:
db.planning.aggregate(
[
{ $project: { remainder: { $mod: [ "$hours", "$tasks" ] } } }
]
) - $ multiply
Toán tử multiply cho tích của hai hoặc nhiều số.
Cú pháp:
{$ multiply: [<expression1>, <expression2>, .....]}Ví dụ:
db.sales.aggregate( [ { $project: { date: 1, item: 1, total: { $multiply: [ "$price", "$quantity" ] } } } ] ) - $ pow
Toán tử pow nâng số thành số mũ đã cho và trả về kết quả.
Cú pháp:
{$ pow: [<number>, <exponent>]}Ví dụ:
db.quizzes.aggregate ([{$ project: {variance: {$ pow: [{$ stdDevPop: "$ score.score"}, 2]}}}])- $ round
Toán tử round làm tròn một số thành một số nguyên hoặc một chữ số thập phân được chỉ định.
Cú pháp:
{$ round: [<number>, <place>]}Ví dụ:
db.samples.aggregate ([{$ project: {roundValue: {$ round: ["$ value", 1]}}}])- $ sqrt
Toán tử sqrt trả về căn bậc hai của một số dương là nhân đôi.
Cú pháp:
{$ sqrt: <number>}Ví dụ:
db.points.aggregate([
{
$project: {
distance: {
$sqrt: {
$add: [
{ $pow: [ { $subtract: [ "$p2.y", "$p1.y" ] }, 2 ] },
{ $pow: [ { $subtract: [ "$p2.x", "$p1.x" ] }, 2 ] }
]
}
}
}
}
])
- $subtract
Toán tử trừ trừ hai hoặc nhiều số để trả về hiệu của số đó.
Cú pháp:
{ $subtract: [ <expression1>, <expression2> ] } Ví dụ:
db.sales.aggregate( [ { $project: { item: 1, total: { $subtract: [ { $add: [ "$price", "$fee" ] }, "$discount" ] } } } ] ) - $ trunc
Lệnh trunc xóa dữ liệu khỏi vị trí thập phân được chỉ định.
Cú pháp:
{$ trunc: [<number>, <place>]}Ví dụ:
db.samples.aggregate ([{$ project: {truncatedValue: {$ trunc: ["$ value", 1]}}}])Toán tử Array Expression
- $ arrayElemAt
Nó trả về phần tử ở chỉ số mảng được chỉ định.
Cú pháp:
{$ arrayElemAt: [<array>, <idx>]}Ví dụ:
db.users.aggregate([
{
$project:
{
name: 1,
first: { $arrayElemAt: [ "$favorites", 0 ] },
last: { $arrayElemAt: [ "$favorites", -1 ] }
}
}
]) - $ arrayToObject
Toán tử arrayToObject chuyển đổi một mảng thành một tài liệu duy nhất.
Cú pháp:
[["item", "abc123"], ["qty", 25]]
Ví dụ:
db.inventory.aggregate(
[
{
$project: {
item: 1,
dimensions: { $arrayToObject: "$dimensions" }
}
}
]
)
- $ concatArrays
Toán tử concatArrays tham gia vào mảng để trả về mảng đã nối.
Cú pháp:
{$ concatArrays: [<array1>, <array2>, ...]}Ví dụ:
db.warehouses.aggregate([
{ $project: { items: { $concatArrays: [ "$instock", "$ordered" ] } } }
]) - $ filter
Toán tử bộ lọc chọn một tập hợp con của một mảng để trả về kết quả dựa trên điều kiện đã chỉ định.
Cú pháp:
{$ filter: {input: <array>, as: <string>, cond: <expression>}}Ví dụ:
db.sales.aggregate([
{
$project: {
items: {
$filter: {
input: "$items",
as: "item",
cond: { $gte: [ "$$item.price", 100 ] }
}
}
}
}
]) - $ in
Toán tử in trả về một boolean cho biết rằng giá trị được chỉ định có nằm trong mảng hay không.
Cú pháp:
{ $in: [ <expression>, <array expression> ] } Ví dụ:
db.fruit.aggregate([
{
$project: {
"store location" : "$location",
"has bananas" : {
$in: [ "bananas", "$in_stock" ]
}
}
}
]) - $ indexOfArray
Toán tử indexOfArray tìm kiếm mảng cho sự xuất hiện của một giá trị được chỉ định và trả về chỉ số mảng của lần xuất hiện đầu tiên.
Cú pháp:
{ $indexOfArray: [ <array expression>, <search expression>, <start>, <end> ] } Ví dụ:
db.inventory.aggregate(
[
{
$project:
{
index: { $indexOfArray: [ "$items", 2 ] },
}
}
]
)
- $ isArray
Nó xác định và trả về một giá trị Boolean nếu toán hạng là một Mảng.
Cú pháp:
{ $isArray: [ <expression> ] } Ví dụ:
db.shop.aggregate( [ { $project: { items: { $cond:
{ if: { $and: [ { $isArray: "$instock" }, { $isArray: "$ordered" } ] }, then: { $concatArrays: [ "$instock", "$ordered" ] },
else: "One or more fields is not an array." } } } } ) - $ map
Toán tử bản đồ gắn giá trị cho từng mục trong một mảng và trả về một mảng với kết quả được áp dụng.
Cú pháp:
{$ map: {input: <expression>, as: <string>, in: <expression>}}Ví dụ:
db.grades.aggregate(
[
{ $project:
{ adjustedGrades:
{
$map:
{
input: "$quizzes",
as: "grade",
in: { $add: [ "$$grade", 2 ] }
}
}
}
}
]
}
Xem thêm Truy vấn Plan Cache Commands trong MongoDB
- $ objectToArray
Toán tử này chuyển đổi một tài liệu thành một mảng.
Cú pháp:
{$ objectToArray: <object>}Ví dụ:
db.inventory.aggregate(
[
{
$project: {
item: 1,
dimensions: { $objectToArray: "$dimensions" }
}
}
]
)
- $range
Toán tử phạm vi trả về một mảng có các phần tử là một chuỗi số được tạo ra.
Cú pháp:
{$ range: [<start>, <end>, <non-zero step>]}Ví dụ:
db.distances.aggregate([{
$project: {
_id: 0,
city: 1,
"Rest stops": { $range: [ 0, "$distance", 25 ] } } } ] ) - $reduce
Toán tử rút gọn áp dụng một biểu thức cho mỗi phần tử trong một mảng và kết hợp chúng thành một giá trị duy nhất.
Cú pháp:
{
$reduce: {
input: <array>,
initialValue: <expression>,
in: <expression>
}
} Ví dụ:
db.clothes.aggregate( [ { $project: { "discountedPrice": {
$reduce: { input: "$discounts", initialValue: "$price", in: { $multiply: [ "$$value", { $subtract: [ 1, "$$this" ] } ] } } } } } ] )Xem thêm Aggregation trong data mining
- $ reverseArray
Nó trả về một mảng có phần tử theo thứ tự ngược lại.
Cú pháp:
{ $reverseArray: <array expression> } Ví dụ:
db.users.aggregate( [ { $project: {name: 1,
reverseFavorites: { $reverseArray: "$favorites" } } } ] ) - $size
Toán tử kích thước đếm và trả về tổng số mục trong một mảng.
Cú pháp:
{$ size: <expression>}Ví dụ:
db.books.aggregate( [ { $project: { item: 1, numberOfColors: { $cond: { if: { $isArray: "$colors" }, then: { $size: "$colors" }, else: "NA"} } } } ] )- $ slice
Toán tử lát cắt dẫn đến một tập hợp con của một mảng.
Cú pháp:
{$ slice: [<array>, <n>]}Ví dụ:
db.books.aggregate( [ { $project: { name: 1, threeFavorites: { $slice: [ "$favorites", 3 ] } } }
]) - $ zip
Toán tử zip chuyển vị một mảng để phần tử đầu tiên của mảng đầu ra sẽ là một mảng chứa phần tử đầu tiên của mảng đầu vào đầu tiên.
Cú pháp:
{
$zip: { inputs: [ <array expression1>, ... ], useLongestLength: <boolean>, defaults: <array expression> } } Ví dụ:
db.matrices.aggregate([{ $project: { _id: false, transposed: { $zip: { inputs: [
{ $arrayElemAt: [ "$matrix", 0 ] },
{ $arrayElemAt: [ "$matrix", 1 ] },
{ $arrayElemAt: [ "$matrix", 2 ] },
] } } } } ] ) Xem thêm Truy vấn Modifiers trong MongoDB
Ví dụ về cách sử dụng Aggregation Pipeline Operators
Đây là ví dụ về cách sử dụng Aggregation Pipeline Operators để tính toán tổng số tiền đã chi tiêu trong tất cả các giao dịch của một người dùng cụ thể:
Giả sử chúng ta có một collection trong MongoDB chứa các documents đại diện cho các giao dịch ngân hàng, với các trường như sau:
{
"_id": ObjectId("60a34d1f11dfe00e809541c3"),
"amount": 100.0,
"description": "Mua sắm tại siêu thị",
"category": "Mua sắm",
"user_id": "abc123",
"date": ISODate("2022-05-16T00:00:00.000Z")
}Để tính tổng số tiền đã chi tiêu trong tất cả các giao dịch của người dùng có user_id là abc123, chúng ta có thể sử dụng Aggregation Pipeline Operators như sau:
db.transactions.aggregate([
{
$match: {
user_id: "abc123"
}
},
{
$group: {
_id: null,
total: {
$sum: "$amount"
}
}
}
])Ở đây, chúng ta sử dụng $match stage để lọc ra các documents có user_id là abc123, và sau đó sử dụng $group stage để tính tổng số tiền đã chi tiêu bằng cách sử dụng $sum operator trên trường amount. Kết quả trả về sẽ là một document với trường _id có giá trị là null (do chúng ta không group theo bất kỳ trường nào cả), và trường total chứa tổng số tiền đã chi tiêu.
Kết luận
Trong MongoDB, Aggregation Pipeline Operators là một công cụ mạnh mẽ cho phép các tác vụ truy vấn phức tạp và tính toán được thực hiện dễ dàng và hiệu quả hơn. Chúng giúp cho việc tìm kiếm, phân tích dữ liệu và lọc ra kết quả theo các tiêu chí cụ thể trở nên đơn giản hơn, từ đó giúp người dùng dễ dàng quản lý cơ sở dữ liệu. Các Aggregation Pipeline Operators như $match, $project, $group, $sort,… đều cung cấp những tính năng mạnh mẽ cho việc truy vấn và phân tích dữ liệu. Sử dụng chúng trong quá trình phát triển ứng dụng MongoDB sẽ giúp bạn tiết kiệm thời gian và nâng cao hiệu quả công việc của mình.
Xem thêm Advanced search operators là gì?
