C100DEV Practice Test 2 — 30 Questions

Question 1

A developer is working with a MongoDB collection that stores product data. The collection has documents with a field 'price' that is sometimes stored as a double and sometimes as a string, due to inconsistent data entry. A query is run to find all products with a price greater than 100. What is the expected behavior of this query?

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

Accepted Answer

The query will return only documents where 'price' is a double greater than 100.. MongoDB uses type bracketing for comparison operators: only values of the same BSON type as the operand are considered. Since 100 is a double, only double prices greater than 100 are returned. Strings are not converted, and no error occurs. This underscores the importance of consistent data types in a collection.

Answer

The query will return an error because of the mixed data types in the 'price' field.

Answer

The query will return documents where 'price' is a string greater than '100' lexicographically, as well as doubles greater than 100.

Answer

The query will return all documents where 'price' is greater than 100, regardless of whether it is a double or string.

Question 2

An application stores customer profiles in a MongoDB collection. A developer notices that documents created by different services have inconsistent shapes: some use a string for phone, others an array of strings, and some omit the field entirely. The team wants to enforce a consistent structure for new writes while still allowing existing documents to remain. Which MongoDB feature should they use?

Accepted Answer

A JSON Schema validator attached to the collection with the $jsonSchema operator and validationLevel set to strict.. MongoDB supports schema validation through the $jsonSchema operator, configured on a collection with collMod. Setting validationLevel to strict applies the rules to all inserts and updates, so new writes must match the declared structure. Existing documents that are not modified remain untouched, which satisfies the requirement to leave current data as is while enforcing consistency going forward.

Answer

A unique index on the phone field, which forces every document to use the same BSON type for that field.

Answer

A partial index with a filter expression that excludes documents lacking the phone field.

Answer

A change stream that watches the collection and rejects documents whose shape differs from a template.

Question 3

An application using the MongoDB Node.js driver must ensure that a multi-document transaction is retried correctly when it encounters a transient error. Which two practices are required? (Choose two.)

Accepted Answer

On a commit error with the UnknownTransactionCommitResult label, retry the commit operation.. The Node.js driver exposes error labels that tell the application how to recover. A TransientTransactionError requires restarting the entire transaction, while UnknownTransactionCommitResult requires retrying the commit. These two behaviors are the documented retry pattern for multi-document transactions. Other options either misplace read concern, misunderstand the lifetime limit or weaken durability without addressing retries.

Answer

Increase the transaction lifetime limit beyond 60 seconds to avoid all retries.

Answer

Set the readConcern to 'snapshot' on every individual operation inside the transaction.

Answer

Disable write concern to make commits faster and reduce retries.

Question 4

A development team is modeling a MongoDB collection for a ticketing system. Each ticket has a unique ticketId, a status, and a variable set of custom fields that differ by department. The team wants to ensure that queries on ticketId and status can use indexes efficiently and that the custom fields remain flexible. Which statement best describes how the document model supports this requirement?

Accepted Answer

Documents in the same collection can have different fields, and indexes on ticketId and status can be created regardless of the custom fields present.. The document model allows each ticket to have its own shape while sharing common fields. Indexes are created on specific fields such as ticketId and status, and they work even when documents contain additional custom fields. This gives the team efficient lookups on the common fields and the flexibility to store department-specific data without schema migrations.

Answer

MongoDB enforces a collection-level schema, so the team must define all custom fields in a validator before inserting tickets.

Answer

Custom fields must be stored in a separate collection because MongoDB does not allow arrays or subdocuments in the same collection as scalar fields.

Answer

Indexes in MongoDB are created on collections, not fields, so the team cannot index ticketId and status without also indexing all custom fields.

Question 5

A developer needs to create an Atlas Search index that supports autocomplete on a `name` field. Which Atlas Search index definition is required?

Accepted Answer

An index with a field of type 'autocomplete' and an analyzer such as 'lucene.standard' or a custom edge-gram analyzer.. Atlas Search uses the `autocomplete` field type to support prefix suggestions. The field must be configured with an analyzer that produces edge-grams or n-grams, such as a custom analyzer using the edgeGram tokenizer. Standard string or text indexes do not provide this behavior. Wildcard indexes are unrelated to Atlas Search and cannot satisfy the autocomplete requirement.

Answer

A text index with the default language analyzer.

Answer

A standard string index with dynamic mapping enabled.

Answer

A wildcard index on the `name` field.

Question 6

A developer needs to quickly inspect the contents of a collection and run ad-hoc queries against a MongoDB Atlas cluster without installing any additional software. Which tool should be used?

Accepted Answer

Atlas Data Explorer. Atlas Data Explorer is a web-based interface integrated into MongoDB Atlas that lets users view and query data without installing any software. It is the most convenient tool for quick inspection and ad-hoc queries, as it is accessible directly from the Atlas UI and requires no local setup.

Answer

MongoDB Database Tools

Answer

MongoDB Compass

Answer

mongosh

Question 7

A financial application stores transaction records in a MongoDB collection. Each transaction document includes a Decimal128 amount field and a Date field for the transaction time. A developer needs to query for transactions with amounts greater than 100.00 and times within the last 24 hours, and wants the queries to use indexes efficiently. Which statement about the document model and BSON types is correct for this scenario?

Accepted Answer

Date values are stored as 64-bit integers representing milliseconds since the Unix epoch, and they can be indexed and compared with range operators.. BSON Date is stored as a 64-bit integer of milliseconds since the Unix epoch, which makes it directly comparable and indexable for range queries. Decimal128 is a separate numeric type that also supports range comparisons and indexing. Together, they allow the application to filter by amount and time efficiently using appropriate indexes, without converting values to strings or avoiding range queries.

Answer

Range queries on Decimal128 fields are not supported; only equality queries can use an index on a Decimal128 field.

Answer

Decimal128 values are stored as strings, so range queries on the amount field require a text index rather than a numeric index.

Answer

Because Decimal128 and Date are both binary types, they cannot be used together in a compound index on the same collection.

Question 8

A developer is designing a MongoDB collection to store sensor readings. Each reading document contains a sensorId, a timestamp, and a readings array of subdocuments with type and value fields. The application frequently queries for readings where the readings array contains a subdocument with type "temperature" and value greater than 30. Which document model feature allows the query to match elements within the array efficiently?

Accepted Answer

Multikey indexes, which are created automatically when an index is built on a field that contains an array, allow the query to match individual array elements.. A multikey index is created when an index is built on a field containing an array. MongoDB generates an index entry for each array element, so queries that filter on subdocument fields within the array can use the index. This allows the sensor reading query to match temperature readings above 30 efficiently, as long as an appropriate index exists on the readings field.

Answer

The _id index, which is created on every collection, includes all array elements and can be used to match subdocument fields.

Answer

Capped collections, which store documents in insertion order, automatically index array elements for fast lookups.

Answer

Array flattening, which merges all subdocuments into a single document, allows the query to treat the readings array as a flat set of fields.

Question 9

A developer needs to load a large JSON file into a collection named 'inventory' in the 'retail' database on a MongoDB server running on localhost. The file contains one JSON document per line. Which command-line tool should be used?

Accepted Answer

mongoimport --db retail --collection inventory --file inventory.json. The correct tool is mongoimport, which is part of the MongoDB Database Tools and specifically built to import data from JSON, CSV, or TSV files into a collection. The other tools serve different purposes: mongorestore restores BSON dumps, mongoexport exports data, and mongofiles manages GridFS files. Only mongoimport matches the requirement of loading a JSON file into a collection.

Answer

mongofiles --db retail --collection inventory --file inventory.json

Answer

mongoexport --db retail --collection inventory --file inventory.json

Answer

mongorestore --db retail --collection inventory inventory.json

Question 10

You are the lead developer for a high-traffic e-commerce application using MongoDB 6.0. A query on the `orders` collection that filters on `customerId` and sorts by `orderDate` in descending order is performing poorly. You decide to create an index to improve its performance. Which of the following indexes would be most efficient for this query?

Accepted Answer

db.orders.createIndex({ customerId: 1, orderDate: -1 }). The most efficient index for a query with an equality filter and a sort is one that follows the Equality, Sort, Range (ESR) rule: equality fields first, then sort fields. The index must also match the sort direction. Here, the query filters on `customerId` (equality) and sorts by `orderDate` descending. Therefore, an index on `{ customerId: 1, orderDate: -1 }` allows MongoDB to use the index for both filtering and sorting, avoiding an expensive in-memory sort and ensuring optimal performance.

Answer

db.orders.createIndex({ customerId: 1, orderDate: 1 })

Answer

db.orders.createIndex({ orderDate: -1, customerId: 1 })

Answer

db.orders.createIndex({ orderDate: 1, customerId: 1 })

Question 11

An application requires grouping orders by customer ID and calculating the total purchase amount per customer. However, some customers have orders with missing or null purchase amounts that must be excluded before calculation. Which aggregation pipeline stage sequence correctly achieves this goal?

Accepted Answer

{ $match: { purchaseAmount: { $ne: null } } }, { $group: { _id: "$customerId", total: { $sum: "$purchaseAmount" } } }. Filtering out documents with null or missing purchase amounts using the $match stage ensures that subsequent grouping operations do not process corrupted or incomplete data. Placing $match before $group also allows MongoDB to utilize indexes on the purchaseAmount field, significantly improving aggregation performance on large collections.

Answer

{ $group: { _id: "$customerId", total: { $sum: "$purchaseAmount" } } }, { $match: { purchaseAmount: { $ne: null } } }

Answer

{ $project: { customerId: 1, purchaseAmount: 1 } }, { $group: { _id: "$customerId", total: { $sum: "$purchaseAmount" } } }

Answer

{ $sort: { purchaseAmount: 1 } }, { $group: { _id: "$customerId", total: { $sum: "$purchaseAmount" } } }

Question 12

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 13

A social media application stores user posts. Each post document currently embeds a comments array. A single popular post can accumulate over 50,000 comments, causing the document to grow beyond 10 MB. The development team wants to avoid hitting the 16 MB document size limit while still being able to retrieve a post with its most recent 10 comments in a single query. Which schema design should they implement?

Accepted Answer

Keep the most recent 10 comments embedded in the post document and store older comments in a separate comments collection.. The Subset Pattern is ideal when a document contains a large array that grows indefinitely. By embedding only the most recent 10 comments, the post document remains small and the application can still fetch the post with its recent comments in one read. Older comments are stored separately, preserving access to historical data without bloating the main document.

Answer

Move all comments into a separate comments collection and store an array of comment _ids in the post document.

Answer

Use a capped collection for the posts collection to automatically limit document size.

Answer

Convert the comments array into a GridFS bucket and store the file reference in the post document.

Question 14

A financial analytics team stores daily stock snapshots as one document per symbol per day in a collection named 'prices'. Each document contains an array of 60 subdocuments, one per minute, with fields 'minute', 'open', 'close', and 'volume'. The team now needs to compute the hourly average 'close' for a single symbol over a single day. Which aggregation approach is most appropriate for this schema?

Accepted Answer

Use $unwind on the minute array, then group by an expression that truncates 'minute' to the hour and average 'close'.. The data is stored in buckets, so per-minute analysis requires expanding the embedded array before grouping. $unwind emits one document per array element, and a subsequent $group can bucket by a truncated hour value and compute the average 'close'. This preserves the storage benefits of embedding while still enabling fine-grained aggregation over the measurements.

Answer

Run a $match for the symbol and day, then use $replaceRoot with the minute array to promote each element.

Answer

Use $group with $push to collect all 'close' values into an array, then apply $avg to the array.

Answer

Create a separate collection with one document per minute and migrate the data, then aggregate over it.

Question 15

A development team is designing a schema for an e-commerce application that stores product data. Products have a set of core fields (name, price, description) that are common to all products, but different product categories have unique attributes (e.g., 'screen_size' for electronics, 'fabric' for clothing). Queries often filter on these category-specific attributes. The team wants a flexible schema that supports efficient queries on any attribute. Which TWO of the following design approaches are most appropriate? (Choose two.)

Accepted Answer

Use the Polymorphic Pattern to store all products in one collection with a 'category' field and include category-specific fields at the top level.. The Polymorphic Pattern allows a single collection to store documents with different structures, while the Attribute Pattern converts variable attributes into an indexable array of key-value pairs. Together, they provide a flexible schema that supports efficient queries on any category-specific attribute. Both patterns are widely used in MongoDB for handling heterogeneous data and are appropriate here.

Answer

Use the Bucket Pattern to group products by category into buckets of 100 documents.

Answer

Embed all possible category-specific attributes in every product document, using null for missing attributes.

Answer

Create a separate collection for each product category with its own schema and indexes.

Question 16

A team is modeling orders and customers. Orders are frequently displayed with basic customer details such as name and email, but customer profiles are large and change often. Which approach best balances read performance with avoiding duplication problems?

Accepted Answer

Embed a small subset of frequently accessed customer fields in the order while keeping the full profile in the customers collection.. A selective embedding of only the fields commonly shown with orders keeps those reads fast and self-contained, while the authoritative, larger profile stays in its own collection to avoid widespread duplication. This balances read locality with manageable update cost. The other choices either over-duplicate volatile data or force a lookup on every read.

Answer

Embed the entire customer profile document inside every order.

Answer

Normalize customers and orders into separate collections with no duplicated fields and use $lookup for every read.

Answer

Store only a customerId reference in each order and always perform an application-side join.

Question 17

A developer is troubleshooting a Python application that uses the MongoDB driver to query the 'products' collection with find({'category': 'tools'}). Which two statements about the returned cursor are correct? (Choose two.)

Accepted Answer

The cursor automatically closes when it is exhausted, but must be closed explicitly if iteration stops early.. Cursors are lazy and fetch documents in batches during iteration, and they close automatically when exhausted but require explicit close() if iteration stops early. They do not eagerly load all matches, do not automatically re-execute on concurrent writes, and do not guarantee any result order without an explicit sort. These properties affect both memory use and server resource management.

Answer

The cursor loads all matching documents into client memory immediately when find is called.

Answer

The cursor returns documents in an order guaranteed by the storage engine, so no explicit sort is needed.

Answer

The cursor is invalidated and re-executed automatically whenever the underlying collection is modified by another client.

Question 18

An analyst needs a pipeline that reads from a `sales` collection and, for each document, emits one output document per entry in the `regions` array, copying all other fields unchanged. Which stage accomplishes this?

Accepted Answer

{ $unwind: "$regions" }. Expanding an array into individual documents is the job of $unwind, which emits one document per element and replicates the non-array fields. It requires an array path; other stages either reduce document count, replace the whole document, or merely reshape fields without altering cardinality.

Answer

{ $group: { _id: "$regions" } }

Answer

{ $project: { regions: 1 } }

Answer

{ $replaceRoot: { newRoot: "$regions" } }

Question 19

You are optimizing a collection containing user logs. Queries frequently filter by 'category' and sort by 'timestamp' in descending order. Which index configuration best supports these queries while maintaining efficiency?

Accepted Answer

{ category: 1, timestamp: -1 }. The ESR rule suggests placing Equality fields before Sort fields. By indexing { category: 1, timestamp: -1 }, MongoDB can filter by category and then traverse the index in the order specified for sorting. This eliminates the need for an in-memory sort stage, which is crucial for performance as the result set grows. Efficient index usage directly reduces memory consumption and prevents expensive blocking operations on the primary node.

Answer

{ category: 1 }

Answer

{ timestamp: -1, category: 1 }

Answer

{ timestamp: -1 }

Question 20

Refer to the exhibit. You are implementing the Subset Pattern for a user profile that tracks recent orders. As the number of orders per user grows indefinitely, which strategy prevents the 'unbounded array' anti-pattern?

Accepted Answer

Keep only the 10 most recent orders in the array and offload older orders to a separate collection.. The Subset Pattern is designed to keep the most relevant data in the primary document while moving the bulk of historical data to a separate collection. By storing only the most recent orders in the array, you prevent the document from exceeding the 16MB limit and ensure that high-frequency read operations remain performant, as smaller documents yield better cache utilization in the WiredTiger engine.

Answer

Move all orders to a separate collection and reference them by ID in the user document.

Answer

Increase the maximum document size limit to accommodate the growing order array.

Answer

Use a capped collection for the orders array to automatically drop old orders.