C100DEV CRUD Operations — Timed 20 Questions

Question 1

An application needs to update a document in the 'orders' collection. If the document matching the query does not exist, a new document must be inserted using fields from both the query and the update document. Which parameter accomplishes this behavior?

20 minute time limit — choose an answer to begin.

Accepted Answer

{ upsert: true } is used alongside the query and update parameters to insert a new document when no match is found.. The upsert option instructs MongoDB to insert a new document when no existing document matches the query filter. By default, updates only modify existing records, but combining query criteria with update operators during an upsert ensures data completeness. This pattern is fundamental for idempotent data ingestion pipelines where record creation and modification share a unified entry point, preventing race conditions.

Answer

{ multi: true }

Answer

{ upsert: true }

Answer

{ returnNewDocument: true }

Question 2

A developer is writing a bulk operation against the 'inventory' collection using db.inventory.bulkWrite(). The batch must (1) insert a new item only if no document already exists with the same 'sku', and (2) increment the 'qty' field of an existing item by 5 in the same round trip. Which two operations should be included in the bulkWrite array to meet these requirements? (Choose two.)

Accepted Answer

{ updateOne: { filter: { sku: "A100" }, update: { $inc: { qty: 5 } } } }. The conditional insert is achieved with an upsert updateOne using $setOnInsert, which only writes fields when the insert path is taken. The increment is achieved with a separate updateOne applying $inc to qty without upsert, so it modifies an existing document only. Together they fulfill both requirements in a single bulkWrite round trip.

Answer

{ insertOne: { document: { sku: "A100", qty: 0 } } }

Answer

{ replaceOne: { filter: { sku: "A100" }, replacement: { sku: "A100", qty: 5 } } }

Answer

{ deleteOne: { filter: { sku: "A100" } } }

Question 3

A booking system stores reservations in the 'reservations' collection. Each document has a 'guests' array of embedded subdocuments, each with 'name' and 'checkedIn' fields. An operator needs to mark only the subdocument whose 'name' is 'M. Chen' as checked in, leaving all other array elements unchanged. Which update accomplishes this?

Accepted Answer

db.reservations.updateOne({ 'guests.name': 'M. Chen' }, { $set: { 'guests.$.checkedIn': true } }). The positional $ operator is the canonical way to update the first array element matched by the query. The query 'guests.name': 'M. Chen' establishes which element the $ refers to, and the $set targets that element's field. Omitting the positional operator or using the all-positional operator both fail to achieve the single-element targeting.

Answer

db.reservations.updateOne({ 'guests.name': 'M. Chen' }, { $set: { 'guests.$[elem].checkedIn': true } }, { arrayFilters: [{ 'elem.name': 'M. Chen' }] })

Answer

db.reservations.updateOne({ 'guests.name': 'M. Chen' }, { $set: { 'guests.checkedIn': true } })

Answer

db.reservations.updateOne({ 'guests.name': 'M. Chen' }, { $set: { 'guests.$[].checkedIn': true } })

Question 4

A monitoring service writes metric documents with a 'sensorId' field to the 'metrics' collection. The application occasionally retries writes and must avoid creating duplicate documents when a document with the same 'sensorId' already exists. The update should set 'lastSeen' to the current date and increment a 'readings' counter when the sensor already exists. Which operation meets both requirements?

Accepted Answer

db.metrics.updateOne({ sensorId: 'S-42' }, { $set: { lastSeen: new Date() }, $inc: { readings: 1 } }, { upsert: true }). An upsert combined with $set and $inc handles both branches: insert when absent, update when present. The filter field is reused in the inserted document, and the increment operator preserves the running count. Replacement and insert-only approaches either reset the counter or create duplicates.

Answer

db.metrics.updateOne({ sensorId: 'S-42' }, { $setOnInsert: { lastSeen: new Date(), readings: 1 } })

Answer

db.metrics.replaceOne({ sensorId: 'S-42' }, { sensorId: 'S-42', lastSeen: new Date(), readings: 1 }, { upsert: true })

Answer

db.metrics.insertOne({ sensorId: 'S-42', lastSeen: new Date(), readings: 1 })

Question 5

A developer needs to retrieve documents from the 'sensors' collection where the 'readings' array contains at least one element greater than 100, but the query must return only the first matching element from each array. Which projection correctly limits the returned array to the first matching element?

Accepted Answer

{ readings: { $elemMatch: { $gt: 100 } } }. The $elemMatch projection operator returns the first array element matching a condition, making it the right tool when only the first matching element is wanted. Positional $slice, full inclusion, and aggregation $filter either ignore the predicate, return everything, or are invalid in a find projection. This distinction is important for APIs that should surface a single representative reading per sensor.

Answer

{ readings: 1, _id: 0 }

Answer

{ readings: { $slice: 1 } }

Answer

{ readings: { $filter: { input: '$readings', as: 'r', cond: { $gt: ['$$r', 100] } } } }

Question 6

A logistics application stores shipment documents in the 'shipments' collection, where each document has an 'events' array of subdocuments containing 'status' and 'timestamp' fields. A developer must append a new event to the 'events' array only if no event with the same 'status' and 'timestamp' already exists, to avoid duplicate entries during retries. Which update operation achieves this?

Accepted Answer

db.shipments.updateOne({ _id: id }, { $addToSet: { events: newEvent } }). $addToSet provides set semantics for array updates, adding the element only when an identical value is not already present. Because equality for subdocuments compares field order and values, an event subdocument with the same status and timestamp is recognized as a duplicate and skipped, making the update idempotent and safe to retry.

Answer

db.shipments.updateOne({ _id: id, 'events.status': { $ne: status } }, { $push: { events: newEvent } })

Answer

db.shipments.updateOne({ _id: id }, { $push: { events: newEvent } })

Answer

db.shipments.updateOne({ _id: id }, { $set: { 'events.$[elem]': newEvent } }, { arrayFilters: [{ 'elem.status': status }] })

Question 7

A developer is working with a 'logs' collection where each document has a field 'timestamp' of type Date. They need to find all documents where the timestamp is in the year 2023. Which two queries will achieve this? (Choose two.)

Accepted Answer

db.logs.find({ timestamp: { $gte: ISODate("2023-01-01T00:00:00Z"), $lt: ISODate("2024-01-01T00:00:00Z") } }). The two correct queries use either a precise date range with $gte and $lt on the start of the next year, or the aggregation operator $year within $expr to extract and compare the year. Both reliably match all timestamps in 2023, while other options either misuse operators or have boundary issues.

Answer

db.logs.find({ timestamp: { $gte: ISODate("2023-01-01T00:00:00Z"), $lte: ISODate("2023-12-31T23:59:59Z") } })

Answer

db.logs.find({ timestamp: { $year: 2023 } })

Answer

db.logs.find({ timestamp: { $gte: ISODate("2023-01-01"), $lte: ISODate("2023-12-31") } })

Question 8

A media application stores user profiles in the 'profiles' collection. A developer must remove a deprecated field named 'legacyScore' from all documents in the collection without affecting any other fields or documents. Which two operations accomplish this? (Choose two.)

Accepted Answer

db.profiles.updateMany({}, { $unset: { legacyScore: '' } }). $unset is the operator that deletes a field from a document, and updateMany applies it across all matching documents. Using an empty filter removes the field from every profile, while a filter of legacyScore: { $exists: true } limits the write to documents that actually contain it, which is more efficient. Both forms correctly remove only legacyScore and preserve all other data.

Answer

db.profiles.replaceMany({}, { $unset: { legacyScore: '' } })

Answer

db.profiles.updateMany({}, { $rename: { legacyScore: null } })

Answer

db.profiles.updateMany({}, { $pull: { legacyScore: { $exists: true } } })

Question 9

A social media application stores user profiles in the 'profiles' collection. Each document has a field 'username' that should be unique. You need to insert a new profile document, but only if the username does not already exist. If it exists, the insert should fail and return an error. Which method should you use?

Accepted Answer

db.profiles.updateOne({ username: 'alice' }, { $setOnInsert: { username: 'alice', ... } }, { upsert: true }). The updateOne method with upsert:true and $setOnInsert provides a way to insert a document only if no document matches the query. If the username exists, it will not insert; it may perform an update if other operators are present, but with only $setOnInsert it does nothing. To ensure failure on duplicate, a unique index is required. This is the idiomatic MongoDB approach for conditional inserts.

Answer

db.profiles.insertOne({ username: 'alice', ... })

Answer

db.profiles.findAndModify({ query: { username: 'alice' }, update: { $setOnInsert: { username: 'alice', ... } }, upsert: true, new: true })

Answer

db.profiles.replaceOne({ username: 'alice' }, { username: 'alice', ... }, { upsert: true })

Question 10

An application needs to update a user document in the 'users' collection. If the document does not exist, a new document must be inserted using fields from both the filter and the update document. Which parameter accomplishes this behavior in MongoDB?

Accepted Answer

Setting the { upsert: true } option in updateOne or findOneAndUpdate.. The upsert option instructs MongoDB to insert a new document if no existing document matches the query filter. When combined with update operators, the final document is constructed by merging the query filter with the update operators, which is crucial for idempotent bootstrapping patterns.

Answer

Setting the { writeConcern: { w: 'majority' } } option during the update operation.

Answer

Setting the { returnDocument: 'after' } option in the findOneAndUpdate method.

Answer

Setting the { multi: true } option to force updates across multiple matching records.

Question 11

You are designing an e-commerce catalog where products can have a dynamic array of tags. You need to query for documents where the 'tags' array contains both 'electronics' and 'sale' simultaneously, regardless of their order or other elements. Which query operator should you use?

Accepted Answer

{ tags: { $all: ['electronics', 'sale'] } }. The $all operator selects the documents where the value of a field is an array that contains all the specified elements. This is essential when searching arrays for multiple matching criteria without enforcing strict positional indexing or exact array equality.

Answer

{ tags: { $in: ['electronics', 'sale'] } }

Answer

{ tags: ['$electronics', '$sale'] }

Answer

{ tags: { $elemMatch: { $eq: 'electronics', $eq: 'sale' } } }

Question 12

A support ticketing system stores documents in the 'tickets' collection. An operator wants to add a new field 'priority' set to 'high' only for tickets whose 'status' is 'open' and that do not already have a 'priority' field. The update must not create any new documents and must not modify tickets that already have a 'priority' field. Which update operation should be used?

Accepted Answer

db.tickets.updateMany({ status: 'open', priority: { $exists: false } }, { $set: { priority: 'high' } }). The correct operation must update multiple open tickets that lack a priority field, add the field without overwriting existing values, and avoid creating new documents. Using updateMany with a filter that includes $exists: false and a $set modifier satisfies all conditions. Operators like $setOnInsert or upsert options are designed for insert scenarios and would either do nothing or risk unintended inserts, while replaceOne would remove other fields.

Answer

db.tickets.updateMany({ status: 'open' }, { $set: { priority: 'high' } }, { upsert: true })

Answer

db.tickets.replaceOne({ status: 'open', priority: { $exists: false } }, { status: 'open', priority: 'high' })

Answer

db.tickets.updateMany({ status: 'open', priority: { $exists: false } }, { $setOnInsert: { priority: 'high' } })

Question 13

A logistics application stores shipment documents in the 'shipments' collection. Each document has a 'packages' array of embedded subdocuments, each with a 'trackingCode' field. A developer needs to remove only the embedded subdocument whose 'trackingCode' equals 'TRK-9981' from the document with '_id' 42, leaving all other packages untouched. Which update operation should be used?

Accepted Answer

db.shipments.updateOne({ _id: 42 }, { $pull: { packages: { trackingCode: "TRK-9981" } } }). The $pull operator deletes array elements that match a specified condition or value, which is exactly what removing a single embedded subdocument by its trackingCode requires. $pop and $pullAll operate positionally or on exact element values and cannot target a nested field match, while $unset would leave a null placeholder instead of deleting the element.

Answer

db.shipments.updateOne({ _id: 42 }, { $pullAll: { packages: ["TRK-9981"] } })

Answer

db.shipments.updateOne({ _id: 42, "packages.trackingCode": "TRK-9981" }, { $unset: { "packages.$": "" } })

Answer

db.shipments.updateOne({ _id: 42 }, { $pop: { packages: 1 } })

Question 14

A reporting service reads from the 'sensors' collection, which holds millions of documents each containing an 'active' boolean field. The service queries only for documents where 'active' is true and reads a handful of fields. A developer wants the query to avoid scanning documents that are inactive. Which index should be created to support this access pattern most directly?

Accepted Answer

db.sensors.createIndex({ active: 1 }). An equality filter on a single boolean field is best served by a single-field index on that field, which allows the planner to seek directly to the matching entries and fetch only relevant documents. A compound index led by _id, a text index, or a sparse variant cannot provide that access path, because the query does not supply a usable prefix or field type for those structures.

Answer

db.sensors.createIndex({ active: 1 }, { sparse: true })

Answer

db.sensors.createIndex({ _id: 1, active: 1 })

Answer

db.sensors.createIndex({ active: "text" })

Question 15

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 16

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?

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 17

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 18

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 19

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 20

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