A MongoDB data modeler is designing a system for a blogging platform where articles can receive
comments and be tagged with multiple categories. To ensure efficient retrieval of articles by
category and manage comments in a scalable way, which design pattern should the data modeler
implement?
Correct Answer: A
Explanation:
Apply the Outlier Pattern, storing most comments within the article document and exceptionally long or numerous comments in a separate collection. -> Correct. This pattern optimizes for the common case where articles have a manageable number of comments, while still accommodating outliers without impacting the document size limit. Store articles and comments in the same document, using an array for comments and another array for categories. -> Incorrect. This could lead to document growth issues and potentially hit the BSON document size limit if an article receives a large number of comments. Use separate collections for articles, comments, and categories, linking them through reference IDs. -> Incorrect. While this maintains data normalization, it could increase the complexity of queries and affect performance due to the need for multiple joins. Implement the Bucket Pattern by grouping comments into buckets within each article document and categorize articles using a separate collection. -> Incorrect. The Bucket Pattern is efficient for managing growing arrays like comments, but using a separate collection for categories might not be necessary.
Question 2
A data modeler is tasked with designing a database for a movie streaming service. The database
needs to efficiently store and retrieve information about movies, including the movie's title,
director, genre(s), release year, and average viewer rating. How should the data modeler
structure the Movie entity?
Correct Answer: C
Explanation:
Model Movie as a movie's title, director, genre(s), release year, and average viewer rating. -> Correct. It includes all the necessary attributes to efficiently store and retrieve information about movies without including unnecessary data that can be stored separately if needed. Model Movie as a movie's title, director, genre(s), release year, average viewer rating, and the total number of viewers. -> Incorrect. The total number of viewers is a dynamic attribute that can significantly fluctuate, which might not be necessary for the primary model of the Movie entity and could be stored separately for scalability. Model Movie as the movie's title only. -> Incorrect. This does not include other critical information about the movie that the streaming service needs to store and retrieve, such as director, genre(s), release year, and average viewer rating. Model Movie as a movie's title, director, and genre(s). -> Incorrect. It omits some important attributes like release year and average viewer rating, which are essential for users to make informed viewing choices
Question 3
In a MongoDB database, a query frequently sorts documents based on two fields, createdAt (a
timestamp) and priority (an integer representing the item's urgency), to fulfill a reporting
requirement. This query is critical for daily operations. You notice that the query performance is
suboptimal, and upon reviewing the query plan, you observe that MongoDB is not using an index
for sorting. Which of the following actions would most effectively optimize the query
performance?
Correct Answer: A
Explanation:
Use a compound index that includes both createdAt and priority fields in the same order as they appear in the sort clause. -> Correct. A compound index that matches the sort order of the query can greatly improve performance by allowing MongoDB to use the index for both filtering and sorting operations. This minimizes the number of documents MongoDB has to examine and sort in memory, leading to faster query execution. Create separate single field indexes on both createdAt and priority. -> Incorrect. While single field indexes could potentially improve performance for queries filtering on these fields individually, they wouldn't be as effective for optimizing a sort operation that includes both fields. MongoDB can only use one index per query for sorting, so separate indexes would not optimize a sort on both fields together. Increase the RAM of the MongoDB server to ensure that all indexes fit into memory. -> Incorrect. While having sufficient RAM for indexes to fit into memory is important for overall performance, simply increasing RAM does not directly address the inefficiency of the sorting operation in the query. The underlying issue is the lack of an appropriate index for the sort. Remove all existing indexes on the collection to reduce the overhead of index maintenance. -> Incorrect. Removing indexes might reduce the overhead of maintaining those indexes during write operations, but it would also degrade read and sort operation performance. This approach would likely worsen the performance of the query in question.
Question 4
In a content management system (CMS) for a news website, articles are frequently accessed with
their associated comments. Given the high volume of comments and the need for efficient article
retrieval, how should the data model be designed to optimize read operations while considering
the trade-offs between embedding and referencing?
Correct Answer: B
Explanation:
Use a hybrid model, embedding recent comments in the article document and referencing older comments. -> Correct. The hybrid model offers a balanced approach, enabling efficient access to recent comments while avoiding the large document size issue by referencing older comments. This method provides fast access to the most relevant comments without compromising performance. Embed all comments within their respective article documents. -> Incorrect. While embedding comments provides fast read access to articles and their comments, it could lead to document size exceeding the MongoDB document size limit, especially for articles with a very high number of comments. Reference comments in articles using an array of comment IDs. -> Incorrect. This approach avoids large document sizes but requires additional queries to fetch comments, potentially reducing read efficiency for articles and their associated comments. Store comments and articles in the same document. -> Incorrect. Storing all comments and articles in a single document would significantly increase document size, risking exceeding the MongoDB document size limit and making updates inefficient.
Question 5
A database designer is structuring a database for a book publishing company using MongoDB. In
this design, there are two entities: Author and Book. An Author can write multiple Books, but
each Book can be written by only one Author.
What is the relationship between Authors and
Books?
Correct Answer: D
Explanation:
One-to-many -> Correct. This is the appropriate choice because a single Author can write multiple Books, establishing a one-to-many relationship where the "one" side is the Author and the "many" side is the Books. One-to-one -> Incorrect. This would imply that each Author is linked to exactly one Book and each Book is written by exactly one Author, which does not align with the scenario that an Author can write multiple Books. Many-to-many -> Incorrect. This suggests that each Book could be written by multiple Authors and each Author could write multiple Books. While the latter part fits, the former does not, as each Book is written by only one Author in the given scenario. Many-to-one -> Incorrect. This implies that multiple Books could be written by a single Author, which is true; however, it inaccurately suggests that a Book could have multiple Authors, reversing the actual relationship. Squillions-to-one -> Incorrect. This term might describe an extremely large number of entities on one side of a relationship, typically used in contexts with a vast disparity in quantities. It does not accurately reflect the relationship between Authors and Books as described.
Demo Practice Mode
You are viewing only the questions marked as Demo.