C100DEV Practice Test 13 — 15 Questions

Question 1

You are reviewing an aggregation pipeline on an `orders` collection that must return only orders with a `total` greater than 100 and then compute the number of orders per `customerId`. The collection has an index on `total`. Which two stages should you use, and in what order, to maximize performance while returning the correct results? (Choose two.)

Choose an answer to begin — your selection is scored in the full session.

Accepted Answer

Place a `$group` stage with `_id: "$customerId"` and `count: { $sum: 1 }` after the filtering stage.. To maximize performance while returning correct counts, the pipeline should start with a `$match` on `total` so the indexed field filters documents early, then use `$group` with `$sum: 1` keyed by `customerId`. This order reduces the number of documents entering the grouping stage and ensures the counts reflect only qualifying orders. Other stages either fail to filter correctly or change the result set.

Answer

Place a `$project` stage that includes only `customerId` and `total` before the `$group` stage.

Answer

Place a `$sort` stage on `total` as the first stage to speed up the filter.

Answer

Place a `$limit` stage of 100 before the `$group` stage to reduce the number of documents processed.

Question 2

A developer is reviewing how MongoDB represents and stores data at the document level. Which TWO statements accurately describe the behavior of the BSON format and MongoDB documents? (Choose two.)

Accepted Answer

The maximum size of a single BSON document in MongoDB is 16 MB, and this limit applies to the document as stored on the server.. BSON is a binary-encoded format that extends JSON with types such as ObjectId, Date, and Binary, each identified by a type code. MongoDB also enforces a 16 MB maximum document size, which affects how applications design their data model. These two facts are central to understanding how documents are represented and stored, and they explain why BSON is used rather than plain JSON.

Answer

Field order within a BSON document is not preserved, so queries that depend on field order will not work consistently.

Answer

BSON documents are stored as plain text JSON on disk to simplify backup and restore operations.

Answer

A MongoDB document can contain fields with duplicate names, and the server preserves both values when the document is stored.

Question 3

A social application stores posts with an embedded array of likes containing userId values. Some posts have millions of likes. The team wants to keep post documents small and still answer questions such as whether a specific user liked a post and how many likes a post has. Which two design changes best meet these goals? (Choose two.)

Accepted Answer

Move likes into a separate collection where each document records a postId and userId pair.. Moving likes to their own collection removes the unbounded array from posts and enables indexed per-user lookups, while a denormalized likeCount on the post answers the count question without embedding all likes. Together these keep post documents small and support both required questions. Indexing the array, capped collections, or truncation do not satisfy both goals.

Answer

Store likes in a capped collection and read the count with countDocuments.

Answer

Keep the full likes array on the post and add an index on the array field.

Answer

Embed only the first 100 likes in the post and discard the rest.

Question 4

A team stores user profiles in a `profiles` collection. About 90% of documents have a `deletedAt` field set to null, and only 10% have an actual timestamp indicating soft deletion. Queries that list active users filter on `deletedAt: null` and sort by `createdAt`. The team wants an index that stays small and avoids maintaining entries for deleted documents. Which index definition best matches this requirement?

Accepted Answer

db.profiles.createIndex({ createdAt: 1 }, { partialFilterExpression: { deletedAt: null } }). A partial index limits entries to documents matching its filter expression. Filtering on `deletedAt: null` stores only active profiles, so the index is far smaller than a full compound or sparse index and still supports the equality-plus-sort query. Sparse indexes are unsuitable because the field exists with a null value rather than being absent.

Answer

db.profiles.createIndex({ createdAt: 1 }, { expireAfterSeconds: 0 })

Answer

db.profiles.createIndex({ deletedAt: 1 }, { sparse: true })

Answer

db.profiles.createIndex({ deletedAt: 1, createdAt: 1 })

Question 5

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 6

A financial analytics collection stores documents with fields 'accountId' (string), 'transactionDate' (date), and 'amount' (decimal). A common query is: db.transactions.find({ accountId: 'A123', transactionDate: { $gte: ISODate('2024-01-01'), $lte: ISODate('2024-01-31') }, amount: { $gt: 1000 } }). You need an index that supports this query efficiently. Following the ESR rule, which index key pattern is optimal?

Accepted Answer

{ accountId: 1, transactionDate: 1, amount: 1 }. The query contains an equality on accountId and range predicates on transactionDate and amount, with no explicit sort. The ESR rule dictates that equality fields come first, then sort fields (none here), then range fields. Placing the equality field accountId first allows a direct seek, and ordering the range fields transactionDate then amount lets the index scan the date range efficiently while filtering amount as a residual index condition. This reduces keys examined and avoids a collection scan.

Answer

{ accountId: 1, amount: 1 } and a separate index on transactionDate

Answer

{ transactionDate: 1, accountId: 1, amount: 1 }

Answer

{ accountId: 1, amount: 1, transactionDate: 1 }

Question 7

A developer is building an inventory system for a hardware store. Each item document needs to store the product's name, a unique SKU, the quantity on hand, and a list of compatible replacement part numbers. The developer wants to ensure that the `sku` field is always present and is a string, while still allowing other fields to vary between item types. Which MongoDB feature should the developer use to enforce this requirement?

Accepted Answer

JSON Schema validation with the `$jsonSchema` operator in a collection validator. The requirement is to enforce a specific field and type at write time while allowing other fields to vary. MongoDB's schema validation with `$jsonSchema` is designed for exactly this: you can specify required fields and BSON types in a validator, and the server rejects documents that do not comply. This keeps the collection flexible for other fields but guarantees the `sku` contract.

Answer

The `$exists` query operator in all read operations

Answer

A unique index on the `sku` field

Answer

Storing the `sku` in a separate collection and using `$lookup`

Question 8

A social media platform stores each user's 'followers' as an array of ObjectIds inside the user document. Analytics shows that a small number of celebrity accounts have millions of followers, and these documents are approaching the 16MB BSON limit. Which schema pattern should a MongoDB developer apply to resolve this issue?

Accepted Answer

Apply the Outlier Pattern by adding an overflow flag and moving the followers array into a separate collection only for users that exceed a threshold.. The Outlier Pattern is the correct design when a minority of documents drastically exceed the typical size of the rest. By marking outlier documents and relocating their oversized arrays to a separate collection, developers preserve the simple embedded model for the common case while still supporting celebrity-scale data. Neither subsetting recent entries nor time-bucketing events addresses the real requirement of storing a complete, queryable follower list for every user.

Answer

Apply the Bucket Pattern by grouping follower ObjectIds into fixed-size buckets of 1000 per document in a separate collection.

Answer

Apply the Extended Reference Pattern by duplicating the ten most important follower documents into the user document.

Answer

Apply the Subset Pattern by storing only the 100 most recent followers in the user document and the full list in a separate collection.

Question 9

A logistics application stores shipment events in the 'shipments' collection. Each document contains a field 'events' that is an array of subdocuments with fields 'status' and 'timestamp'. You need to remove the subdocument where 'status' equals 'cancelled' from all documents in the collection, without affecting other array elements. Which update operation should you use?

Accepted Answer

db.shipments.updateMany({}, { $pull: { events: { status: 'cancelled' } } }). The $pull operator is designed to remove array elements that match a specified condition, making it ideal for removing subdocuments based on a field value. It works with updateMany to affect all documents. Other operators like $unset, $pop, and $pullAll do not support conditional removal of subdocuments based on a field, so they would not achieve the desired result.

Answer

db.shipments.updateMany({}, { $pullAll: { events: [{ status: 'cancelled' }] } })

Answer

db.shipments.updateMany({}, { $unset: { events: { status: 'cancelled' } } })

Answer

db.shipments.updateMany({}, { $pop: { events: { status: 'cancelled' } } })

Question 10

A financial application stores transactions in a MongoDB collection. Each transaction document includes a 'timestamp' field. The application needs to query transactions for a specific day, and the queries must be efficient. Which indexing strategy is most appropriate?

Accepted Answer

Create a single-field index on the 'timestamp' field. For efficient range queries on a single field, a single-field index is the correct choice. It allows MongoDB to quickly find documents with timestamps within the desired range. Compound indexes can also work but are unnecessary here, and other index types like text or hashed do not support range queries on dates. The single-field index provides the best balance of performance and simplicity.

Answer

Create a hashed index on the 'timestamp' field

Answer

Create a compound index on {timestamp: 1, _id: 1}

Answer

Create a text index on the 'timestamp' field

Question 11

A developer is writing a Node.js application that must execute a series of document updates across two collections atomically. The application uses the MongoDB Node.js driver and needs to ensure that if any operation fails, all changes are rolled back. Which driver API should the developer use to achieve this?

Accepted Answer

Use the startSession() method on the MongoClient instance and then call session.withTransaction() to run the operations.. Multi-document transactions in MongoDB are managed through client sessions. The Node.js driver's session.withTransaction() method handles the lifecycle, including retries on transient errors and automatic commit or abort. This ensures that updates across multiple collections are atomic. Other methods like bulkWrite or findOneAndUpdate operate on a single collection or document and lack the necessary transactional guarantees.

Answer

Use the insertMany() method with the ordered option set to false to ensure atomicity.

Answer

Use the bulkWrite() method with ordered: true to group updates across collections.

Answer

Use the findOneAndUpdate() method with a session parameter for each update.

Question 12

You are troubleshooting a pipeline over a large `telemetry` collection that exceeds the aggregation memory limit while running on a single mongod instance. You must let the pipeline complete successfully without changing the server-wide configuration. Which two actions will allow the pipeline to keep running? (Choose two.)

Accepted Answer

Add a $match stage before the memory-intensive stage to reduce the document count.. Two levers work within the stated constraints: enabling allowDiskUse so blocking stages can spill to disk, and shrinking the input with an early $match that can also exploit indexes. Together they address both the spill capacity and the underlying data volume, letting the pipeline complete on a single instance without any server-wide reconfiguration.

Answer

Move the memory-intensive stage to the end of the pipeline.

Answer

Disable the memory limit by restarting mongod with a larger wiredTigerCacheSizeGB value.

Answer

Set the internalQueryMaxBlockingSortMemoryUsageBytes parameter to a larger value.

Question 13

A logistics company uses MongoDB to store shipment data. Each shipment document includes a status field that can be one of several values: 'pending', 'in_transit', 'delivered', 'cancelled'. The application frequently queries shipments by status and also needs to generate reports that count shipments per status. The team wants to ensure efficient queries and minimal index overhead. Which schema design consideration is most important?

Accepted Answer

Store the status as a string and create a single-field index on it.. For a field with a limited set of values that is frequently queried, a simple single-field index on that field is the most efficient and straightforward solution. It supports equality matches and aggregation for counting, and it has minimal impact on write performance. More complex patterns or compound indexes are not warranted based on the described access patterns.

Answer

Use a compound index on status and shipment_date to support both filtering and sorting.

Answer

Store the status as an integer code and create a single-field index on it.

Answer

Use the Attribute Pattern to store status as a key-value pair and index the key and value fields.

Question 14

You are managing a MongoDB collection that stores sensor data. Each document has a `timestamp` field and a `sensorId` field. The collection is very large, and you need to optimize a query that finds the most recent reading for a specific sensor. The query is: `db.sensors.find({ sensorId: 'abc123' }).sort({ timestamp: -1 }).limit(1)`. Which index would best support this query?

Accepted Answer

db.sensors.createIndex({ sensorId: 1, timestamp: -1 }). The query filters on `sensorId` (equality) and sorts by `timestamp` descending. To optimize, the index should follow the ESR rule: equality field first, then sort field. The index must also match the sort direction. Therefore, an index on `{ sensorId: 1, timestamp: -1 }` allows MongoDB to quickly find the specific sensor and then retrieve the most recent timestamp from the index without scanning or sorting. This is the most efficient index for this query pattern.

Answer

db.sensors.createIndex({ timestamp: -1, sensorId: 1 })

Answer

db.sensors.createIndex({ sensorId: 1, timestamp: 1 })

Answer

db.sensors.createIndex({ timestamp: 1, sensorId: 1 })

Question 15

A financial application stores account documents with an embedded array of transactions. The array is unbounded and documents have reached 8MB. Auditors require a complete, ordered history of every transaction. Which approach best preserves full history while keeping account documents within size limits?

Accepted Answer

Move transactions to a separate collection, each transaction referencing its account, and use the Bucket Pattern to group transactions by month for efficient range queries.. The correct design separates the unbounded child data into its own collection and uses bucketing to keep related transactions efficient to query. Referencing the account preserves relational integrity, while monthly buckets cut index size and improve range-scan performance. Capping, compressing, or pushing structured data into GridFS all fail either the completeness requirement or the queryability requirement that auditors demand.

Answer

Embed transactions but compress them using BSON binary subtype 0 so they consume less space.

Answer

Keep transactions embedded but cap the array at 1000 entries, discarding the oldest when new ones arrive.

Answer

Store transactions in a GridFS bucket because GridFS is designed for data that exceeds 16MB.