Node.js MongoDB Join

MongoDB does not have a direct JOIN operation like SQL databases, but you can use the $lookup stage in aggregation to join data from multiple collections. The $lookup operator allows you to combine documents from one collection with documents from another collection based on a shared field.

 

Key Features of MongoDB Join

1. Aggregation Framework: Use $lookup within an aggregation pipeline for joins.
2. Combine Data: Join two collections based on a common field.
3. Optimized for MongoDB's NoSQL Structure: Join documents in a flexible, schema-less environment.

 

Step 1 Prerequisites

Ensure MongoDB is installed and running, and the mongodb package is installed in your project.

npm install mongodb

Step 2 Using $lookup to Join Collections

The $lookup operator allows you to combine documents from two collections. It performs a left outer join, meaning it will include documents from the primary collection even if there are no matching documents in the secondary collection.

Example Code

Assume we have two collections:

• users: Contains user information.
• orders: Contains order information.

We want to join these collections based on the userId field.

const { MongoClient } = require('mongodb');

// Connection URL and Database Name
const url = 'mongodb://127.0.0.1:27017';
const dbName = 'mydatabase';

async function joinCollections() {
  const client = new MongoClient(url);

  try {
    await client.connect();
    const db = client.db(dbName);
    const usersCollection = db.collection('users');
    const ordersCollection = db.collection('orders');

    // Perform a join using the $lookup operator
    const result = await usersCollection.aggregate([
      {
        $lookup: {
          from: 'orders',           // The collection to join
          localField: '_id',        // Field from the users collection
          foreignField: 'userId',   // Field from the orders collection
          as: 'userOrders'          // Name of the array to store the joined data
        }
      }
    ]).toArray();

    console.log(result);
  } finally {
    await client.close();
  }
}

joinCollections().catch(console.error);

Output:

[
  {
    "_id": "user1",
    "name": "Alice",
    "userOrders": [
      { "orderId": "order1", "amount": 100, "userId": "user1" },
      { "orderId": "order2", "amount": 150, "userId": "user1" }
    ]
  },
  {
    "_id": "user2",
    "name": "Bob",
    "userOrders": [
      { "orderId": "order3", "amount": 200, "userId": "user2" }
    ]
  }
]

In this example, we perform a join on the users collection with the orders collection. The result is an array userOrders that contains the orders associated with each user.

Step 3 Filtering with $lookup

You can also filter the results of the join by adding a $match stage after the $lookup.

Example Code

async function joinAndFilter() {
  const client = new MongoClient(url);

  try {
    await client.connect();
    const db = client.db(dbName);
    const usersCollection = db.collection('users');
    const ordersCollection = db.collection('orders');

    // Perform join and filter orders where the amount is greater than 100
    const result = await usersCollection.aggregate([
      {
        $lookup: {
          from: 'orders',
          localField: '_id',
          foreignField: 'userId',
          as: 'userOrders'
        }
      },
      {
        $unwind: '$userOrders'  // Flatten the array
      },
      {
        $match: { 'userOrders.amount': { $gt: 100 } }  // Filter orders with amount > 100
      }
    ]).toArray();

    console.log(result);
  } finally {
    await client.close();
  }
}

joinAndFilter().catch(console.error);

Output:

[
  {
    "_id": "user1",
    "name": "Alice",
    "userOrders": { "orderId": "order2", "amount": 150, "userId": "user1" }
  },
  {
    "_id": "user2",
    "name": "Bob",
    "userOrders": { "orderId": "order3", "amount": 200, "userId": "user2" }
  }
]

Step 4 Using $lookup with Multiple Joins

You can also use $lookup multiple times to join more than two collections.

Example Code

async function multipleJoins() {
  const client = new MongoClient(url);

  try {
    await client.connect();
    const db = client.db(dbName);
    const usersCollection = db.collection('users');
    const ordersCollection = db.collection('orders');
    const productsCollection = db.collection('products');

    const result = await usersCollection.aggregate([
      {
        $lookup: {
          from: 'orders',
          localField: '_id',
          foreignField: 'userId',
          as: 'userOrders'
        }
      },
      {
        $unwind: '$userOrders'
      },
      {
        $lookup: {
          from: 'products',
          localField: 'userOrders.productId',
          foreignField: '_id',
          as: 'orderProducts'
        }
      }
    ]).toArray();

    console.log(result);
  } finally {
    await client.close();
  }
}

multipleJoins().catch(console.error);

 

Summary

MongoDB does not have a direct JOIN operation, but the $lookup stage in the aggregation framework can be used to join documents from multiple collections. You can also filter and manipulate the results of the join by combining $lookup with other aggregation operators such as $match and $unwind. This approach provides powerful ways to work with related data across collections in MongoDB.