C100DEV MongoDB Overview and Document Model Practice Test 2 — 15 Questions

Question 1

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?

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

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 2

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?

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

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 3

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 4

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 5

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 6

A developer is working with a MongoDB collection that stores sensor readings. Each document contains a timestamp, sensor ID, and a nested object 'readings' with fields like 'temperature', 'humidity', and 'pressure'. The developer needs to query for all documents where the temperature reading exceeds 30 degrees Celsius. Which query correctly retrieves these documents?

Accepted Answer

db.sensors.find( { "readings.temperature": { $gt: 30 } } ). MongoDB uses dot notation to query nested fields within documents. The query with "readings.temperature" and $gt correctly targets the nested temperature value. The other options either misinterpret the structure, use array-specific operators incorrectly, or rely on inefficient JavaScript evaluation, making them unsuitable for this scenario.

Answer

db.sensors.find( { $where: "this.readings.temperature > 30" } )

Answer

db.sensors.find( { readings: { temperature: { $gt: 30 } } } )

Answer

db.sensors.find( { "readings": { $elemMatch: { temperature: { $gt: 30 } } } } )

Question 7

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?

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

Accepted Answer

Date. The BSON Date type is the correct choice because it stores time as a 64-bit integer (milliseconds since epoch), enabling efficient range queries and sorting. It is the standard type for timestamps in MongoDB applications and is fully supported by query and aggregation operators. The Timestamp type is reserved for internal use, while String and Long would require manual handling and lack native date functionality.

Answer

String

Answer

Timestamp

Answer

Long

Question 8

A developer is using the MongoDB Node.js driver to insert a document into a collection. The document includes a field `_id` set to a custom string value. After the insert, the developer checks the returned result and notices that the `insertedId` matches the custom string. What does this indicate about MongoDB's handling of the `_id` field?

Accepted Answer

MongoDB automatically generates an ObjectId for the `_id` field if it is not provided, but if provided, it must be unique within the collection.. The `_id` field is the primary key for MongoDB documents. If omitted, the driver generates an ObjectId; if provided, it can be any BSON type except an array, but it must be unique within the collection. MongoDB automatically creates a unique index on `_id`. The scenario confirms that a custom string was accepted and used as the `_id`, demonstrating this flexibility.

Answer

The `_id` field is always an ObjectId and cannot be overridden with a custom value.

Answer

The `_id` field is only unique per shard, not across the entire collection.

Answer

MongoDB automatically indexes the `_id` field only if it is an ObjectId.

Question 9

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?

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

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 10

A financial application stores transaction documents in a MongoDB collection. Each document includes fields such as 'transactionId', 'amount', 'currency', and 'timestamp'. The application requires that the 'amount' field always be present and be a double, and that 'currency' be one of a predefined list of ISO codes. Which MongoDB feature should the developer use to enforce these requirements at the database level?

Accepted Answer

Schema validation using JSON Schema with $jsonSchema operator.. Schema validation with $jsonSchema allows developers to specify required fields, BSON types, and allowed values, enforcing data integrity directly in MongoDB. This is ideal for ensuring that 'amount' is always a double and 'currency' is from a predefined list. Other options either provide weaker guarantees or are unrelated to validation.

Answer

Application-level validation using Mongoose schema definitions.

Answer

Unique indexes on the 'amount' and 'currency' fields.

Answer

Sharding the collection on the 'currency' field.

Question 11

A developer is new to MongoDB and is examining a collection of documents. Each document contains fields like `name`, `age`, and `address`, where `address` is a nested document with `street`, `city`, and `zip`. The developer wants to query for all documents where the `city` in the nested `address` document is 'New York'. Which query correctly retrieves these documents?

Accepted Answer

db.collection.find({ 'address.city': 'New York' }). To query a nested field in MongoDB, you use dot notation within a string, such as `'address.city'`. This allows the query to match documents where the nested `city` field equals 'New York', regardless of other fields in the subdocument. The other options either perform an exact match on the entire subdocument, use invalid syntax, or misuse the `$elemMatch` operator.

Answer

db.collection.find({ $elemMatch: { 'address.city': 'New York' } })

Answer

db.collection.find({ address: { city: 'New York' } })

Answer

db.collection.find({ address.city: 'New York' })

Question 12

A developer is designing a MongoDB collection to store user profiles. Each profile document includes fields for name, email, and an array of phone numbers. The developer wants to ensure that the email field is unique across all documents. Which MongoDB feature should be used to enforce this constraint?

Accepted Answer

Unique index on the email field. A unique index on the email field is the only reliable way to enforce uniqueness in MongoDB. It guarantees that no two documents can have the same email value, even under concurrent operations. Schema validation, sharding, and application-level checks cannot provide this guarantee. The unique index also speeds up queries that filter by email.

Answer

Sharding the collection on the email field

Answer

Schema validation with $jsonSchema

Answer

Application-level check before insert

Question 13

A developer is building an inventory system for a hardware store. Each item document needs to store the product's name, a unique SKU, the quantity on hand, and a list of compatible replacement part numbers. The developer wants to ensure that the `sku` field is always present and is a string, while still allowing other fields to vary between item types. Which MongoDB feature should the developer use to enforce this requirement?

Accepted Answer

JSON Schema validation with the `$jsonSchema` operator in a collection validator. The requirement is to enforce a specific field and type at write time while allowing other fields to vary. MongoDB's schema validation with `$jsonSchema` is designed for exactly this: you can specify required fields and BSON types in a validator, and the server rejects documents that do not comply. This keeps the collection flexible for other fields but guarantees the `sku` contract.

Answer

The `$exists` query operator in all read operations

Answer

A unique index on the `sku` field

Answer

Storing the `sku` in a separate collection and using `$lookup`

Question 14

A developer is designing a MongoDB collection to store blog posts. Each post document includes an array of comments, and each comment has fields such as 'author', 'text', and 'timestamp'. The developer wants to optimize for queries that retrieve posts along with their comments, and also wants to ensure that comments are stored efficiently. Which two of the following statements are true regarding the document model in this scenario? (Choose two.)

Accepted Answer

Embedding comments as an array within the post document allows retrieving the post and its comments in a single query.. Embedding comments within the post document allows retrieving the post and comments in one query, which is efficient for read-heavy access patterns. However, the 16MB document size limit must be considered if comments grow unbounded. The other statements are either incorrect or not directly related to the document model design in this scenario.

Answer

Storing comments in a separate collection and referencing them from the post document reduces data duplication.

Answer

Embedding comments always improves write performance because it requires only a single document update.

Answer

Using the $slice operator in a query can limit the number of comments returned from an embedded array.

Question 15

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"] }