C100DEV Practice Test 8 — 10 Questions

Question 1

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?

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

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 2

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 3

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 4

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 5

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 6

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 7

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 8

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 9

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 10

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.