MongoDB join multiple collections

MongoDB is a NoSQL database that is one of the most customary documents accessible and stores both as a completely controlled cloud service and also for deploying on self-managed infrastructure. Since MongoDB is not an RDBMS type, but still, a user can execute a left outer join by means of the $lookup stage. This stage $lookup allows you to state which collection a user needs to join with the present collection and also which fields that must match.

In MongoDB it is quite difficult to relate data from one collection to another excluding when basic script query functions are used. Therefore, to resolve this the JOIN concept is introduced which facilitates the data relation. MongoDB JOIN operation with two collections is performed by the use of $lookup operator developed having version 3.2.

Syntax:

The key concept behind the MongoDB JOIN operation is to achieve a correlation between one collection data to another one. This is done by using the $lookup operator so, the basic syntax for this to join two collections can be defined as follows:

Start Your Free Data Science Course

Hadoop, Data Science, Statistics & others

{
$lookup:
{
From:<join collections>,
localField: <input documents’ field>,
foreignField:<documents’ field of the ‘from’ collection>,
as: <result array field>
}
}

The $lookup operator proceeds a document having the below fields:

All in One Data Science Bundle(360+ Courses, 50+ projects)

Price
View Courses

360+ Online Courses | 50+ projects | 1500+ Hours | Verifiable Certificates | Lifetime Access
4.7 (86,527 ratings)

• From: It states the collection within the identical database for executing the join with but with Sharded Collection Restrictions.
• LocalField: It states the field from the documents input to the stage of $lookup which operates an equivalence match on the local-field to the foreign field from the documents of the collection ‘from’. When an input document has no local-field value then this operator will give the field to have a null value for further matching purposes.
• foreignField: It states the field from the documents in the ‘from’ collection which operates an equivalence match on the foreignField to the localField from the input documents. When a document in the collection ‘from’ has no value for the foreignField then this operator will give the field to have a null value for further matching purposes.
• As: It states the name of the new array field for adding to the input documents. Also, the new array field includes the matching documents from the collection ‘from’. But when the stated name already prevails in the input document then the prevailing field will be overwritten.

In the case of the SQL concept, the result of a JOIN operation is always a different row that associates all fields present from the parent and foreign tables. But in MongoDB, the case is variant where the output documents are supplemented as an array of native collection documents.

How to join two collections in MongoDB?

For joining MongoDB collections, we require to implement the operator as $lookup, which is defined as a stage executing a left outer join with other collection and also aids to filter data info from joined documents.
Suppose a user needs to fetch all the students with grades, then the below query can be written:

Students.aggregate([{
$lookup: {
From: ‘Grades’,
LocalField: ‘Student_id’,
foreignField: ‘Stud_id’,
as: ‘Student_grade’
}}]);

We can see in the above query that the initial parameter named ‘from’ states the collection that is to be joined with the present one, on the other side the ‘localField’ parameter states the key prevailing in the present collection that is to be matched with the foreign key in another collection by means of ‘foreignField’ parameter. Here, Student_id from Students and stud_id from Grades are matched as well as joined for retrieving the data. Also, the end parameter ‘as’ is added as a code-named to the data.

It must be noted that here in every record of result from lookup, also the data from the joined table appears inside an array as the primary element, every one row from the output data of the query above that will display like,

{_ID: String, Quantity: Number, Student_id: String, Student_grade: Array, Stud_id: String, Student_name: String}

Here, in the grades array, the initial element will be the data that the query joined.

Example

Let us illustrate few examples to show the joining of two collections in MongoDB explained as follows:
Suppose we have two collections created named students and marks as,

Students:

{“_id”: 1, “name”: “Nikhil Singh”, “age”: 25, “grade”: “A”}
{“_id”: 2, “name”: “Kiran Sharma”, “age”:20, “grade”: “B”}
{“_id”: 3, “name”: “Krishna Raj”, “age”: 19, “grade”: “A”}
db.Students.find()

Marks:

{“_id”: 1, “English”: “A”, “Maths”: “B”, “Science”: “A”}
{“_id”: 2, “English”: “C”, “Maths”: “A”, “Science”: “B”}
{“_id”: 3, “English”: “B”, “Maths”: “C”, “Science”: “A”}
db.Grades.find()

We can fetch the students’ marks with corresponding grades by means of the $lookup operator using the JOIN methodology defined below:

Db.getCollection(‘Students’).aggregate([{
$lookup:
{
From: “Grades”,
localField: “_id”,
foreignField: “_id”,
as: “StudentMarks”
}
}])

On execution, the output will provide the following results,

{“_id”: 1, “name”: “Nikhil Singh”, “age”: 25, “grade”: “A”, “StudentMarks”: [{“_id”: 1, “English”: “A”, “Maths”: “B”, “Science”: “A”}]}

The structure of the written query may decide the performance duration. Like for instance, when there are several documents in one collection over the other, then aggregation is needed from one collection with smaller documents followed by lookup in the one having various documents. This type of lookup performed for the selected field from the smaller documents collection is rather finest and proceeds smaller time than executing numerous lookups for a selected field present in the collection having various documents. Thus, it is sensible to place the smaller collection initially.

But the order of the databases does not trouble in case of a relational database as maximum of the SQL interpreters includes optimizers that provide access to additional information to select which one must be the primary one.

In this MongoDB, to simplify the JOIN operation we may require to implement an index. Since all MongoDB documents include an _id key that for a relational DBM is measured as the primary key. An index delivers a better chance of minimizing the quantity of data which requires to be retrieved besides associating the operation when applied in the $lookup foreign key.

Conclusion

JOIN operator is one of the basic distinctive features available between SQL database and NoSQL database. In SQL databases, a user can execute a JOIN operation between two tables inside identical or different databases.

While the case in MongoDB for JOIN is varied, MongoDB lets JOIN operations perform between two collections implemented in a similar database.

Recommended Articles

This is a guide to MongoDB Join Two Collections. Here we discuss definition, How to join two collections in MongoDB? along with examples respectively. You may also have a look at the following articles to learn more –

How do I join multiple collections with $lookup MongoDB?

Can a MongoDB have multiple collections?

How to get data from 2 different collections of MongoDB using node js?

How do I join a collection in MongoDB?