JIYIK CN >

Comparison operators are very useful when working with large data sets. They are helpful in gaining insights from the data.

$ninThis article explains how to use the ( ) comparison operator in MongoDB NOT IN.

It also shows how to use $ninwith find()and update()methods in MongoDB. In addition, we will also learn about $ninregular expressions using the operator.

$nin( NOT IN) comparison operator in MongoDB

$ninIs one of the comparison operators in MongoDB. This operator selects documents whose field value does not belong to the specified array, or the field does not exist.

If the field contains an array, array of documents, or array of embedded documents, then we will fetch only those documents where the field contains that array and no item is equal to the value in the given array (we will also see this case later in this tutorial).

Before we dive into more details, let's create a sample collection with some documents.

Sample code:

db.createCollection('students');
db.students.insertMany([
    {
        "name": {first: "Mehvish", last: "Ashiq"},
        "age": 30,
        "gender": "Female",
        "discipline": "BSCS",
        "joining_year": 2014,
        "department": "Computer Science",
        "courses":[ "Python","Java", "Machine Learning", "Data Science"],
        "contact":[
            { phone: { type: "cell", number: "923042516485" }},
            { mail: { type: "official", email: "mehvishofficial@gmail.com"}}
        ]
    },
    {
        "name": {first: "Aftab", last: "Raza"},
        "age": 25,
        "gender": "Male",
        "discipline": "BSIT",
        "joining_year": 2012,
        "department": "Information Technology",
        "courses":[ "Python","JavaScript", "Information Security"],
        "contact":[
            { phone: { type: "landline", number: "111-444-5555" }},
            { mail: { type: "personal", email: "aftab@hotmail.com"}}
        ]
    }
])

db.students.find().pretty()

Output:

{
        "_id" : ObjectId("6298ef54271c5124b739d7d3"),
        "name" : {
                "first" : "Mehvish",
                "last" : "Ashiq"
        },
        "age" : 30,
        "gender" : "Female",
        "discipline" : "BSCS",
        "joining_year" : 2014,
        "department" : "Computer Science",
        "courses" : [
                "Python",
                "Java",
                "Machine Learning",
                "Data Science"
        ],
        "contact" : [
                {
                        "phone" : {
                                "type" : "cell",
                                "number" : "923042516485"
                        }
                },
                {
                        "mail" : {
                                "type" : "official",
                                "email" : "mehvishofficial@gmail.com"
                        }
                }
        ]
}
{
        "_id" : ObjectId("6298ef54271c5124b739d7d4"),
        "name" : {
                "first" : "Aftab",
                "last" : "Raza"
        },
        "age" : 25,
        "gender" : "Male",
        "discipline" : "BSIT",
        "joining_year" : 2012,
        "department" : "Information Technology",
        "courses" : [
                "Python",
                "JavaScript",
                "Information Security"
        ],
        "contact" : [
                {
                        "phone" : {
                                "type" : "landline",
                                "number" : "111-444-5555"
                        }
                },
                {
                        "mail" : {
                                "type" : "personal",
                                "email" : "aftab@hotmail.com"
                        }
                }
        ]
}

The only reason the document is a bit complex is to learn to use $nincomparison operators with different fields. For example, a single field, a field containing an embedded document, a field containing an array, and an array of embedded documents.

$ninUsing the operator and find()method to query fields in MongoDB

Sample code:

db.students.find({ "joining_year": { $nin: [2011,2014] }}).pretty();

Output:

{
        "_id" : ObjectId("6298ef54271c5124b739d7d4"),
        "name" : {
                "first" : "Aftab",
                "last" : "Raza"
        },
        "age" : 25,
        "gender" : "Male",
        "discipline" : "BSIT",
        "joining_year" : 2012,
        "department" : "Information Technology",
        "courses" : [
                "Python",
                "JavaScript",
                "Information Security"
        ],
        "contact" : [
                {
                        "phone" : {
                                "type" : "landline",
                                "number" : "111-444-5555"
                        }
                },
                {
                        "mail" : {
                                "type" : "personal",
                                "email" : "aftab@hotmail.com"
                        }
                }
        ]
}

In this example, we use $ninthe operator and find()the method to search for the entire document joining_yearwhere is neither 2011nor 2014.

If we want to have only certain fields instead of the entire document, we can use the command as follows. Write 1to print the field and its value on the computer screen, while 0indicates that we do not want the field to appear in the result set.

Sample code:

db.students.find(
    { "joining_year": { $nin: [2011,2014] }},
    {"name": 1, "discipline": 1, "department": 1, "_id":0}
).pretty();

Output:

{
        "name" : {
                "first" : "Aftab",
                "last" : "Raza"
        },
        "discipline" : "BSIT",
        "department" : "Information Technology"
}

Querying Embedded Documents in MongoDB Using $ninthe operator and methodfind()

Sample code:

db.students.find(
    { "name.last": { $nin: ["Raza", "Ali"] }},
    { "name": 1, "gender": 1, "age": 1, "_id":0}
).pretty();

Output:

{
        "name" : {
                "first" : "Mehvish",
                "last" : "Ashiq"
        },
        "age" : 30,
        "gender" : "Female"
}

For this article, the sample document has a namefield called , which also contains an embedded document with two fields ( firstand ). To use the comparison operator with the field, we use dot notation .last$ninnamename.first

For this code snippet, we attempt to retrieve the , , and operators for documents whose name.lastvalue of is not $nina member of the specified array of .nameagegender

We get the specified field from those documents name.lastwhere is neither Razanor . We can also use the condition with the operator.AliAND$nin

Sample code:

db.students.find(
    { "name.last": { $nin: ["Raza", "Ali"]}, "name.first": {$nin: ["Mehvish"]}},
    { "name": 1, "gender": 1, "age": 1, "_id":0}
).pretty();

This time, we will not get any output because we have two documents where the first document has a value Mehvishof as name.firstand the second document contains a value of Razaas name.lastfield. Therefore, both documents are excluded from the result set and we get nothing.

Querying arrays in MongoDB using $ninthe operator and methodfind()

Sample code:

db.students.find(
    { "courses": { $nin: ["JavaScript", "Networking", "Psychology"] }},
    { "courses": 1, "department": 1, "_id":0}
).pretty();

Output:

{
        "department" : "Computer Science",
        "courses" : [
                "Python",
                "Java",
                "Machine Learning",
                "Data Science"
        ]
}

Understand this output carefully. In this output, coursefield contains an array where no element is equal to $ninthe value in the given array of the operator.

The entire document, any fields containing arrays with elements equal to JavaScript, , Networkingor will be excluded from the result set.Psychology

Querying an array of documents in MongoDB using $ninthe operator and methodfind()

studentsTake a close look at the field that we used when populating the collection at the beginning of this tutorial contact. It contains an array of documents, each of which has an embedded (nested) document.

How do I use $ninthe operator to query? See the example given below.

db.students.find(
    { "contact.phone.type": { $nin: ["cell"] }},
    { "contact": 1, "department": 1, "_id":0}
).pretty();

Output:

{
        "department" : "Information Technology",
        "contact" : [
                {
                        "phone" : {
                                "type" : "landline",
                                "number" : "111-444-5555"
                        }
                },
                {
                        "mail" : {
                                "type" : "personal",
                                "email" : "aftab@hotmail.com"
                        }
                }
        ]
}

Use $nincomparison operators and update()methods to update field values ​​in MongoDB

Sample code:

db.students.update(
    { "joining_year": {$nin: [2011,2014]}},
    { $set: {"joining_year": 2000}}
);

In this code snippet, we retrieve documents joining_yearwhere is neither 2014nor and then set the value of to . Next, use the following command to view the updated document.2011joining_year2000

db.students.find().pretty()

$ninUsing the operator with regular expressions in MongoDB

Sample code:

var array_of_regex = [/Data+/];
db.students.find(
    { "courses": {$nin: array_of_regex}},
    {"name":1, "courses":1, "department":1, "_id":0}
).pretty();

Output:

{
        "name" : {
                "first" : "Aftab",
                "last" : "Raza"
        },
        "department" : "Information Technology",
        "courses" : [
                "Python",
                "JavaScript",
                "Information Security"
        ]
}

For this example, we create an array that can contain different regular expressions. Currently, we only have one regular expression.

Why do we have to make an array of regular expressions? This is because $ninwe need an array to compare.