C100DEV Practice Test 10 — 10 Questions

Question 1

A developer is modeling a blog platform. Posts are read frequently, and each post has a small, bounded set of tags. The tags are always displayed with the post and are never queried independently across posts. The developer is deciding between embedding the tags as an array inside each post document versus storing them in a separate tags collection with references. Which design choice aligns with MongoDB document model guidance for this scenario?

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

Accepted Answer

Embed the tags as an array within each post document, since they are bounded, accessed together with the post, and not queried independently.. MongoDB document modeling favors embedding when related data is bounded, is retrieved together with its parent, and is not queried on its own. The tags described fit all three conditions, so embedding them as an array in each post yields single-read retrieval and avoids join overhead. A separate collection would only be justified if tags needed independent querying or unbounded growth.

Answer

Store tags both embedded in posts and in a separate collection, keeping them synchronized manually, to satisfy both read and write paths.

Answer

Store tags in a separate collection and use a $lookup aggregation in every read, because aggregation pipelines are the only way to combine related data.

Answer

Store tags in a separate collection and reference them from posts, because normalization always reduces duplication and improves read performance.

Question 2

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 3

A developer is working with a collection 'products' that has an index { category: 1, price: 1 }. They want to understand how MongoDB can use this index for queries that include a sort on price. Which TWO of the following statements are true regarding the use of this index for sorting? (Choose two.)

Accepted Answer

The index can support a sort on price descending if the query includes an equality condition on category, by scanning the index in reverse.. The index { category: 1, price: 1 } can support sorting on price when the query includes an equality condition on category, because then the index's price entries are contiguous and sorted. It can also support a descending sort by scanning the index in reverse. Without an equality condition on category, the index cannot provide a global sort on price because the leading field category varies.

Answer

The index can support a sort on price descending even if the query does not include any condition on category, because the index stores price in descending order when traversed in reverse.

Answer

The index can support a sort on price ascending if the query includes a range condition on category, such as { category: { $gt: 'A' } }.

Answer

The index can support a sort on price ascending even if the query does not include any condition on category.

Question 4

A developer is working with a MongoDB collection that stores product data. Each product document has a 'price' field. The developer needs to find all products with a price greater than 100 and less than 200. Which query operator should be used?

Accepted Answer

$gt and $lt. To find documents where a field falls within an exclusive range, MongoDB provides the $gt and $lt operators. Combining them in a single query object on the same field applies both conditions. This is a common pattern for range queries and is efficient when an index exists on the field. The other operators either include boundary values or are for different query types.

Answer

$gte and $lte

Answer

$and with $gt

Answer

$in

Question 5

A developer is designing a MongoDB collection to store user profiles. Each profile document includes fields for name, email, and an array of phone numbers. The developer wants to ensure that the email field is unique across all documents. Which MongoDB feature should be used to enforce this constraint?

Accepted Answer

Unique index on the email field. A unique index on the email field is the only reliable way to enforce uniqueness in MongoDB. It guarantees that no two documents can have the same email value, even under concurrent operations. Schema validation, sharding, and application-level checks cannot provide this guarantee. The unique index also speeds up queries that filter by email.

Answer

Sharding the collection on the email field

Answer

Schema validation with $jsonSchema

Answer

Application-level check before insert

Question 6

A developer is debugging a multi-document transaction in the MongoDB Node.js driver. The transaction updates a document in the `orders` collection and inserts into `audit`. The commit fails with a `WriteConflict` error that does not carry the `TransientTransactionError` label. What is the most appropriate action?

Accepted Answer

Inspect the error, resolve the conflict by re-reading or reordering operations, and retry the transaction with backoff.. A WriteConflict that lacks the TransientTransactionError label is not automatically retryable by the driver's standard loop. The developer must inspect the error and decide how to resolve the conflict, often by re-reading the latest document version or reordering operations, then retrying with backoff. Blindly retrying the commit or the whole transaction without addressing the cause is unlikely to succeed.

Answer

Retry the entire transaction from the beginning.

Answer

Retry only the commit operation with the same transaction number.

Answer

Abort the transaction and report a permanent failure to the user.

Question 7

A financial application has a collection `transactions` with fields `accountId`, `type`, `amount`, and `createdAt`. A query filters on `accountId` and `type`, sorts descending by `createdAt`, and projects only `_id` and `amount`. A developer creates the index `{ accountId: 1, type: 1, createdAt: -1 }`. Which statement best describes whether this index can support the query as a covered query?

Accepted Answer

It cannot be covered because the index lacks the `amount` field, so MongoDB must fetch documents to return `amount`.. A covered query requires that all fields used in the filter, sort, and projection exist in the index. Here the projected field `amount` is not part of the compound index, so MongoDB must fetch documents to return it. Neither excluding `_id` nor using `explain()` changes that; the index would need to include `amount`.

Answer

It can be covered if the query uses `explain()` with the `covered` option, which forces MongoDB to answer from the index.

Answer

It can be covered only if the projection explicitly excludes `_id`, because the index does not contain the `_id` field.

Answer

It is automatically covered because `_id` is always included in every index, so all projected fields are present.

Question 8

A collection 'orders' has a compound index { status: 1, customerId: 1, orderDate: -1 }. A developer runs a query: db.orders.find({ customerId: 'C123', status: 'shipped' }).sort({ orderDate: -1 }). Which statement about how MongoDB uses this index for the query is correct?

Accepted Answer

The index can be used for the equality filter on status and customerId, and it can also provide the sort on orderDate in descending order without an in-memory sort.. The compound index begins with status and customerId, both of which have equality conditions in the query. Since those fields are fixed, the index's remaining field orderDate is effectively ordered by its index direction. The query sorts by orderDate descending, matching the index direction, so MongoDB can use the index to satisfy both the filter and the sort without an in-memory sort stage.

Answer

The index cannot be used for this query because the query includes a sort on a field that is not the first field of the index.

Answer

The index can be used for the equality filter on status and customerId, but the sort on orderDate will require an in-memory sort because the index stores orderDate in ascending order only.

Answer

The index can be used for both the equality filter on status and customerId, but it cannot provide the sort order on orderDate because the sort field is not contiguous with the equality fields.

Question 9

A catalog stores products of many categories, each with different attributes: books have ISBN and author, while electronics have voltage and warrantyMonths. Queries always filter by category and then by category-specific attributes. Which schema approach best supports these queries?

Accepted Answer

Store products in one collection with a category field and category-specific fields present only where relevant, indexed appropriately.. Using one collection with a category discriminator and only the fields relevant to each category keeps documents compact and allows targeted indexes on the attributes used in filters. Queries that filter by category and then by category-specific fields are efficient. Padding with nulls, splitting into many collections, or using unpredictable keys all undermine those queries.

Answer

Store all products in one collection with a shared set of fields and use null for attributes that do not apply.

Answer

Store products in one collection with a single generic attributes subdocument whose keys vary unpredictably.

Answer

Store each category in its own separate collection with only that category's fields.

Question 10

You are building an aggregation pipeline that processes millions of documents. The pipeline includes a $match stage, a $group stage that calculates sums, and a $sort stage. You notice the pipeline is spilling to disk and running slowly. Which stage should you place first to optimize performance while maintaining correct results?

Accepted Answer

$match. The $match stage should be placed at the beginning of the pipeline to filter documents early, using indexes when possible. This reduces the volume of data passed to $group and $sort, lowering memory consumption and avoiding disk spills. It also maintains the correct aggregation logic by filtering before grouping and sorting.

Answer

$group

Answer

$sort

Answer

$project