C100DEV CRUD Operations Practice Test 2 — 15 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 developer is exploring a 'reviews' collection and wants to retrieve only the 'author' and 'rating' fields from every review document, without the _id field, to reduce the payload sent to the application. Which query accomplishes this?

Accepted Answer

db.reviews.find({}, { author: 1, rating: 1, _id: 0 }). Projection is the second parameter of find, and mixing inclusion values with _id: 0 is the standard way to return a subset of fields without the identifier. Passing fields as the first argument turns them into a filter, and using exclusion values in a projection drops the very fields the developer needs.

Answer

db.reviews.find({}, { author: true, rating: true })

Answer

db.reviews.aggregate([{ $project: { author: 0, rating: 0, _id: 0 } }])

Answer

db.reviews.find({ author: 1, rating: 1, _id: 0 })

Question 3

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 4

A developer is writing a Python application using the official MongoDB driver to insert a single document into the 'inventory' collection. They call `inventory.insert_one({'sku': 'A100', 'qty': 5})`. Which statement accurately describes what happens?

Accepted Answer

The driver sends an insert command; MongoDB adds the document with a generated _id and returns an InsertOneResult containing the inserted_id.. The insert_one method inserts a single document and returns an InsertOneResult whose inserted_id exposes the generated identifier. It does not upsert, does not defer writes to connection close, and does not require the application to provide _id. Understanding this return object matters because applications commonly need the generated _id to link related documents or respond to clients.

Answer

The driver performs an upsert automatically, so if a document with the same sku exists it replaces it.

Answer

The server rejects the insert because the document lacks an explicit _id field, requiring the application to supply one.

Answer

The document is written only to the driver's local buffer and flushed to the server when the client closes the connection.

Question 5

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 6

A MongoDB application stores inventory documents in the 'inventory' collection with fields 'sku', 'on_hand', and 'reserved'. During a flash sale, many concurrent sessions must decrement 'on_hand' by 1 only when on_hand is greater than 0, and each successful decrement must return the resulting document to the client. Which approach guarantees this behavior?

Accepted Answer

db.inventory.findOneAndUpdate({ sku: 'A100', on_hand: { $gt: 0 } }, { $inc: { on_hand: -1 } }, { returnDocument: 'after' }). findOneAndUpdate performs the conditional match, the $inc decrement, and the return of the document in one atomic operation. The on_hand: { $gt: 0 } filter guards against negative inventory under concurrency, and returnDocument: 'after' supplies the resulting state. Separating read and write, or using updateOne or bulkWrite, either introduces races or fails to return the document.

Answer

db.inventory.bulkWrite([{ updateOne: { filter: { sku: 'A100', on_hand: { $gt: 0 } }, update: { $inc: { on_hand: -1 } } } }])

Answer

db.inventory.find({ sku: 'A100', on_hand: { $gt: 0 } }) followed by db.inventory.updateOne({ sku: 'A100' }, { $inc: { on_hand: -1 } })

Answer

db.inventory.updateOne({ sku: 'A100', on_hand: { $gt: 0 } }, { $inc: { on_hand: -1 } }, { returnDocument: 'after' })

Question 7

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 8

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 9

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 10

A developer wants to remove all documents from the 'logs' collection where the 'level' field equals 'debug'. The collection has an index on level. Which operation should be used, and what does it return?

Accepted Answer

deleteMany({ level: 'debug' }) returns a result whose deletedCount is the number of documents removed.. deleteMany with a filter removes all matching documents and reports how many were deleted via deletedCount. deleteOne only removes the first match, drop destroys the whole collection, and remove is deprecated. When a selective deletion is needed and the filter is indexed, deleteMany preserves unrelated documents and existing indexes.

Answer

drop() removes the collection and its index, which is the recommended way to clear matching documents.

Answer

deleteOne({ level: 'debug' }) returns the number of documents removed.

Answer

remove({ level: 'debug' }) is the modern method and returns a cursor of deleted documents.

Question 11

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 12

A developer queries the 'events' collection with db.events.find({ tags: { $in: ["sports", "music"] } }) and observes a COLLSCAN in explain output even though an index exists on the 'tags' array field. The collection holds a few hundred documents. Which explanation best accounts for the planner choosing a collection scan?

Accepted Answer

The query planner may prefer a collection scan when the collection is small, because the estimated cost of scanning is lower than the overhead of using a multikey index.. Query plan selection is cost-based. With a few hundred documents, the estimated cost of a full collection scan can be lower than the cost of using a multikey index plus document fetches, so the planner may reasonably choose COLLSCAN. As the collection grows, or with a more selective predicate, the same index is likely to be selected.

Answer

COLLSCAN appears whenever a query returns more than one document, because index scans are limited to single-document lookups.

Answer

A multikey index cannot answer $in queries, so the planner ignores the tags index and falls back to a collection scan.

Answer

The index on 'tags' is invalid because arrays cannot be indexed directly, so it must be rebuilt as a compound index with _id first.

Question 13

A developer must update a document in the 'accounts' collection by incrementing the 'balance' field by 25 and simultaneously setting the 'lastUpdated' field to the current date. The update must apply only if the account is active. Which update statement satisfies all conditions?

Accepted Answer

updateOne({ active: true }, { $inc: { balance: 25 }, $set: { lastUpdated: new Date() } }). The correct approach is updateOne with a filter on active, $inc for the numeric change, and $set for the timestamp. Using update operators applies atomic field-level changes to one matched document. Omitting operators triggers replacement semantics, updateMany affects too many documents, and replaceOne forbids modifier keys, so each alternative violates part of the requirement.

Answer

replaceOne({ active: true }, { $inc: { balance: 25 }, $set: { lastUpdated: new Date() } })

Answer

updateMany({ active: true }, { $inc: { balance: 25 }, $set: { lastUpdated: new Date() } })

Answer

updateOne({ active: true }, { balance: 25, lastUpdated: new Date() })

Question 14

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" } })

Question 15

A developer is troubleshooting a Python application that uses the MongoDB driver to query the 'products' collection with find({'category': 'tools'}). Which two statements about the returned cursor are correct? (Choose two.)

Accepted Answer

The cursor automatically closes when it is exhausted, but must be closed explicitly if iteration stops early.. Cursors are lazy and fetch documents in batches during iteration, and they close automatically when exhausted but require explicit close() if iteration stops early. They do not eagerly load all matches, do not automatically re-execute on concurrent writes, and do not guarantee any result order without an explicit sort. These properties affect both memory use and server resource management.

Answer

The cursor loads all matching documents into client memory immediately when find is called.

Answer

The cursor returns documents in an order guaranteed by the storage engine, so no explicit sort is needed.

Answer

The cursor is invalidated and re-executed automatically whenever the underlying collection is modified by another client.