MongoDB $bottom Accumulator

Example 1 — Sample Data

Imagine five students. Each document has a class, student name, and score.

db.scores.insertMany([
  { class: "A", student: "Sam", score: 90 },
  { class: "A", student: "Ana", score: 70 },
  { class: "A", student: "Lee", score: 85 },
  { class: "B", student: "Mia", score: 60 },
  { class: "B", student: "Omar", score: 95 }
]);

How the Data Is Stored in MongoDB

After the insert, MongoDB keeps 5 documents in scores. Run find() to see them:

db.scores.find()

[
  { class: "A", student: "Sam", score: 90 },
  { class: "A", student: "Ana", score: 70 },
  { class: "A", student: "Lee", score: 85 },
  { class: "B", student: "Mia", score: 60 },
  { class: "B", student: "Omar", score: 95 }
]

Read each document like this:

Class A scores: Sam 90, Ana 70, Lee 85
Class B scores: Mia 60, Omar 95

Next: $bottom finds the lowest-ranked student per class.

How It Works

1. Insert once. The sample command adds 5 documents to scores.
2. MongoDB stores fields as written. Each document keeps the same field names and values you inserted.
3. find() shows the same shape. What you inserted is what you get back—ready for $bottom in the next examples.

With sortBy: { score: -1 }, class A’s bottom is Ana (70); class B’s bottom is Mia (60).

Example 2 — Lowest Scorer per Class

Goal: for each class, return the student with the lowest score—name and score only. Descending sortBy puts the smallest score last, so $bottom picks it.

db.scores.aggregate([
  {
    $group: {
      _id: "$class",
      lowest: {
        $bottom: {
          output: { name: "$student", score: "$score" },
          // descending → last document = lowest score
          sortBy: { score: -1 }
        }
      }
    }
  },
  { $sort: { _id: 1 } }
]);

[
  { _id: "A", lowest: { name: "Ana", score: 70 } },
  { _id: "B", lowest: { name: "Mia", score: 60 } }
]

How It Works

1. Split by class. _id: "$class" makes groups "A" and "B".
2. Rank high to low. sortBy: { score: -1 } orders each group from highest score to lowest.
3. Pick the last row. That last document is the lowest score (Ana 70, Mia 60)—exactly what official MongoDB examples do.
4. Shape the result. output keeps only name and score—not the full source document.
5. Need only the number? Use { $min: "$score" } when you do not need the student name.

Example 3 — Full Document with $$ROOT

Goal: return the entire bottom-ranked document. output: "$$ROOT" keeps every field from the winning row.

db.scores.aggregate([
  {
    $group: {
      _id: "$class",
      lowestDoc: {
        $bottom: {
          output: "$$ROOT",
          sortBy: { score: -1 }
        }
      }
    }
  },
  { $sort: { _id: 1 } }
]);

[
  {
    _id: "A",
    lowestDoc: { _id: ObjectId("…"), class: "A", student: "Ana", score: 70 }
  },
  {
    _id: "B",
    lowestDoc: { _id: ObjectId("…"), class: "B", student: "Mia", score: 60 }
  }
]

How It Works

1. Same ranking. sortBy: { score: -1 } still picks Ana and Mia as the last (lowest) rows.
2. $$ROOT means the whole doc. You get class, student, score, and the original _id.
3. Projection vs root. Example 2 is lighter for APIs; Example 3 is handy when you need every field later.
4. Need several lows? Switch to $bottomN with an n value.