C100DEV Practice Test 9 — 10 Questions

Question 1

A developer runs `mongosh` against a replica set and wants to inspect the current database's collections before writing any queries. Which command should be executed?

Accepted Answer

show collections. The shell helper `show collections` is the idiomatic mongosh command for listing collections in the active database. It is concise, requires no JavaScript and directly satisfies the developer's need to inspect the database before writing queries. Other options either query a nonexistent collection, return different metadata or list databases rather than collections.

Answer

db.runCommand({ listDatabases: 1 })

Answer

db.collections.find()

Answer

db.getCollectionInfos()

Question 2

A developer is building an application that uses the MongoDB Node.js driver to perform a multi-document transaction. The transaction includes an update to an 'inventory' collection and an insert into an 'orders' collection. During testing, the developer notices that occasionally the transaction aborts with a TransientTransactionError. What is the most appropriate way to handle this error in the application code?

Accepted Answer

Immediately retry the entire transaction from the beginning.. TransientTransactionError is a label indicating a temporary failure that may be resolved by retrying the transaction. The correct approach is to retry the entire transaction, often using the driver's built-in retry mechanism like withTransaction. Aborting without retry, committing despite the error, or restarting the server are all inappropriate responses that could lead to data inconsistency or unnecessary failures.

Answer

Restart the MongoDB server to clear the error condition.

Answer

Commit the transaction and ignore the error, as the changes may have been applied.

Answer

Abort the transaction and return an error to the user without retrying.

Question 3

An inventory collection stores documents with a numeric 'quantity' field. A warehouse system must decrement quantity by 5 on a specific item, and if the field is missing it should be created starting from the decremented value. Which update operator and command achieve this?

Accepted Answer

db.inventory.updateOne({ sku: "A1" }, { $inc: { quantity: -5 } }). $inc performs atomic relative addition, so a negative value decrements the field and creates it when absent. $set replaces the value outright, $mul scales instead of subtracting, and $push targets arrays rather than numeric fields, so none of those meet the decrement requirement.

Answer

db.inventory.updateOne({ sku: "A1" }, { $push: { quantity: -5 } })

Answer

db.inventory.updateOne({ sku: "A1" }, { $mul: { quantity: -5 } })

Answer

db.inventory.updateOne({ sku: "A1" }, { $set: { quantity: -5 } })

Question 4

A retail application queries an `orders` collection with a filter on `status` and `customerId`, and a sort on `orderDate`. The query shape is: `db.orders.find({ status: "shipped", customerId: 12345 }).sort({ orderDate: -1 })`. The collection has no indexes other than the default `_id` index. Which index should be created to best support this query according to the ESR guideline?

Accepted Answer

{ status: 1, customerId: 1, orderDate: -1 }. The ESR guideline orders compound index fields as Equality, Sort, Range. The query has equality predicates on `status` and `customerId` and a sort on `orderDate`. Placing both equality fields first and the sort field last, as in `{ status: 1, customerId: 1, orderDate: -1 }`, lets the index serve the equality matches and provide sorted output without an in-memory sort.

Answer

{ status: 1, orderDate: -1, customerId: 1 }

Answer

{ customerId: 1, orderDate: -1, status: 1 }

Answer

{ orderDate: -1, status: 1, customerId: 1 }

Question 5

An IoT platform ingests sensor readings every second from thousands of devices. The team wants to minimize the number of documents and index entries while still querying by device and time range. Which schema design best matches these requirements?

Accepted Answer

Group readings into time-bucketed documents, each holding many readings for a device over a fixed interval.. Bucketing readings into fixed-interval documents per device reduces document count and index footprint while keeping queries by device and time range efficient. Because each bucket is bounded, documents remain small and writes spread across buckets over time. The alternatives either multiply documents or create unbounded arrays that risk the size limit.

Answer

Store one document per reading with fields for deviceId, timestamp, and value.

Answer

Store each reading as a separate document and rely on a compound index on deviceId and timestamp.

Answer

Store one document per device containing an array of all readings since deployment.

Question 6

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.

Question 7

A healthcare application stores patient records. Each patient document includes a `medications` array of subdocuments, each with `name`, `dosage`, and `frequency`. The application needs to query patients who are taking a specific medication with a specific dosage. The array is expected to grow to hundreds of entries per patient. Which schema design best supports efficient querying and management of this data?

Accepted Answer

Move medications to a separate `medications` collection with documents referencing the patient ID, and create a compound index on `{ name: 1, dosage: 1, patientId: 1 }`.. Separating medications into their own collection prevents unbounded array growth in patient documents and enables efficient querying with a compound index. The index on `name`, `dosage`, and `patientId` supports queries for patients taking a specific medication with a specific dosage. This design scales well and simplifies management of individual medication records.

Answer

Embed the `medications` array as is, and create a multikey index on `medications.name` and `medications.dosage`.

Answer

Use the Subset Pattern to store only the most recent 10 medications in the patient document and archive older medications in a separate collection.

Answer

Use the Bucket Pattern to group medications into buckets of 50 per patient document, and index the `name` and `dosage` fields.

Question 8

A developer is building a MongoDB application to store user profiles. Each profile document includes a field `lastLogin` that records the exact date and time of the user's most recent login. The developer wants to ensure that this field is stored using the most appropriate BSON type for date and time values, allowing for efficient range queries and sorting. Which BSON type should be used for the `lastLogin` field?

Accepted Answer

Date. The BSON Date type is the standard for storing date and time values in MongoDB. It provides millisecond precision and integrates with query operators like `$gt`, `$lt`, and aggregation date operators. Using it for a `lastLogin` field ensures accurate temporal comparisons and efficient indexing. Other types like String or Timestamp are either inefficient or semantically incorrect for application-level timestamps.

Answer

Timestamp

Answer

ObjectId

Answer

String

Question 9

A financial application stores transactions in a collection named transactions. Each document has fields: `accountId` (string), `amount` (decimal), `type` (string, either 'debit' or 'credit'), and `timestamp` (date). The team needs to calculate the net balance per account, defined as the sum of credits minus the sum of debits. The result should include only accounts with at least 10 transactions. Which aggregation pipeline achieves this?

Accepted Answer

db.transactions.aggregate([ { $group: { _id: "$accountId", netBalance: { $sum: { $cond: [ { $eq: [ "$type", "credit" ] }, "$amount", { $multiply: [ "$amount", -1 ] } ] } }, count: { $sum: 1 } } }, { $match: { count: { $gte: 10 } } } ]). The correct pipeline groups transactions by accountId, computes net balance by conditionally adding credits and subtracting debits, and counts transactions. It then filters groups with a count of at least 10 using $match. This approach correctly handles the arithmetic and the threshold, and it is efficient because grouping is necessary to compute the count per account.

Answer

db.transactions.aggregate([ { $match: { $expr: { $gte: [ { $size: "$transactions" }, 10 ] } } }, { $group: { _id: "$accountId", netBalance: { $sum: { $cond: [ { $eq: [ "$type", "credit" ] }, "$amount", { $multiply: [ "$amount", -1 ] } ] } } } } ])

Answer

db.transactions.aggregate([ { $group: { _id: "$accountId", netBalance: { $sum: { $cond: [ { $eq: [ "$type", "credit" ] }, "$amount", { $multiply: [ "$amount", -1 ] } ] } }, count: { $sum: 1 } } }, { $match: { count: { $gt: 10 } } } ])

Answer

db.transactions.aggregate([ { $group: { _id: "$accountId", netBalance: { $sum: { $cond: [ { $eq: [ "$type", "credit" ] }, "$amount", { $multiply: [ "$amount", -1 ] } ] } }, count: { $sum: 1 } } }, { $having: { count: { $gte: 10 } } } ])

Question 10

A logistics application stores shipment records in a MongoDB collection where each document includes a 'status' field (e.g., 'pending', 'in_transit', 'delivered') and a 'createdAt' date. The operations team frequently runs the query: db.shipments.find({ status: 'in_transit' }).sort({ createdAt: -1 }).limit(20). They want an index that allows this query to execute without an in-memory sort and with minimal keys scanned. Which index should you create?

Accepted Answer

db.shipments.createIndex({ status: 1, createdAt: -1 }). The query has an equality predicate on status followed by a descending sort on createdAt. The ESR rule (Equality, Sort, Range) indicates that equality fields should precede sort fields in a compound index. Creating an index with status first and createdAt second in the matching sort direction allows MongoDB to seek directly to the in_transit entries and traverse them in already-sorted order, eliminating the blocking in-memory sort and minimizing scanned keys.

Answer

db.shipments.createIndex({ createdAt: -1, status: 1 })

Answer

db.shipments.createIndex({ createdAt: -1 }) with a partial filter on status

Answer

db.shipments.createIndex({ status: 1 }) and rely on the sort in memory