C100DEV CRUD Operations — Timed 15 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?

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