$first and $last accumulators in MongoDB - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

What is the output of this MongoDB aggregation using $first?

Consider a collection named sales with documents:

{ "_id": 1, "item": "apple", "qty": 5, "date": ISODate("2023-01-01") }

{ "_id": 2, "item": "apple", "qty": 10, "date": ISODate("2023-01-02") }

{ "_id": 3, "item": "apple", "qty": 7, "date": ISODate("2023-01-03") }

What will be the result of this aggregation?

db.sales.aggregate([
  { $match: { item: "apple" } },
  { $sort: { date: 1 } },
  { $group: {
      _id: "$item",
      firstQty: { $first: "$qty" }
  } }
])

MongoDB

db.sales.aggregate([
  { $match: { item: "apple" } },
  { $sort: { date: 1 } },
  { $group: {
      _id: "$item",
      firstQty: { $first: "$qty" }
  } }
])

A [{ "_id": "apple", "firstQty": 5 }]

B [{ "_id": "apple", "firstQty": 7 }]

C [{ "_id": "apple", "firstQty": 10 }]

D [{ "_id": "apple", "firstQty": null }]

💡 Hint

Remember $first returns the value from the first document in the group after sorting.

The documents are sorted by date ascending, so the first document for 'apple' has qty 5. $first returns this value.

❓ query_result

intermediate

What does $last return in this aggregation?

Given the same sales collection as before, what is the output of:

db.sales.aggregate([
  { $match: { item: "apple" } },
  { $sort: { date: 1 } },
  { $group: {
      _id: "$item",
      lastQty: { $last: "$qty" }
  } }
])

MongoDB

db.sales.aggregate([
  { $match: { item: "apple" } },
  { $sort: { date: 1 } },
  { $group: {
      _id: "$item",
      lastQty: { $last: "$qty" }
  } }
])

A [{ "_id": "apple", "lastQty": 5 }]

B [{ "_id": "apple", "lastQty": 7 }]

C [{ "_id": "apple", "lastQty": 10 }]

D [{ "_id": "apple", "lastQty": null }]

💡 Hint

Think about the last document after sorting by date ascending.

After sorting by date ascending, the last document for 'apple' has qty 7, so $last returns 7.

📝 Syntax

advanced

Which aggregation stage correctly uses $first to get the earliest date?

You want to group documents by category and get the earliest date for each group. Which option is correct?

A { $group: { _id: "$category", earliestDate: { $first: "$dates" } } }

B { $group: { _id: "$category", earliestDate: { $first: { $date: "$date" } } } }

C { $group: { _id: "$category", earliestDate: { $first: "$category.date" } } }

D { $group: { _id: "$category", earliestDate: { $first: "$date" } } }

💡 Hint

Use the field name directly inside $first after sorting.

Option D correctly uses $first on the field "$date". Other options have invalid field references or syntax.

🔧 Debug

advanced

Why does this aggregation return null for $last?

Given this aggregation:

db.orders.aggregate([
  { $group: { _id: "$customer", lastOrder: { $last: "$orderDate" } } }
])

It returns lastOrder: null for all customers. Why?

MongoDB

db.orders.aggregate([
  { $group: { _id: "$customer", lastOrder: { $last: "$orderDate" } } }
])

A Because the documents are not sorted before grouping, so $last returns the last document in an unordered group, which can be null.

B Because the field name "orderDate" is misspelled or missing in documents.

C Because $last only works on arrays, not on fields.

D Because $last requires a $sort stage before $group to work correctly.

💡 Hint

Check if the field exists in the documents.

If the field "orderDate" does not exist or is misspelled, $last returns null. Sorting is not required but affects which document is last.

🧠 Conceptual

expert

How do $first and $last behave without a $sort stage?

In a MongoDB aggregation pipeline, if you use $first and $last inside a $group stage without a preceding $sort, what determines the values returned?

A $first and $last return values from documents in the natural order of the input collection, which is undefined and may vary.

B $first and $last always return the earliest and latest values by date automatically.

C $first returns the minimum value and $last returns the maximum value of the grouped field.

D $first and $last cause an error if $sort is not used before $group.

💡 Hint

Think about how MongoDB processes documents without explicit sorting.

$first and $last pick values from the first and last documents in the group as they appear in the input, which is not guaranteed without sorting.