C100DEV Practice Exam 4 — 20 Questions

Question 1

An inventory system stores each product's supplier as an embedded subdocument containing the supplier name, address, and contact email. The supplier's address changes frequently, and updates now require scanning and updating thousands of product documents. Which data modeling change best resolves this maintenance problem?

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

Accepted Answer

Convert the supplier subdocument to a reference by storing the supplier's ObjectId in the product document and keeping supplier details in a suppliers collection.. Referencing is appropriate when a subdocument represents a shared entity that changes independently of its parent. Keeping supplier details in their own collection means one update fixes every product, removes duplicate mutable data, and keeps product documents lean. Indexing the embedded field, versioning the schema, or archiving supplier history all leave the core duplication and mass-update cost in place.

Answer

Add an index on the embedded supplier.address field so updates to that field become faster.

Answer

Move the supplier subdocument into an array field so all supplier versions are retained for auditing.

Answer

Use the Schema Versioning Pattern by adding a version field to each product document and migrating documents lazily.

Question 2

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 3

A developer needs to ensure that a `users` collection does not contain two documents with the same email address. Which index type should be created on the `email` field?

Accepted Answer

A unique index. To prevent duplicate email addresses, a unique index on the email field is required. Unique indexes enforce that each value appears at most once. Other index types like sparse, partial, or hashed do not provide this guarantee. A unique index is the correct choice to maintain data integrity for the email field.

Answer

A sparse index

Answer

A partial index

Answer

A hashed index

Question 4

A developer is using mongosh to connect to a MongoDB Atlas cluster and needs to run several administrative commands. The developer wants to ensure that the connection uses the correct authentication database and that all commands are executed with the appropriate read preference. Which mongosh command-line option should be used to specify the authentication database?

Accepted Answer

--authenticationDatabase. In mongosh, the --authenticationDatabase option explicitly sets the database used for authentication. This is necessary when user credentials reside in a database other than the default (often admin). Other options like --db or --readPreference affect connection behavior but not authentication. Specifying the correct authentication database ensures that the provided username and password are validated against the intended database.

Answer

--readPreference

Answer

--username

Answer

--db

Question 5

A developer is working with a MongoDB collection that stores user profiles. The collection has an index on the `email` field. The developer runs a query to find a user by email and then examines the query plan using `explain()`. The output shows that the query used an `IXSCAN` stage. What does this indicate about the query execution?

Accepted Answer

The query used the index to find the matching documents without scanning the entire collection.. The `IXSCAN` stage in the explain output signifies that MongoDB used an index scan to retrieve the documents matching the query. This is the expected behavior when querying on an indexed field like `email`. It means the query did not perform a full collection scan, which would be indicated by `COLLSCAN`. Using an index allows MongoDB to efficiently locate the relevant documents, reducing the number of documents examined and improving query performance.

Answer

The query returned all documents from the collection because the index was not selective.

Answer

The query used the index to sort the results but still had to scan the collection to filter documents.

Answer

The query performed a collection scan because no suitable index was found.

Question 6

A developer is using the MongoDB Node.js driver to insert a document into a collection. The document includes a field `_id` set to a custom string value. After the insert, the developer checks the returned result and notices that the `insertedId` matches the custom string. What does this indicate about MongoDB's handling of the `_id` field?

Accepted Answer

MongoDB automatically generates an ObjectId for the `_id` field if it is not provided, but if provided, it must be unique within the collection.. The `_id` field is the primary key for MongoDB documents. If omitted, the driver generates an ObjectId; if provided, it can be any BSON type except an array, but it must be unique within the collection. MongoDB automatically creates a unique index on `_id`. The scenario confirms that a custom string was accepted and used as the `_id`, demonstrating this flexibility.

Answer

The `_id` field is always an ObjectId and cannot be overridden with a custom value.

Answer

The `_id` field is only unique per shard, not across the entire collection.

Answer

MongoDB automatically indexes the `_id` field only if it is an ObjectId.

Question 7

A developer maintains a collection of sensor readings. Queries almost always filter on `status` and then sort by `timestamp` descending. The current index is { status: 1, timestamp: 1 }. The developer observes that the query planner selects a COLLSCAN even though the index covers both fields. Which index change should be made to allow an efficient index scan for this query?

Accepted Answer

Create a new index { status: 1, timestamp: -1 } and drop the existing index.. The query combines an equality predicate on `status` with a descending sort on `timestamp`. Following equality-sort-range ordering, the equality field belongs first and the sort field must match the query direction, giving `{ status: 1, timestamp: -1 }`. That lets the planner walk the index in the requested order without a blocking sort, which is why the reversed or split alternatives fail.

Answer

Add a separate index { timestamp: -1 } and keep the existing compound index.

Answer

Create a new index { timestamp: -1, status: 1 } and drop the existing index.

Answer

Create a hashed index on `status` combined with `timestamp` to improve selectivity.

Question 8

A developer is designing a collection to store catalog items. Different item categories have different attributes: books have 'isbn' and 'pageCount', while electronics have 'wattage' and 'warrantyMonths'. All items share '_id', 'name', 'price', and 'category'. Which data modeling approach best fits this requirement?

Accepted Answer

Store all items in one collection and include only the attributes relevant to each item's category.. The Polymorphic pattern stores documents with a shared core plus category-specific fields in one collection. It supports queries across all items using common fields and queries within a category using the discriminator field. This is the natural fit when different document shapes share a meaningful set of fields and are queried together.

Answer

Create one collection per category, such as 'books' and 'electronics', and never query across them.

Answer

Normalize all attributes into a separate 'attributes' collection referenced by item documents.

Answer

Store all category-specific attributes in a single 'attributes' array of key-value pairs for every item.

Question 9

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 10

A developer is designing a MongoDB collection to store blog posts. Each post has a title, content, and an array of tags. The developer wants to ensure that the tags field is always an array of strings. Which BSON data type should be used for the tags field?

Accepted Answer

Array. MongoDB's document model supports arrays natively, allowing a field to hold multiple values. For a tags field that should contain multiple strings, the Array BSON type is the correct choice. It enables efficient querying (e.g., finding posts with a specific tag) and indexing (multikey indexes), and it aligns with the flexible schema design that MongoDB encourages.

Answer

Object

Answer

BinData

Answer

String

Question 11

A developer is using the MongoDB Node.js driver to perform a multi-document transaction that includes a read operation followed by a write operation. The developer wants to ensure that the read sees a consistent snapshot of the data and that the write is atomic with the read. Which of the following read concerns should be used for the read operation within the transaction?

Accepted Answer

snapshot. Within a multi-document transaction, the read concern must be 'snapshot' to ensure a consistent snapshot of the data for all operations in the transaction. This provides the required isolation and atomicity. Other read concerns like 'local', 'majority', or 'linearizable' do not provide the same guarantees within a transaction and may not be supported.

Answer

linearizable

Answer

local

Answer

majority

Question 12

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 13

A logistics application stores shipment records in a collection where each document has a numeric field `weight_kg`. Queries frequently filter on `weight_kg` with a range (e.g., between 50 and 200) and sort by `weight_kg` ascending. You create a standard ascending index on `weight_kg`. Which statement best describes the index's behavior for these queries?

Accepted Answer

The index can efficiently serve both the range filter and the ascending sort, avoiding an in-memory sort.. A single-field ascending index on a numeric field stores keys in sorted order. When a query filters on a range of that field and sorts ascending on the same field, MongoDB can scan the index range and return results in the requested order. This avoids an expensive blocking sort and leverages the index for both filtering and sorting, making it the optimal choice for such query patterns.

Answer

The index cannot be used for range queries on numeric fields because B-tree indexes are designed for equality matches only.

Answer

The index can support the range filter but cannot provide sorted results, so a blocking sort will be required.

Answer

The index will be used only if the range filter is selective enough; otherwise, MongoDB ignores it and performs a collection scan.

Question 14

A development team is building a MongoDB application to store user profiles. They want to enforce that every user document contains an 'email' field of type string, and they want documents that violate this rule to be rejected at insert time. Which MongoDB feature should they use?

Accepted Answer

JSON Schema validation with the $jsonSchema operator in the collection's validator option. MongoDB's JSON Schema validation allows developers to enforce a schema on a collection while still accommodating flexible fields. By defining a validator with $jsonSchema, the team can require the 'email' field and ensure it is a string. This provides server-side enforcement, ensuring that any insert or update that violates the schema is rejected, regardless of the client used.

Answer

Storing the email in a separate collection with a reference

Answer

Unique index on the 'email' field

Answer

Application-level validation using Mongoose schema definitions

Question 15

A product catalog must support thousands of products whose attributes differ significantly: books have ISBN and page count, electronics have wattage and warranty, and clothing has size and material. Queries frequently filter on these type-specific attributes. Which schema design best supports this requirement in MongoDB?

Accepted Answer

Use the Polymorphic Pattern by storing all products in one collection with a 'category' field and category-specific attributes in a shared subdocument.. The Polymorphic Pattern is designed for collections whose documents share some fields but differ in others. A discriminator like 'category' lets the application and indexes target category-specific attributes while keeping all products queryable in one place. Splitting into multiple collections, flattening to generic key-value pairs, or misapplying schema versioning all sacrifice either query simplicity or schema clarity that this catalog needs.

Answer

Use the Schema Versioning Pattern with a 'schema_version' field and store attributes in version-specific subdocuments.

Answer

Store all attributes in a single generic 'attributes' array of key-value pairs without a category field.

Answer

Create a separate collection for each product category and route queries based on category.

Question 16

A team is designing a MongoDB collection to store user profiles. Each profile document includes a `name` string, an `age` integer, and an array of `hobbies` strings. A new developer asks which BSON type is used to represent the `hobbies` field in the stored document. What is the correct BSON type for an array of strings?

Accepted Answer

Array. MongoDB documents are stored in BSON, which includes an Array type for ordered lists of values. A field like `hobbies` that contains multiple strings is represented as a BSON array of strings. This allows the database to index the array elements, query with operators like `$in` or `$elemMatch`, and update individual elements, making Array the correct and natural choice.

Answer

Binary data

Answer

Object

Answer

String

Question 17

A developer is working with a MongoDB collection that stores sensor readings. Each document has a 'sensorId' field and a 'readings' array containing numeric values. The developer creates an index on the 'readings' field. Which statement best describes the resulting index?

Accepted Answer

The index is a multikey index, and it contains an entry for each element in the readings array across all documents.. Indexing a field that holds an array causes MongoDB to create a multikey index, which stores one index entry for each element of the array in every document. This enables efficient queries that match individual array elements. The other options incorrectly describe the index structure or claim unsupported behavior. Understanding multikey indexes is fundamental for querying arrays efficiently.

Answer

The index stores a single entry per document representing the entire array, similar to a composite value.

Answer

The index is a sparse index automatically, excluding documents where the readings array is empty.

Answer

The index cannot be created because indexing an array field is not supported in MongoDB.

Question 18

A financial reporting system reads account documents that each contain a nested array of the last 90 daily balance snapshots. Analysts run aggregations that only need the current balance and account type, but the full snapshot array is being loaded on every read. Which schema pattern most directly reduces the working set size for these read-heavy analytics queries?

Accepted Answer

Subset Pattern, keeping only the most recent snapshots in the main document and archiving older ones in a separate collection.. The Subset Pattern is specifically designed for documents with a large array where only a small portion is accessed regularly. By retaining the frequently used snapshots in the main document and relocating the rest, the document shrinks, the working set fits more easily in RAM, and read-heavy analytics touch far less data while still returning the fields analysts require.

Answer

Schema Versioning Pattern, adding a version field so old documents can be migrated incrementally.

Answer

Computed Pattern, precomputing derived totals into new fields on the account document.

Answer

Bucket Pattern, grouping many accounts into a single document with shared metadata.

Question 19

A pipeline on a `sales` collection must return only the `item` and `price` fields for all documents where `price` is greater than 50, and it should not return the `_id` field. Which pipeline achieves this?

Accepted Answer

[ { $match: { price: { $gt: 50 } } }, { $project: { _id: 0, item: 1, price: 1 } } ]. The pipeline should filter with `$match` on `price` first, then use `$project` to include `item` and `price` while excluding `_id`. This returns only the requested fields for documents meeting the condition. Projecting before matching or using `$unset` does not satisfy the requirement to return only those two fields without `_id`.

Answer

[ { $project: { _id: 0, item: 1, price: 1 } }, { $match: { price: { $gt: 50 } } } ]

Answer

[ { $match: { price: { $gt: 50 } } }, { $project: { item: 1, price: 1 } } ]

Answer

[ { $match: { price: { $gt: 50 } } }, { $unset: ["_id", "department"] } ]

Question 20

A social platform stores user profiles in a 'users' collection and their posts in a 'posts' collection. Each post document embeds a small 'author' subdocument with 'userId', 'displayName', and 'avatarUrl'. A user changes their display name. The application must keep existing posts showing the new name. What is the most accurate statement about this Extended Reference design?

Accepted Answer

The change requires an update to the user document plus a multi-document update to every post embedding that author's duplicated fields.. Extended Reference embeds a small set of frequently accessed fields to avoid extra reads, accepting duplication as the cost. Because MongoDB does not synchronize fields across collections, any change to a duplicated field must be written to the source document and to every embedding document. The design is valid and useful, but the application owns consistency.

Answer

The design is invalid because embedding an author subdocument violates the rule that referenced data must never be duplicated.

Answer

The design guarantees strong consistency between the user document and all posts as long as both writes occur in a single transaction.

Answer

No propagation is needed because MongoDB automatically synchronizes duplicated fields across collections when the source document changes.