Retrieve documents in MongoDB that rely on information from other documents

Question

Retrieve documents in MongoDB that rely on information from other documents

Consider the following mongoose model:

const UserSchema = Schema({
  //_id: ObjectId,
  //more fields,
  blockedIds: [{
    type: ObjectId,
    ref: 'User'
  }]
})

What would be the most optimal approach to retrieve all users who do not have their _id listed in the blockedIds array of a specific user?

One way to do this could be by executing two separate queries:

User.findById(id).then(user => {
  return User.find({_id: {$nin: user.blockedIds}})
})

Is it feasible to utilize the aggregation framework and $facets in order to achieve this requirement with just one query?

javascript mongodb mongoose nosql

Answer 1

Answer №1

Consider implementing a non-correlated subquery feature from version 3.6 to address your specific use case.

You can try the following code snippet:

User.aggregate(
 [{$lookup:{
   from: "users",
   pipeline:[
    {$match: {_id:mongoose.Types.ObjectId(id)}},
    {$project: {_id:0,blockedIds:1}}
   ],
   as: "noncr"
 }},
 {$match:{
   $expr:{
     $not:[
      {$in:[
        $_id,
        {$arrayElemAt:["$noncr.blockedIds",0]}
      ]}
    ]
  }
}},
{$project:{noncr:0}}]
)

Utilize the $lookup operator to retrieve the "blockedIds" for the specified input id and follow it up with the $match operation to filter out documents where "_id" is not within the list of blockedIds.

The $expr feature enables the utilization of aggregation comparison operators in the $match stage.

Use $arrayElemAt function to extract the first element from the $lookup array.

Employ $in operator to compare the _id against the blockedIds field.

Finally, consider utilizing the $project functionality with exclusion to eliminate the "noncr" field from the resulting output.

Keep in mind to use the collection name instead of the model or schema name when testing the query in the "from" attribute of the lookup stage.

Answer 2

Consider implementing a non-correlated subquery feature from version 3.6 to address your specific use case.

You can try the following code snippet:

User.aggregate(
 [{$lookup:{
   from: "users",
   pipeline:[
    {$match: {_id:mongoose.Types.ObjectId(id)}},
    {$project: {_id:0,blockedIds:1}}
   ],
   as: "noncr"
 }},
 {$match:{
   $expr:{
     $not:[
      {$in:[
        $_id,
        {$arrayElemAt:["$noncr.blockedIds",0]}
      ]}
    ]
  }
}},
{$project:{noncr:0}}]
)

Utilize the $lookup operator to retrieve the "blockedIds" for the specified input id and follow it up with the $match operation to filter out documents where "_id" is not within the list of blockedIds.

The $expr feature enables the utilization of aggregation comparison operators in the $match stage.

Use $arrayElemAt function to extract the first element from the $lookup array.

Employ $in operator to compare the _id against the blockedIds field.

Finally, consider utilizing the $project functionality with exclusion to eliminate the "noncr" field from the resulting output.

Keep in mind to use the collection name instead of the model or schema name when testing the query in the "from" attribute of the lookup stage.

Answer 3

Answer №2

While the aggregation framework mentioned in another response is certainly valuable, it's important to consider all perspectives when designing Redis database structures. By approaching data access from multiple angles and considering ways to invert results, we can come up with alternative solutions.

One such approach involves using a blockedBy array instead of a blockedIds array on the user object:

const UserSchema = Schema({
  blockedBy: [{
    type: ObjectId,
    ref: 'User',
    index: true,
  }]
});

This simple adjustment allows us to rethink the problem and make querying straightforward:

User.find({ userID: { $nin: blockedBy: } });

In certain scenarios, this could prove to be a feasible solution worth considering.

Answer 4

While the aggregation framework mentioned in another response is certainly valuable, it's important to consider all perspectives when designing Redis database structures. By approaching data access from multiple angles and considering ways to invert results, we can come up with alternative solutions.

One such approach involves using a blockedBy array instead of a blockedIds array on the user object:

const UserSchema = Schema({
  blockedBy: [{
    type: ObjectId,
    ref: 'User',
    index: true,
  }]
});

This simple adjustment allows us to rethink the problem and make querying straightforward:

User.find({ userID: { $nin: blockedBy: } });

In certain scenarios, this could prove to be a feasible solution worth considering.

Retrieve documents in MongoDB that rely on information from other documents

Answer №1

Answer №2

Similar questions

Is there a way to change an ISO 8601 date into the format '/Date(1525687010053)/' using JavaScript?

Utilizing recursion and the reduce method for calculating the total of an array elements

Vue2: when passing a function as a prop, a warning will be triggered indicating that the prop has

Ways to replace "localhost" with a domain name in a mongodb connection string?

Using a hashtag in the URL to open an HTML <div> element

Having trouble with transmitting a JSON array to a Node.js server using AJAX

Why won't both routes for Sequelize model querying work simultaneously?

Halting the HTML-Embedded Video

Guide on populating a table with user input using jQuery and ajax

Leveraging JavaScript variables conditionally within a JSON object

Error when utilizing the useLocation Hook: "The useLocation() function is only allowed within the scope of a <Router> component" in a React App

Alert: Zone.js has identified that the ZoneAwarePromise '(window|global).Promise' has been replaced with polyfills. Kindly address this issue

Working with JSON data in AngularJS: A guide to loading data onto a scope variable

Custom control unable to display MP3 file

Tips for navigating to the top of the browser window from the middle or bottom using JavaScript in Protractor

The final piece left in stitching together an array

What distinguishes between employing a div versus a canvas element for a three.js display?

What is the best way to transfer a variable from jQuery to a PHP script?

How to handle JavaScript exceptions when encountering a null JSON value?

Querying MongoDB to find a single alphanumeric zip code located between the specified fields