Referencje: relacje jeden-do-wielu i wiele-do-wielu

Referencing means storing an ObjectId (or another unique identifier) inside one document that points to a document in a different collection, similar to a foreign key in relational databases. Instead of nesting data, you link it. This approach is essential when the child count is large, when children are shared among multiple parents, or when children need to be queried independently.

In a one-to-many relationship a single parent has many children. A user can have hundreds of orders—far too many to safely embed. Instead, each order document stores a userId reference pointing back to the parent user. This keeps the user document small while allowing unbounded order growth.

A many-to-many relationship—like students enrolled in multiple courses, and courses containing multiple students—cannot be embedded without duplication. The cleanest approach is to store an array of references on one side. For example, each student document holds an array of courseId values it is enrolled in.

To retrieve a document along with its referenced data, use the $lookup aggregation stage. It performs a left outer join between two collections. The from field names the collection to join, localField is the reference field in the current collection, and foreignField is the field to match in the joined collection.

You can store the reference on either side of the relationship. Child-side reference: the child stores the parent's ID (e.g., order.userId)—queries like 'all orders for a user' are simple range queries. Parent-side reference: the parent stores an array of child IDs (e.g., user.orderIds)—useful when you frequently retrieve all child IDs without querying child documents.

To resolve a many-to-many relationship—finding all courses a student is enrolled in—use $lookup with the array of IDs stored in the student document. The $in syntax inside $lookup's pipeline form lets you match multiple IDs efficiently.

Mongoose provides the populate() method as an abstraction over $lookup. You declare a field as a reference using type: mongoose.Schema.Types.ObjectId, ref: 'ModelName', and then call .populate('fieldName') on a query to automatically resolve the reference to the full document.

When querying child documents by their parent reference—such as all orders for a given user—MongoDB must scan the entire collection unless the userId field is indexed. Always create an index on reference fields used in frequent queries. An index on userId turns a full collection scan into a fast index scan.

When multiple documents share the same child—like many blog posts sharing the same author profile—embedding would duplicate the author data in every post. With referencing, only the authorId is stored in each post. If the author's name changes, one update to the authors collection propagates everywhere, whereas with embedding you'd have to update every post.

Referencing requires at least two round trips to the database (or one aggregation with $lookup) to fetch the parent and its children. This is slower than a single embedded read, but the trade-off is often worth it when children are large in number, updated independently, or shared across parents. Design choices always depend on your dominant query patterns.

Real schemas often mix both strategies. An order document might embed the shipping address (immutable at order time) while referencing the productId for each line item (shared catalogue data). This hybrid approach co-locates data that changes together and references data that is shared or grows independently. There is no rule against mixing the two patterns in a single document.

Test your understanding of MongoDB & NoSQL Databases concepts from this lesson.

In this lesson you learned: referencing stores ObjectId links across collections, $lookup and populate() resolve references at query time, and referencing is preferred when child count is large, data is shared, or children need independent updates. Next up we explore the unbounded array anti-pattern—when embedding goes wrong.