C100DEV Practice Test 16 — 15 Questions

Question 1

A retail company stores order documents in a collection named orders. Each document has a field `total` (numeric) and a field `status` (string). The analytics team needs to produce a report that shows, for each `status`, the total revenue and the number of orders, but only for orders where `total` is greater than 100. The report must be sorted by total revenue in descending order. Which aggregation pipeline correctly produces this report?

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

Accepted Answer

db.orders.aggregate([ { $match: { total: { $gt: 100 } } }, { $group: { _id: "$status", totalRevenue: { $sum: "$total" }, orderCount: { $sum: 1 } } }, { $sort: { totalRevenue: -1 } } ]). The correct pipeline filters orders with total greater than 100 using $match before grouping. Then it groups by status, calculates total revenue with $sum on the total field, and counts orders with $sum: 1. Finally, it sorts the grouped results by totalRevenue in descending order. This order of stages is efficient and produces the required report.

Answer

db.orders.aggregate([ { $group: { _id: "$status", totalRevenue: { $sum: "$total" }, orderCount: { $sum: 1 } } }, { $match: { total: { $gt: 100 } } }, { $sort: { totalRevenue: -1 } } ])

Answer

db.orders.aggregate([ { $match: { total: { $gt: 100 } } }, { $group: { _id: "$status", totalRevenue: { $sum: "$total" }, orderCount: { $count: {} } } }, { $sort: { totalRevenue: -1 } } ])

Answer

db.orders.aggregate([ { $match: { total: { $gt: 100 } } }, { $group: { _id: "$status", totalRevenue: { $sum: "$total" }, orderCount: { $sum: 1 } } }, { $sort: { total: 1 } } ])

Question 2

A developer must update a document in the 'accounts' collection by incrementing the 'balance' field by 25 and simultaneously setting the 'lastUpdated' field to the current date. The update must apply only if the account is active. Which update statement satisfies all conditions?

Accepted Answer

updateOne({ active: true }, { $inc: { balance: 25 }, $set: { lastUpdated: new Date() } }). The correct approach is updateOne with a filter on active, $inc for the numeric change, and $set for the timestamp. Using update operators applies atomic field-level changes to one matched document. Omitting operators triggers replacement semantics, updateMany affects too many documents, and replaceOne forbids modifier keys, so each alternative violates part of the requirement.

Answer

replaceOne({ active: true }, { $inc: { balance: 25 }, $set: { lastUpdated: new Date() } })

Answer

updateMany({ active: true }, { $inc: { balance: 25 }, $set: { lastUpdated: new Date() } })

Answer

updateOne({ active: true }, { balance: 25, lastUpdated: new Date() })

Question 3

A developer is building an aggregation pipeline on a collection of sensor readings. The pipeline must group documents by sensorId and compute two values: the total number of readings and the timestamp of the most recent reading. Which $group accumulator pair should be used?

Accepted Answer

{ $sum: 1 } and { $max: "$timestamp" }. Counting documents in a group requires an accumulator that increments per document, and $sum with a literal 1 achieves this. To retrieve the most recent reading, $max on the timestamp field returns the highest timestamp value in each group. These two accumulators satisfy both requirements in a single $group stage without needing an extra sort.

Answer

{ $count: 1 } and { $last: "$timestamp" }

Answer

{ $sum: "$timestamp" } and { $max: "$timestamp" }

Answer

{ $size: 1 } and { $max: "$timestamp" }

Question 4

A developer is tuning indexes on an `orders` collection. The team reports slow queries and heavy write latency, and they suspect too many indexes. Which TWO practices should the developer apply when reviewing the index set? (Choose two.)

Accepted Answer

Compare query patterns with existing indexes to confirm each index supports a real workload.. Reducing index bloat requires evidence. `$indexStats` shows which indexes are actually used, and comparing real query patterns against the existing index set confirms whether each index earns its keep. Together these two practices let the team drop unused indexes and keep only those that support measured workload, lowering write cost without sacrificing query performance.

Answer

Replace all single-field indexes with wildcard indexes to consolidate coverage.

Answer

Set the notablescan parameter to true so the server rejects unindexed queries.

Answer

Drop every compound index whose prefix duplicates another index to reduce write cost.

Question 5

A support team stores tickets in a `tickets` collection where each document has a `status` field that may be missing on legacy records. A developer runs a pipeline whose first stage is { $match: { status: { $ne: "closed" } } } and expects every non-closed ticket to appear in the results. Which set of documents does this stage pass downstream?

Accepted Answer

Only documents where status exists and is not equal to "closed".. Comparison operators in an aggregation $match evaluate against existing field values. When a field is absent, a comparison to a string such as $ne "closed" cannot be satisfied, so those documents are filtered out. To retain them, the pipeline would need an explicit $or clause testing for field absence or null alongside the inequality.

Answer

All documents, because $match only removes documents when a field is explicitly set to null.

Answer

Documents where status exists and equals "closed", because $ne inverts the comparison during aggregation.

Answer

Documents where status is not "closed", including documents where the field is absent.

Question 6

A blog platform stores posts in the 'posts' collection. Each document has an array field 'comments' containing subdocuments with fields 'author' and 'text'. You need to add a new comment to the 'comments' array of a specific post identified by its '_id'. The new comment should be appended to the end of the array. Which update operation should you use?

Accepted Answer

db.posts.updateOne({ _id: postId }, { $push: { comments: { author: 'user1', text: 'Great post!' } } }). The $push operator is specifically designed to append values to an array. It adds the new comment subdocument to the 'comments' array without affecting existing elements. The other options either prevent duplicates, overwrite the array, or use an invalid operator. $push is the standard and correct choice for this scenario.

Answer

db.posts.updateOne({ _id: postId }, { $set: { comments: { author: 'user1', text: 'Great post!' } } })

Answer

db.posts.updateOne({ _id: postId }, { $addToSet: { comments: { author: 'user1', text: 'Great post!' } } })

Answer

db.posts.updateOne({ _id: postId }, { $concat: { comments: { author: 'user1', text: 'Great post!' } } })

Question 7

You are building an aggregation pipeline on a collection of sensor readings where each document has a `timestamp` field and a `value` field. You need to compute, for each calendar day, the highest `value` and the average `value` across all readings for that day. Which `$group` stage accomplishes this?

Accepted Answer

{ $group: { _id: { $dateToString: { format: "%Y-%m-%d", date: "$timestamp" } }, maxValue: { $max: "$value" }, avgValue: { $avg: "$value" } } }. The `$group` stage must group by a day-level key while applying the correct accumulators to the `value` field. Using `$dateToString` in `_id` collapses all readings for a calendar day into one document, and `$max` plus `$avg` return the highest and mean values. Grouping by raw timestamps or using `$sum` fails to satisfy the daily maximum and average requirement.

Answer

{ $group: { _id: { $dateToString: { format: "%Y-%m-%d", date: "$timestamp" } }, maxValue: { $max: "$value" }, avgValue: { $sum: "$value" } } }

Answer

{ $group: { _id: "$timestamp", maxValue: { $max: "$value" }, avgValue: { $avg: "$value" } } }

Answer

{ $group: { _id: { $dateToString: { format: "%Y-%m-%d", date: "$timestamp" } }, maxValue: { $max: "$value" }, avgValue: { $avg: "$timestamp" } } }

Question 8

A developer queries the 'events' collection with db.events.find({ tags: { $in: ["sports", "music"] } }) and observes a COLLSCAN in explain output even though an index exists on the 'tags' array field. The collection holds a few hundred documents. Which explanation best accounts for the planner choosing a collection scan?

Accepted Answer

The query planner may prefer a collection scan when the collection is small, because the estimated cost of scanning is lower than the overhead of using a multikey index.. Query plan selection is cost-based. With a few hundred documents, the estimated cost of a full collection scan can be lower than the cost of using a multikey index plus document fetches, so the planner may reasonably choose COLLSCAN. As the collection grows, or with a more selective predicate, the same index is likely to be selected.

Answer

COLLSCAN appears whenever a query returns more than one document, because index scans are limited to single-document lookups.

Answer

A multikey index cannot answer $in queries, so the planner ignores the tags index and falls back to a collection scan.

Answer

The index on 'tags' is invalid because arrays cannot be indexed directly, so it must be rebuilt as a compound index with _id first.

Question 9

A developer is reviewing a MongoDB collection that stores blog posts. Each post document has a field 'tags' that is an array of strings. The developer wants to find all posts that have both 'mongodb' and 'database' in the tags array. Which query correctly retrieves these documents?

Accepted Answer

{ tags: { $all: ["mongodb", "database"] } }. The $all operator is designed to match arrays that contain all specified elements, making it the correct choice for finding posts with both 'mongodb' and 'database' tags. The $in operator matches any of the elements, the exact array match is too strict, and $elemMatch is for conditions on a single element. Only $all satisfies the requirement.

Answer

{ tags: { $in: ["mongodb", "database"] } }

Answer

{ tags: { $elemMatch: { $eq: "mongodb", $eq: "database" } } }

Answer

{ tags: ["mongodb", "database"] }

Question 10

A support team frequently runs a query that filters on status and sorts by created_at, both fields in the same collection. An existing index { status: 1 } is in place, but the query still performs an in-memory sort and gets killed once result sets grow past the 100 MB sort limit. Which index should you create to let the server satisfy both the filter and the sort without a blocking sort stage?

Accepted Answer

{ status: 1, created_at: 1 }. An index that lists the equality predicate field first and the sort field second stores entries for each status value in created_at order. The server can then read the matching range sequentially and emit results already sorted, which removes the blocking SORT stage and its 100 MB memory ceiling. Reversing the field order or flipping the sort direction prevents the index from supplying the required order.

Answer

{ created_at: 1, status: 1 }

Answer

{ status: 1, created_at: -1 }

Answer

{ created_at: 1 }

Question 11

A developer is working with a collection that stores user profiles. The collection has an index on the `email` field. The developer runs a query that uses a regular expression to find all users whose email ends with "@example.com". The query is: `db.users.find({ email: /@example\.com$/ })`. What is the most likely behavior of this query with respect to the index?

Accepted Answer

The query will perform a collection scan because the regular expression is not anchored at the beginning.. MongoDB can use an index for regular expression queries only when the regex is anchored at the start of the string (e.g., /^prefix/). A regex that matches a suffix or an arbitrary substring cannot leverage the index's sorted order, so the query performs a full collection scan. The given query, which looks for emails ending with "@example.com", is not left-anchored and therefore cannot use the index efficiently.

Answer

The query will use the index but will still need to filter the results in memory.

Answer

The query will use the index efficiently because regular expressions can always leverage indexes.

Answer

The query will use the index only if the field is a covered index.

Question 12

A developer is designing a MongoDB collection to store user profiles for a mobile application. Each profile document may contain a varying set of optional fields, such as 'phoneNumber', 'profilePicture', and 'preferences'. The developer wants to ensure that the database can efficiently store and query these documents without requiring a predefined schema. Which MongoDB feature best supports this requirement?

Accepted Answer

The document model, which allows each document in a collection to have a different structure.. The document model in MongoDB allows each document to have its own structure, meaning fields can vary from one document to another. This is ideal for user profiles with optional fields because developers can add or omit fields without altering a global schema. The other options impose rigid structures that are not part of MongoDB's core flexibility.

Answer

The use of strict schema validation rules enforced at the collection level.

Answer

The ability to store data in a fixed tabular format with rows and columns.

Answer

The requirement to define all possible fields in advance using a schema definition language.

Question 13

A collection 'logs' has a TTL index on the 'createdAt' field with expireAfterSeconds set to 3600. A developer notices that some documents older than one hour are still present in the collection. Which explanation is most likely?

Accepted Answer

The TTL monitor runs every 60 seconds and may have not yet processed those documents, so they can remain for a short period beyond the expiration time.. The TTL monitor is a background process that runs every 60 seconds to delete expired documents. Due to this interval, documents can remain for a short time after their expiration time. This is the most likely reason for seeing documents older than one hour still present in the collection.

Answer

The TTL index only deletes documents when they are queried, so unqueried documents remain indefinitely.

Answer

The TTL index only deletes documents when the MongoDB server is restarted.

Answer

The TTL index does not delete documents if the collection has a compound index that includes the createdAt field.

Question 14

A developer is writing a Node.js script that inserts a user document into a MongoDB 7.0 collection. The document includes an _id field whose value is generated by the driver as an ObjectId. A teammate asks why the _id field is present even though the insertOne call did not specify it. Which statement best explains the behavior of _id in MongoDB?

Accepted Answer

The _id field is mandatory in every document, and if the client omits it the driver generates an ObjectId before sending the insert.. MongoDB mandates a unique _id in every stored document and automatically builds a unique index on that field. Official drivers generate an ObjectId on the client when the application does not provide one, so the field is present in the inserted document without explicit developer action. This guarantees each document can be uniquely identified and located efficiently.

Answer

The _id field is added by the mongod server after the insert completes, and the client must run a find to retrieve the generated value.

Answer

The _id field is optional and is only populated when the collection has a unique index defined by the developer.

Answer

The _id field is only required for capped collections and time series collections, while normal collections allow documents without it.

Question 15

Refer to the exhibit. What is the impact of setting 'dynamic' to true in this Atlas Search index definition?

Accepted Answer

It automatically indexes all fields in every document.. Setting 'dynamic' to true enables Atlas Search to automatically index all fields in every document within the collection. This is useful for rapid prototyping or collections with unpredictable schemas. However, it can significantly increase the size of the index and consume more resources compared to manual mappings. Understanding this balance is critical for developers managing performance and cost when dealing with large datasets and varying document structures in search-enabled collections.

Answer

It forces all documents to follow a strict schema.

Answer

It prevents the creation of any custom field mappings.

Answer

It disables the indexing of nested object fields.