C100DBA CRUD Operations Practice Test 1 — 15 Questions

Question 1

An application needs to update a user document by incrementing the 'login_count' field by 1 only if the 'status' field is set to 'active'. Which method is most efficient for this atomic operation?

Accepted Answer

db.users.updateOne({status: 'active'}, {$inc: {login_count: 1}}). The updateOne method with an $inc operator and a query filter is the standard approach for atomic updates in MongoDB. By specifying the condition in the query filter, MongoDB ensures the operation only executes when the status is active, avoiding race conditions that could occur if the application fetched the document, modified it locally, and sent it back. This promotes data integrity and reduces network round trips.

Answer

db.users.save({status: 'active', $inc: {login_count: 1}})

Answer

db.users.findAndModify({query: {status: 'active'}, update: {$inc: {login_count: 1}}})

Answer

db.users.updateMany({status: 'active'}, {$set: {login_count: 1}})

Question 2

Which TWO of the following statements regarding the 'upsert' option in MongoDB update operations are correct?

Accepted Answer

When upsert: true is used, the query filter fields are merged with the update document if a new document is created.. The upsert option is a powerful feature that combines update and insert logic into a single atomic operation. When set to true, MongoDB will update the document if it matches the filter, or create a new document if no matches are found. This is critical for idempotency in application logic, reducing the need for explicit existance checks before performing updates, which simplifies code paths and prevents race conditions.

Answer

Upsert operations are only available for the replaceOne method.

Answer

Using upsert: true with updateMany will never create more than one document.

Answer

Upserts can only be performed if the collection is empty.

Question 3

Which THREE of the following are valid ways to modify an array field in a document?

Accepted Answer

$push adds an element to an array, potentially creating duplicates.. Modifying arrays is a common task in MongoDB. Operators like $push, $addToSet, and $pull provide specific logic for adding or removing items. $push allows duplicates, $addToSet ensures uniqueness, and $pull removes elements. Mastering these operators is essential for handling nested data structures and managing user-generated content or tagging systems effectively within a document-oriented database schema.

Answer

$merge combines two different collection documents into one array.

Answer

$updateArray is the default operator for all array modifications.

Question 4

Refer to the exhibit. What will be the result of this query?

Accepted Answer

Returns documents with only the 'name' field and no '_id' field.. The query returns all documents where the status field is 'active'. The projection { name: 1, _id: 0 } explicitly includes the 'name' field and explicitly excludes the '_id' field, which is included by default. This is a common pattern for generating clean reports or API responses where internal database identifiers should be hidden from the client or where unnecessary data transfer is undesirable for application performance.

Answer

Returns documents with only the 'status' and 'name' fields.

Answer

Returns an error because 'name' and '_id' cannot be mixed.

Answer

Returns the entire document including all fields.

Question 5

Which THREE of these are valid methods for deleting documents from a MongoDB collection?

Accepted Answer

db.collection.deleteOne(). MongoDB provides specific methods to handle document removal. deleteOne() and deleteMany() are the standard, modern approaches for filtering and removing data. drop() is a collection-level operation that removes all documents and indexes simultaneously. Knowing the difference between these is crucial for data management, as dropping a collection is an irreversible action that bypasses individual document deletion criteria and significantly alters the collection's structure.

Answer

db.collection.removeOne()

Answer

db.collection.removeAll()

Question 6

How do you perform a case-insensitive search using a regular expression in MongoDB?

Accepted Answer

{ field: { $regex: 'pattern', $options: 'i' } }. MongoDB supports PCRE-compatible regular expressions for pattern matching. By using the $regex operator combined with the 'i' option, you can perform case-insensitive searches. This is a common requirement for search features, such as usernames or email addresses, where the user might provide mixed-case input. While powerful, developers should use these carefully, as regex queries can be slow if they do not utilize an appropriate index.

Answer

{ field: { $regex: /pattern/i } }

Answer

{ field: { $insensitive: 'pattern' } }

Answer

{ field: 'pattern' }

Question 7

Which THREE operations would require a write lock on the entire collection in older MongoDB versions (pre-WiredTiger) or affect performance significantly?

Accepted Answer

db.collection.drop(). Before the introduction of the WiredTiger storage engine, MongoDB utilized collection-level locking. Operations like dropping a collection, creating indexes, or performing heavy batch updates could block all other operations. While modern storage engines provide document-level concurrency, understanding these legacy behaviors is still important for database administrators managing older clusters or troubleshooting performance bottlenecks that might arise from global or collection-level locking contention patterns.

Answer

db.collection.findOne({_id: 1})

Answer

db.collection.find().limit(10)

Question 8

You are updating a 'products' collection. You need to increment the 'stock' field by 5 for a document with SKU 'ABC-123', but only if the document currently exists. Which operator is most efficient for this?

Accepted Answer

$inc. The $inc operator modifies a field value by a specified amount, which is atomic and highly efficient for counter updates. Using an update operation rather than a find-and-replace approach avoids transferring the entire document over the network. Understanding atomic operators is critical for high-concurrency environments where multiple application threads might attempt to modify the same document simultaneously, ensuring data consistency without the overhead of application-level locking.

Answer

$set

Answer

$push

Answer

$add

Question 9

Which TWO of the following statements correctly describe the behavior of the find() method in the MongoDB Node.js driver?

Accepted Answer

The query is executed lazily, meaning data is only fetched when the cursor is iterated.. The find() method returns a cursor object that allows efficient iteration over query results without loading the entire result set into memory at once. It does not execute the query immediately, but lazily fetches batches as the application iterates. Mastery of cursor mechanics is essential for building scalable applications that handle large data volumes, as improper handling of cursors can lead to significant memory consumption and performance bottlenecks in production.

Answer

The find() method returns a Promise that resolves to an array of documents.

Answer

The find() method automatically closes the cursor after the first document is retrieved.

Answer

The find() method always returns the documents in the order they were inserted.

Question 10

You are managing a MongoDB collection with a unique index on the 'email' field. You need to insert a new user document, but if a document with the same email already exists, you want to update the existing document with new fields. Which TWO operations achieve this? (Choose two.)

Accepted Answer

db.users.replaceOne({email: 'user@example.com'}, {email: 'user@example.com', name: 'New Name'}, {upsert: true}). Both updateOne with upsert: true and replaceOne with upsert: true can conditionally update or insert a document based on a query filter. They are atomic and work with unique indexes to prevent duplicates. insertOne fails on duplicate, and updateMany is less precise for unique fields. findAndModify is deprecated.

Answer

db.users.updateMany({email: 'user@example.com'}, {$set: {name: 'New Name'}}, {upsert: true})

Answer

db.users.insertOne({email: 'user@example.com', name: 'New Name'})

Answer

db.users.findAndModify({query: {email: 'user@example.com'}, update: {$set: {name: 'New Name'}}, upsert: true})

Question 11

A collection named `orders` contains documents with a field `status` that can be "pending", "shipped", or "delivered". You need to find all orders where `status` is either "pending" or "shipped", but you also want to exclude any orders where a boolean field `archived` is true. Which query should you use?

Accepted Answer

db.orders.find({ status: { $in: ["pending", "shipped"] }, archived: false }). The $in operator matches documents where the field equals any value in the specified array, making it ideal for retrieving orders with status either pending or shipped. Adding archived: false ensures only non-archived orders are returned. This query is concise, uses the correct operator, and avoids the pitfalls of $ne or invalid syntax.

Answer

db.orders.find({ $and: [{ status: "pending" }, { status: "shipped" }], archived: false })

Answer

db.orders.find({ $or: [{ status: "pending" }, { status: "shipped" }], archived: { $ne: true } })

Answer

db.orders.find({ status: { $or: ["pending", "shipped"] }, archived: false })

Question 12

You are a MongoDB DBA. You need to update a document in the 'inventory' collection by adding a new field 'lastUpdated' with the current date and time, but only if the document's 'quantity' is less than 10. Which update operation should you use?

Accepted Answer

db.inventory.updateOne({quantity: {$lt: 10}}, {$set: {lastUpdated: new Date()}}). To update a single document conditionally, updateOne with a query filter and $set is the correct approach. It atomically modifies the first matching document. updateMany would affect multiple documents, replaceOne would overwrite the entire document, and the legacy update method is deprecated.

Answer

db.inventory.updateMany({quantity: {$lt: 10}}, {$set: {lastUpdated: new Date()}})

Answer

db.inventory.update({quantity: {$lt: 10}}, {$set: {lastUpdated: new Date()}})

Answer

db.inventory.replaceOne({quantity: {$lt: 10}}, {lastUpdated: new Date()})

Question 13

You are using the MongoDB Node.js driver to insert a document into a collection. The write concern is set to { w: "majority", j: true }. Which two statements about the behavior of this write operation are correct? (Choose two.)

Accepted Answer

The write concern ensures that the write will not be rolled back even if the primary steps down immediately after the acknowledgement.. The write concern { w: "majority", j: true } ensures the write is acknowledged by a majority of voting members and persisted to the journal on those members. This provides durability and rollback protection. The other options incorrectly describe the acknowledgement scope or add guarantees that are not part of the write concern.

Answer

The write concern guarantees that the write will be visible to all secondary members immediately after acknowledgement.

Answer

The write concern will cause the insert to fail if the replica set has fewer than three members.

Answer

The write will be acknowledged after it is written to the primary's journal only.

Question 14

A financial application uses MongoDB 6.0. A DBA needs to implement a bulk write that processes a mix of inserts, updates, and deletes in a single network round trip while ensuring that operations are executed in the order they are provided. The collection has a unique index on `accountId`. Which two options correctly describe how to achieve this with the `bulkWrite()` method? (Choose two.)

Accepted Answer

Call `db.accounts.bulkWrite([...], { ordered: true })` to guarantee sequential execution of operations.. To perform an ordered bulk write with mixed operations, use `bulkWrite()` with `ordered: true` (or omit the option since true is the default) and include the desired operations in a single array. This ensures sequential execution and a single round trip. The legacy `initializeOrderedBulkOp()` is deprecated, and write concern does not influence ordering.

Answer

Use `db.accounts.bulkWrite([...], { ordered: false })` to allow the server to reorder operations for performance.

Answer

Use `db.accounts.initializeOrderedBulkOp()` to create an ordered bulk operation.

Answer

Set the `writeConcern` to `{ w: 0 }` to ensure the operations are applied in order.

Question 15

A DBA needs to update all documents in the `users` collection where the `lastLogin` field is older than 90 days. The update should set a `status` field to "inactive" and add a `deactivatedAt` field with the current date. The collection contains millions of documents and the operation must not impact production performance. Which approach is most appropriate?

Accepted Answer

Use a script that repeatedly calls `db.users.updateMany()` with a `limit` and a filter on `_id` to process documents in small batches.. For large-scale updates, batching is critical to avoid performance degradation. By iterating over documents in small batches using `_id` ranges and `limit`, the DBA can update millions of documents without locking the collection for extended periods or causing replication lag. This is a standard operational best practice.

Answer

Use `db.users.updateMany( { lastLogin: { $lt: new Date(Date.now() - 90*24*60*60*1000) } }, { $set: { status: "inactive", deactivatedAt: new Date() } } )`.

Answer

Use `db.users.replaceMany( { lastLogin: { $lt: ... } }, { ... } )` to replace entire documents.

Answer

Use `db.users.updateMany()` with `{ multi: true }` option to ensure all documents are updated.