C100DEV Aggregation Framework Practice Test 4 — 15 Questions

Question 1

When using the $lookup stage, what happens if the 'foreignField' contains values that are not present in the 'localField' of the joined collection?

Accepted Answer

The result field contains an empty array for those documents.. The $lookup operator acts as a left outer join. If there is no match in the foreign collection for a given document, the resulting array field will simply be empty. This behavior is standard for left outer joins, ensuring that no source documents are dropped from the result set simply because they lack a corresponding record in the joined collection, preserving the integrity of the primary dataset.

Answer

The entire document is dropped from the pipeline result.

Answer

The database throws an error and the aggregation fails.

Answer

The result field is set to null.

Question 2

Which stage would you use to limit the output of your aggregation to the top 10 most expensive items?

Accepted Answer

$sort followed by $limit. To achieve this, you must first sort the data by price in descending order using the $sort stage, and then use the $limit stage to capture only the first 10 documents. This is a common pattern in reporting. Getting the order of these stages correct is vital, as limiting before sorting would produce arbitrary results rather than the correct top 10 based on value.

Answer

$limit

Answer

$match followed by $limit

Answer

$group followed by $limit

Question 3

What is the purpose of the $merge stage in an aggregation pipeline?

Accepted Answer

To write results into a collection, optionally updating existing documents.. The $merge stage is used to output the aggregation result to a collection, allowing for upserts and merging data into an existing collection. Unlike $out, which replaces the entire collection, $merge provides greater flexibility for incremental updates. This makes it ideal for maintaining materialized views or updating existing summary tables with new data without the performance cost of rewriting the entire target collection from scratch.

Answer

To filter the pipeline based on multiple conditions.

Answer

To replace the entire contents of a collection with new results.

Answer

To sort the final output before it is returned to the client.

Question 4

Which aggregation operator is most appropriate for counting the total number of documents in a collection?

Accepted Answer

$count. The $count stage is a specialized aggregation stage that returns a document containing the number of input documents at that point in the pipeline. It is shorthand for a $group stage with a $sum accumulator. Using $count is more readable and concise than building a manual $group stage, making it the best practice for simple document counting tasks within an aggregation pipeline.

Answer

$group with $sum

Answer

$limit

Answer

$match

Question 5

Refer to the exhibit. What happens to documents in the collection that do not contain the 'category' field?

Accepted Answer

They are assigned to a group with _id: null.. When grouping by a field, MongoDB treats missing fields or null values as having the value 'null'. Therefore, all documents lacking a 'category' field will be grouped together under the ID 'null'. This behavior is consistent and ensures no documents are silently dropped during a $group operation, allowing developers to identify and handle data quality issues where mandatory fields might be missing from certain records.

Answer

They are excluded from the results.

Answer

The aggregation throws an error.

Answer

They are grouped individually as unique documents.

Question 6

What is the primary benefit of using an index with the $match stage at the beginning of an aggregation pipeline?

Accepted Answer

It enables the engine to quickly select a subset of documents.. When an aggregation pipeline starts with a $match stage, MongoDB can utilize indexes to filter the collection before processing any further stages. This drastically reduces the number of documents loaded into memory, which is the most effective way to optimize pipeline performance. Without index usage, MongoDB must perform a collection scan, which is significantly slower as the dataset grows, making index usage essential for production applications.

Answer

It guarantees that the output documents are sorted.

Answer

It allows the pipeline to bypass the 100MB RAM limit.

Answer

It automatically formats the output fields.

Question 7

Which stage is used to change the order of documents in an aggregation pipeline?

Accepted Answer

$sort. The $sort stage is the standard operator for ordering the documents in a pipeline based on specified fields. It supports both ascending and descending order. Proper sorting is a requirement for many other stages, such as $limit or $group, when those stages rely on the order of input data to produce correct or expected results in a deterministic manner.

Answer

$order

Answer

$match

Answer

$project

Question 8

Refer to the exhibit. What is the expected behavior if the 'price' field exists but the 'tax' field is missing in a document?

Accepted Answer

It returns a null value for the 'result' field.. In MongoDB, arithmetic expressions like $add treat missing fields as null. When any input in an arithmetic expression is null, the result of the entire expression is null. Consequently, the 'result' field will be set to null for those documents. This behavior is intentional to alert developers to incomplete data and requires explicit handling, such as using $ifNull, to ensure valid calculations are produced when expected data might be missing.

Answer

It treats the missing field as 0 and returns the price.

Answer

The operation throws an error due to the missing field.

Answer

It ignores the price and returns a value of 0.

Question 9

An application requires grouping orders by customer ID and calculating the total purchase amount per customer. However, some customers have orders with missing or null purchase amounts that must be excluded before calculation. Which aggregation pipeline stage sequence correctly achieves this goal?

Accepted Answer

{ $match: { purchaseAmount: { $ne: null } } }, { $group: { _id: "$customerId", total: { $sum: "$purchaseAmount" } } }. Filtering out documents with null or missing purchase amounts using the $match stage ensures that subsequent grouping operations do not process corrupted or incomplete data. Placing $match before $group also allows MongoDB to utilize indexes on the purchaseAmount field, significantly improving aggregation performance on large collections.

Answer

{ $group: { _id: "$customerId", total: { $sum: "$purchaseAmount" } } }, { $match: { purchaseAmount: { $ne: null } } }

Answer

{ $project: { customerId: 1, purchaseAmount: 1 } }, { $group: { _id: "$customerId", total: { $sum: "$purchaseAmount" } } }

Answer

{ $sort: { purchaseAmount: 1 } }, { $group: { _id: "$customerId", total: { $sum: "$purchaseAmount" } } }

Question 10

An analytics collection contains order documents with an array of items. You need to output a single document for each element in the items array while preserving documents that have an empty or missing items array. Which stage configuration achieves this?

Accepted Answer

{ $unwind: { path: "$items", preserveNullAndEmptyArrays: true } }. Using the preserveNullAndEmptyArrays option within the $unwind stage ensures that parent documents lacking the target array or containing empty arrays are not dropped from the pipeline result set. This behavior is essential when performing left outer joins or maintaining complete statistical counts across documents with optional nested arrays.

Answer

{ $unwind: "$items" }, { $match: { items: { $exists: false } } }

Answer

{ $project: { items: { $ifNull: ["$items", [null]] } } }, { $unwind: "$items" }

Answer

{ $lookup: { from: "items", localField: "itemId", foreignField: "_id", as: "items", preserveNullAndEmptyArrays: true } }

Question 11

A developer is building an aggregation pipeline on a collection of sensor readings. The pipeline must group documents by sensorId and compute two values: the total number of readings and the timestamp of the most recent reading. Which $group accumulator pair should be used?

Accepted Answer

{ $sum: 1 } and { $max: "$timestamp" }. Counting documents in a group requires an accumulator that increments per document, and $sum with a literal 1 achieves this. To retrieve the most recent reading, $max on the timestamp field returns the highest timestamp value in each group. These two accumulators satisfy both requirements in a single $group stage without needing an extra sort.

Answer

{ $count: 1 } and { $last: "$timestamp" }

Answer

{ $sum: "$timestamp" } and { $max: "$timestamp" }

Answer

{ $size: 1 } and { $max: "$timestamp" }

Question 12

A retail company stores orders in a collection where each document has a `customerId` field and a `total` field. The analytics team needs to see, for each customer, both the sum of all order totals and a list of the individual order totals. Which aggregation pipeline stage and accumulator combination should be used?

Accepted Answer

$group with { _id: "$customerId", totalSum: { $sum: "$total" }, totals: { $push: "$total" } }. The $group stage groups documents by customerId, and within it, $sum calculates the total of all total fields while $push collects each total into an array. This yields one document per customer containing both the sum and the list of individual totals, meeting the analytics requirement without extra stages that would alter the output shape.

Answer

$project with { customerId: 1, totalSum: { $sum: "$total" }, totals: { $push: "$total" } }

Answer

$group with { _id: "$customerId", totalSum: { $sum: "$total" }, totals: { $addToSet: "$total" } }

Answer

$group with { _id: "$customerId", totalSum: { $sum: "$total" }, totals: { $push: "$total" } } followed by $unwind on totals

Question 13

You maintain a MongoDB collection named `readings` that stores hourly sensor measurements. Each document includes a `sensorId` string, a `recordedAt` date, and a `temperature` numeric value. You need to produce a report that, for each sensor, lists the sensor identifier alongside the timestamp of its single highest temperature reading. Duplicate temperatures are possible, and in that case any one of the tied readings is acceptable. Which aggregation pipeline should you run?

Accepted Answer

db.readings.aggregate([ { $sort: { sensorId: 1, temperature: -1 } }, { $group: { _id: "$sensorId", recordedAt: { $first: "$recordedAt" }, temperature: { $first: "$temperature" } } } ]). Selecting the top record per group requires ordering the input before the grouping stage, because accumulators such as $first operate on the incoming document stream order. Sorting by the group key and then by the ranking field descending guarantees the desired record arrives first for each group, letting $first extract both the timestamp and the measurement together.

Answer

db.readings.aggregate([ { $group: { _id: "$sensorId", temperatures: { $push: "$temperature" }, times: { $push: "$recordedAt" } } }, { $sort: { temperatures: -1 } } ])

Answer

db.readings.aggregate([ { $sort: { temperature: -1 } }, { $group: { _id: "$sensorId", recordedAt: { $last: "$recordedAt" }, temperature: { $last: "$temperature" } } } ])

Answer

db.readings.aggregate([ { $group: { _id: "$sensorId", recordedAt: { $first: "$recordedAt" }, temperature: { $first: "$temperature" } } }, { $sort: { temperature: -1 } } ])

Question 14

A developer needs to calculate the total revenue per product category from a sales collection. The collection has documents with fields `category` and `amount`. Which aggregation pipeline stage should be used to compute the sum of amounts for each category?

Accepted Answer

$group. The $group stage is designed to group documents by a key and apply accumulators like $sum to compute aggregate values. By grouping on category and summing amount, the pipeline yields total revenue per category. Other stages like $project, $match, or $sort do not perform cross-document aggregation, so they cannot produce the required totals.

Answer

$match

Answer

$sort

Answer

$project

Question 15

A support team stores tickets in a `tickets` collection where each document has a `status` field that may be missing on legacy records. A developer runs a pipeline whose first stage is { $match: { status: { $ne: "closed" } } } and expects every non-closed ticket to appear in the results. Which set of documents does this stage pass downstream?

Accepted Answer

Only documents where status exists and is not equal to "closed".. Comparison operators in an aggregation $match evaluate against existing field values. When a field is absent, a comparison to a string such as $ne "closed" cannot be satisfied, so those documents are filtered out. To retain them, the pipeline would need an explicit $or clause testing for field absence or null alongside the inequality.

Answer

All documents, because $match only removes documents when a field is explicitly set to null.

Answer

Documents where status exists and equals "closed", because $ne inverts the comparison during aggregation.

Answer

Documents where status is not "closed", including documents where the field is absent.