Mongoose join operation - node.js

Question

I have 3 schema's like below:
User
var UserSchema = new Schema({
name: String
});
Actor
var ActorSchema = new Schema({
name: String
});
Rating
var RatingSchema = new Schema({
actor: {
type: mongoose.Schema.Types.ObjectId,
ref: 'Actor'
},
user: {
type: mongoose.Schema.Types.ObjectId,
ref: 'Actor'
},
userRating: Number
});
I want to send all actors info to the front end like [actor1, actor2 ...].
Each actor contain actor details and 'userRating' which is given by the user who is currently logged in.
A user can give ratings to multiple actors and an actor can receive ratings from multiple users. These will be stored in Ratings table.
I wrote something like this
Actor
.find({}) // get all actors and populate userRating into each actor
.populate({
path: 'userRating',
model: 'Rating',
match: { actor: {$eq: req.actor}, user: {$eq: req.user}},
select: 'userRating'
})
.exec(function(error, actors){
if(error)
res.status(501).json({error: error});
else
res.json(actors);
});
I got only actors in the result. actor object doesn't contain 'userRating'. can someone correct my query

Answer 1

It depends on what you are actually sending as input for the query parameters here. Also the main thing that you need to understand is that this is not a "JOIN", but in fact separate queries being issued by the mongoose software layer, so there are distinct differences in handling.
In the basic case where the "values" being supplied as parameters are actually the ObjectId values of the references, then you actually just want these directly in the main "query" rather than arguments to the .populate() action ( which is actually where the "additional queries" are happening ).
Furthermore your "relations/references" are in the Rating model, so that is where your query is issued instead:
Rating.find({
"actor": req.actor,
"user": req.user
}).populate("actor user").exec(function(err,ratings) {
// Matched ratings by actor and user supplied
})
If your parameters are instead the "name" data of each object, then since that information is not present in the Rating model until populated the only way mongoose can do this is to retrieve "all" of the Rating objects, then do the "population" with the "match" criteria, and finally filter out any results where the population was null due to un-matched items:
Rating.find().populate([
{ "path": "actor", "match": { "name": req.actor } },
{ "path": "user", "match": { "name": req.user } }
]).exec(function(err,ratings) {
// Now filter out the null results
ratings = ratings.filter(function(rating) {
return ( rating.actor != null && rating.user != null )
});
// Then work with filtered data
})
Of course that is highly inefficient since this is a "client" side operation and you are pulling in all of the Rating content "first". So what you really mean to do in this case is to actually do the "three" query operations yourself, and by getting the ObjectId values from both User and Actor models in order to apply the match to the Rating model instead:
async.parallel(
{
"user": function(callback) {
User.findOne({ "name": req.user },callback)
},
"actor": function(callback) {
Actor.findOne({ "name": req.actor },callback)
}
},
function(err,data) {
// Use returned _id values in query
Rating.find({
"actor": data.actor._id,
"user": data.user._id
}).populate("actor user").exec(err,ratings) {
// populated Rating results
});
}
)
Then the queries resolve the "only" ObjectId values you actually require and the final query on Rating only retrieves those results that actually match the conditions, rather than everything and doing a "post filter" operation.
As a final approach, if you have MongoDB 3.2 available, then you could alternately use the $lookup operation instead to perform the "JOINS" on the "server" instead:
Rating.aggregate(
[
{ "$lookup": {
"from": "users",
"localField": "user",
"foreignField": "_id",
"as": "user"
}},
{ "$unwind": "$user" },
{ "$match": { "user.name": req.user } },
{ "$lookup": {
"from": "actors",
"localField": "actor",
"foreignField": "_id",
"as": "actor"
}},
{ "$unwind": "actor" },
{ "$match": { "actor.name": req.actor } }
],
function(err,ratings) {
// populated on the server in one request
}
)
From the "client" point of view, this is just "one" request and response as opposed to what .populate() does. But it really is not more than a "server" side rendition of the "client" logic presented before.
So if looking up by values of "name", you should instead do the "three" query approach for optimal performance, since the aggregation version is still really working with a lot more data than it needs to.
Of course the "best" perspective is to simply use the ObjectId values to begin with.
Of course the main thing here is that information like "userRating" belongs to the Rating model, and that is therefore where you provide the "query" in all cases in order to retrieve that data. These are not "JOIN" operations like in SQL, so the "server" is not looking at the combined results then selecting the fields.
As a bit of self education turn on "debugging" to see how mongoose is actually issuing statements to the server. Then you will see how .populate() is actually applied:
mongoose.set("debug",true)