C100DEV Practice Test 5 — 10 Questions

Question 1

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?

Choose an answer to begin — your selection is scored in the full session.

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 2

A logistics application stores shipment documents in the 'shipments' collection. Each document has a 'packages' array of embedded subdocuments, each with a 'trackingCode' field. A developer needs to remove only the embedded subdocument whose 'trackingCode' equals 'TRK-9981' from the document with '_id' 42, leaving all other packages untouched. Which update operation should be used?

Accepted Answer

db.shipments.updateOne({ _id: 42 }, { $pull: { packages: { trackingCode: "TRK-9981" } } }). The $pull operator deletes array elements that match a specified condition or value, which is exactly what removing a single embedded subdocument by its trackingCode requires. $pop and $pullAll operate positionally or on exact element values and cannot target a nested field match, while $unset would leave a null placeholder instead of deleting the element.

Answer

db.shipments.updateOne({ _id: 42 }, { $pullAll: { packages: ["TRK-9981"] } })

Answer

db.shipments.updateOne({ _id: 42, "packages.trackingCode": "TRK-9981" }, { $unset: { "packages.$": "" } })

Answer

db.shipments.updateOne({ _id: 42 }, { $pop: { packages: 1 } })

Question 3

A social media application stores user posts. Each post document currently embeds a comments array. A single popular post can accumulate over 50,000 comments, causing the document to grow beyond 10 MB. The development team wants to avoid hitting the 16 MB document size limit while still being able to retrieve a post with its most recent 10 comments in a single query. Which schema design should they implement?

Accepted Answer

Keep the most recent 10 comments embedded in the post document and store older comments in a separate comments collection.. The Subset Pattern is ideal when a document contains a large array that grows indefinitely. By embedding only the most recent 10 comments, the post document remains small and the application can still fetch the post with its recent comments in one read. Older comments are stored separately, preserving access to historical data without bloating the main document.

Answer

Move all comments into a separate comments collection and store an array of comment _ids in the post document.

Answer

Use a capped collection for the posts collection to automatically limit document size.

Answer

Convert the comments array into a GridFS bucket and store the file reference in the post document.

Question 4

A financial analytics team stores daily stock snapshots as one document per symbol per day in a collection named 'prices'. Each document contains an array of 60 subdocuments, one per minute, with fields 'minute', 'open', 'close', and 'volume'. The team now needs to compute the hourly average 'close' for a single symbol over a single day. Which aggregation approach is most appropriate for this schema?

Accepted Answer

Use $unwind on the minute array, then group by an expression that truncates 'minute' to the hour and average 'close'.. The data is stored in buckets, so per-minute analysis requires expanding the embedded array before grouping. $unwind emits one document per array element, and a subsequent $group can bucket by a truncated hour value and compute the average 'close'. This preserves the storage benefits of embedding while still enabling fine-grained aggregation over the measurements.

Answer

Run a $match for the symbol and day, then use $replaceRoot with the minute array to promote each element.

Answer

Use $group with $push to collect all 'close' values into an array, then apply $avg to the array.

Answer

Create a separate collection with one document per minute and migrate the data, then aggregate over it.

Question 5

A development team is designing a schema for an e-commerce application that stores product data. Products have a set of core fields (name, price, description) that are common to all products, but different product categories have unique attributes (e.g., 'screen_size' for electronics, 'fabric' for clothing). Queries often filter on these category-specific attributes. The team wants a flexible schema that supports efficient queries on any attribute. Which TWO of the following design approaches are most appropriate? (Choose two.)

Accepted Answer

Use the Polymorphic Pattern to store all products in one collection with a 'category' field and include category-specific fields at the top level.. The Polymorphic Pattern allows a single collection to store documents with different structures, while the Attribute Pattern converts variable attributes into an indexable array of key-value pairs. Together, they provide a flexible schema that supports efficient queries on any category-specific attribute. Both patterns are widely used in MongoDB for handling heterogeneous data and are appropriate here.

Answer

Use the Bucket Pattern to group products by category into buckets of 100 documents.

Answer

Embed all possible category-specific attributes in every product document, using null for missing attributes.

Answer

Create a separate collection for each product category with its own schema and indexes.

Question 6

A team is modeling orders and customers. Orders are frequently displayed with basic customer details such as name and email, but customer profiles are large and change often. Which approach best balances read performance with avoiding duplication problems?

Accepted Answer

Embed a small subset of frequently accessed customer fields in the order while keeping the full profile in the customers collection.. A selective embedding of only the fields commonly shown with orders keeps those reads fast and self-contained, while the authoritative, larger profile stays in its own collection to avoid widespread duplication. This balances read locality with manageable update cost. The other choices either over-duplicate volatile data or force a lookup on every read.

Answer

Embed the entire customer profile document inside every order.

Answer

Normalize customers and orders into separate collections with no duplicated fields and use $lookup for every read.

Answer

Store only a customerId reference in each order and always perform an application-side join.

Question 7

A developer is troubleshooting a Python application that uses the MongoDB driver to query the 'products' collection with find({'category': 'tools'}). Which two statements about the returned cursor are correct? (Choose two.)

Accepted Answer

The cursor automatically closes when it is exhausted, but must be closed explicitly if iteration stops early.. Cursors are lazy and fetch documents in batches during iteration, and they close automatically when exhausted but require explicit close() if iteration stops early. They do not eagerly load all matches, do not automatically re-execute on concurrent writes, and do not guarantee any result order without an explicit sort. These properties affect both memory use and server resource management.

Answer

The cursor loads all matching documents into client memory immediately when find is called.

Answer

The cursor returns documents in an order guaranteed by the storage engine, so no explicit sort is needed.

Answer

The cursor is invalidated and re-executed automatically whenever the underlying collection is modified by another client.

Question 8

An analyst needs a pipeline that reads from a `sales` collection and, for each document, emits one output document per entry in the `regions` array, copying all other fields unchanged. Which stage accomplishes this?

Accepted Answer

{ $unwind: "$regions" }. Expanding an array into individual documents is the job of $unwind, which emits one document per element and replicates the non-array fields. It requires an array path; other stages either reduce document count, replace the whole document, or merely reshape fields without altering cardinality.

Answer

{ $group: { _id: "$regions" } }

Answer

{ $project: { regions: 1 } }

Answer

{ $replaceRoot: { newRoot: "$regions" } }

Question 9

You are optimizing a collection containing user logs. Queries frequently filter by 'category' and sort by 'timestamp' in descending order. Which index configuration best supports these queries while maintaining efficiency?

Accepted Answer

{ category: 1, timestamp: -1 }. The ESR rule suggests placing Equality fields before Sort fields. By indexing { category: 1, timestamp: -1 }, MongoDB can filter by category and then traverse the index in the order specified for sorting. This eliminates the need for an in-memory sort stage, which is crucial for performance as the result set grows. Efficient index usage directly reduces memory consumption and prevents expensive blocking operations on the primary node.

Answer

{ category: 1 }

Answer

{ timestamp: -1, category: 1 }

Answer

{ timestamp: -1 }

Question 10

Refer to the exhibit. You are implementing the Subset Pattern for a user profile that tracks recent orders. As the number of orders per user grows indefinitely, which strategy prevents the 'unbounded array' anti-pattern?

Accepted Answer

Keep only the 10 most recent orders in the array and offload older orders to a separate collection.. The Subset Pattern is designed to keep the most relevant data in the primary document while moving the bulk of historical data to a separate collection. By storing only the most recent orders in the array, you prevent the document from exceeding the 16MB limit and ensure that high-frequency read operations remain performant, as smaller documents yield better cache utilization in the WiredTiger engine.

Answer

Move all orders to a separate collection and reference them by ID in the user document.

Answer

Increase the maximum document size limit to accommodate the growing order array.

Answer

Use a capped collection for the orders array to automatically drop old orders.