The $bottom accumulator picks the single lowest-ranked document in each $group bucket using a sortBy specification—ideal for “worst score,” “earliest order,” or “lowest price” reports.
Full record at bottom of sort.
Defines what “bottom” means.
$$ROOT or selected fields.
Value only vs whole document.
One record vs N records.
Part of $top/$bottom family.
$bottom is a MongoDB accumulator used in the $group stage. It sorts documents within each group according to sortBy, then returns the document at the bottom of that ordering (the last one if you sorted ascending, or the minimum rank depending on your sort keys).
With sortBy: { score: 1 }, ascending order puts the smallest score at the bottom—so $bottom returns the student with the lowest score in each class. Use score: -1 when “bottom” should mean the lowest rank in a descending list.
Choose $bottom when you need identifying fields (name, id, date) from the extreme record. Use $min when you only need the numeric minimum. Need multiple low-ranked rows? Use $bottomN.
$bottom requires an object with output and sortBy:
{
$group: {
_id: <expression>,
<field>: {
$bottom: {
output: <expression> | { <field>: <expression>, ... },
sortBy: { <field>: <1 | -1>, ... }
}
}
}
}output — what to return: "$$ROOT" for the full document, or a projection object.sortBy — required; same format as $sort (1 = ascending, -1 = descending).$bottomN, result is a single object per group, not an array.db.scores.aggregate([
{
$group: {
_id: "$class",
lowestScorer: {
$bottom: {
output: { name: "$student", score: "$score" },
sortBy: { score: 1 }
}
}
}
}
]);| Question | Answer |
|---|---|
| Stage | $group accumulator |
| Required keys | output, sortBy |
| Returns | One document (or projected object) per group |
| Lowest score pattern | sortBy: { score: 1 } |
| Full document | output: "$$ROOT" |
| MongoDB version | 5.2+ |
sortBy: { score: 1 }Ascending → min at bottom
output: "$$ROOT"Entire source document
output: {
name: "$student",
score: "$score"
}Selected fields only
sortBy: {
score: 1,
student: 1
}Stable ordering
The $bottom object has two required properties:
output RequiredExpression or document defining what the accumulator returns. Use "$$ROOT" for the full input document, or build a sub-object with field projections.
output: "$$ROOT"
output: { id: "$_id", score: "$score" }sortBy RequiredSort specification applied within each group before picking the bottom document. Mirrors $sort syntax with 1 (asc) and -1 (desc).
sortBy: { score: 1 }
sortBy: { date: 1, amount: 1 }_id Group keyStandard $group bucket key—e.g. "$class" for per-class lowest scorers.
_id: "$department"empty group Edge caseIf no documents fall in a group, that group is not emitted. Pipelines with only empty buckets return an empty result set.
$match before $groupStudent scores by class—find the lowest scorer per section and compare with $min.
Sample scores and the core $bottom grouping pattern.
db.scores.insertMany([
{ student: "Alice", class: "10A", score: 85 },
{ student: "Bob", class: "10A", score: 72 },
{ student: "Charlie", class: "10A", score: 91 },
{ student: "Diana", class: "10B", score: 68 },
{ student: "Eve", class: "10B", score: 88 }
]);Class 10A lowest is Bob (72); class 10B lowest is Diana (68)—clear targets for verifying $bottom output.
db.scores.aggregate([
{
$group: {
_id: "$class",
lowestScorer: {
$bottom: {
output: { name: "$student", score: "$score" },
sortBy: { score: 1 }
}
}
}
},
{ $sort: { _id: 1 } }
]);
/* Result:
[
{ _id: "10A", lowestScorer: { name: "Bob", score: 72 } },
{ _id: "10B", lowestScorer: { name: "Diana", score: 68 } }
]
*/Within each class group, MongoDB sorts by ascending score and returns the bottom document’s projected fields.
Return full documents, compare accumulators, and handle ties.
db.scores.aggregate([
{
$group: {
_id: "$class",
lowestRecord: {
$bottom: {
output: "$$ROOT",
sortBy: { score: 1 }
}
}
}
}
]);
// lowestRecord contains student, class, score, _id fields$$ROOT refers to the current document in the group during accumulation—useful when downstream stages need every field.
db.scores.aggregate([
{
$group: {
_id: "$class",
minScore: { $min: "$score" },
bottomStudent: {
$bottom: {
output: { name: "$student", score: "$score" },
sortBy: { score: 1 }
}
}
}
}
]);
/* 10A:
minScore: 72
bottomStudent: { name: "Bob", score: 72 }
— same number, but $bottom also gives you the name */
*/Use both in the same $group when dashboards show the minimum value and the record that achieved it.
When two students share the lowest score, add a secondary key so ranking is predictable:
db.scores.aggregate([
{
$group: {
_id: "$class",
lowestScorer: {
$bottom: {
output: { name: "$student", score: "$score" },
sortBy: { score: 1, student: 1 }
}
}
}
}
]);
// If Bob and Blake both score 72, student: 1
// puts Blake before Bob — Blake wins the tieAlways add tie-breakers (name, timestamp, _id) when business rules require deterministic winners.
$bottom Works$group assigns each document to a group via _id.
sortBy ranks documents inside each bucket independently.
The last document in that sort order becomes the accumulator result.
The output expression shapes what fields appear in the final object.
$bottom requires MongoDB 5.2+—verify server version before deploying.sortBy is mandatory—there is no default sort order.$bottomN for many).sortBy keys.$sort + $group + $first patterns (less efficient).$bottom answers “which single record is at the low end of my ranking?” inside each group. Define sortBy carefully, project with output, and add tie-breakers when duplicates matter.
Pair with $min for the numeric extreme alone, or move to $bottomN when you need several bottom-ranked documents per bucket.
sortBy explicitly—match your business definition of “bottom”student, _id) to break ties$$ROOT when downstream stages need the full document$match before $group to shrink working sets$bottom with $bottomN (one doc vs array)$min to return student names—it only returns the minimum valuesortBy fields$bottomUse these points when ranking documents inside $group.
Bottom of sort per group.
BasicsRequired ranking spec.
SyntaxDoc vs scalar value.
CompareReturn full record.
PatternCheck server version.
Version$bottom and $top were added together in MongoDB 5.2 to replace fragile $sort + $group + $first recipes for ranked group results. See the official $bottom docs.
Pick the single bottom record with $bottom, then learn $bottomN for multiple ranked results.
5 people found this page helpful