C100DEV Aggregation Framework — Timed 15 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