C100DEV Practice Test 12 — 15 Questions

Question 1

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?

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

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 2

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 3

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 4

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 5

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.

Question 6

A developer is working with a MongoDB collection that has a partial index defined as `db.products.createIndex({ price: 1 }, { partialFilterExpression: { price: { $gt: 100 } } })`. The developer runs a query `db.products.find({ price: { $lt: 50 } })`. Which of the following statements describes how MongoDB will execute this query?

Accepted Answer

MongoDB will perform a collection scan to find documents with price less than 50.. A partial index only includes a subset of documents in a collection based on a filter expression. In this case, the partial index only contains documents where `price > 100`. The query filters for `price < 50`, which does not overlap with the partial filter expression. Therefore, the index cannot be used to satisfy the query. MongoDB will perform a collection scan to find the matching documents. It will not use the partial index, nor will it return an error; it will simply choose an alternative execution plan.

Answer

MongoDB will use the partial index to find documents with price less than 50.

Answer

MongoDB will use the partial index but will filter out documents that do not match the query predicate.

Answer

MongoDB will return an error because the query cannot be satisfied by the partial index.

Question 7

An IoT platform ingests temperature readings from thousands of sensors. Each reading is currently stored as its own document with sensorId, timestamp, and value, producing millions of tiny documents per day. Queries typically retrieve readings for a sensor over a specific hour. Which schema design most improves storage efficiency and query performance for this access pattern?

Accepted Answer

Use the Bucket Pattern, grouping readings from a sensor for a time window into a single document with an array of measurements.. The Bucket Pattern is purpose-built for time-series data, grouping measurements into documents keyed by a time window. Because queries retrieve a sensor's readings for a specific hour, a bucket per sensor per hour lets one document serve the query, slashes document count and overhead, and shrinks the index footprint, improving both storage efficiency and read performance.

Answer

Enable sharding on the readings collection with sensorId as the shard key and store one reading per document.

Answer

Add a compound index on sensorId and timestamp and continue storing one reading per document.

Answer

Apply the Attribute Pattern by moving each reading's value into a key-value subdocument.

Question 8

A logistics MongoDB deployment has a 'shipments' collection. A nightly job must remove the 'tracking_history' array element whose 'status' is 'cancelled' from every document where 'carrier' is 'DHL', without deleting the documents themselves. Which update operation should the developer run?

Accepted Answer

db.shipments.updateMany({ carrier: 'DHL' }, { $pull: { tracking_history: { status: 'cancelled' } } }). The $pull operator is designed to remove array elements that match a specified condition, so using it with updateMany and a carrier filter deletes only the cancelled tracking_history entries from every DHL shipment. Operations like deleteMany or $pop either remove whole documents or the wrong array elements, and $unset cannot filter by element values.

Answer

db.shipments.updateMany({ carrier: 'DHL' }, { $pop: { tracking_history: { status: 'cancelled' } } })

Answer

db.shipments.deleteMany({ carrier: 'DHL', 'tracking_history.status': 'cancelled' })

Answer

db.shipments.updateMany({ carrier: 'DHL' }, { $unset: { 'tracking_history.status': 'cancelled' } })

Question 9

A developer is using the MongoDB Node.js driver to perform a multi-document transaction that includes a read operation on a collection with a read concern of 'snapshot'. What is the effect of using 'snapshot' read concern in this transaction?

Accepted Answer

It provides a consistent snapshot of the data at the start of the transaction, ensuring reads see the same version of documents throughout the transaction.. In a multi-document transaction, using snapshot read concern guarantees that all reads within the transaction see a consistent snapshot of the data as of the transaction start. This prevents anomalies such as non-repeatable reads and ensures that the transaction operates on a stable view of the data, which is critical for maintaining integrity.

Answer

It allows reads to see uncommitted changes from other transactions, improving performance.

Answer

It ensures that reads are distributed across secondary nodes for load balancing.

Answer

It automatically retries reads if a transient error occurs, without failing the transaction.

Question 10

A developer wants to run ad-hoc queries against a MongoDB Atlas cluster from a terminal, including commands like db.collection.find() and db.adminCommand({listDatabases: 1}). The developer has the connection string and wants the least additional setup. Which tool should be used?

Accepted Answer

mongosh with the connection string passed as an argument. mongosh is the official MongoDB Shell and is designed for interactive, terminal-based querying and administration. It connects directly with a connection string and supports both CRUD helpers and database commands, so it covers the developer's needs with minimal setup. GUI tools, backup utilities, and federation features serve different purposes and would require more configuration or would not run in a terminal.

Answer

MongoDB Compass connected to the cluster

Answer

Atlas Data Federation with an S3 data source

Answer

mongodump with the --uri option

Question 11

A banking application must atomically transfer funds between two account documents in the 'accounts' collection. The transfer decreases the balance of the source account and increases the balance of the destination account, and both changes must succeed or neither should be applied. The deployment is a replica set. Which approach guarantees this atomicity?

Accepted Answer

Use a session and start a transaction with session.startTransaction(), update both accounts within the session, then commitTransaction().. Multi-document transactions are the correct tool when atomicity must span more than one document. Starting a transaction on a session, performing the debit and credit updates with that session, and committing ensures the operations either all commit or all abort. On a replica set this provides the all-or-nothing behavior the banking scenario demands.

Answer

Embed both account balances in a single document and use updateOne with $inc on both fields.

Answer

Perform two sequential updateOne calls, first on the source and then on the destination, and check the result of each.

Answer

Use updateMany with a filter matching both account _id values and apply $inc to the balance field.

Question 12

A financial application stores transaction documents in a MongoDB collection. Each document includes fields such as 'transactionId', 'amount', 'currency', and 'timestamp'. The application requires that the 'amount' field always be present and be a double, and that 'currency' be one of a predefined list of ISO codes. Which MongoDB feature should the developer use to enforce these requirements at the database level?

Accepted Answer

Schema validation using JSON Schema with $jsonSchema operator.. Schema validation with $jsonSchema allows developers to specify required fields, BSON types, and allowed values, enforcing data integrity directly in MongoDB. This is ideal for ensuring that 'amount' is always a double and 'currency' is from a predefined list. Other options either provide weaker guarantees or are unrelated to validation.

Answer

Application-level validation using Mongoose schema definitions.

Answer

Unique indexes on the 'amount' and 'currency' fields.

Answer

Sharding the collection on the 'currency' field.

Question 13

A team is deciding how to model the relationship between orders and the products each order contains. They want to optimize for the common query that retrieves an order along with the name and current price of every product in it. Which two modeling considerations best support this requirement? (Choose two.)

Accepted Answer

Embedding a copy of the product name and price inside each order line avoids a second lookup when rendering the order.. The requirement is a frequent read that needs an order plus a few product fields. Embedding just those fields as an extended reference satisfies the query with one document read, and accepting limited duplication is justified because the copied fields change rarely. Together these considerations optimize the common read path without inflating documents with unnecessary product data.

Answer

Modeling order lines as a separate collection joined by orderId avoids any duplication and is always the best choice for order reads.

Answer

Storing only the product ObjectId in each order line and resolving names and prices at read time with $lookup keeps data fully normalized.

Answer

Duplicating the entire product document into each order line ensures the order always reflects product details.

Question 14

A logistics application stores shipment records in the 'shipments' collection. A developer must delete all shipment documents whose 'status' field equals 'cancelled'. Which command correctly performs this operation?

Accepted Answer

db.shipments.deleteMany({ status: "cancelled" }). Deleting a subset of documents based on field equality requires deleteMany() with the filter, which removes all matches and reports deletedCount. deleteOne() would remove only one record, the deprecated remove() is unavailable on current servers, and drop() eliminates the entire collection rather than matching documents.

Answer

db.shipments.deleteOne({ status: "cancelled" })

Answer

db.shipments.remove({ status: "cancelled" })

Answer

db.shipments.drop({ status: "cancelled" })

Question 15

A document in the 'profiles' collection has an embedded array 'contacts' of subdocuments, each with 'type' and 'value' fields. A developer must change the 'value' of the subdocument whose 'type' is 'email' without altering any other array element. Which update is correct?

Accepted Answer

db.profiles.updateOne({ _id: 1 }, { $set: { "contacts.$[elem].value": "new@x.com" } }, { arrayFilters: [{ "elem.type": "email" }] }). The filtered positional operator with arrayFilters matches subdocuments by condition, so only the email element changes. A hardcoded index may hit the wrong entry, the plain positional operator needs an array condition in the query, and replacing the whole array deletes other contacts.

Answer

db.profiles.updateOne({ _id: 1 }, { $set: { "contacts.$.value": "new@x.com" } })

Answer

db.profiles.updateOne({ _id: 1 }, { $set: { contacts: [{ type: "email", value: "new@x.com" }] } })

Answer

db.profiles.updateOne({ _id: 1 }, { $set: { "contacts.0.value": "new@x.com" } })