C100DBA Practice Test 8 — 10 Questions

Question 1

A retail application stores product documents in the `products` collection. Each document has an `inventory` array of embedded subdocuments, for example: `{ _id: 1, name: "Widget", inventory: [ { sku: "A1", qty: 5 }, { sku: "B2", qty: 8 } ] }`. The warehouse team needs to increase the `qty` of the subdocument with `sku: "B2"` by 3 for the product with `_id: 1`. Which update operation accomplishes this?

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

Accepted Answer

db.products.updateOne( { _id: 1, "inventory.sku": "B2" }, { $inc: { "inventory.$.qty": 3 } } ). The positional `$` operator updates the first array element that matches the query condition. Pairing `"inventory.sku": "B2"` in the filter with `"inventory.$.qty"` in the update ensures only the subdocument with that SKU is modified. Using `$inc` performs the required arithmetic and preserves the numeric field type, which is essential for inventory counts.

Answer

db.products.updateOne( { _id: 1, "inventory.sku": "B2" }, { $inc: { "inventory.0.qty": 3 } } )

Answer

db.products.updateOne( { _id: 1, "inventory.sku": "B2" }, { $set: { "inventory.$.qty": "3" } } )

Answer

db.products.updateOne( { _id: 1 }, { $inc: { "inventory.qty": 3 } } )

Question 2

A startup is building a mobile app backend. They want to iterate quickly on features without downtime for schema changes. Which MongoDB characteristic best supports this agile development approach?

Accepted Answer

The ability to store documents with varying fields without altering a centralized schema. MongoDB's document model lets developers add or modify fields per document without a centralized schema migration. This means new features can be deployed without database downtime, directly supporting the startup's need for rapid iteration and continuous delivery.

Answer

Schema validation rules that must be updated before any new field can be stored

Answer

Requiring all documents in a collection to have identical fields at all times

Answer

Using a fixed-width binary format that cannot represent new data types

Question 3

A developer needs to insert a document into the inventory collection and wants the operation to fail with a duplicate key error if a document with the same value for the sku field already exists. The sku field has a unique index. Which insert method and option combination achieves this with the least code?

Accepted Answer

db.inventory.insertOne( { sku: "A100", qty: 5 } ). A unique index on sku is what enforces the duplicate constraint. A plain insertOne is sufficient: if the sku already exists, the server returns a duplicate key error. The ordered option is only relevant for multi-document inserts, upsert would update instead of fail, and bypassDocumentValidation only affects schema validation, not unique indexes.

Answer

db.inventory.updateOne( { sku: "A100" }, { $set: { qty: 5 } }, { upsert: true } )

Answer

db.inventory.insertMany( [ { sku: "A100", qty: 5 } ], { bypassDocumentValidation: true } )

Answer

db.inventory.insertOne( { sku: "A100", qty: 5 }, { ordered: false } )

Question 4

A production MongoDB 6.0 sharded cluster has a collection with a ranged shard key on the field `customerId`. Over time, the team notices that nearly all new documents have monotonically increasing `customerId` values, and one shard is receiving a disproportionate share of writes while the other shards remain relatively idle. The balancer is enabled and running. Which of the following is the most likely explanation for this imbalance?

Accepted Answer

The shard key is monotonically increasing, causing all new inserts to target the highest chunk on a single shard.. With a monotonically increasing shard key, new inserts always target the chunk with the highest key range. Because chunks are assigned to shards, that highest chunk lives on one shard at a time, making it a write hotspot. The balancer will eventually migrate chunks, but the stream of new inserts keeps hitting the newest chunk, so the imbalance persists.

Answer

The shard key field is not indexed on the shards, forcing all writes to a single primary.

Answer

The config servers are overloaded and cannot process chunk migration commands.

Answer

The collection has too few chunks, so the balancer cannot distribute them evenly across shards.

Question 5

A collection called events stores documents with an array field named tags. You need to remove all occurrences of the string "obsolete" from the tags array in every document where the array contains that value, without affecting other elements. Which update operator should you use?

Accepted Answer

$pull. $pull is the array update operator that removes all elements matching a value or condition. Filtering on documents where tags contains "obsolete" and applying $pull deletes every such occurrence while leaving other tags intact. $unset removes whole fields, $pop removes positional elements, and $set replaces values rather than selectively removing matches.

Answer

$unset

Answer

$pop

Answer

$set

Question 6

A DBA notices that a query on the products collection uses an index scan but returns only a small fraction of documents. The index is { category: 1, price: 1 }. The query filters on category and price with a range condition on price. Which statement best describes why the index might still be efficient despite scanning many index entries?

Accepted Answer

The index scan is efficient because it can use the index bounds to limit the scan to the relevant category and price range, reducing the number of documents fetched.. The index { category: 1, price: 1 } supports efficient filtering when the query has an equality predicate on category and a range predicate on price. MongoDB can use index bounds to seek to the correct category and scan only the relevant price range, minimizing the number of documents fetched. This makes the index scan efficient despite examining many index entries.

Answer

The index scan is efficient because MongoDB automatically converts it to a collection scan when the selectivity is low.

Answer

The index scan is efficient because it avoids fetching documents entirely due to the index being covered.

Answer

The index scan is efficient because it uses the index only for sorting and not for filtering.

Question 7

A collection 'events' has a compound index { tenantId: 1, createdAt: -1 }. A developer runs db.events.find({ tenantId: "acme", createdAt: { $gte: ISODate("2024-01-01") } }).sort({ createdAt: -1 }).limit(50). The explain output shows the index is used but the query still performs a large in-memory sort. Which action resolves the sort performance issue?

Accepted Answer

Ensure the index is { tenantId: 1, createdAt: -1 } and verify the query does not use a collation or type mismatch that prevents index-provided sort.. A compound index can provide both the equality match and the sort when the equality fields form the prefix and the sort field follows. With { tenantId: 1, createdAt: -1 }, the query's equality on tenantId and sort on createdAt should be served without an in-memory sort. A blocking SORT in explain therefore points to a mismatch such as collation, type, or query shape rather than a missing index.

Answer

Add a sort key to the index: { tenantId: 1, createdAt: -1, _id: 1 }.

Answer

Reverse the compound index to { createdAt: -1, tenantId: 1 }.

Answer

Create a separate single-field index on createdAt.

Question 8

You are a DBA for a MongoDB replica set. A secondary node has been down for several days and is far behind the primary. The oplog on the primary has wrapped, and the secondary's last oplog entry is no longer present. What must you do to bring the secondary back into sync?

Accepted Answer

Perform a full resync by stopping the secondary, deleting its data files, and restarting it.. If a secondary's last oplog entry is no longer in the primary's oplog, the secondary cannot catch up incrementally. A full resync is required, which means deleting the secondary's data files and restarting it to perform an initial sync. This process copies all data from the primary or another sync source.

Answer

Increase the oplog size on the primary to prevent wrapping and then restart the secondary.

Answer

Restart the secondary with the --resync option to force a full resync.

Answer

Run rs.syncFrom() on the secondary to point it to a different sync source.

Question 9

A DBA is designing indexes for a collection that stores user activity logs. The collection has fields: user_id, action, timestamp, and metadata (an embedded document). The most common queries are: (1) find all actions for a given user_id sorted by timestamp descending; (2) find all users who performed a specific action within a time range. Which TWO indexes would best support these queries? (Choose two.)

Accepted Answer

{ user_id: 1, timestamp: -1 }. The two indexes that best support the queries are { user_id: 1, timestamp: -1 } for query (1) and { action: 1, timestamp: 1 } for query (2). The first provides an equality match on user_id and a sort on timestamp, while the second provides an equality match on action and a range on timestamp. These indexes align with the equality-sort and equality-range patterns, ensuring efficient index usage.

Answer

{ metadata: 1 }

Answer

{ user_id: 1, action: 1, timestamp: -1 }

Answer

{ timestamp: 1 }

Question 10

You are updating a document in the `products` collection. The document has an array field `tags`. You need to add the tag "sale" to the array only if it does not already exist, and you want to ensure that no duplicate tags are added even if multiple updates run concurrently. Which update operator should you use?

Accepted Answer

$addToSet. $addToSet is designed to add a value to an array only if it is not already present, making it the correct operator for ensuring uniqueness. It performs this check atomically, so concurrent updates will not introduce duplicates. $push would append duplicates, $set would replace the array, and $addToSet with $each is overkill for a single value.

Answer

$addToSet with $each

Answer

$push

Answer

$set