C100DEV Practice Test 4 — 25 Questions

Question 1

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?

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

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 2

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 3

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 4

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 5

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.

Question 6

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 7

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 8

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 9

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 10

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 11

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 12

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 13

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 14

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 15

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

Question 16

A developer is modeling a blog platform. Posts are read frequently, and each post has a small, bounded set of tags. The tags are always displayed with the post and are never queried independently across posts. The developer is deciding between embedding the tags as an array inside each post document versus storing them in a separate tags collection with references. Which design choice aligns with MongoDB document model guidance for this scenario?

Accepted Answer

Embed the tags as an array within each post document, since they are bounded, accessed together with the post, and not queried independently.. MongoDB document modeling favors embedding when related data is bounded, is retrieved together with its parent, and is not queried on its own. The tags described fit all three conditions, so embedding them as an array in each post yields single-read retrieval and avoids join overhead. A separate collection would only be justified if tags needed independent querying or unbounded growth.

Answer

Store tags both embedded in posts and in a separate collection, keeping them synchronized manually, to satisfy both read and write paths.

Answer

Store tags in a separate collection and use a $lookup aggregation in every read, because aggregation pipelines are the only way to combine related data.

Answer

Store tags in a separate collection and reference them from posts, because normalization always reduces duplication and improves read performance.

Question 17

You maintain a MongoDB collection named `readings` that stores hourly sensor measurements. Each document includes a `sensorId` string, a `recordedAt` date, and a `temperature` numeric value. You need to produce a report that, for each sensor, lists the sensor identifier alongside the timestamp of its single highest temperature reading. Duplicate temperatures are possible, and in that case any one of the tied readings is acceptable. Which aggregation pipeline should you run?

Accepted Answer

db.readings.aggregate([ { $sort: { sensorId: 1, temperature: -1 } }, { $group: { _id: "$sensorId", recordedAt: { $first: "$recordedAt" }, temperature: { $first: "$temperature" } } } ]). Selecting the top record per group requires ordering the input before the grouping stage, because accumulators such as $first operate on the incoming document stream order. Sorting by the group key and then by the ranking field descending guarantees the desired record arrives first for each group, letting $first extract both the timestamp and the measurement together.

Answer

db.readings.aggregate([ { $group: { _id: "$sensorId", temperatures: { $push: "$temperature" }, times: { $push: "$recordedAt" } } }, { $sort: { temperatures: -1 } } ])

Answer

db.readings.aggregate([ { $sort: { temperature: -1 } }, { $group: { _id: "$sensorId", recordedAt: { $last: "$recordedAt" }, temperature: { $last: "$temperature" } } } ])

Answer

db.readings.aggregate([ { $group: { _id: "$sensorId", recordedAt: { $first: "$recordedAt" }, temperature: { $first: "$temperature" } } }, { $sort: { temperature: -1 } } ])

Question 18

A developer is working with a collection 'products' that has an index { category: 1, price: 1 }. They want to understand how MongoDB can use this index for queries that include a sort on price. Which TWO of the following statements are true regarding the use of this index for sorting? (Choose two.)

Accepted Answer

The index can support a sort on price descending if the query includes an equality condition on category, by scanning the index in reverse.. The index { category: 1, price: 1 } can support sorting on price when the query includes an equality condition on category, because then the index's price entries are contiguous and sorted. It can also support a descending sort by scanning the index in reverse. Without an equality condition on category, the index cannot provide a global sort on price because the leading field category varies.

Answer

The index can support a sort on price descending even if the query does not include any condition on category, because the index stores price in descending order when traversed in reverse.

Answer

The index can support a sort on price ascending if the query includes a range condition on category, such as { category: { $gt: 'A' } }.

Answer

The index can support a sort on price ascending even if the query does not include any condition on category.

Question 19

A developer is working with a MongoDB collection that stores product data. Each product document has a 'price' field. The developer needs to find all products with a price greater than 100 and less than 200. Which query operator should be used?

Accepted Answer

$gt and $lt. To find documents where a field falls within an exclusive range, MongoDB provides the $gt and $lt operators. Combining them in a single query object on the same field applies both conditions. This is a common pattern for range queries and is efficient when an index exists on the field. The other operators either include boundary values or are for different query types.

Answer

$gte and $lte

Answer

$and with $gt

Answer

$in

Question 20

A developer is designing a MongoDB collection to store user profiles. Each profile document includes fields for name, email, and an array of phone numbers. The developer wants to ensure that the email field is unique across all documents. Which MongoDB feature should be used to enforce this constraint?

Accepted Answer

Unique index on the email field. A unique index on the email field is the only reliable way to enforce uniqueness in MongoDB. It guarantees that no two documents can have the same email value, even under concurrent operations. Schema validation, sharding, and application-level checks cannot provide this guarantee. The unique index also speeds up queries that filter by email.

Answer

Sharding the collection on the email field

Answer

Schema validation with $jsonSchema

Answer

Application-level check before insert