El operador de comparación NOT IN en MongoDB

1. el operador de comparación $nin (NOT IN) en MongoDB
2. Utilice el operador $nin con el método find() para consultar un campo en MongoDB
3. Utilice el operador $nin con el método find() para consultar un documento incrustado en MongoDB
4. Utilice el operador $nin con el método find() para consultar un array en MongoDB
5. Utilice el operador $nin con el método find() para consultar un array de documentos en MongoDB
6. Utilice el operador de comparación $nin con el método update() para actualizar un valor de campo en MongoDB
7. Utilice el operador $nin con expresiones regulares en MongoDB

Los operadores de comparación son muy útiles cuando se trabaja con grandes conjuntos de datos. Es útil obtener información de los datos.

Este tutorial educa sobre el uso del operador de comparación $nin (NOT IN) en MongoDB.

También muestra cómo usar los métodos $nin con find() y update() en MongoDB. Además, también aprenderemos el uso de expresiones regulares con el operador $nin.

el operador de comparación $nin (NOT IN) en MongoDB

El $nin es uno de los operadores de comparación en MongoDB. Este operador selecciona aquellos documentos donde el valor del campo no pertenece al array especificada, o el campo no existe.

En caso de que el campo contenga un array, un array de documentos o un array de documentos incrustados, solo obtendremos aquellos documentos donde el campo contengal array sin ningún elemento igual al valor del array dado (también (veremos este escenario también más adelante en este tutorial).

Antes de profundizar en más detalles, creemos la colección de muestra con algunos documentos.

Código de ejemplo:

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()

Producción :

{
        "_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"
                        }
                }
        ]
}

La única razón para tener documentos un poco complicados es aprender el uso del operador de comparación $nin con diferentes campos. Por ejemplo, un solo campo, un campo con el documento incrustado, un campo que contiene un array y un array de documentos incrustados.

Utilice el operador $nin con el método find() para consultar un campo en MongoDB

Código de ejemplo:

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

Producción :

{
        "_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"
                        }
                }
        ]
}

En este ejemplo, usamos el operador $nin con el método find() para buscar documentos completos donde joining_year no es ni 2011 ni 2014.

Podemos usar el comando de la siguiente manera si queremos tener solo ciertos campos en lugar de todo el documento. Escriba 1 para imprimir el campo y su valor en la pantalla de la computadora, mientras que 0 significa que no queremos este campo en el conjunto de resultados.

Código de ejemplo:

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

Producción :

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

Utilice el operador $nin con el método find() para consultar un documento incrustado en MongoDB

Código de ejemplo:

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

Producción :

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

Los documentos de muestra tienen un campo llamado name para este tutorial, que además contiene el documento incrustado con dos campos (first y last). Para usar el operador de comparación $nin con el campo name, usamos la notación de punto name.first.

Para este fragmento de código, estamos tratando de recuperar el name, la edad y el género para aquellos documentos donde el valor de name.last no es el miembro de la matriz especificada para $nin operador.

Obtenemos los campos especificados de aquellos documentos donde el name.last no es ni Raza ni Ali. También podemos usar la condición AND con el operador $nin.

Código de ejemplo:

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

Esta vez, no obtendremos ningún resultado porque tenemos dos documentos donde el primer documento tiene Mehvish como el valor de name.first mientras que el segundo documento contiene Raza como el valor del campo name.last. . Entonces, ambos documentos están excluidos del conjunto de resultados y no obtuvimos nada.

Utilice el operador $nin con el método find() para consultar un array en MongoDB

Código de ejemplo:

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

Producción :

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

Entienda esta salida cuidadosamente. En esta salida, el campo curso contiene un array sin ningún elemento igual al valor de la matriz dada para el operador $nin.

Todo el documento donde cualquier campo que contenga un array con elementos iguales a JavaScript, Networking, o Psychology será excluido del conjunto de resultados.

Utilice el operador $nin con el método find() para consultar un array de documentos en MongoDB

Observe cuidadosamente el campo de contact que usamos al completar la colección de students al comienzo de este tutorial. Contiene un array de documentos donde cada documento tiene un documento incrustado (anidado).

¿Cómo consultar eso usando el operador $nin? Vea el ejemplo dado a continuación.

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

Producción :

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

Utilice el operador de comparación $nin con el método update() para actualizar un valor de campo en MongoDB

Código de ejemplo:

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

En este fragmento de código, recuperamos los documentos en los que joining_year no es ni 2014 ni 2011 y luego establecemos el valor de joining_year en 2000. A continuación, utilice el siguiente comando para ver el documento actualizado.

db.students.find().pretty()

Utilice el operador $nin con expresiones regulares en MongoDB

Código de ejemplo:

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

Producción :

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

Para este ejemplo, creamos un array que puede contener diferentes expresiones regulares. Por ahora, solo tenemos una expresión regular.

¿Por qué tenemos que hacer un array de expresiones regulares? Es porque el $nin toma un array para comparar.