C100DEV MongoDB Overview and Document Model — 25 Questions

Question 1

Which TWO of the following statements accurately describe the characteristics of MongoDB documents?

Accepted Answer

Documents within the same collection can have different fields.. MongoDB documents follow the BSON specification and are limited to a maximum size of 16MB. This limit is designed to ensure that developers avoid creating excessively large, monolithic documents that could negatively impact performance and memory usage. Additionally, documents are flexible in nature, allowing fields to vary between documents within the same collection, which is a core tenant of the document model.

Answer

Documents can contain up to 64MB of data.

Answer

The order of fields within a document is always strictly preserved.

Answer

Field names can contain any character, including null bytes.

Question 2

Which THREE of the following are valid BSON data types available in MongoDB?

Accepted Answer

Array. BSON supports a robust set of data types that extend beyond standard JSON. These types include 'ObjectId', which acts as a unique identifier; 'Decimal128', which is designed for high-precision financial calculations; and 'Date', which handles time representation internally as a 64-bit integer. These types allow MongoDB to perform database-level operations that would otherwise be difficult or inaccurate when using simple strings or floating-point numbers.

Answer

Float32

Answer

Pointer

Question 3

A developer is working with a MongoDB collection that stores documents representing books. Each document has fields such as `title`, `author`, `publishedYear`, and `genres` (an array of strings). The developer needs to write queries that efficiently retrieve books based on multiple criteria. Which TWO of the following statements are true regarding querying and indexing in MongoDB for this scenario? (Choose two.)

Accepted Answer

A compound index on `{ author: 1, publishedYear: 1 }` can support queries that filter on `author` alone.. The correct statements are that a compound index on `{ author: 1, publishedYear: 1 }` supports queries on `author` alone due to the prefix rule, and that a multikey index on an array field like `genres` enables efficient queries for specific array elements. These reflect fundamental MongoDB indexing behaviors that are crucial for query performance.

Answer

A compound index on `{ publishedYear: 1, author: 1 }` can support queries that sort by `publishedYear` and filter on `author`.

Answer

An index on `{ title: 1 }` can improve the performance of a query that uses `$text` search on the `title` field.

Answer

A query that uses a regular expression on the `title` field can use an index on `title` only if the regex is case-insensitive.

Question 4

A developer is building a MongoDB application to store blog posts and their comments. Comments are frequently added and retrieved alongside the post, but the total number of comments per post can grow to thousands. The developer wants to optimize for read performance of the post with its comments while keeping document size manageable. Which data modeling approach is most appropriate?

Accepted Answer

Store comments in a separate collection with a postId field, and query comments by postId when needed.. Storing comments in a separate collection with a postId reference is the most scalable approach because it avoids document size limits and allows independent scaling. Embedding or referencing via an array of IDs can lead to large documents. The bucket pattern, while useful for other scenarios, does not eliminate the fundamental size constraint.

Answer

Use a bucket pattern to group comments into fixed-size buckets within the post document.

Answer

Embed all comments as an array of subdocuments within the post document.

Answer

Reference comments from the post document using an array of comment IDs.

Question 5

A developer is designing a MongoDB collection to store orders. Each order document contains an array of line items, and each line item has a product ID and quantity. The developer needs to frequently query for orders that contain a specific product ID with a quantity greater than 5. Which field should be indexed to optimize this query?

Accepted Answer

Create a compound index on { "lineItems.productId": 1, "lineItems.quantity": 1 }.. A compound multikey index on the embedded fields productId and quantity is the best choice because it allows MongoDB to efficiently evaluate both conditions within the same array element. Single-field indexes or an index on the entire array do not provide the same level of optimization. This index supports the query pattern and improves performance.

Answer

Create a multikey index on { "lineItems": 1 }.

Answer

Create a single index on { "lineItems.productId": 1 }.

Answer

Create a single index on { "lineItems.quantity": 1 }.

Question 6

A team is designing a collection that stores IoT sensor readings. Each document must record the sensor identifier, a timestamp, a numeric temperature value, an array of recent status codes, and a nested object describing the device firmware. The developers want to confirm which BSON types MongoDB will natively support for these fields. (Choose two.)

Accepted Answer

The timestamp field can be stored using the BSON Date type, which holds a 64-bit integer representing milliseconds since the Unix epoch.. BSON Date is the correct type for temporal values because it stores milliseconds since the epoch and supports rich date operators. BSON Array is the correct type for the status code list because MongoDB natively stores arrays and can build multikey indexes over their elements. Both are first-class BSON types suited to the fields described, while the other listed options are either redundant or deprecated.

Answer

The nested firmware object can be stored using the BSON Document type, allowing embedded fields to be queried with dot notation.

Answer

The numeric temperature value can be stored using the BSON Decimal128 type, which is a 16-byte floating-point format designed for exact decimal arithmetic.

Answer

The sensor identifier can be stored using the BSON Symbol type, which is deprecated but still accepted by modern MongoDB servers.

Question 7

A developer is deploying a new MongoDB 7.0 replica set for an application that stores user profiles. The application must be able to update a single user's nested address fields without reading and rewriting the entire document, and each profile must remain under 16 MB. Which statement describes the document model characteristic that makes this possible?

Accepted Answer

Documents are stored as a tree of fields and values, and the update engine can target nested paths using dot notation for $set operations.. The document model stores data as hierarchical BSON objects, and MongoDB update operators accept dot-notation paths such as "address.city". This lets the application modify nested fields without fetching and replacing the whole document, which is exactly what the scenario requires. It also keeps each profile as one document, so the 16 MB limit is respected as long as the profile stays within that size.

Answer

The WiredTiger storage engine keeps all documents in memory, so nested field updates are applied to the in-memory copy and then lazily persisted.

Answer

MongoDB stores each document as a BSON object, and the server can modify individual field values in place without rewriting the whole document.

Answer

Each document is assigned a fixed schema at insert time, and updates to nested fields are validated against that schema before being applied.

Question 8

An e-commerce application stores products in a collection. Each product has a variable number of attributes, such as 'size', 'color', or 'material'. Which data modeling approach best leverages MongoDB's flexible schema while maintaining query efficiency?

Accepted Answer

Embed variable attributes directly within each product document.. Using a polymorphic schema with optional fields directly in the document is the canonical MongoDB approach. This strategy avoids the JOIN operations required by relational databases when attributes are stored in separate tables. By keeping data together, developers achieve high performance for read operations and take full advantage of MongoDB's indexing capabilities on specific document fields, regardless of whether every document contains that field.

Answer

Normalize all attributes into a secondary 'attributes' collection linked by ProductID.

Answer

Implement a fixed schema using a single large object containing every possible attribute as a null value.

Answer

Serialize the entire attribute set into a single base64-encoded string field.

Question 9

Which of the following describes the behavior of the BSON format within MongoDB?

Accepted Answer

It is a binary-encoded serialization of JSON documents.. BSON (Binary JSON) is the primary data storage format for MongoDB. It extends JSON by providing additional types like Date and BinData while being optimized for fast traversal and efficient serialization. Understanding BSON is critical because it dictates how data is physically stored on disk and read into memory, ensuring that MongoDB maintains its high-performance characteristics while handling complex data structures.

Answer

It is a text-based format identical to JSON but with limited character support.

Answer

It supports a subset of data types compared to standard JSON.

Answer

It requires manual conversion by the driver for every read operation.

Question 10

Refer to the exhibit. Why would an operation attempting to insert the document shown in the exhibit fail?

Accepted Answer

The field '$created' starts with a reserved character.. The document contains a field named '$created'. In MongoDB, field names starting with a '$' symbol are reserved for internal query operators. When the database engine parses a document, it interprets fields beginning with '$' as instructions rather than data fields. This naming conflict is a common trap for developers migrating legacy data or building generic metadata structures without validating field name constraints.

Answer

The '_id' field is invalid.

Answer

The field 'metadata' is a reserved keyword.

Answer

The value 'null' is not allowed for the 'last_login' field.

Question 11

Which document design pattern should be used to store a one-to-many relationship where the child documents are frequently accessed together with the parent?

Accepted Answer

Embed child documents directly as an array within the parent document.. The embedding pattern is preferred for one-to-many relationships where children are always retrieved alongside the parent. This pattern minimizes the number of required read operations by ensuring all necessary data is located within a single document. This reduces latency and eliminates the need for expensive application-level joins, resulting in highly performant read operations for typical read-heavy application workflows.

Answer

Normalize the data by creating a separate collection for child documents.

Answer

Store the child data in a separate database to isolate the write load.

Answer

Use a flat structure and duplicate parent information in every child document.

Question 12

Which of the following describes the 'schema-flexible' nature of MongoDB?

Accepted Answer

Documents can have different fields, and the structure can change over time.. Schema-flexibility means that documents in the same collection do not need to have the same fields or structure. This allows developers to iterate quickly, as adding new fields or changing data structures doesn't require modifying existing data or taking the database offline. This is a fundamental departure from rigid, table-based relational schemas that mandate defined structures before any data can be inserted.

Answer

All documents must have a predefined structure determined by the first document inserted.

Answer

The database automatically flattens all nested documents upon insertion.

Answer

Schema enforcement can only be achieved by using third-party database proxies.

Question 13

What is the primary benefit of the 'Bucket Pattern' in MongoDB data modeling?

Accepted Answer

It keeps document sizes within reasonable limits for time-series data.. The Bucket Pattern is used to avoid the 'unbounded array' problem, where a single document could grow indefinitely. By grouping data into manageable 'buckets' (e.g., one document per day of sensor data), the pattern keeps document sizes manageable, ensures efficient indexing, and optimizes write performance. This approach prevents documents from hitting the 16MB limit while maintaining query speed for time-series data.

Answer

It eliminates the need for any indexing on the collection.

Answer

It forces data normalization across multiple sharded clusters.

Answer

It automatically migrates old data to archival storage systems.

Question 14

When designing a document model, which factor is most important for determining whether to embed or reference data?

Accepted Answer

The application's data access patterns.. The access pattern—specifically how often data is retrieved and how it is used—is the deciding factor. If data is usually needed together, embedding provides the best read performance. If data is accessed independently or the child data grows without bound, referencing is more appropriate. Aligning the model with access patterns is the core tenet of MongoDB performance optimization and design.

Answer

The total number of documents in the collection.

Answer

The memory limit of the database server.

Answer

The complexity of the data's object-oriented relationships.

Question 15

An application needs to store an e-commerce catalog where products have varying attributes such as clothing sizes or electronic specifications. You choose MongoDB for its dynamic schema. Which design approach best leverages the MongoDB document model for this use case?

Accepted Answer

Embed the varying attributes directly within each product document using flexible subdocuments or arrays that match the specific item.. Storing variable attributes directly inside the document using flexible subdocuments or arrays allows efficient single-query retrieval of all product details. This harnesses the core advantage of the document model by keeping related data together, avoiding complex multi-table joins and matching the natural data access patterns of modern applications.

Answer

Normalize product attributes into multiple separate collections linked by manual application references to enforce rigid schema constraints.

Answer

Serialize all product attributes into a single large binary blob string stored in a single generic text field inside the main document.

Answer

Enforce a strict static schema across all product documents using server-side validation rules that require every possible attribute key to be present.

Question 16

A developer is building a MongoDB application that stores social media posts. Each post document includes an array of comments, and each comment is a subdocument with fields such as author, text, and timestamp. The developer later needs to update a specific comment's text. Which update operation should they use to modify only the targeted comment's text without replacing the entire comments array?

Accepted Answer

db.posts.updateOne({ _id: postId, "comments.author": "Alice" }, { $set: { "comments.$.text": "updated text" } }). To update a specific subdocument within an array, MongoDB provides the positional $ operator, which acts as a placeholder for the first array element that matches the query condition. The query must include a filter on the array field to identify which element to update. This approach modifies only the targeted subdocument without affecting other elements or replacing the entire array.

Answer

db.posts.updateOne({ _id: postId }, { $set: { comments: [{ author: "Alice", text: "updated text" }] } })

Answer

db.posts.updateOne({ _id: postId }, { $set: { "comments.$.text": "updated text" } })

Answer

db.posts.updateOne({ _id: postId }, { $push: { comments: { author: "Alice", text: "updated text" } } })

Question 17

A developer is building a MongoDB application to store user profiles. Each profile document includes a field `lastLogin` that records the exact date and time of the user's most recent login. The developer wants to ensure that this field is stored using the most appropriate BSON type for date and time values, allowing for efficient range queries and sorting. Which BSON type should be used for the `lastLogin` field?

Accepted Answer

Date. The BSON Date type is the standard for storing date and time values in MongoDB. It provides millisecond precision and integrates with query operators like `$gt`, `$lt`, and aggregation date operators. Using it for a `lastLogin` field ensures accurate temporal comparisons and efficient indexing. Other types like String or Timestamp are either inefficient or semantically incorrect for application-level timestamps.

Answer

Timestamp

Answer

ObjectId

Answer

String

Question 18

A development team is designing a MongoDB collection to store sensor readings. Each reading document contains a `sensorId`, a `timestamp`, and a `value`. The team expects billions of readings and needs to optimize for fast queries that retrieve the latest reading for a specific sensor. They decide to use a compound index. Which index key order best supports this query pattern?

Accepted Answer

{ sensorId: 1, timestamp: -1 }. The optimal compound index for retrieving the latest reading per sensor is `{ sensorId: 1, timestamp: -1 }`. This allows MongoDB to seek directly to the sensor's entries and return them in descending time order, so the first result is the most recent. It also supports equality on sensorId and sort on timestamp, enabling an efficient, non-blocking query.

Answer

{ timestamp: 1, sensorId: 1 }

Answer

{ value: 1, sensorId: 1 }

Answer

{ sensorId: 1, value: 1 }

Question 19

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 20

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.