C100DEV Practice Test 5 — 25 Questions

Question 1

An analytics job updates counters in the 'metrics' collection with db.metrics.updateOne({ metric: "visits" }, { $inc: { count: 1 } }). The job runs with write concern w:1 against a three-node replica set, and a failover occurs immediately after the primary acknowledges a write. The developer reports that a counter increment appears to be lost. Which statement best explains this outcome?

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

Accepted Answer

With w:1 the primary acknowledged before the update was replicated, so if it stepped down and rolled back, the increment could be undone on the new primary.. Write concern w:1 confirms the write only on the primary. If that primary fails before the operation reaches any secondary, the new primary never has the change, and the old primary rolls it back upon rejoining, so an acknowledged increment can disappear. Stronger write concern such as majority prevents this by requiring replication before acknowledgement.

Answer

$inc is not atomic on a replica set, so two nodes can apply the increment independently and produce a divergent count value.

Answer

The update used an equality filter on 'metric', so the query planner could not use an index and the write was silently skipped under load.

Answer

Because the collection has no unique index on 'metric', the increment was applied to multiple documents and the count became ambiguous.

Question 2

A reporting service reads from the 'sensor_readings' collection, which contains millions of documents. The service runs a query that filters on 'deviceId' and returns results sorted by 'recordedAt' descending. The query performs a collection scan and an in-memory sort, causing high memory usage. Which index should you create to allow the query to use an index for both filtering and sorting?

Accepted Answer

db.sensor_readings.createIndex({ deviceId: 1, recordedAt: -1 }). The optimal index follows the equality-sort-range rule: equality fields first, then the sort field. Because the query filters on deviceId with equality and sorts on recordedAt descending, a compound index { deviceId: 1, recordedAt: -1 } lets MongoDB use the prefix for filtering and read entries in the requested sort order, avoiding the blocking in-memory sort and its memory overhead.

Answer

db.sensor_readings.createIndex({ recordedAt: -1, deviceId: 1 })

Answer

db.sensor_readings.createIndex({ deviceId: 1 })

Answer

db.sensor_readings.createIndex({ recordedAt: 1 })

Question 3

A team is designing a schema for a product catalog where different product categories have entirely different attributes: books have ISBN and page count, electronics have wattage and warranty period, and clothing has size and material. All products must be searchable in a single query by name. Which data modeling approach best fits this requirement?

Accepted Answer

Store all products in one collection, allowing each document to have its own category-specific fields alongside common fields.. The Polymorphic Pattern is the standard MongoDB approach when multiple entity types share some fields and a common query path but differ in their specific attributes. Keeping all products in one collection with shared fields such as name and category-specific fields lets a single indexed query serve the catalog search while preserving each category's natural structure.

Answer

Create a separate collection per product category and query them with $unionWith for every search.

Answer

Normalize all attributes into a generic key-value array so every product has identical field names.

Answer

Embed every possible attribute for all categories in each document, leaving unused fields null.

Question 4

A logistics application stores shipment records in the 'shipments' collection. Each document includes a 'status' field and a 'deliveredAt' field (a Date). A developer must set 'deliveredAt' to the current date and time for every shipment whose 'status' is 'in_transit' and whose 'carrier' is 'FastShip'. Which operation satisfies this requirement with a single command?

Accepted Answer

db.shipments.updateMany({ status: 'in_transit', carrier: 'FastShip' }, { $set: { deliveredAt: new Date() } }). The requirement is a filtered, multi-document field update, which maps directly to updateMany with the $set operator. The filter expresses both conditions, and $set preserves the existing document structure while adding or overwriting deliveredAt. The single-document helpers leave other matches untouched, and replacement operations would remove the untouched fields.

Answer

db.shipments.updateOne({ status: 'in_transit', carrier: 'FastShip' }, { $set: { deliveredAt: new Date() } })

Answer

db.shipments.replaceMany({ status: 'in_transit', carrier: 'FastShip' }, { deliveredAt: new Date() })

Answer

db.shipments.findAndModify({ query: { status: 'in_transit', carrier: 'FastShip' }, update: { $set: { deliveredAt: new Date() } }, multi: true })

Question 5

A developer needs to insert a single document into the 'inventory' collection and wants the operation to return the generated _id value in the result. Which method should be used?

Accepted Answer

db.inventory.insertOne({ item: 'canvas', qty: 100 }). insertOne is the purpose-built method for adding a single document and returns an InsertOneResult whose insertedId field exposes the generated or supplied _id. This satisfies the requirement to obtain the identifier immediately, without a follow-up find or relying on deprecated methods such as save or update.

Answer

db.inventory.update({ item: 'canvas' }, { qty: 100 }, { upsert: true })

Answer

db.inventory.insertMany([{ item: 'canvas', qty: 100 }])

Answer

db.inventory.save({ item: 'canvas', qty: 100 })

Question 6

A sensor platform writes readings to the 'readings' collection. A developer needs to insert three documents in a single operation and have the server process them in the given order, stopping at the first error rather than continuing. Which insert command should be used?

Accepted Answer

db.readings.insertMany([doc1, doc2, doc3], { ordered: true }). An ordered insertMany() writes documents in sequence and stops at the first error, matching the requirement. Unordered insertion continues past failures, insertOne() handles only one document, and bulkWrite() is intended for mixed operations and here omits a document.

Answer

db.readings.insertMany([doc1, doc2, doc3], { ordered: false })

Answer

db.readings.insertOne([doc1, doc2, doc3])

Answer

db.readings.bulkWrite([{ insertOne: { document: doc1 } }, { insertOne: { document: doc2 } }])

Question 7

A social media platform stores user profiles in a `users` collection. Each user document includes a `followers` array of user IDs. For highly popular accounts, this array has grown to over 2 million entries, causing documents to approach the 16 MB BSON limit and slowing read operations. The application frequently displays a user's follower count and the first 20 followers. Which schema design change best addresses this issue?

Accepted Answer

Use the Outlier Pattern: store the first 1000 followers in the user document and flag the document as an outlier; store remaining followers in a separate `followers` collection keyed by user ID.. The Outlier Pattern is specifically designed to handle documents that grow beyond typical limits due to a few outliers. By embedding only a subset of followers and storing the rest separately, the design keeps the common case fast while accommodating the extreme case. This maintains the ability to quickly show the follower count and first 20 followers without hitting the 16 MB limit.

Answer

Convert the `followers` array to a GridFS bucket to store the list of follower IDs as a binary blob.

Answer

Normalize the schema by moving the entire `followers` array into a separate `followers` collection with one document per follower relationship.

Answer

Apply the Attribute Pattern by converting the `followers` array into a set of key-value pairs where each follower ID is a field name.

Question 8

A library management system stores book information in a `books` collection. Each book document includes fields such as `title`, `author`, `ISBN`, and `genre`. The application frequently queries books by `genre` and `author`. Which index strategy is most appropriate to optimize these queries?

Accepted Answer

Create a compound index on `{ genre: 1, author: 1 }`.. A compound index on `{ genre: 1, author: 1 }` efficiently supports queries that filter on both fields or on `genre` alone, leveraging the index prefix. It also supports sorting by `genre` and `author`, which aligns with common library queries. Single-field indexes may require index intersection, which is less efficient, while text and hashed indexes are unsuitable for exact-match queries.

Answer

Create a text index on `title`, `author`, and `genre`.

Answer

Create a hashed index on `genre` and a regular index on `author`.

Answer

Create a single-field index on `genre` and another single-field index on `author`.

Question 9

A developer is new to MongoDB and is examining a collection of documents. Each document contains fields like `name`, `age`, and `address`, where `address` is a nested document with `street`, `city`, and `zip`. The developer wants to query for all documents where the `city` in the nested `address` document is 'New York'. Which query correctly retrieves these documents?

Accepted Answer

db.collection.find({ 'address.city': 'New York' }). To query a nested field in MongoDB, you use dot notation within a string, such as `'address.city'`. This allows the query to match documents where the nested `city` field equals 'New York', regardless of other fields in the subdocument. The other options either perform an exact match on the entire subdocument, use invalid syntax, or misuse the `$elemMatch` operator.

Answer

db.collection.find({ $elemMatch: { 'address.city': 'New York' } })

Answer

db.collection.find({ address: { city: 'New York' } })

Answer

db.collection.find({ address.city: 'New York' })

Question 10

A logistics company stores shipment events in a collection where each document contains a `history` array of subdocuments with fields `status`, `timestamp`, and `location`. Queries frequently filter on `history.status` and sort by `history.timestamp`. An index is created on `history.status`. What is the most accurate statement about this index?

Accepted Answer

The index is multikey; each element of the `history` array produces a separate index key, and querying `history.status` can use the index.. When an indexed field contains an array, MongoDB builds a multikey index and creates an index key for each array element. This allows queries that filter on `history.status` to use the index efficiently. The index is not restricted to the first element, it is not sparse by default, and creating it is fully supported.

Answer

The index is sparse by default because array fields often contain missing values, so it excludes documents where `history.status` is absent.

Answer

The index stores one key per document, using the first element of the `history` array, so only queries matching the first event can use it.

Answer

The index cannot be created because MongoDB does not allow indexing a field that contains an array of subdocuments.

Question 11

A retail catalog team stores each product as a document. Products share core fields such as sku, name, and price, but electronics carry warrantyMonths while apparel carries sizeChart. The application queries all products uniformly by category and price. Which modeling approach best fits this requirement?

Accepted Answer

Store all products in one collection and allow documents to carry category-specific fields alongside the shared fields.. MongoDB schemas are flexible by design, so a single products collection can hold documents that share common fields and add category-specific ones as needed. This supports one uniform query path indexed on category and price, avoids joins, and lets new categories be introduced without schema migrations. Splitting collections or normalizing into fixed keys adds routing and storage costs that the scenario does not justify.

Answer

Store category-specific attributes in a separate attributes collection and $lookup them when rendering each product.

Answer

Normalize the schema by storing all category-specific fields in a shared subdocument with a fixed set of keys for every product.

Answer

Create a separate collection per product category so each collection has a uniform schema.

Question 12

A logistics company stores shipment documents in a collection named shipments. Each document has fields: `origin` (string), `destination` (string), `weight` (number), and `status` (string). The analytics team wants to find the total weight of shipments for each unique pair of origin and destination, but only for shipments with status 'delivered'. They also want to include the average weight per pair and sort the results by total weight descending. Which two stages are essential to achieve the grouping and calculation of these metrics? (Choose two.)

Accepted Answer

$match. The $match stage filters shipments to only those with status 'delivered', and the $group stage aggregates by origin and destination, computing total weight and average weight. These two stages are essential to achieve the required grouping and calculations. Other stages like $sort are used for ordering but are not essential for the core aggregation.

Answer

$limit

Answer

$project

Answer

$sort

Question 13

You are designing indexes for a MongoDB collection that stores user profiles. The collection has a field 'email' that must be unique, and a field 'username' that is also unique. You also need to support queries that find users by a combination of 'country' and 'city'. Which TWO of the following statements are correct regarding index creation and behavior in this scenario? (Choose two.)

Accepted Answer

Creating a unique index on email will prevent insertion of documents with duplicate email values, but will allow multiple documents with missing email field only if the index is sparse or partial.. The scenario requires unique constraints on email and username, and query support for country and city. A unique index on email allows multiple missing emails only if sparse or partial, so that statement is correct. A compound index on country and city supports queries on the leading field country and on both fields together, making that statement correct. The other statements misstate index prefix behavior, compound uniqueness, or the scope of unique indexes.

Answer

A compound index on { country: 1, city: 1 } can support queries that filter on city alone, because MongoDB can use the index prefix from the right side.

Answer

Creating a unique index on username will automatically create a unique index on email if both are specified in the same createIndex command using a compound key pattern.

Answer

Unique indexes in MongoDB enforce uniqueness across all fields in the document, not just the indexed field, to prevent duplicate documents.

Question 14

A developer stores product documents in a MongoDB collection. Some documents include a nested details object with a warranty subfield, while others do not. The developer needs to retrieve only the documents where details.warranty equals the string "2 years". Which query correctly targets that nested field?

Accepted Answer

db.products.find({ "details.warranty": "2 years" }). Dot notation is the correct way to query a field inside an embedded document. Writing the path as a quoted string, such as details.warranty, tells MongoDB to look inside the details object for the warranty field and compare its value. This approach uses indexes when available and returns only documents whose nested field equals the requested value.

Answer

db.products.find({ details: { warranty: "2 years" } })

Answer

db.products.find({ $where: "this.details.warranty === '2 years'" })

Answer

db.products.find({ details: { $elemMatch: { warranty: "2 years" } } })

Question 15

A developer is building a MongoDB application that tracks server metrics. Each metric document must include a timestamp, and the application frequently queries metrics for a specific server within a date range. The developer wants to ensure that the timestamp field is stored in a way that supports efficient range queries and sorting. Which BSON data type should the timestamp field use?

Accepted Answer

Date. The BSON Date type is the correct choice because it stores time as a 64-bit integer (milliseconds since epoch), enabling efficient range queries and sorting. It is the standard type for timestamps in MongoDB applications and is fully supported by query and aggregation operators. The Timestamp type is reserved for internal use, while String and Long would require manual handling and lack native date functionality.

Answer

String

Answer

Timestamp

Answer

Long

Question 16

A developer needs to create a backup of a MongoDB deployment that includes all databases and their indexes, and then restore it to a different server. The backup should be in a binary format that preserves BSON data types. Which tool should be used to create the backup?

Accepted Answer

mongodump. mongodump creates a binary backup of a MongoDB deployment, preserving BSON data types and index definitions. mongoexport produces JSON/CSV, which loses type fidelity. mongorestore is for restoring, and mongofiles is for GridFS. Thus, mongodump is the correct choice for a binary backup.

Answer

mongoexport

Answer

mongofiles

Answer

mongorestore

Question 17

A developer is querying the 'events' collection to retrieve documents and needs to control which fields are returned to reduce network payload. Which two statements about projection in MongoDB find() operations are correct? (Choose two.)

Accepted Answer

Setting _id to 0 in an inclusion projection removes the _id field from the returned documents while still returning the other included fields.. Projection operates in either inclusion or exclusion mode, never both, with _id as the sole exception that can be suppressed alongside included fields. Projection only shapes query results and does not alter stored documents, and _id can indeed be excluded.

Answer

A projection cannot exclude the _id field under any circumstance because it is mandatory in every query result.

Answer

A projection may freely mix inclusion and exclusion fields as long as at least one field is set to 1 and at least one is set to 0.

Answer

Projection reduces the size of documents written to disk, so it permanently shrinks the stored data for the collection.

Question 18

A MongoDB collection contains documents with a field `tags` that is an array of strings. A developer creates an index on the `tags` field. Which of the following statements is true about the resulting index?

Accepted Answer

The index will contain one entry for each element in the array, and it is called a multikey index.. When you create an index on a field that contains an array, MongoDB automatically creates a multikey index. This index has separate entries for each element of the array, allowing efficient queries on individual array elements. It is not sparse by default, and it does not index only the first element. This behavior is fundamental to querying arrays in MongoDB.

Answer

The index will only include the first element of the array to save space.

Answer

The index will be a sparse index by default because arrays can be empty.

Answer

The index will contain one entry per document, using the entire array as the key.

Question 19

An aggregation pipeline processes a collection of sensor readings with fields `sensorId`, `timestamp`, and `value`. The pipeline must output, for each sensor, the most recent reading's value and the average value across all readings. Which pipeline correctly achieves this?

Accepted Answer

$sort by timestamp descending, then $group with { _id: "$sensorId", latestValue: { $first: "$value" }, avgValue: { $avg: "$value" } }. To get the most recent reading's value per sensor, the pipeline must sort by timestamp descending so that the first document per group is the latest. Then $group uses $first to extract that value and $avg to compute the average. This combination ensures both requirements are met correctly.

Answer

$group with { _id: "$sensorId", latestValue: { $max: "$value" }, avgValue: { $avg: "$value" } }

Answer

$group with { _id: "$sensorId", latestValue: { $last: "$value" }, avgValue: { $avg: "$value" } }

Answer

$sort by timestamp ascending, then $group with { _id: "$sensorId", latestValue: { $last: "$value" }, avgValue: { $avg: "$value" } }

Question 20

A developer is working with a collection that has a compound index on { a: 1, b: 1, c: 1 }. They run a query that includes a filter on `a` and a sort on `c`. The query is: `db.collection.find({ a: 5 }).sort({ c: 1 })`. Which of the following best describes how MongoDB will execute this query?

Accepted Answer

The query will use the index to filter on `a` and then sort the results in memory by `c`.. With a compound index { a: 1, b: 1, c: 1 }, an equality filter on `a` can use the index efficiently. However, a sort on `c` cannot be satisfied by the index because `b` intervenes. MongoDB must perform an in-memory sort on the filtered results. The index is still used for filtering, but it does not avoid the sort stage.

Answer

The query will use the index to both filter on `a` and sort by `c`, avoiding an in-memory sort.

Answer

The query will use a covered index scan because all fields are in the index.

Answer

The query will not use the index at all and will perform a collection scan.