C100DEV Practice Test 15 — 15 Questions

Question 1

A logistics application stores shipment documents. Each shipment references a carrier by carrierId. Carriers are a small, slow-changing set (about 40 documents) that the application joins on nearly every shipment view. Which design decision is most appropriate for the carrier reference?

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

Accepted Answer

Keep carrierId as a reference and resolve carrier details with $lookup, optionally caching the small carrier set in the application.. When the referenced set is small and slow-changing, a reference is preferable to embedding because it avoids duplicating data and keeps one authoritative source. The $lookup join is inexpensive for a tiny collection, and the application can cache the whole carrier set, so shipment reads rarely pay join cost. Full denormalization or cross-database joins add complexity without benefit here.

Answer

Denormalize all carrier fields into the shipment and treat the shipment copy as authoritative for carrier data.

Answer

Embed the full carrier document in every shipment to eliminate the join entirely.

Answer

Store carrier details in a separate database and use a manual application-side join for every shipment read.

Question 2

A development team is migrating a legacy application to MongoDB. They need to store product inventory data that includes a unique identifier, a name, a price, and a list of warehouse locations with quantities. The team wants to minimize the number of queries required to retrieve all information for a product. Which MongoDB document design approach best meets this requirement?

Accepted Answer

Embed the warehouse locations as an array of subdocuments within the product document.. Embedding related data within a single document aligns with MongoDB's document model and supports atomic operations and efficient reads. By embedding warehouse locations as an array, the application retrieves the full product inventory in one query, which is optimal for this access pattern. Referencing or normalizing would require additional queries or application-side joins, increasing latency and complexity.

Answer

Store warehouse locations in a separate collection and reference them by ObjectId from the product document.

Answer

Normalize the data into multiple collections: products, warehouses, and inventory, with foreign key relationships.

Answer

Store each warehouse location as a separate document in the same collection as products.

Question 3

A retail company stores orders in a collection where each document has a `customerId` field and a `total` field. The analytics team needs to see, for each customer, both the sum of all order totals and a list of the individual order totals. Which aggregation pipeline stage and accumulator combination should be used?

Accepted Answer

$group with { _id: "$customerId", totalSum: { $sum: "$total" }, totals: { $push: "$total" } }. The $group stage groups documents by customerId, and within it, $sum calculates the total of all total fields while $push collects each total into an array. This yields one document per customer containing both the sum and the list of individual totals, meeting the analytics requirement without extra stages that would alter the output shape.

Answer

$project with { customerId: 1, totalSum: { $sum: "$total" }, totals: { $push: "$total" } }

Answer

$group with { _id: "$customerId", totalSum: { $sum: "$total" }, totals: { $addToSet: "$total" } }

Answer

$group with { _id: "$customerId", totalSum: { $sum: "$total" }, totals: { $push: "$total" } } followed by $unwind on totals

Question 4

An application queries a users collection with db.users.find({ email: "a@b.com" }). The collection holds about 2 million documents, and the email field is unique for every user. A developer proposes creating an index { email: 1, country: 1 } to speed up the query. What is the most accurate assessment of this proposal?

Accepted Answer

It works, but it is wasteful; a single-field index { email: 1 } on this unique field would give the same lookup efficiency with a smaller index.. Because email is the leading field of the compound index, the planner can use it and seek directly to the single matching entry, so the query is still fast. But the trailing country key is never touched by this query, and email is already unique, so it adds no selectivity. A single-field index on email achieves the same lookup with less storage and lower write amplification.

Answer

It is invalid unless the index is declared as unique to match the field's uniqueness.

Answer

It is optimal because compound indexes always outperform single-field indexes on the leading field.

Answer

It fails because the query does not include the country field, so the compound index cannot be used.

Question 5

A developer needs to calculate the total revenue per product category from a sales collection. The collection has documents with fields `category` and `amount`. Which aggregation pipeline stage should be used to compute the sum of amounts for each category?

Accepted Answer

$group. The $group stage is designed to group documents by a key and apply accumulators like $sum to compute aggregate values. By grouping on category and summing amount, the pipeline yields total revenue per category. Other stages like $project, $match, or $sort do not perform cross-document aggregation, so they cannot produce the required totals.

Answer

$match

Answer

$sort

Answer

$project

Question 6

A developer is building an aggregation pipeline on a collection of blog posts. Each post document contains an array field `comments`, where each comment is an object with `author` and `text`. The developer needs to produce a separate document for each comment, preserving the post's `title` and the comment's `author` and `text`. Which TWO stages are required to achieve this? (Choose two.)

Accepted Answer

$unwind. To create a separate document for each comment, the pipeline must first use $unwind to deconstruct the comments array. Then, $project is used to shape the output documents, including the post title and the comment's author and text fields. Together, these stages achieve the required transformation.

Answer

$sort

Answer

$match

Answer

$group

Question 7

A developer is using the MongoDB Node.js driver to perform a multi-document transaction that updates multiple collections. During testing, the transaction occasionally fails with a TransientTransactionError. What is the most appropriate way to handle this error?

Accepted Answer

Retry the entire transaction from the beginning, including starting a new session and re-executing all operations.. When a transaction fails with TransientTransactionError, the correct approach is to retry the entire transaction. This means aborting the current transaction if it is still open, starting a new session or reusing the session after aborting, and re-executing all operations. Retrying only a single operation or ignoring the error can result in partial updates or constraint violations.

Answer

Increase the transaction lifetime limit using the maxTransactionTimeMS option and continue without retrying.

Answer

Ignore the error and proceed, as MongoDB will automatically retry the transaction.

Answer

Retry only the failed operation within the same transaction, without aborting or restarting the transaction.

Question 8

A developer is using the MongoDB Node.js driver to perform a multi-document transaction that updates a document in the 'orders' collection and inserts a record into the 'audit' collection. After starting the session and transaction, the update succeeds, but the insert fails due to a duplicate key error. What should the developer do to handle this error and ensure data consistency?

Accepted Answer

Call session.abortTransaction() to roll back the update, then retry the entire transaction if appropriate.. In a multi-document transaction, if any operation fails, the entire transaction must be aborted to maintain atomicity. The correct action is to call abortTransaction() to roll back all changes made within the transaction. Committing or ignoring the error would lead to inconsistent data. Ending the session does not explicitly abort. Retrying without aborting is futile.

Answer

Retry the insert operation within the same transaction without aborting, hoping the duplicate key error resolves.

Answer

Call session.commitTransaction() to commit the successful update and ignore the failed insert.

Answer

Call session.endSession() to close the session and automatically roll back the transaction.

Question 9

A team is designing a schema for a MongoDB application that stores user profiles. Each profile includes a list of the user's favorite movies, which is typically fewer than 20 items and updated infrequently. Queries often retrieve the entire profile along with the favorite movies. Which data modeling approach is most appropriate?

Accepted Answer

Embed the favorite movies as an array of subdocuments within the user profile document.. For a one-to-few relationship where the embedded data is small, updated infrequently, and always accessed with the parent document, embedding is the recommended approach. It simplifies queries, ensures atomicity, and provides the best read performance without the overhead of joins or multiple round trips.

Answer

Normalize the data by creating a separate collection for movies and a junction collection linking users and movies.

Answer

Use the Bucket Pattern to group favorite movies into buckets of 10.

Answer

Store favorite movies in a separate collection and reference them by _id in the user profile.

Question 10

A developer needs to run a multi-document transaction using the MongoDB Node.js driver. The transaction must read from the 'orders' collection and write to the 'inventory' collection. Which sequence of operations correctly implements the transaction?

Accepted Answer

Start a session with client.startSession(), start a transaction with session.startTransaction(), perform reads and writes with the session option, then commit with session.commitTransaction().. A multi-document transaction in the Node.js driver requires a session. The session must be started, the transaction begun, operations executed with the session passed as an option, and then the transaction committed. Omitting any step, such as not passing the session to operations or not explicitly committing, results in operations not being part of the transaction or the transaction remaining open.

Answer

Use a session, start a transaction, perform operations with the session, and rely on automatic commit when the session ends.

Answer

Begin a transaction with db.beginTransaction(), run operations on the db object, and call db.commitTransaction().

Answer

Use client.startTransaction() directly, perform operations without a session, and call transaction.commit().

Question 11

A developer is building a MongoDB application to store sensor readings from thousands of IoT devices. Each reading document contains a device ID, timestamp, and an array of up to 100 numeric values. The developer wants to minimize document size and storage overhead while preserving the ability to query individual readings. Which BSON data type should be used to store the numeric values array to achieve the smallest document size?

Accepted Answer

Store the values as a BSON array of 32-bit integers (int).. For integer sensor readings, the 32-bit integer BSON type offers the best balance of compactness and queryability. It uses half the space of a double and allows direct indexing and querying of array elements, unlike binary blobs. Decimal128 and doubles are unnecessarily large for whole numbers, and BinData would require custom deserialization.

Answer

Store the values as a BSON array of Decimal128.

Answer

Store the values as a BSON array of doubles.

Answer

Store the values as a BSON binary subtype 0 (generic binary) using the BinData type.

Question 12

You are designing a schema for a social feed where each post has a small, bounded set of reactions (like, love, wow) that are always displayed together with the post, and a potentially very large set of comments that are paginated on demand. Which TWO design choices correctly apply MongoDB schema patterns to these requirements? (Choose two.)

Accepted Answer

Store comments in a separate collection with a postId field and a compound index on { postId: 1, createdAt: -1 } for pagination.. Embedding is correct for bounded data read together with its parent, so reactions belong inside the post. Referencing is correct for unbounded, independently paginated data, so comments belong in their own collection with an index supporting ordered retrieval by post. The two patterns are applied to the two data sets according to their cardinality and access patterns rather than uniformly.

Answer

Store both reactions and comments in a single embedded array on the post to simplify rendering.

Answer

Embed all comments in the post document so pagination can be done with $slice against the embedded array.

Answer

Store reactions in a separate collection and aggregate them with $lookup whenever a post is rendered.

Question 13

A developer needs to import a large JSON file into a MongoDB collection named 'products' in the 'catalog' database. The file contains one JSON document per line (JSON Lines format). Which MongoDB tool should be used to accomplish this efficiently?

Accepted Answer

mongoimport. The task requires importing a JSON Lines file into a MongoDB collection. mongoimport is the designated tool for importing JSON, CSV, or TSV data. It handles JSON Lines natively and is optimized for bulk imports. The other tools serve different purposes: mongorestore is for BSON backups, mongodump is for creating backups, and mongostat is for monitoring.

Answer

mongorestore

Answer

mongodump

Answer

mongostat

Question 14

You are aggregating a `logs` collection where each document has a `timestamp` and a `level` field. You need to produce a single document that contains two arrays: one with all `timestamp` values for `level: "ERROR"` and one with all `timestamp` values for `level: "WARN"`. Which pipeline should you use?

Accepted Answer

[ { $group: { _id: null, errorTimes: { $push: { $cond: [ { $eq: ["$level", "ERROR"] }, "$timestamp", "$$REMOVE" ] } }, warnTimes: { $push: { $cond: [ { $eq: ["$level", "WARN"] }, "$timestamp", "$$REMOVE" ] } } } } ]. To produce a single document with two arrays, group all documents with `_id: null` and use `$push` with a conditional expression. The `$$REMOVE` variable in the false branch of `$cond` omits non-matching values so the arrays contain only the relevant timestamps. Using `null` would introduce null entries, and grouping by `level` would produce multiple documents.

Answer

[ { $match: { level: { $in: ["ERROR", "WARN"] } } }, { $group: { _id: "$level", times: { $push: "$timestamp" } } } ]

Answer

[ { $group: { _id: null, errorTimes: { $push: { $cond: [ { $eq: ["$level", "ERROR"] }, "$timestamp", null ] } }, warnTimes: { $push: { $cond: [ { $eq: ["$level", "WARN"] }, "$timestamp", null ] } } } } ]

Answer

[ { $group: { _id: null, errorTimes: { $addToSet: { $cond: [ { $eq: ["$level", "ERROR"] }, "$timestamp", "$$REMOVE" ] } }, warnTimes: { $addToSet: { $cond: [ { $eq: ["$level", "WARN"] }, "$timestamp", "$$REMOVE" ] } } } } ]

Question 15

A financial application stores transactions in the 'transactions' collection. Each document has fields: 'accountId', 'amount', 'timestamp', and 'status'. You need to find all transactions for account 'A123' that have an amount greater than 1000 and a status of either 'pending' or 'review'. Which two query documents correctly retrieve these transactions? (Choose two.)

Accepted Answer

{ accountId: 'A123', $and: [ { amount: { $gt: 1000 } }, { status: { $in: ['pending', 'review'] } } ] }. The correct queries must combine accountId, amount greater than 1000, and status in a list using logical AND. The implicit AND version and the explicit $and version both achieve this. The other options either use invalid syntax, combine conditions with OR instead of AND, or use the wrong comparison operator, leading to incorrect results.

Answer

{ accountId: 'A123', amount: { $gt: 1000 }, status: { $or: ['pending', 'review'] } }

Answer

{ accountId: 'A123', amount: { $gte: 1000 }, status: { $in: ['pending', 'review'] } }

Answer

{ accountId: 'A123', $or: [ { amount: { $gt: 1000 } }, { status: { $in: ['pending', 'review'] } } ] }