C100DEV Aggregation Framework — 40 Questions

Question 1

Which THREE of the following are valid ways to limit the memory usage of an aggregation pipeline?

Accepted Answer

Use $match with an indexed field at the start.. Managing memory is vital, as aggregation operations exceeding 100MB fail unless allowDiskUse is enabled. Strategies include early filtering to reduce data, utilizing indexes for sorting, and projecting only necessary fields. These techniques minimize the amount of data the engine must hold in RAM, preventing spillover to disk and keeping query performance high, which is a core competency for developers building performant MongoDB-backed applications.

Answer

Increase the default memory limit to 5GB using setParameter.

Answer

Avoid using $unwind because it always duplicates data in memory.

Question 2

Which TWO of the following are true regarding the $match stage?

Accepted Answer

It can be used multiple times in a single pipeline.. The $match stage is the primary filter in the aggregation framework. When used correctly, it can utilize indexes to significantly prune the data stream, which is crucial for performance. It acts as a gatekeeper for subsequent stages, ensuring that only relevant documents are processed, which is a standard pattern for optimizing pipelines and reducing the total execution time for complex analytics tasks.

Answer

It must be the last stage in the pipeline.

Answer

It can only filter on the _id field.

Answer

It performs document-level transformations.

Question 3

You are aggregating a collection of orders. You need to calculate the total revenue per product, but only for orders placed in 2023. Which pipeline sequence is most efficient?

Accepted Answer

[$match: { date: /^2023/ }, $group: { ... }]. Filtering at the earliest possible stage using $match significantly reduces the number of documents passed to subsequent stages. By narrowing the dataset before performing expensive operations like $group, you minimize memory usage and CPU overhead. This pattern is critical for scalable aggregation, as it ensures that the accumulator functions only process the relevant subset of data, leading to faster query execution times and lower resource consumption.

Answer

[$group: { ... }, $match: { date: /2023/ }]

Answer

[$project: { ... }, $group: { ... }, $match: { ... }]

Answer

[$sort: { date: 1 }, $match: { ... }, $group: { ... }]

Question 4

Which TWO of the following statements regarding the $lookup stage are accurate?

Accepted Answer

$lookup always returns an array field in the output.. The $lookup stage performs a left outer join to another collection in the same database. Understanding its limitations is vital: it does not support sharded collections as the 'from' target in older versions, and it always outputs an array field, even if only one match is found. Using it correctly involves understanding that it is a blocking operation that requires sufficient RAM for the join process.

Answer

$lookup can join data across different databases.

Answer

The 'as' field in $lookup is optional.

Answer

$lookup does not support sub-queries.

Question 5

Refer to the exhibit. Which index would most effectively optimize this aggregation query?

Accepted Answer

{ category: 1 }. For an aggregation involving $group, an index on the grouping field ($category) allows the database to perform the group operation more efficiently by streaming sorted results. If the index matches the group key, the database can avoid a large blocking group operation in memory. In this case, indexing the 'category' field is the primary requirement for optimizing the grouping phase of this pipeline.

Answer

{ amount: 1 }

Answer

{ total: -1 }

Answer

{ category: 1, amount: 1 }

Question 6

Which THREE of the following are valid ways to handle missing or null fields in an aggregation pipeline?

Accepted Answer

Using $ifNull to provide a default value.. Handling schema variability is a common task in MongoDB. Using $ifNull allows for a fallback value, $match with $exists filters out unwanted records, and $project can conditionally add fields. These techniques ensure that aggregations do not fail or produce inaccurate results when dealing with heterogeneous collections where some documents may lack specific fields needed for calculation.

Answer

Using $group with $nullCount.

Answer

Using $sort to push nulls to the end.

Question 7

What is the primary difference between $project and $set stages in an aggregation pipeline?

Accepted Answer

$set is an alias for $addFields.. $project is intended to explicitly define the output document shape, allowing for the inclusion, exclusion, and transformation of fields. $set, however, is a convenience alias for $addFields, designed to add or modify fields without needing to explicitly redefine the entire document structure. This distinction is important for managing pipeline verbosity and ensuring that unexpected fields are not accidentally dropped during transformation steps.

Answer

$set is faster than $project.

Answer

$project requires defining all fields.

Answer

$project cannot perform calculations.

Question 8

Which approach is recommended to aggregate data across a sharded collection effectively?

Accepted Answer

Filtering by the shard key.. When aggregating over sharded collections, the aggregation framework attempts to push the initial stages to the shards to perform distributed processing. To be effective, the query must be 'targeted' or benefit from the cluster's architecture. By using local-shard aggregation, you minimize data movement across the network and leverage the parallel processing power of the individual shards, which is critical for maintaining performance in large-scale deployments.

Answer

Using allowDiskUse: true.

Answer

Using $lookup with a sharded collection.

Answer

Increasing the batch size.

Question 9

Which THREE of the following are true regarding the $facet stage?

Accepted Answer

It allows multiple sub-pipelines to run on the same input documents.. The $facet stage allows for executing multiple independent aggregation pipelines within a single stage. This is powerful for generating multi-dimensional reports or summary statistics in one trip to the database. It is important to remember that $facet introduces specific constraints, such as the 100MB RAM limit per stage, and cannot be used with certain operators that require external cursors, making it a powerful but potentially memory-intensive tool.

Answer

It can be used to join data from other collections.

Answer

The result set is limited by a 16MB document size limit.

Question 10

What happens if you omit the '_id' field in a $group stage?

Accepted Answer

The aggregation results in an error.. The '_id' field is mandatory in the $group stage. If you omit it, the aggregation pipeline will throw an error because the engine requires an identifier to determine which documents belong to which group. This identifier serves as the key for the grouping operation, allowing the engine to aggregate values correctly. Without it, the grouping logic cannot function, leading to a failed query execution.

Answer

The engine groups all documents into a single group.

Answer

The pipeline ignores the grouping and returns no data.

Answer

The engine groups by the first field in the document.

Question 11

You need to compute the average rating of products across an e-commerce catalog, but only include products that have received at least 5 reviews. Which aggregation pipeline stage sequence correctly accomplishes this filtering condition efficiently?

Accepted Answer

{ $match: { reviewCount: { $gte: 5 } } }, { $group: { _id: "$category", avgRating: { $avg: "$rating" } } }. Placing the $match stage before $group allows the query optimizer to push the filter down to the storage engine, drastically reducing the working set size before memory-intensive grouping operations execute. This pattern is fundamental to building high-performance aggregation pipelines in production systems, minimizing resource consumption.

Answer

{ $group: { _id: "$category", avgRating: { $avg: "$rating" }, count: { $sum: 1 } } }, { $match: { count: { $gte: 5 } } }

Answer

{ $project: { category: 1, rating: 1 } }, { $group: { _id: "$category", avgRating: { $avg: "$rating" } } }, { $match: { avgRating: { $gte: 5 } } }

Answer

{ $sort: { reviewCount: -1 } }, { $group: { _id: "$category", avgRating: { $avg: "$rating" }, minCount: { $min: "$reviewCount" } } }, { $match: { minCount: { $gte: 5 } } }

Question 12

A pipeline processes a collection of employees. The developer wants to add a new field named annualBonus that equals the employee's salary multiplied by 0.1, without removing any existing fields. Which stage accomplishes this?

Accepted Answer

$addFields with { annualBonus: { $multiply: ["$salary", 0.1] } }. The $addFields stage adds new fields to documents while keeping all existing fields intact. Using $multiply within the expression computes the bonus from the salary field. This stage is specifically designed for augmenting documents without reshaping them, making it the ideal choice for the described requirement.

Answer

$replaceRoot with { newRoot: { $mergeObjects: ["$$ROOT", { annualBonus: { $multiply: ["$salary", 0.1] } }] } }

Answer

$project with { annualBonus: { $multiply: ["$salary", 0.1] } } and all other fields set to 0

Answer

$set with { annualBonus: { $multiply: ["$salary", 0.1] } }

Question 13

A developer is using the $lookup stage to join an orders collection with a customers collection. The localField is customerId and the foreignField is _id. The pipeline must include only the customer's name and email from the joined documents, not the entire customer document. Which approach correctly shapes the joined data?

Accepted Answer

Use $lookup with a pipeline that includes $project to select only name and email from the foreign collection.. The pipeline form of $lookup allows embedding a sub-pipeline that can include $project to select only the required fields from the foreign collection. This shapes the joined data at the source, reducing the amount of data transferred and processed. It is the most efficient and correct method for including only specific fields from the joined documents.

Answer

Use $graphLookup to recursively join the collections and then filter fields with $project.

Answer

Use $lookup with localField and foreignField, then use $unwind and $replaceRoot to extract only name and email.

Answer

Use $lookup with localField and foreignField, then a subsequent $project stage to include only the desired fields from the joined array.

Question 14

A retail company stores orders in a collection where each document has a 'customerId' field, an 'items' array, and a 'status' field. A developer needs to produce a report that shows, for each customer, only the total number of items across all their orders that have status 'completed'. The 'items' array contains subdocuments with a 'qty' field. Which aggregation pipeline snippet correctly computes this?

Accepted Answer

db.orders.aggregate([ { $match: { status: 'completed' } }, { $group: { _id: '$customerId', totalItems: { $sum: { $sum: '$items.qty' } } } } ]). The correct pipeline filters completed orders first, then groups by customerId and sums the nested quantities. Using $sum with an inner $sum on the array field directly aggregates the quantities without expanding the array, which is efficient and accurate. The other options either filter after grouping, sum the wrong field, or use $unwind unnecessarily.

Answer

db.orders.aggregate([ { $group: { _id: '$customerId', totalItems: { $sum: { $size: '$items' } } } }, { $match: { status: 'completed' } } ])

Answer

db.orders.aggregate([ { $match: { status: 'completed' } }, { $unwind: '$items' }, { $group: { _id: '$customerId', totalItems: { $sum: '$items.qty' } } } ])

Answer

db.orders.aggregate([ { $match: { status: 'completed' } }, { $group: { _id: '$customerId', totalItems: { $sum: '$items' } } } ])

Question 15

An aggregation pipeline processes a collection of log entries. The developer needs to filter documents where the status field is "error" and then count the number of errors per service. Which sequence of stages correctly achieves this?

Accepted Answer

$match on { status: "error" }, then $group by service with $sum: 1. Filtering with $match before grouping is a best practice because it reduces the number of documents that the $group stage must process. Grouping by service and using $sum: 1 counts the errors per service. This sequence is both correct and efficient, leveraging early filtering to optimize pipeline performance.

Answer

$match on { status: "error" }, then $count by service

Answer

$group by service with $sum: 1, then $match on { status: "error" }

Answer

$project to include only service and status, then $match on { status: "error" }, then $group by service with $sum: 1

Question 16

You are building a pipeline over an `events` collection to compute, per `deviceId`, the count of events and the most recent `eventTime`. Documents may contain a `deviceId` of type string, but a subset of legacy documents store the identifier as an ObjectId in the same field. You want a single group key that treats both representations consistently by producing a string for every document. Which stage should you insert before $group?

Accepted Answer

{ $addFields: { deviceKey: { $toString: "$deviceId" } } }. Grouping on a field that holds multiple BSON types creates separate groups per type, because equality is type-sensitive. Inserting a stage that coerces the identifier to a single type, such as converting every value to a string with $toString, guarantees one group per real device. The conversion stage must precede $group so the accumulator sees normalized keys.

Answer

{ $addFields: { deviceKey: { $concat: [ "$deviceId", "" ] } } }

Answer

{ $project: { deviceKey: { $ifNull: [ "$deviceId", "unknown" ] } } }

Answer

{ $addFields: { deviceKey: { $convert: { input: "$deviceId", to: "string" } } } }

Question 17

A pipeline processes a collection of financial transactions. The developer needs to calculate the cumulative sum of `amount` for each account, ordered by `date`, and output only the final cumulative sum and account ID. Which pipeline correctly computes the running total?

Accepted Answer

$sort by accountId and date, then $group with { _id: "$accountId", cumulativeSum: { $sum: "$amount" } } is not correct; the correct approach uses $setWindowFields with partitionBy and sortBy, and an accumulator.. Cumulative sums require window functions. The $setWindowFields stage can partition data by accountId, sort by date, and compute a running sum using a window that includes all previous documents. Options using $group only produce final totals, not running totals, so they are incorrect.

Answer

$sort by accountId and date, then $group with { _id: "$accountId", cumulativeSum: { $sum: "$amount" } }, then $project with { cumulativeSum: 1 }

Answer

$sort by accountId and date, then $group with { _id: "$accountId", amounts: { $push: "$amount" } }, then $project with { cumulativeSum: { $sum: "$amounts" } }

Answer

$sort by accountId and date, then $group with { _id: "$accountId", cumulativeSum: { $sum: "$amount" } }

Question 18

A developer is building an aggregation pipeline that processes a large collection of financial transactions. The pipeline includes a $group stage that accumulates sums and averages, and a $sort stage that orders results by total amount. Which two statements about memory usage and optimization are correct? (Choose two.)

Accepted Answer

The $group stage can exceed the 100 MB memory limit and will error unless allowDiskUse is enabled.. The $group stage is memory-intensive and can exceed the 100 MB limit, requiring allowDiskUse to spill to disk. Placing a $match before $group reduces the number of documents processed, lowering memory usage. These two statements correctly describe memory optimization techniques for aggregation pipelines with large datasets.

Answer

The $sort stage is always executed before $group regardless of pipeline order to optimize performance.

Answer

The $group stage automatically spills to disk when it exceeds 100 MB, so no configuration is needed.

Answer

The $sort stage can use an index if it is the first stage in the pipeline and the sort field is indexed.

Question 19

A retail company stores sales in a collection named sales with documents containing fields: storeId (string), amount (double), and saleDate (date). A developer needs to produce a report that shows, for each store, the total sales amount and the number of transactions, but only for transactions with amount greater than 100. Which aggregation pipeline correctly computes this?

Accepted Answer

db.sales.aggregate([ { $match: { amount: { $gt: 100 } } }, { $group: { _id: "$storeId", totalAmount: { $sum: "$amount" }, count: { $sum: 1 } } } ]). The correct pipeline uses $match early to filter individual transactions with amount greater than 100, then $group to compute total amount and count per store. This approach is efficient and produces the desired report. Other options either filter after grouping (which loses the amount field), add unnecessary stages, or apply the wrong filter condition.

Answer

db.sales.aggregate([ { $group: { _id: "$storeId", totalAmount: { $sum: "$amount" }, count: { $sum: 1 } } }, { $match: { totalAmount: { $gt: 100 } } } ])

Answer

db.sales.aggregate([ { $group: { _id: "$storeId", totalAmount: { $sum: "$amount" }, count: { $sum: 1 } } }, { $match: { amount: { $gt: 100 } } } ])

Answer

db.sales.aggregate([ { $match: { amount: { $gt: 100 } } }, { $group: { _id: "$storeId", totalAmount: { $sum: "$amount" }, count: { $sum: 1 } } }, { $project: { storeId: "$_id", totalAmount: 1, count: 1, _id: 0 } } ])

Question 20

A collection `employees` contains documents with fields `name`, `department`, and `skills` where `skills` is an array of strings. You need to produce a document for each employee that contains only `name` and the number of skills, with the count field named `skillCount`. Which aggregation stage and expression should you use?

Accepted Answer

{ $project: { _id: 0, name: 1, skillCount: { $size: "$skills" } } }. The `$project` stage can reshape documents by including `name`, excluding `_id`, and adding a computed field. To count the elements of the `skills` array, the correct expression is `$size`, which returns the array length. Other operators either are not valid in `$project` or return a single element rather than the count.

Answer

{ $project: { _id: 0, name: 1, skillCount: { $count: "$skills" } } }

Answer

{ $project: { _id: 0, name: 1, skillCount: { $arrayElemAt: ["$skills", 0] } } }

Answer

{ $project: { _id: 0, name: 1, skillCount: { $sum: "$skills" } } }