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

Question 1

A team is designing a MongoDB collection to store user profiles. Each profile document includes a `name` string, an `age` integer, and an array of `hobbies` strings. A new developer asks which BSON type is used to represent the `hobbies` field in the stored document. What is the correct BSON type for an array of strings?

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

Accepted Answer

Array. MongoDB documents are stored in BSON, which includes an Array type for ordered lists of values. A field like `hobbies` that contains multiple strings is represented as a BSON array of strings. This allows the database to index the array elements, query with operators like `$in` or `$elemMatch`, and update individual elements, making Array the correct and natural choice.

Answer

Binary data

Answer

Object

Answer

String

Question 2

A development team is building a MongoDB application to store user profiles. They want to enforce that every user document contains an 'email' field of type string, and they want documents that violate this rule to be rejected at insert time. Which MongoDB feature should they use?

Accepted Answer

JSON Schema validation with the $jsonSchema operator in the collection's validator option. MongoDB's JSON Schema validation allows developers to enforce a schema on a collection while still accommodating flexible fields. By defining a validator with $jsonSchema, the team can require the 'email' field and ensure it is a string. This provides server-side enforcement, ensuring that any insert or update that violates the schema is rejected, regardless of the client used.

Answer

Storing the email in a separate collection with a reference

Answer

Unique index on the 'email' field

Answer

Application-level validation using Mongoose schema definitions

Question 3

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 4

A developer is reviewing the characteristics of MongoDB documents. Which two of the following statements are accurate? (Choose two.)

Accepted Answer

Each document must have a unique _id field, which can be of any BSON data type except an array.. The maximum BSON document size is 16 MB, and every document must have a unique _id field that can be any BSON type except an array. Documents in a collection need not share the same fields, they are stored in BSON not JSON, and field names cannot contain null characters.

Answer

Documents are stored in a human-readable JSON format on disk.

Answer

Field names in a document can contain the null character.

Answer

Documents in the same collection must have the same set of fields.

Question 5

A developer is designing a MongoDB collection to store blog posts. Each post has a title, content, and an array of tags. The developer wants to ensure that the tags field is always an array of strings. Which BSON data type should be used for the tags field?

Accepted Answer

Array. MongoDB's document model supports arrays natively, allowing a field to hold multiple values. For a tags field that should contain multiple strings, the Array BSON type is the correct choice. It enables efficient querying (e.g., finding posts with a specific tag) and indexing (multikey indexes), and it aligns with the flexible schema design that MongoDB encourages.

Answer

Object

Answer

BinData

Answer

String

Question 6

A developer is working with a MongoDB collection that stores product data. The collection has documents with a field 'price' that is sometimes stored as a double and sometimes as a string, due to inconsistent data entry. A query is run to find all products with a price greater than 100. What is the expected behavior of this query?

Accepted Answer

The query will return only documents where 'price' is a double greater than 100.. MongoDB uses type bracketing for comparison operators: only values of the same BSON type as the operand are considered. Since 100 is a double, only double prices greater than 100 are returned. Strings are not converted, and no error occurs. This underscores the importance of consistent data types in a collection.

Answer

The query will return an error because of the mixed data types in the 'price' field.

Answer

The query will return documents where 'price' is a string greater than '100' lexicographically, as well as doubles greater than 100.

Answer

The query will return all documents where 'price' is greater than 100, regardless of whether it is a double or string.

Question 7

A financial application stores transactions in a MongoDB collection. Each transaction document includes a 'timestamp' field. The application needs to query transactions for a specific day, and the queries must be efficient. Which indexing strategy is most appropriate?

Accepted Answer

Create a single-field index on the 'timestamp' field. For efficient range queries on a single field, a single-field index is the correct choice. It allows MongoDB to quickly find documents with timestamps within the desired range. Compound indexes can also work but are unnecessary here, and other index types like text or hashed do not support range queries on dates. The single-field index provides the best balance of performance and simplicity.

Answer

Create a hashed index on the 'timestamp' field

Answer

Create a compound index on {timestamp: 1, _id: 1}

Answer

Create a text index on the 'timestamp' field

Question 8

A developer is working with a MongoDB collection that stores product data. Each product document has a 'price' field. The developer needs to find all products with a price greater than 100 and less than 200. Which query operator should be used?

Accepted Answer

$gt and $lt. To find documents where a field falls within an exclusive range, MongoDB provides the $gt and $lt operators. Combining them in a single query object on the same field applies both conditions. This is a common pattern for range queries and is efficient when an index exists on the field. The other operators either include boundary values or are for different query types.

Answer

$gte and $lte

Answer

$and with $gt

Answer

$in

Question 9

A developer is modeling a blog platform. Posts are read frequently, and each post has a small, bounded set of tags. The tags are always displayed with the post and are never queried independently across posts. The developer is deciding between embedding the tags as an array inside each post document versus storing them in a separate tags collection with references. Which design choice aligns with MongoDB document model guidance for this scenario?

Accepted Answer

Embed the tags as an array within each post document, since they are bounded, accessed together with the post, and not queried independently.. MongoDB document modeling favors embedding when related data is bounded, is retrieved together with its parent, and is not queried on its own. The tags described fit all three conditions, so embedding them as an array in each post yields single-read retrieval and avoids join overhead. A separate collection would only be justified if tags needed independent querying or unbounded growth.

Answer

Store tags both embedded in posts and in a separate collection, keeping them synchronized manually, to satisfy both read and write paths.

Answer

Store tags in a separate collection and use a $lookup aggregation in every read, because aggregation pipelines are the only way to combine related data.

Answer

Store tags in a separate collection and reference them from posts, because normalization always reduces duplication and improves read performance.

Question 10

An application stores customer profiles in a MongoDB collection. A developer notices that documents created by different services have inconsistent shapes: some use a string for phone, others an array of strings, and some omit the field entirely. The team wants to enforce a consistent structure for new writes while still allowing existing documents to remain. Which MongoDB feature should they use?

Accepted Answer

A JSON Schema validator attached to the collection with the $jsonSchema operator and validationLevel set to strict.. MongoDB supports schema validation through the $jsonSchema operator, configured on a collection with collMod. Setting validationLevel to strict applies the rules to all inserts and updates, so new writes must match the declared structure. Existing documents that are not modified remain untouched, which satisfies the requirement to leave current data as is while enforcing consistency going forward.

Answer

A unique index on the phone field, which forces every document to use the same BSON type for that field.

Answer

A partial index with a filter expression that excludes documents lacking the phone field.

Answer

A change stream that watches the collection and rejects documents whose shape differs from a template.

Question 11

A developer stores product documents in a MongoDB collection. Some documents include a nested details object with a warranty subfield, while others do not. The developer needs to retrieve only the documents where details.warranty equals the string "2 years". Which query correctly targets that nested field?

Accepted Answer

db.products.find({ "details.warranty": "2 years" }). Dot notation is the correct way to query a field inside an embedded document. Writing the path as a quoted string, such as details.warranty, tells MongoDB to look inside the details object for the warranty field and compare its value. This approach uses indexes when available and returns only documents whose nested field equals the requested value.

Answer

db.products.find({ details: { warranty: "2 years" } })

Answer

db.products.find({ $where: "this.details.warranty === '2 years'" })

Answer

db.products.find({ details: { $elemMatch: { warranty: "2 years" } } })

Question 12

A development team is modeling a MongoDB collection for a ticketing system. Each ticket has a unique ticketId, a status, and a variable set of custom fields that differ by department. The team wants to ensure that queries on ticketId and status can use indexes efficiently and that the custom fields remain flexible. Which statement best describes how the document model supports this requirement?

Accepted Answer

Documents in the same collection can have different fields, and indexes on ticketId and status can be created regardless of the custom fields present.. The document model allows each ticket to have its own shape while sharing common fields. Indexes are created on specific fields such as ticketId and status, and they work even when documents contain additional custom fields. This gives the team efficient lookups on the common fields and the flexibility to store department-specific data without schema migrations.

Answer

MongoDB enforces a collection-level schema, so the team must define all custom fields in a validator before inserting tickets.

Answer

Custom fields must be stored in a separate collection because MongoDB does not allow arrays or subdocuments in the same collection as scalar fields.

Answer

Indexes in MongoDB are created on collections, not fields, so the team cannot index ticketId and status without also indexing all custom fields.

Question 13

A developer is reviewing how MongoDB represents and stores data at the document level. Which TWO statements accurately describe the behavior of the BSON format and MongoDB documents? (Choose two.)

Accepted Answer

The maximum size of a single BSON document in MongoDB is 16 MB, and this limit applies to the document as stored on the server.. BSON is a binary-encoded format that extends JSON with types such as ObjectId, Date, and Binary, each identified by a type code. MongoDB also enforces a 16 MB maximum document size, which affects how applications design their data model. These two facts are central to understanding how documents are represented and stored, and they explain why BSON is used rather than plain JSON.

Answer

Field order within a BSON document is not preserved, so queries that depend on field order will not work consistently.

Answer

BSON documents are stored as plain text JSON on disk to simplify backup and restore operations.

Answer

A MongoDB document can contain fields with duplicate names, and the server preserves both values when the document is stored.

Question 14

A financial application stores transaction records in a MongoDB collection. Each transaction document includes a Decimal128 amount field and a Date field for the transaction time. A developer needs to query for transactions with amounts greater than 100.00 and times within the last 24 hours, and wants the queries to use indexes efficiently. Which statement about the document model and BSON types is correct for this scenario?

Accepted Answer

Date values are stored as 64-bit integers representing milliseconds since the Unix epoch, and they can be indexed and compared with range operators.. BSON Date is stored as a 64-bit integer of milliseconds since the Unix epoch, which makes it directly comparable and indexable for range queries. Decimal128 is a separate numeric type that also supports range comparisons and indexing. Together, they allow the application to filter by amount and time efficiently using appropriate indexes, without converting values to strings or avoiding range queries.

Answer

Range queries on Decimal128 fields are not supported; only equality queries can use an index on a Decimal128 field.

Answer

Decimal128 values are stored as strings, so range queries on the amount field require a text index rather than a numeric index.

Answer

Because Decimal128 and Date are both binary types, they cannot be used together in a compound index on the same collection.

Question 15

A developer is designing a MongoDB collection to store sensor readings. Each reading document contains a sensorId, a timestamp, and a readings array of subdocuments with type and value fields. The application frequently queries for readings where the readings array contains a subdocument with type "temperature" and value greater than 30. Which document model feature allows the query to match elements within the array efficiently?

Accepted Answer

Multikey indexes, which are created automatically when an index is built on a field that contains an array, allow the query to match individual array elements.. A multikey index is created when an index is built on a field containing an array. MongoDB generates an index entry for each array element, so queries that filter on subdocument fields within the array can use the index. This allows the sensor reading query to match temperature readings above 30 efficiently, as long as an appropriate index exists on the readings field.

Answer

The _id index, which is created on every collection, includes all array elements and can be used to match subdocument fields.

Answer

Capped collections, which store documents in insertion order, automatically index array elements for fast lookups.

Answer

Array flattening, which merges all subdocuments into a single document, allows the query to treat the readings array as a flat set of fields.