Welcome. Another relationship we frequently encounter is the one-to-many. Examples of one-to-many relationships include customer and purchases, or automaker and car models. In this video, we'll look at the one-to-many relationship in our bookstore app using a printed book in its reviews. In this relationship, printed books represent the one side of the relationship and the reviews represent the many side of the relationship. Let's look at embedding first. The most common way to embed a one-to-many relationship in MongoDB is to embed the many side as an array of subdocuments in the one side of the relationship. Here we've created an array called reviews. This array contains subdocuments of reviews for one book. The second way to embed this relationship is by creating one subdocument within the parent document. In this example, within the book document, we have a review subdocument. This subdocument contains subdocuments for each review. An attribute from each review, in this case, a user ID, becomes a key for each subdocument. An advantage of embedding a one-to-many relationship is that there isn't duplication of information. It's also a good option when the information on the many side cannot exist by itself, like a review without a book. Now let's look at ways to model references. The first way to reference a one-to-many relationship is to use an array of references within the parent document. In this example, each entry in the reviews array is a reference to a separate document for the given review. We can use the reference value in the reviews array to look up the details for a given review. The second way is to reference the parent in each of the many child documents. As you see in the example, each review document has a field for book ID that points back to the parent document. We could use a query for a specific book ID to return all relevant review documents without a join. You can also have bidirectional references. The book document includes a reference to its review documents, while each review document contains a reference to its book. When considering whether to embed a reference for a one-to-many relationship, embedding an array of subdocuments is usually the preferred option. By using arrays to hold related data, our application can retrieve information for a document without $lookup operations or indexes on other collections. However, we also have to remember the cardinality guideline. We aim to have one billion reviews in our app in three years. There is a strong possibility that within a book document, the array of subdocuments containing the reviews could become an unbounded array, especially for popular books. You may recall that sometimes particular guidelines can become a priority when we are deciding whether to embed a reference. If an array is unbounded, or very large like in the case of the relationship between printed books and reviews, those arrays may ultimately degrade performance. In this case, because an unbounded array within the book document is a possibility, whether we embed a reference, we should reference the book ID in each review instead. Let's recap what you learned in this video. When embedding a one-to-many relationship, we have two main options. We can use an array of subdocuments, or we can use a single subdocument with multiple key value pairs where each value is a subdocument and the key is simply a unique value. Using an array of subdocuments is a preferred option. However, if an array is unbounded or very large, like in the case of the relationship between printed books and reviews, those arrays may ultimately degrade performance, so referencing would be a better option. When referencing a one-to-many relationship, we have a few options. Use an array of references to the child documents in the parent document, use a reference to the parent document in the child documents, or have it both ways and create bidirectional references.