Many-to-many with references in MongoDB

Introduction

Many-to-many with references helps connect two groups of things where each item in one group can link to many items in the other group, and vice versa.

When you have students and courses, and each student can take many courses, and each course can have many students.

When you have books and authors, and each book can have multiple authors, and each author can write multiple books.

When you have users and roles, and each user can have many roles, and each role can belong to many users.

Syntax

MongoDB

In MongoDB, use arrays of ObjectId references in both collections.

Example:
{
  _id: ObjectId,
  name: String,
  relatedIds: [ObjectId, ObjectId, ...]
}

Use ObjectId to reference documents from another collection.

Store arrays of these ObjectId in each document to link many items.

Examples

Each student lists courses they take, and each course lists students enrolled.

MongoDB

/* Student document */
{
  _id: ObjectId("507f1f77bcf86cd799439011"),
  name: "Alice",
  courseIds: [ObjectId("507f1f77bcf86cd799439021"), ObjectId("507f1f77bcf86cd799439022")]
}

/* Course document */
{
  _id: ObjectId("507f1f77bcf86cd799439021"),
  title: "Math",
  studentIds: [ObjectId("507f1f77bcf86cd799439011"), ObjectId("507f1f77bcf86cd799439012")]
}

Authors reference books they wrote, and books reference their authors.

MongoDB

/* Author document */
{
  _id: ObjectId("507f1f77bcf86cd799439031"),
  name: "Bob",
  bookIds: [ObjectId("507f1f77bcf86cd799439041"), ObjectId("507f1f77bcf86cd799439043")]
}

/* Book document */
{
  _id: ObjectId("507f1f77bcf86cd799439041"),
  title: "Learn MongoDB",
  authorIds: [ObjectId("507f1f77bcf86cd799439031"), ObjectId("507f1f77bcf86cd799439032")]
}

Sample Program

This example creates two students and two courses. Each student has a list of course IDs, and each course has a list of student IDs. Then it finds all courses Alice takes by looking up her course IDs.

MongoDB

use schoolDB;

// Insert students
db.students.insertOne({ _id: ObjectId("507f1f77bcf86cd799439011"), name: "Alice", courseIds: [ObjectId("507f1f77bcf86cd799439021"), ObjectId("507f1f77bcf86cd799439022")] });
db.students.insertOne({ _id: ObjectId("507f1f77bcf86cd799439012"), name: "Bob", courseIds: [ObjectId("507f1f77bcf86cd799439022")] });

// Insert courses
db.courses.insertOne({ _id: ObjectId("507f1f77bcf86cd799439021"), title: "Math", studentIds: [ObjectId("507f1f77bcf86cd799439011"), ObjectId("507f1f77bcf86cd799439012")] });
db.courses.insertOne({ _id: ObjectId("507f1f77bcf86cd799439022"), title: "Science", studentIds: [ObjectId("507f1f77bcf86cd799439011"), ObjectId("507f1f77bcf86cd799439012")] });

// Query: Find courses Alice takes
const alice = db.students.findOne({ name: "Alice" });
const courses = db.courses.find({ _id: { $in: alice.courseIds } }).toArray();
courses;

Important Notes

Keep references consistent: if a student references a course, the course should reference that student.

Use $in operator to find documents by multiple IDs.

Summary

Many-to-many with references uses arrays of IDs in both collections.

This lets each item link to many items in the other collection.

It keeps data organized and easy to query in MongoDB.

Practice

1. What does a many-to-many relationship with references mean in MongoDB?

easy

A. Only one collection has references, the other does not.

B. One collection stores all data, the other is empty.

C. Both collections store arrays of IDs pointing to each other.

D. Data is duplicated in both collections without IDs.

Solution

1. Step 1: Understand many-to-many references

   In MongoDB, many-to-many means each document in one collection can link to many documents in another, and vice versa.

2. Step 2: Identify how references are stored

   This is done by storing arrays of IDs in both collections, so each side knows its related documents.

3. Final Answer:

   Both collections store arrays of IDs pointing to each other. -> Option C

4. Quick Check:

   Many-to-many references = arrays of IDs in both collections [OK]

Hint: Many-to-many means both sides hold arrays of IDs [OK]

Common Mistakes:

• Thinking only one side stores references
• Confusing many-to-many with embedding all data
• Assuming data is duplicated without IDs

2. Which of the following is the correct way to store references for a many-to-many relationship between students and courses collections in MongoDB?

easy

A. { _id: 1, name: 'Alice', courses: 101 } and { _id: 101, title: 'Math', students: 1 }

B. { _id: 1, name: 'Alice', courses: [101, 102] } and { _id: 101, title: 'Math', students: [1, 2] }

C. { _id: 1, name: 'Alice', courses: 'Math' } and { _id: 101, title: 'Math', students: 'Alice' }

D. { _id: 1, name: 'Alice', courses: [] } and { _id: 101, title: 'Math', students: [] }

Solution

1. Step 1: Check reference format

   References must be arrays of IDs to represent many-to-many links.

2. Step 2: Validate { _id: 1, name: 'Alice', courses: [101, 102] } and { _id: 101, title: 'Math', students: [1, 2] }

   { _id: 1, name: 'Alice', courses: [101, 102] } and { _id: 101, title: 'Math', students: [1, 2] } shows arrays of IDs in both collections, correctly linking students and courses.

3. Final Answer:

   { _id: 1, name: 'Alice', courses: [101, 102] } and { _id: 101, title: 'Math', students: [1, 2] } -> Option B

4. Quick Check:

   Arrays of IDs in both collections = correct syntax [OK]

Hint: Use arrays of IDs, not single values or names [OK]

Common Mistakes:

• Using single ID instead of array for many-to-many
• Storing names instead of IDs as references
• Leaving reference arrays empty without reason

3. Given these two documents:
{ _id: 1, name: 'Bob', courses: [201, 202] }
{ _id: 201, title: 'History', students: [1, 3] }
What will be the result of querying the courses array for student with _id: 1?

medium

A. ['History']

B. [1, 3]

C. []

D. [201, 202]

Solution

1. Step 1: Identify the student's courses field

   The student document with _id 1 has a courses array: [201, 202].

2. Step 2: Understand the query result

   Querying the courses array for this student returns the IDs [201, 202], not titles or student IDs.

3. Final Answer:

   [201, 202] -> Option D

4. Quick Check:

   Student's courses array = [201, 202] [OK]

Hint: Query returns stored IDs, not linked document fields [OK]

Common Mistakes:

• Confusing course IDs with student IDs
• Expecting course titles instead of IDs
• Assuming empty array if unsure

4. You have these two collections:
students: { _id: 2, name: 'Eve', courses: [301] }
courses: { _id: 301, title: 'Science', students: [] }
What is the problem with this many-to-many reference setup?

medium

A. The students array in courses is missing the student ID.

B. The courses array in students is empty.

C. The student document is missing the courses field.

D. The course document has an invalid _id.

Solution

1. Step 1: Check references in both collections

   The student document lists course 301, but the course document's students array is empty.

2. Step 2: Identify missing reciprocal reference

   For many-to-many, both sides must reference each other. The course's students array should include student ID 2.

3. Final Answer:

   The students array in courses is missing the student ID. -> Option A

4. Quick Check:

   Both sides must reference each other [OK]

Hint: Both sides must list each other's IDs [OK]

Common Mistakes:

• Ignoring missing reciprocal references
• Assuming one side is enough
• Confusing empty arrays with missing fields

5. You want to find all courses taken by students who are enrolled in both course 401 and 402. Given collections with many-to-many references, which MongoDB aggregation pipeline stage helps find students enrolled in both courses?

hard

A. { $match: { courses: { $all: [401, 402] } } }

B. { $match: { courses: { $in: [401, 402] } } }

C. { $match: { courses: 401 } }

D. { $match: { courses: { $size: 2 } } }

Solution

1. Step 1: Understand the query goal

   We want students enrolled in both courses 401 and 402, so their courses array must contain both IDs.

2. Step 2: Choose correct MongoDB operator

   The $all operator matches arrays containing all specified elements, perfect for this case.

3. Final Answer:

   { $match: { courses: { $all: [401, 402] } } } -> Option A

4. Quick Check:

   $all matches arrays containing all elements [OK]

Hint: Use $all to match arrays containing all specified IDs [OK]

Common Mistakes:

• Using $in matches any, not all elements
• Using $size only checks array length, not content
• Matching single course ID misses the second course