C100DBA Practice Test 3 — 30 Questions

Question 1

Which configuration file setting is used to specify the network interface and port that a mongod instance listens on?

Accepted Answer

net. The 'net' section in the YAML configuration file provides granular control over how the MongoDB instance communicates over the network. Configuring the 'bindIp' and 'port' is a fundamental step in securing and reaching the database. Properly setting these parameters ensures that the server is accessible only on the intended interfaces, which is a critical security practice to prevent unauthorized access from untrusted networks or public interfaces.

Answer

systemLog

Answer

storage

Answer

processManagement

Question 2

Which read concern provides the strongest consistency guarantee by ensuring the data returned has been acknowledged by a majority of the replica set?

Accepted Answer

majority. The 'majority' read concern guarantees that the data read has been committed to a majority of the replica set members, ensuring that the read will not be rolled back after a failover. This is essential for applications requiring strong consistency, such as financial systems. DBAs must guide developers on when to trade off performance for this level of consistency to ensure the application behaves correctly under all possible cluster failure scenarios.

Answer

local

Answer

available

Answer

snapshot

Question 3

In a three-node replica set with default write concern w:1, what happens to an unacknowledged write if the primary crashes immediately after receiving the write command but before replicating it to secondaries?

Accepted Answer

The write is lost, and the new primary will not contain the data.. With w:1, the primary acknowledges the write as soon as it is applied to its local oplog. If the primary fails before replication, the new primary elected from the remaining nodes will not contain this write. This demonstrates the critical trade-off between performance and durability. Clients must use w:'majority' to ensure data consistency during failover events, as single-node acknowledgments are insufficient to guarantee persistence against primary loss.

Answer

The write is automatically rolled back and re-applied when the old primary recovers.

Answer

The write remains in the local storage of the crashed node and becomes visible upon restart.

Answer

The replica set triggers an automatic consistency recovery to force the write to other nodes.

Question 4

When designing a compound shard key in MongoDB, what is the architectural significance of placing a high-cardinality field as the prefix compared to placing a low-cardinality field first?

Accepted Answer

A high-cardinality prefix ensures fine-grained chunk boundaries and even data distribution, whereas a low-cardinality prefix causes massive chunks that cannot be split effectively.. The shard key prefix dictates how MongoDB organizes and partitions chunk ranges across the cluster. A high-cardinality prefix ensures fine-grained chunk boundaries and prevents massive, unmanageable chunks from forming around repetitive values, which often happens when low-cardinality fields like boolean flags or status codes occupy the leading position.

Answer

A high-cardinality prefix allows the query router to bypass authentication checks on secondary shards, improving overall cluster query response times.

Answer

A low-cardinality prefix enables the WiredTiger storage engine to cache entire indexes in RAM, eliminating disk I/O bottlenecks entirely.

Answer

A low-cardinality prefix automatically triggers hashed shard evaluation, bypassing the need for explicit hashing functions during collection creation.

Question 5

A multi-document transaction is being executed across multiple shards. Which component is responsible for coordinating the transaction and ensuring the all-or-nothing property?

Accepted Answer

The mongos router that initiated the transaction.. Multi-document transactions in a sharded cluster are coordinated by the mongos router where the transaction was initiated. The mongos acts as the transaction coordinator, using a two-phase commit protocol to ensure consistency across the participant shards. This allows applications to maintain ACID guarantees even when data is distributed across a horizontally scaled environment.

Answer

The primary node of the config server replica set.

Answer

The shard that contains the first document accessed in the transaction.

Answer

A specialized 'Transaction Manager' node that must be configured.

Question 6

A MongoDB 6.0 replica set is experiencing performance issues during peak hours. The DBA notices that the primary is spending significant time on disk I/O. The DBA wants to identify which collections are generating the most disk reads and writes. Which administrative command should the DBA use?

Accepted Answer

mongotop. mongotop is designed to provide per-collection read and write statistics, showing how much time each collection spends on these operations. This directly answers the need to find collections generating the most disk I/O. The other tools either provide server-wide metrics, point-in-time operation lists, or static collection statistics that do not reflect active I/O.

Answer

db.currentOp()

Answer

db.serverStatus()

Answer

db.collection.stats()

Question 7

A logistics company is designing a MongoDB database for a real-time shipment tracking system. The operations team needs to frequently update shipment statuses and query the latest events. The development team is debating the trade-offs of embedding versus referencing for the shipment events. Which two considerations align with MongoDB's philosophy for this scenario? (Choose two.)

Accepted Answer

Embedding events within the shipment document ensures atomic updates and fast reads for the event history.. The correct considerations are that embedding provides atomic updates and fast reads for the event history, while referencing allows unlimited growth and avoids the 16 MB limit. These reflect MongoDB's flexible modeling philosophy: choose embedding when data is accessed together and atomicity is needed, but opt for referencing when data grows unbounded or is accessed independently. The decision hinges on access patterns and data lifecycle.

Answer

Embedding events is always preferred because it eliminates the need for multi-document transactions.

Answer

Referencing events requires using $lookup for every read, which is as fast as an embedded document read.

Answer

Embedding events ensures that the shipment document remains small and efficient for writes.

Question 8

A DBA is reviewing update operations that use the upsert option. Which TWO statements about upsert behavior in MongoDB are correct? (Choose two.)

Accepted Answer

If no document matches the filter, upsert inserts a new document based on the filter and the update operators.. Upsert inserts a new document when the filter matches nothing, building it from equality conditions in the filter plus the update operators. Non-equality operators do not contribute fields, so the inserted document may lack the filtered field. A unique index is recommended to prevent duplicate inserts from concurrent upserts, but it is not mandatory. Array operators such as $push are allowed in upserts.

Answer

Upsert cannot be used with update operators that modify array elements, such as $push.

Answer

If multiple documents match the filter, upsert updates all of them and inserts no new document.

Answer

Upsert always requires a unique index on the filter fields to avoid duplicate inserts.

Question 9

A financial services company runs a sharded MongoDB cluster with three shards. They need to shard a new collection that stores transaction records. The collection will be queried primarily by 'accountId' and 'transactionDate'. The team wants to minimize scatter-gather queries and ensure even data distribution. Which two actions should they take when choosing and implementing the shard key? (Choose two.)

Accepted Answer

Ensure the shard key has high cardinality and low frequency to avoid jumbo chunks and hot spots.. The compound shard key with 'accountId' first supports targeted queries on account and range queries on date, while also providing high cardinality and low frequency. This combination reduces scatter-gather and avoids hot spots. Hashed or random keys improve distribution but break query targeting, and a monotonically increasing key creates write hot spots.

Answer

Choose a shard key that is monotonically increasing, such as an auto-incrementing transaction ID, to simplify range queries.

Answer

Use a random shard key generated by the application to guarantee even distribution across shards.

Answer

Use a hashed shard key on 'accountId' to ensure even distribution, even though it prevents efficient range queries on 'transactionDate'.

Question 10

A MongoDB DBA is configuring a new sharded cluster. The application requires that queries on the sharded collection include the shard key to avoid scatter-gather. The DBA decides to use a ranged shard key on the field 'region'. After sharding, the DBA notices that queries filtering only on 'region' are performing well, but queries that also filter on 'city' are still scanning all shards. What is the most likely cause?

Accepted Answer

The shard key does not include 'city', so queries with both 'region' and 'city' cannot be targeted to a single shard.. Query targeting in a sharded cluster depends on the shard key. If the shard key is only 'region', queries that filter on 'region' can be routed to specific shards. Adding 'city' does not change the routing because 'city' is not part of the shard key. To target on both fields, the shard key would need to be compound, including both 'region' and 'city'.

Answer

The 'city' field is not indexed, causing the query to scan all shards.

Answer

The balancer has not yet distributed chunks evenly, so some shards have more data and cause the query to scan them.

Answer

The shard key 'region' has low cardinality, so queries cannot be targeted efficiently.

Question 11

A retail application stores product documents in the `products` collection. Each document has an `inventory` array of embedded subdocuments, for example: `{ _id: 1, name: "Widget", inventory: [ { sku: "A1", qty: 5 }, { sku: "B2", qty: 8 } ] }`. The warehouse team needs to increase the `qty` of the subdocument with `sku: "B2"` by 3 for the product with `_id: 1`. Which update operation accomplishes this?

Accepted Answer

db.products.updateOne( { _id: 1, "inventory.sku": "B2" }, { $inc: { "inventory.$.qty": 3 } } ). The positional `$` operator updates the first array element that matches the query condition. Pairing `"inventory.sku": "B2"` in the filter with `"inventory.$.qty"` in the update ensures only the subdocument with that SKU is modified. Using `$inc` performs the required arithmetic and preserves the numeric field type, which is essential for inventory counts.

Answer

db.products.updateOne( { _id: 1, "inventory.sku": "B2" }, { $inc: { "inventory.0.qty": 3 } } )

Answer

db.products.updateOne( { _id: 1, "inventory.sku": "B2" }, { $set: { "inventory.$.qty": "3" } } )

Answer

db.products.updateOne( { _id: 1 }, { $inc: { "inventory.qty": 3 } } )

Question 12

A startup is building a mobile app backend. They want to iterate quickly on features without downtime for schema changes. Which MongoDB characteristic best supports this agile development approach?

Accepted Answer

The ability to store documents with varying fields without altering a centralized schema. MongoDB's document model lets developers add or modify fields per document without a centralized schema migration. This means new features can be deployed without database downtime, directly supporting the startup's need for rapid iteration and continuous delivery.

Answer

Schema validation rules that must be updated before any new field can be stored

Answer

Requiring all documents in a collection to have identical fields at all times

Answer

Using a fixed-width binary format that cannot represent new data types

Question 13

A developer needs to insert a document into the inventory collection and wants the operation to fail with a duplicate key error if a document with the same value for the sku field already exists. The sku field has a unique index. Which insert method and option combination achieves this with the least code?

Accepted Answer

db.inventory.insertOne( { sku: "A100", qty: 5 } ). A unique index on sku is what enforces the duplicate constraint. A plain insertOne is sufficient: if the sku already exists, the server returns a duplicate key error. The ordered option is only relevant for multi-document inserts, upsert would update instead of fail, and bypassDocumentValidation only affects schema validation, not unique indexes.

Answer

db.inventory.updateOne( { sku: "A100" }, { $set: { qty: 5 } }, { upsert: true } )

Answer

db.inventory.insertMany( [ { sku: "A100", qty: 5 } ], { bypassDocumentValidation: true } )

Answer

db.inventory.insertOne( { sku: "A100", qty: 5 }, { ordered: false } )

Question 14

A production MongoDB 6.0 sharded cluster has a collection with a ranged shard key on the field `customerId`. Over time, the team notices that nearly all new documents have monotonically increasing `customerId` values, and one shard is receiving a disproportionate share of writes while the other shards remain relatively idle. The balancer is enabled and running. Which of the following is the most likely explanation for this imbalance?

Accepted Answer

The shard key is monotonically increasing, causing all new inserts to target the highest chunk on a single shard.. With a monotonically increasing shard key, new inserts always target the chunk with the highest key range. Because chunks are assigned to shards, that highest chunk lives on one shard at a time, making it a write hotspot. The balancer will eventually migrate chunks, but the stream of new inserts keeps hitting the newest chunk, so the imbalance persists.

Answer

The shard key field is not indexed on the shards, forcing all writes to a single primary.

Answer

The config servers are overloaded and cannot process chunk migration commands.

Answer

The collection has too few chunks, so the balancer cannot distribute them evenly across shards.

Question 15

A collection called events stores documents with an array field named tags. You need to remove all occurrences of the string "obsolete" from the tags array in every document where the array contains that value, without affecting other elements. Which update operator should you use?

Accepted Answer

$pull. $pull is the array update operator that removes all elements matching a value or condition. Filtering on documents where tags contains "obsolete" and applying $pull deletes every such occurrence while leaving other tags intact. $unset removes whole fields, $pop removes positional elements, and $set replaces values rather than selectively removing matches.

Answer

$unset

Answer

$pop

Answer

$set

Question 16

A DBA notices that a query on the products collection uses an index scan but returns only a small fraction of documents. The index is { category: 1, price: 1 }. The query filters on category and price with a range condition on price. Which statement best describes why the index might still be efficient despite scanning many index entries?

Accepted Answer

The index scan is efficient because it can use the index bounds to limit the scan to the relevant category and price range, reducing the number of documents fetched.. The index { category: 1, price: 1 } supports efficient filtering when the query has an equality predicate on category and a range predicate on price. MongoDB can use index bounds to seek to the correct category and scan only the relevant price range, minimizing the number of documents fetched. This makes the index scan efficient despite examining many index entries.

Answer

The index scan is efficient because MongoDB automatically converts it to a collection scan when the selectivity is low.

Answer

The index scan is efficient because it avoids fetching documents entirely due to the index being covered.

Answer

The index scan is efficient because it uses the index only for sorting and not for filtering.

Question 17

A collection 'events' has a compound index { tenantId: 1, createdAt: -1 }. A developer runs db.events.find({ tenantId: "acme", createdAt: { $gte: ISODate("2024-01-01") } }).sort({ createdAt: -1 }).limit(50). The explain output shows the index is used but the query still performs a large in-memory sort. Which action resolves the sort performance issue?

Accepted Answer

Ensure the index is { tenantId: 1, createdAt: -1 } and verify the query does not use a collation or type mismatch that prevents index-provided sort.. A compound index can provide both the equality match and the sort when the equality fields form the prefix and the sort field follows. With { tenantId: 1, createdAt: -1 }, the query's equality on tenantId and sort on createdAt should be served without an in-memory sort. A blocking SORT in explain therefore points to a mismatch such as collation, type, or query shape rather than a missing index.

Answer

Add a sort key to the index: { tenantId: 1, createdAt: -1, _id: 1 }.

Answer

Reverse the compound index to { createdAt: -1, tenantId: 1 }.

Answer

Create a separate single-field index on createdAt.

Question 18

You are a DBA for a MongoDB replica set. A secondary node has been down for several days and is far behind the primary. The oplog on the primary has wrapped, and the secondary's last oplog entry is no longer present. What must you do to bring the secondary back into sync?

Accepted Answer

Perform a full resync by stopping the secondary, deleting its data files, and restarting it.. If a secondary's last oplog entry is no longer in the primary's oplog, the secondary cannot catch up incrementally. A full resync is required, which means deleting the secondary's data files and restarting it to perform an initial sync. This process copies all data from the primary or another sync source.

Answer

Increase the oplog size on the primary to prevent wrapping and then restart the secondary.

Answer

Restart the secondary with the --resync option to force a full resync.

Answer

Run rs.syncFrom() on the secondary to point it to a different sync source.

Question 19

A DBA is designing indexes for a collection that stores user activity logs. The collection has fields: user_id, action, timestamp, and metadata (an embedded document). The most common queries are: (1) find all actions for a given user_id sorted by timestamp descending; (2) find all users who performed a specific action within a time range. Which TWO indexes would best support these queries? (Choose two.)

Accepted Answer

{ user_id: 1, timestamp: -1 }. The two indexes that best support the queries are { user_id: 1, timestamp: -1 } for query (1) and { action: 1, timestamp: 1 } for query (2). The first provides an equality match on user_id and a sort on timestamp, while the second provides an equality match on action and a range on timestamp. These indexes align with the equality-sort and equality-range patterns, ensuring efficient index usage.

Answer

{ metadata: 1 }

Answer

{ user_id: 1, action: 1, timestamp: -1 }

Answer

{ timestamp: 1 }

Question 20

You are updating a document in the `products` collection. The document has an array field `tags`. You need to add the tag "sale" to the array only if it does not already exist, and you want to ensure that no duplicate tags are added even if multiple updates run concurrently. Which update operator should you use?

Accepted Answer

$addToSet. $addToSet is designed to add a value to an array only if it is not already present, making it the correct operator for ensuring uniqueness. It performs this check atomically, so concurrent updates will not introduce duplicates. $push would append duplicates, $set would replace the array, and $addToSet with $each is overkill for a single value.

Answer

$addToSet with $each

Answer

$push

Answer

$set