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

10 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.