C100DEV Exam Questions and Answers

Embed variable attributes directly within each product document.

Embedding directly supports data locality, allowing the entire product state to be fetched in a single read operation. Since MongoDB documents are schemaless, having varying fields across products is natively supported, efficient for indexing, and avoids the performance degradation associated with relational JOINs in highly dynamic datasets.

It is a binary-encoded serialization of JSON documents.

BSON provides a binary representation that allows for rapid traversal and encoding. By using length prefixes, it enables the database to skip over fields or documents without parsing the entire structure, which is a major performance boost for complex read operations compared to standard JSON text parsing.

The field '$created' starts with a reserved character.

MongoDB reserves the dollar sign ($) at the beginning of a field name for its own internal operators, such as $set or $push. Because the database tries to evaluate '$created' as an operator instead of a string key, the document insertion will be rejected by the server as invalid.

Embed child documents directly as an array within the parent document.

Embedding captures the relationship within a single atomic unit. By storing children in an array, you allow the database to return the entire hierarchical data structure in a single operation. This improves performance and simplifies application logic because the database handles the retrieval of the entire record structure.

Documents can have different fields, and the structure can change over time.

MongoDB allows documents in the same collection to vary in structure and field types. This adaptability is critical for applications that need to evolve their data models rapidly. Developers can add new features without disruptive migration processes, allowing for continuous delivery and seamless updates to the application's underlying data.

It keeps document sizes within reasonable limits for time-series data.

By grouping related events into a single document based on a time interval, the Bucket Pattern prevents the growth of documents that could otherwise exceed the 16MB limit. This design improves memory management and performance by allowing the database to read and write fewer, more relevant documents.

It automatically indexes all fields in every document.

When dynamic mapping is enabled, Atlas Search scans the documents and automatically indexes every field it encounters. This provides a 'search-everything' capability out of the box, which is extremely convenient for collections where you do not want to manually define mappings for every individual document field.

The Explain Plan tab.

The Explain Plan tab in Compass displays the execution metrics in a clear, visual format. It provides details on stage transitions, index scans, and document counts, making it the primary tool within the GUI for interpreting how the database engine processes queries and where performance issues arise.

It is specified during the commitTransaction command.

The write concern is explicitly set when calling commitTransaction. This allows the application to control the acknowledgement level for the entire transaction block. This mechanism is standard for ensuring that all changes are successfully hardened on the required number of nodes before the application considers the transaction finished.

Abort the transaction and retry the entire operation.

When a TransientTransactionError occurs, the correct procedure is to abort the failed transaction and execute the entire sequence of operations again. This guarantees that all changes are applied atomically, adhering to the ACID properties of the transaction and ensuring that the final state is correct and consistent.

IClientSessionHandle

IClientSessionHandle is the standard interface in the C# driver for managing sessions and transactions. It allows developers to start, commit, and abort transactions safely. By passing this object into every operation, you link them to the same session, enabling the ACID properties required for multi-document operations.

To serve as a modern interactive JavaScript shell.

mongosh is a full-featured JavaScript environment that allows developers to run commands against MongoDB. It is designed to be the primary interactive shell for developers, providing enhanced usability, better autocompletion, and support for the latest MongoDB features, significantly improving the experience over the previous, deprecated 'mongo' shell.

$match

The $match stage serves as a query filter that can utilize existing indexes when placed at the beginning of a pipeline. By reducing the number of documents passed to downstream stages, it saves CPU and memory. This is the standard practice for performance optimization in MongoDB aggregation pipelines.

$group

The $group stage must consume all input documents to calculate aggregate results like sums or averages. Because it must see the entire stream to finalize values for grouping keys, it is a blocking operation that requires significant RAM. Developers must be cautious with memory limits when grouping.

$sort

The $sort stage is blocking because it needs the full set of documents to determine their relative order. While it can use indexes to avoid memory issues, a sort without an index must pull all documents into memory, potentially exceeding the 100MB limit during the sorting process.

$sqrt

The $sqrt operator is the standard aggregation function for calculating the square root of a non-negative number. It is highly optimized for performance and is the correct choice for mathematical transformations involving square roots within an aggregation pipeline's $project or $addFields stages.

It adds new fields to documents, preserving existing fields.

$addFields adds specified fields to the input documents, and if a field already exists, it updates its value with the result of the expression. This is the standard mechanism for augmenting documents without losing pre-existing data, providing maximum flexibility for data reporting and transformation tasks.

The aggregation operation fails and returns an error.

When memory usage exceeds 100MB and allowDiskUse is false, the database throws an error to prevent resource exhaustion. This forces developers to design more efficient pipelines or intentionally enable disk usage, ensuring that resource-heavy queries are executed with full awareness of the potential performance trade-offs.

$avg

$avg is the standard accumulator used to calculate the arithmetic mean. It automatically handles the summation and division by the count of documents, providing a clean and efficient way to summarize numeric trends within the aggregation pipeline's grouping phase.

{ userId: 1, timestamp: -1 }

A compound index on userId ascending then timestamp descending matches both the equality filter and the sort order, so MongoDB walks the index in the required descending sequence and returns results without an in-memory sort stage, satisfying the no-blocking-sort constraint.

MongoDB will perform a collection scan as the query lacks the 'category' prefix required by the index.

The index prefix rule dictates that a query must use the first field of the compound index to enable an index scan. Because 'category' is omitted, the query engine cannot utilize the B-tree structure of the index for 'brand' and 'price', resulting in a full collection scan to find matching documents.

The index build fails with an error stating that a compound index cannot include more than one array.

A compound index can only contain one field that is an array to maintain a manageable index size. If you try to index two different array fields in one compound index, MongoDB returns an error to prevent the explosive growth of index entries that would occur from mapping every possible combination of elements.

This is a covered query, and MongoDB retrieves all data from the index alone.

The query is considered 'covered' because the index on { age: 1 } contains the 'age' field used in the filter, and the projection only asks for 'age' while excluding '_id'. By satisfying the query without accessing the actual documents, MongoDB reduces disk I/O and speeds up the response time significantly.

Hashed indexes do not support range-based queries or sort operations.

Because hashing transforms values into a pseudo-random distribution, the original order of the data is lost. A query for values greater than 100 cannot use a hashed index because the hash of 101 might be numerically smaller or larger than the hash of 1000, making the B-tree structure useless for ranges.

MongoDB will perform a collection scan because the index is on the whole object.

By indexing 'metadata', you are indexing the full BSON subdocument. Queries on sub-fields like 'metadata.type' are not supported by this index. For the index to be useful for the given query, it should have been created on the specific path 'metadata.type' using dot notation in the createIndex command.

Setting the { upsert: true } option in updateOne or findOneAndUpdate.

Upsert combines update and insert semantics in one atomic operation: when no document matches the filter, MongoDB inserts a new document built from the filter equality fields plus the update operators. This exactly meets the requirement to insert using fields from both documents.

{ tags: { $all: ['electronics', 'sale'] } }

$all matches documents whose tags array contains every listed element, independent of order, duplicates or extra values. That precisely satisfies the requirement for simultaneous presence of both 'electronics' and 'sale', which a simple equality match cannot guarantee.

db.tickets.updateMany({ status: 'open', priority: { $exists: false } }, { $set: { priority: 'high' } })

This operation uses updateMany with a filter that matches only open tickets lacking a priority field, and $set adds the field without inserting new documents. Because the filter includes $exists: false, tickets that already have priority are untouched, and updateMany never performs an upsert unless explicitly requested, so no new documents are created.

db.shipments.updateOne({ _id: 42 }, { $pull: { packages: { trackingCode: "TRK-9981" } } })

The $pull operator removes every array element that matches the supplied condition, so this deletes only the embedded package whose trackingCode equals TRK-9981 while preserving the rest of the array and the parent document. The filter on _id restricts the update to the intended shipment, making this the precise and minimal operation for the scenario.

db.sensors.createIndex({ active: 1 })

A single-field ascending index on 'active' lets the query planner satisfy the equality predicate on that field by scanning only the matching index entries and fetching the corresponding documents. Because the filter is a simple equality on one field, this index directly narrows the candidate set and avoids a full collection scan for the inactive documents.

db.shipments.updateMany({ status: 'in_transit', carrier: 'FastShip' }, { $set: { deliveredAt: new Date() } })

updateMany applies the $set update operator to every document matching the filter { status: 'in_transit', carrier: 'FastShip' }, writing the current date into deliveredAt. The filter combines both conditions with implicit AND, which matches the requirement exactly and updates all qualifying shipments in one round trip.

Implementing the Attribute Pattern with an array of key-value pairs.

This pattern creates a standardized structure that allows you to index the key and value fields uniformly. It enables efficient queries across different product types without modifying the schema, ensuring that MongoDB can perform high-performance index lookups regardless of which specific attributes are stored for a given document.

Keep only the 10 most recent orders in the array and offload older orders to a separate collection.

This is the core implementation of the Subset Pattern. By limiting the array size to a manageable count, you guarantee the user document stays small and performant. Historical data remains accessible via a secondary query only when requested, optimizing for the common case of viewing recent activity.

A user document containing the user's primary shipping address.

Addresses have a strong 'contains' relationship with the user and are rarely queried independently of the user profile. Embedding them allows the application to retrieve both the user identity and their shipping information in a single read operation, significantly reducing application-side latency and database server load.

A movie document embedding the names of its three main cast members.

The number of main cast members is small and relatively static, fitting the one-to-few pattern perfectly. Embedding them allows the application to display core movie details immediately without needing secondary lookups, providing a much faster user experience for common read operations on the movie details page.

Use the multikey index created on the tags array.

Multikey indexes are the native way MongoDB handles array indexing. When an index is created on a field that contains an array, MongoDB automatically creates entries for each element, allowing for high-speed retrieval of documents based on specific tag values without any additional configuration or complex data restructuring.

Create a separate collection for followers and store references.

Storing followers in their own collection allows the system to scale to millions of followers per user. You can index the user ID field in this collection to perform fast lookups, ensuring that the user document remains small and that follow counts can be efficiently managed via aggregation queries.

It reduces index size and improves read performance by grouping data.

The Bucket pattern aggregates multiple individual readings into a single document. This creates a much smaller index, as there is one entry per bucket rather than one entry per individual reading. This allows the working set to fit better in memory, dramatically increasing the speed of time-based query operations.