在 MongoDB 中设计多对多关系（而不是关系表）

Question

Using a classic example - Suppose that we have an application which has a Courses collection and a Students collection, while each student can participate in many courses, and each course can have many participants. We will need to query all the courses that one student participates in efficiently, But we also need to query the students those are participating in a single course.

I know that using relational database to handle this will be the optimal solution, but for now I just want to use one type of databases which is MongoDB, now I want to ask if this schema design could work efficiently? what is the cons and pros of using it? and which design could be better?

User: {
   _id,
   //...properties
}

Course: {
   _id,
   //...properties
}

CourseParticipate: {
   _id,
   userId,
   courseId,
   //...properties
}

CourseAdmin: {
   _id,
   userId,
   courseId,
   //...properties
}

Now I like this design because in the future if I have the ability to work with multiple databases, it will be easy to transfer these collections to a relational DB (or not?), I also like it becayse it is fast to write the data and to remove the relations between the objects, but it will make the reading queries a little bit slower(or a lot?) as I can see.

Because I never seen this design before in the internet, I already know that there is better solutions (I hope that I don't hear heartful comments and answers because I'm new).

I also want to hear from you whether Neo4j can handle this problem or not? and what relational DBs works the best next to MongoDB?

Links to documentations and articles will be very helpful! Thanks!

Answer 1

This is a case of having the data with Many-to-Many relationship. I would think there are few thousand students and a few hundred courses in your database.

To start with I can use the following design with course details embedded with each student as an array of sub-documents called as courses .

- students collection
id:
name:
courses: [ { id: 1, name: },  { id: 5, name: }, ... ]

- courses collection
id:
name:
description:

Note, the course id and name are stored in both collections. This is duplication of data. This should be okay, as the duplicated details do not change often (or may not change at all).

Query all courses a student is enrolled into, for example: db.students.find( { name: "John" } ) . This will return one student document with the matching name and all the courses (the array field). See db.collection.find .

Query all students enrolled into a particular course: db.students.find( { "courses.name": "Java Programming" } ) . This will return all the student documents who have the course name matching the criteria "java Programming". See Query an Array of Embedded Documents .

Further, you can use projection to exclude and include fields from the result.

NOTES:

• You can embed students info within the courses collection, instead of the courses into the students. The queries will be similar to the above ones, but you will be querying the courses collection. It depends upon your use case.
• You can just store the course id field in the courses array, of the students collection; this is the case where you have course name field changes often. The queries will use Aggregation $lookup (a "join" operation) to get the course and from the courses collection.
• Information on Data Model Design for document based MongoDB data.