C100DEV Multiple Select — 10 Questions

Question 1

Which TWO of the following scenarios are best suited for using the 'Subset Pattern' in MongoDB?

Accepted Answer

A blog post collection where you display the last 5 comments on the main view.. The Subset Pattern is used to prevent documents from growing too large while keeping frequently accessed data local. By embedding only the most important subset of child documents (e.g., the five most recent comments) and referencing the rest, you balance read performance with document size management. This is essential for maintaining consistent performance levels as datasets scale, ensuring that the working set remains efficient for typical user queries.

Answer

A shopping cart collection where items are added and removed constantly.

Answer

A product catalog where you need to filter by over 100 different categories.

Answer

An audit log collection where every action must be stored for compliance.

Question 2

Which TWO of the following scenarios are optimal for using the Embedding pattern instead of Referencing?

Accepted Answer

A user document containing the user's primary shipping address.. Embedding is preferred when data is accessed together or exhibits a 'contains' relationship, minimizing round trips. It is ideal for one-to-few relationships. Conversely, Referencing is better for large, unbounded datasets or many-to-many relationships. Understanding these trade-offs is critical for MongoDB developers to minimize I/O and maximize the efficiency of read operations, as embedded documents are retrieved in a single read operation by the database engine.

Answer

A blog post containing a list of comments that grows indefinitely.

Answer

A product catalog with millions of items linked to various categories.

Answer

A sensor data stream that stores millions of readings per hour.

Question 3

A developer is reviewing the characteristics of MongoDB documents. Which two of the following statements are accurate? (Choose two.)

Accepted Answer

Each document must have a unique _id field, which can be of any BSON data type except an array.. The maximum BSON document size is 16 MB, and every document must have a unique _id field that can be any BSON type except an array. Documents in a collection need not share the same fields, they are stored in BSON not JSON, and field names cannot contain null characters.

Answer

Documents are stored in a human-readable JSON format on disk.

Answer

Field names in a document can contain the null character.

Answer

Documents in the same collection must have the same set of fields.

Question 4

An application using the MongoDB Node.js driver must ensure that a multi-document transaction is retried correctly when it encounters a transient error. Which two practices are required? (Choose two.)

Accepted Answer

On a commit error with the UnknownTransactionCommitResult label, retry the commit operation.. The Node.js driver exposes error labels that tell the application how to recover. A TransientTransactionError requires restarting the entire transaction, while UnknownTransactionCommitResult requires retrying the commit. These two behaviors are the documented retry pattern for multi-document transactions. Other options either misplace read concern, misunderstand the lifetime limit or weaken durability without addressing retries.

Answer

Increase the transaction lifetime limit beyond 60 seconds to avoid all retries.

Answer

Set the readConcern to 'snapshot' on every individual operation inside the transaction.

Answer

Disable write concern to make commits faster and reduce retries.

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 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 7

A development team is designing a schema for a chat application where each conversation contains messages that grow continuously. Messages are read in chronological order, and the application must display the most recent 50 messages quickly while retaining the full history. Which TWO design decisions best support these requirements? (Choose two.)

Accepted Answer

Embed only the most recent 50 messages in the conversation document and store the full history in a separate collection.. The requirements split into two needs: fast access to recent messages and complete retention of history. Referencing messages in a dedicated collection with an indexed timestamp satisfies retention and efficient recent-message queries, while the Subset Pattern's bounded embedded window gives the fastest possible read for the latest 50. Together they keep conversation documents small and preserve the full message log without hitting the 16MB limit.

Answer

Store each message as its own document in the conversations collection using a message-specific discriminator field.

Answer

Embed messages in the conversation document and rely on the 16MB limit to naturally cap growth.

Answer

Store all messages in a single capped collection so older messages are automatically overwritten.

Question 8

A developer is designing a MongoDB collection to store blog posts. Each post document includes an array of comments, and each comment has fields such as 'author', 'text', and 'timestamp'. The developer wants to optimize for queries that retrieve posts along with their comments, and also wants to ensure that comments are stored efficiently. Which two of the following statements are true regarding the document model in this scenario? (Choose two.)

Accepted Answer

Embedding comments as an array within the post document allows retrieving the post and its comments in a single query.. Embedding comments within the post document allows retrieving the post and comments in one query, which is efficient for read-heavy access patterns. However, the 16MB document size limit must be considered if comments grow unbounded. The other statements are either incorrect or not directly related to the document model design in this scenario.

Answer

Storing comments in a separate collection and referencing them from the post document reduces data duplication.

Answer

Embedding comments always improves write performance because it requires only a single document update.

Answer

Using the $slice operator in a query can limit the number of comments returned from an embedded array.

Question 9

A developer is working with a MongoDB collection that stores user profiles. The collection has a unique index on `email` and a compound index on `{ lastName: 1, firstName: 1 }`. The developer needs to enforce that no two documents have the same combination of `tenantId` and `username`. Which TWO of the following statements are correct regarding the creation and behavior of a unique compound index for this requirement? (Choose two.)

Accepted Answer

Creating a unique compound index on `{ tenantId: 1, username: 1 }` enforces uniqueness across the combination of both fields, not on each field individually.. A unique compound index on `{ tenantId: 1, username: 1 }` enforces uniqueness on the combination of both fields, not on either field alone. If existing duplicates are present, the index build will fail until they are resolved or excluded via a partial filter expression. The index is not sparse by default, does not enforce prefix uniqueness, and is created with `createIndex`, not `collMod`.

Answer

The unique compound index will also enforce uniqueness on `tenantId` alone, because the first field of a compound index is treated as a separate unique key.

Answer

Creating the unique compound index requires the `collMod` command to be run first on the collection to enable unique constraints.

Answer

A unique compound index automatically becomes a sparse index, so documents missing either `tenantId` or `username` are excluded from the uniqueness constraint.

Question 10

A team is modeling a schema for an order-processing system that must support atomic updates across an order and its line items and must guarantee that reading an order never returns a partially updated set of line items. (Choose two.)

Accepted Answer

Store line items in a separate collection and use a multi-document transaction spanning the order and its items.. Atomic updates and no-partial-read guarantees come from either keeping related data in one document, where MongoDB's single-document atomicity applies, or wrapping separate documents in a multi-document transaction with snapshot isolation. References and read concern settings do not by themselves provide cross-document atomicity, and capped collections are unrelated to the requirement.

Answer

Enable majority read concern on the order collection, which by itself guarantees that line-item updates are applied atomically.

Answer

Store line items in a separate collection and rely on the order's '_id' reference to enforce atomic updates across documents.

Answer

Use a capped collection for line items so older writes are overwritten and consistency is maintained.