How to Model a “likes” voting system with MongoDB

No matter how you structure your overall document there are basically two things you need. That is basically a property for a “count” and a “list” of those who have already posted their “like” in order to ensure there are no duplicates submitted. Here’s a basic structure:

{ 
    "_id": ObjectId("54bb201aa3a0f26f885be2a3")
    "photo": "imagename.png",
    "likeCount": 0
    "likes": []
}

Whatever the case, there is a unique “_id” for your “photo post” and whatever information you want, but then the other fields as mentioned. The “likes” property here is an array, and that is going to hold the unique “_id” values from the “user” objects in your system. So every “user” has their own unique identifier somewhere, either in local storage or OpenId or something, but a unique identifier. I’ll stick with ObjectId for the example.

When someone submits a “like” to a post, you want to issue the following update statement:

db.photos.update(
    { 
        "_id": ObjectId("54bb201aa3a0f26f885be2a3"), 
        "likes": { "$ne": ObjectId("54bb2244a3a0f26f885be2a4") }
    },
    {
        "$inc": { "likeCount": 1 },
        "$push": { "likes": ObjectId("54bb2244a3a0f26f885be2a4") }
    }
)

Now the $inc operation there will increase the value of “likeCount” by the number specified, so increase by 1. The $push operation adds the unique identifier for the user to the array in the document for future reference.

The main important thing here is to keep a record of those users who voted and what is happening in the “query” part of the statement. Apart from selecting the document to update by it’s own unique “_id”, the other important thing is to check that “likes” array to make sure the current voting user is not in there already.

The same is true for the reverse case or “removing” the “like”:

db.photos.update(
    { 
        "_id": ObjectId("54bb201aa3a0f26f885be2a3"), 
        "likes": ObjectId("54bb2244a3a0f26f885be2a4")
    },
    {
        "$inc": { "likeCount": -1 },
        "$pull": { "likes": ObjectId("54bb2244a3a0f26f885be2a4") }
    }
)

The main important thing here is the query conditions being used to make sure that no document is touched if all conditions are not met. So the count does not increase if the user had already voted or decrease if their vote was not actually present anymore at the time of the update.

Of course it is not practical to read an array with a couple of hundred entries in a document back in any other part of your application. But MongoDB has a very standard way to handle that as well:

db.photos.find(
    { 
        "_id": ObjectId("54bb201aa3a0f26f885be2a3"), 
    },
    { 
       "photo": 1
       "likeCount": 1,
       "likes": { 
          "$elemMatch": { "$eq": ObjectId("54bb2244a3a0f26f885be2a4") }
       }
    }
)

This usage of $elemMatch in projection will only return the current user if they are present or just a blank array where they are not. This allows the rest of your application logic to be aware if the current user has already placed a vote or not.

That is the basic technique and may work for you as is, but you should be aware that embedded arrays should not be infinitely extended, and there is also a hard 16MB limit on BSON documents. So the concept is sound, but just cannot be used on it’s own if you are expecting 1000’s of “like votes” on your content. There is a concept known as “bucketing” which is discussed in some detail in this example for Hybrid Schema design that allows one solution to storing a high volume of “likes”. You can look at that to use along with the basic concepts here as a way to do this at volume.