Usando operadores para realizar Updates en arreglos

Clase 16 de 26 • Curso Básico de MongoDB

Contenido del curso

Introducción

Operaciones CRUD

Esquemas y relaciones

Profundización de queries dentro de MongoDB

Python con MongoDB (opcional)

Recomendaciones para poner en producción tu cluster de Atlas

Conclusiones

26
Resumen y Conclusiones
00:48 min

Tomar examen

En este enlace se encuentran la referencia a todos los operadores que se encuentran en MongoDb, antes de emplear lógica adicional para realizar una operación vale la pena echar una ojeada a la lista de operadores que en algunos casos pueden facilitar mucho las cosas.

Para realizar las relaciones entre carreras y cursos empleamos los operadores $addToSet y $pull estos operadores sirven para agregar $addToSet o retirar $pull documentos de un arreglo dependiendo del filtro que aplicamos.

Así cuando ejecutamos db.carreras.update_one({'_id': ObjectId(json['id_carrera'])}, {'$addToSet': {'cursos': curso}}) $addToSet lo que hace es agregar el objeto curso al arreglo cursos, si el arreglo cursos no existe lo crea.

Para retirar un curso de una carrera usamos $pull de la siguiente manera db.carreras.update_one({'_id': ObjectId(json['id_carrera'])}, {'$pull': {'cursos': {'_id': ObjectId(json['id_curso'])}}}) aquí $pull recibe un filtro y todos los elementos del arreglo cursos que cumplan con ese filtro serán borrados.

skip() y limit()

Si tenemos una consulta que retorna 100 documentos pero solamente necesitamos los documentos del número 20 al 30, la manera de hacerlo es usando skip() y limit().

Si tenemos 100 carreras y solamente queremos las primeras 10 podemos ejecutar db.carreras.find({}).limit(10) esta nos traerá las primeras 10 carreras.

Ahora si queremos las carreras ubicadas en los puestos 40 y 50 lo que debemos hacer es db.carreras.find({}).skip(40).limit(10)

Como vemos skip() y limit() son muy útiles para realizar paginaciones, cuando tenemos consultas que retornan muchos documentos y que en algunos casos la totalidad de los documentos no es utilizada es buena práctica limitar el número de documentos que hacemos viajar entre nuestro cluster de base de datos y el código de nuestra aplicación. Esto puede ayudar a mejorar la velocidad con que las consultas son procesadas por la aplicación.

Ejercicios de práctica usando operadores

// Arreglo de ejemplo
use test
db.inventory.insertMany(

[{ _id: 1, item: { name: "ab", code: "123" }, qty: 15, tags: [ "A", "B", "C" ] },
{ _id: 2, item: { name: "cd", code: "123" }, qty: 20, tags: [ "B" ] },
{ _id: 3, item: { name: "ij", code: "456" }, qty: 25, tags: [ "A", "B" ] },
{ _id: 4, item: { name: "xy", code: "456" }, qty: 30, tags: [ "B", "A" ] },
{ _id: 5, item: { name: "mn", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }]

)

// $or
db.inventory.find({$or: [{qty: {$gt: 25}}, {qty: {$lte: 15}}]})

// $gte
db.inventory.find({qty: {$gte: 25}})

// $size
db.inventory.find({tags: {$size: 2}})

// Insertemos estos documentos de ejemplo en la colección survey
db.survey.insertMany([
{ _id: 1, results: [ { product: "abc", score: 10 }, { product: "xyz", score: 5 } ] }
{ _id: 2, results: [ { product: "abc", score: 8 }, { product: "xyz", score: 7 } ] }
{ _id: 3, results: [ { product: "abc", score: 7 }, { product: "xyz", score: 8 } ] }
])

// $elemMatch
db.survey.find(
   { results: { $elemMatch: { product: "xyz", score: { $gte: 8 } } } }
)

db.survey.find(
   { results: { $elemMatch: { product: "xyz" } } }```

Comentarios

Jose Francisco Romero Meza

student•

el array para insertar el la colección survey tiene un pequeño error falta separar los elementos:

b.survey.insertMany([ 
{ _id: 1, results: [ { product: "abc", score: 10 }, { product: "xyz", score: 5 } ] },
 { _id: 2, results: [ { product: "abc", score: 8 }, { product: "xyz", score: 7 } ] },
 { _id: 3, results: [ { product: "abc", score: 7 }, { product: "xyz", score: 8 } ]}
])

Luis Abdel Rangel Castro

student•

db.survey.insertMany([ 
{ _id:1, results: [ { product:"abc", score:10 }, { product:"xyz", score:5 } ] },
 { _id:2, results: [ { product:"abc", score:8 }, { product:"xyz", score:7 } ] },
 { _id:3, results: [ { product:"abc", score:7 }, { product:"xyz", score:8 } ]}
])```

Usuario anónimo

user•

db.survey.insertMany([ 
{ _id:1, results: [ { product:"abc", score:10 }, { product:"xyz", score:5 } ] },
 { _id:2, results: [ { product:"abc", score:8 }, { product:"xyz", score:7 } ] },
 { _id:3, results: [ { product:"abc", score:7 }, { product:"xyz", score:8 } ]}
])``````

Jovan Fernández

student•

Para mí que vengo del mundo SQL es un poco complejo trabajar con las bases NoSQL; tengo muy metidas las sentencias y la forma de trabajo y hay que cambiar la forma de hacer las cosas.

Sergio de Jesús Huesca Nieva

student•

Me pasa algo parecido, solo queda recordar que estas viendo un JSON ( BSON para ser purista), y cambiar tu paradigma para verlo de otra manera.

José Alberto Ortiz Vargas

student•

Comparto el mismo sentimiento compañeros, al trabajar bastante tiempo con SQL, cuesta trabajo hacer ese cambio de mentalidad y aprender nuevas formas de extraer datos. Pero vamos a darle.

Carlos Martinez

student•

hola, tengo una duda, NOTA: esta pregunta se lee mejor en los aportes de la clase, si, al parecer hay un pequeño "bug" con las preguntas que no muestra los estilos de markdown , en fin, aqui mi pregunta:

cuando ejecutamos el query db.survey.find( { results: { $elemMatch: { product: "xyz", score: { $gte: 8 } } } } )

nos trae la siguiente informacion:

{
    "_id" : 3.0,
    "results" : [ 
        {
            "product" : "abc",
            "score" : 7.0
        }, 
        {
            "product" : "xyz",
            "score" : 8.0
        }
    ]
} ````

genial, sirve pero, como podria hacer una especie de proyeccion para solo traer los elementos de array que cumplan la condicion??

osea, para que no traiga tooodos los elementos del array , solamente aquellos que cumplan con la condicion que se pone primero. para que quede algo asi:

{
    "_id" : 3.0,
    "results" : [  
        {
            "product" : "xyz",
            "score" : 8.0
        }
    ]
}

con que especie de proyeccion podria lograr eso??

yo probé buscando por alli con la proyeccion { "results.product": 1, "results.score": 1} pero da lo mismo

db.survey.find(
   { results: { $elemMatch: { product: "xyz", score: { $gte: 8 } } } },
   { "results.product": 1 , "results.score": 1}
 )

pero da lo mismo.

y lo que yo busco ya que en algun momento lo podria necesitar es

{
    "_id" : 3.0,
    "results" : [  
        {
            "product" : "xyz",
            "score" : 8.0
        }
    ]
}

Albert Ramirez

teacher•

El operador $elemMatch también puede ser usado en la proyección, así la query que estás buscando quedaría:

db.test.find( { results: { $elemMatch: { product: "xyz", score: { $gte: 8 } } } } , { results: { $elemMatch: { product: "xyz", score: { $gte: 8 } } } })

https://docs.mongodb.com/manual/reference/operator/projection/elemMatch/

Carlos Martinez

student•

vaya, eso ni si quiera se me había ocurrido, gracias por responder profesor.

Belen ST

student•

En el insert de survey, si les tira error es porque falta separar los documentos con coma :

db.survey.insertMany([
{ _id: 1, results: [ { product: "abc", score: 10 }, { product: "xyz", score: 5 } ] },
{ _id: 2, results: [ { product: "abc", score: 8 }, { product: "xyz", score: 7 } ] },
{ _id: 3, results: [ { product: "abc", score: 7 }, { product: "xyz", score: 8 } ] }
])

Belen ST

student•

y agrego que falta un parentesis al final en la ultima query quedando así:

db.survey.find(
   { results: { $elemMatch: { product: "xyz" } } })

Juan Guillermo Perez Cardozo

student•

Entendido y funcionando, aun asi cuesta mucho acostumbrarse a hacer update, pull , cuando ya por años uno hace delete from table where condicion=val. pero bueno a tener afinidad con esa nueva forma de trabajar la base de datos

Juan Diego Garin

student•

No lo ví en ningún lado, pero supuse que las siglas de cada uno significan:

$eq: Igual ‘=’. (eq: EQUAL) $gt: Mayor ‘>’. (gt: GREATER THAN) $gte: Mayor o igual ‘>=’. (gte: GREATER THAN or EQUAL) $lt: Menor ‘<’. (lt: LESS THAN) $lte: Menor o igual ‘<=’. (lte: LESS THAN or EQUAL) $ne: Diferente ‘!=’. (ne: NOT EQUAL) $in: Valores dentro de un arreglo. (in: INSIDE) $nin: Valores que no están dentro de un arreglo. (nin: NOT INSIDE)

Nicolas David Pastran Zamora

student•

Es posible retornar datos de forma intercalada. Es decir que retorne los ultimos 10, pero solo los pares o solo los impares. Se preguntaran que uso tiene, resulta que tenemos muchos datos de sensores y se van a graficar a lo largo del tiempo, si tengo una escala de meses no necesito toda esta cantidad de datos solo algunos cada dos dias por ejemplo.

Gonzalo Amador Hernández

student•

Para recuperar las ultimos 10 que fueron creados y que el numero de secuencia sea par podria ser asi:

db.myCollection
	.find({ sequenceNumber: { $mod: [ 2, 0 ] } }) // filtro pares
	.sort({ createdAt: 'desc'  }) // ordeno de ultimo a primero
	.limit(10) // limito a 10

Para recuperar las ultimos 10 que fueron creados y que el numero de secuencia sea inpar podria ser asi:

db.myCollection
	.find({ sequenceNumber: { $mod: [ 2, 1 ] } }) // filtro impares
	.sort({ createdAt: 'desc'  }) // ordeno de ultimo a primero
	.limit(10) // limito a solo 10

El operador que use fue $mod que es el equivalente al operador de modulo % puedes checarlo aqui https://docs.mongodb.com/manual/reference/operator/query/mod/

Luis Fernando Zarazua Aguilar

student•

Les comparto en link para el manual de MongoDB 4.4, para que lo tengan sin conexión y ordenado. Manual MongoDB

Jesús Miguel Moreno Plasencia

student•

Siempre usado SQL y hubo un punto de quiebre en como se realizan las queries, pero como todo es cuestión de seguir las reglas.

David Pinchao

student•

Me gusta la forma de trabajar las queries, hay que prestar mucha atención al detalle

Carlos Enrique Ramírez Flores

student•

Es complicado un poco complicado para los que venimos de sql, pero creo que me puede adaptar

Luis Ruiz Ramos

student•

Excelente

Milton Garcia

student•

Excelente

Alexander Moreno Córdoba

student•

Me quedo una duda respespecto a la lectura, podemos hacer Actualizaciones de arrays y subdocumentos con Dot Notation?

Miguel Ángel Ramón Candia

student•

Notas 📒

✏️ $addToSet

$addToSet Agregr un elemento a un arreglo de un documento.

Ejemplo

Colección
{
    _id: ObjectId("6359ae116d030db950c54ec5"),
    nombres: [ 'Lorena', 'Javier' ],
    numeros: [ 8, 3, 7 ],
    curso: [ 'Java' ]
  }
Agregar número 4 a arreglo números

db.arreglo.updateOne({_id: ObjectId("6359575e6d030db950c54ec3")},{$addToSet:{numeros:4}}) )

💡 Si el dato agregado ya existe en el arreglo, no se agregará. Sólo se puede ingresar un solo dato a la vez.

💡 Para agregar más de un valor se puede ocupar el operador $each

Agregar los valores 4,6,7,8,9 al arreglo número

db.arreglo.updateOne({_id: ObjectId("6359575e6d030db950c54ec3")},{$addToSet:{numeros:{$each:[4,6,7,8,9]}}})

💡 De igual forma si ya existen los valores no los agregará

Agregar una arreglo de números al arreglo número

db.arreglo.updateOne({_id: ObjectId("6359575e6d030db950c54ec3")},{$addToSet:{numeros:[4,6,7,8,9]}})

✏️ $pull

Elimina elementos de un arreglo.

Ejemplo

Colección
{
    _id: ObjectId("6359ae116d030db950c54ec5"),
    nombres: [ 'Lorena', 'Javier' ],
    numeros: [ 8, 3, 7, 1, 4, 5],
    curso: [ 'Java' ]
  }
Eliminar el numero 8 del arreglo números

db.arreglo.updateOne({_id: ObjectId("6359575e6d030db950c54ec3")},{$pull:{numeros:8}})

Eliminar los números 5, 6 y 4 de del arreglo número

db.arreglo.updateOne({_id: ObjectId("6359575e6d030db950c54ec3")},{$pull:{numeros:{$in:[5,7,4]}}})

💡 Se puede eliminar los elementos especificados en todos los documentos de una colección si se usa updateMany en su lugar.

Eliminar el número 4 en el arreglo números de todos los documentos.

db.arreglo.updateMany({}, {$pull:{numeros:4}})

✏️ $limit y $skip

$limit limita el número de documentos a mostrar.

$skip salta al número de documento especificado.

Ejemplo

Mostrar los primeros 10 documentos.

db.micoleccion.find().limit(10)

Mostrar los documentos del 40 al 50

db.micoleccion.find().skip(39).limit(10)

💡 El conteo al igual que en los arreglos comienza en cero

Mostrar los documentos del índice 40 al 50

db.micoleccion.find().skip(40).limit(50)

Luis Santiago Cortés Hernández

student•

En // $elemMatch le hace falta cerrar con un parentesis.

db.survey.find(
   { results: { $elemMatch: { product: "xyz" } } }
)

Alexander Moreno Córdoba

student•

Auí pueden encontrar todos los operadores

https://docs.mongodb.com/manual/reference/operator/

Carlos Nassif Trejo Garcia

student•

El ultimo falta un parentesis, quedaria asi:

db.survey.find(
   { results: { $elemMatch: { product: "xyz" } } })

Fredy Mendoza Vargas

student•

👍👍👍👍

Carlos Enrique Ramírez Flores

student•

Falta adentrarme más a entender mongo! aunque la verdad se que no es complicado!

DAVID EDUARDO BAEZ SANCHEZ

student•

Entendido.

// Arreglo de ejemplo
use test
db.inventory.insertMany(

[{ _id: 1, item: { name: "ab", code: "123" }, qty: 15, tags: [ "A", "B", "C" ] },
{ _id: 2, item: { name: "cd", code: "123" }, qty: 20, tags: [ "B" ] },
{ _id: 3, item: { name: "ij", code: "456" }, qty: 25, tags: [ "A", "B" ] },
{ _id: 4, item: { name: "xy", code: "456" }, qty: 30, tags: [ "B", "A" ] },
{ _id: 5, item: { name: "mn", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }]

)

// $or
db.inventory.find({$or: [{qty: {$gt: 25}}, {qty: {$lte: 15}}]})

// $gte
db.inventory.find({qty: {$gte: 25}})

// $size
db.inventory.find({tags: {$size: 2}})

// Insertemos estos documentos de ejemplo en la colección survey
db.survey.insertMany([
{ _id: 1, results: [ { product: "abc", score: 10 }, { product: "xyz", score: 5 } ] }
{ _id: 2, results: [ { product: "abc", score: 8 }, { product: "xyz", score: 7 } ] }
{ _id: 3, results: [ { product: "abc", score: 7 }, { product: "xyz", score: 8 } ] }
])

// $elemMatch
db.survey.find(
   { results: { $elemMatch: { product: "xyz", score: { $gte: 8 } } } }
)

db.survey.find(
   { results: { $elemMatch: { product: "xyz" } } }```

b.survey.insertMany([ 
{ _id: 1, results: [ { product: "abc", score: 10 }, { product: "xyz", score: 5 } ] },
 { _id: 2, results: [ { product: "abc", score: 8 }, { product: "xyz", score: 7 } ] },
 { _id: 3, results: [ { product: "abc", score: 7 }, { product: "xyz", score: 8 } ]}
])

db.survey.insertMany([ 
{ _id:1, results: [ { product:"abc", score:10 }, { product:"xyz", score:5 } ] },
 { _id:2, results: [ { product:"abc", score:8 }, { product:"xyz", score:7 } ] },
 { _id:3, results: [ { product:"abc", score:7 }, { product:"xyz", score:8 } ]}
])```

db.survey.insertMany([ 
{ _id:1, results: [ { product:"abc", score:10 }, { product:"xyz", score:5 } ] },
 { _id:2, results: [ { product:"abc", score:8 }, { product:"xyz", score:7 } ] },
 { _id:3, results: [ { product:"abc", score:7 }, { product:"xyz", score:8 } ]}
])``````

{
    "_id" : 3.0,
    "results" : [ 
        {
            "product" : "abc",
            "score" : 7.0
        }, 
        {
            "product" : "xyz",
            "score" : 8.0
        }
    ]
} ```` 

db.survey.insertMany([
{ _id: 1, results: [ { product: "abc", score: 10 }, { product: "xyz", score: 5 } ] },
{ _id: 2, results: [ { product: "abc", score: 8 }, { product: "xyz", score: 7 } ] },
{ _id: 3, results: [ { product: "abc", score: 7 }, { product: "xyz", score: 8 } ] }
])

Usando operadores para realizar Updates en arreglos

Introducción

Qué aprenderás sobre MongoDB

Bases de datos NoSQL

Definición de MongoDB y su ecosistema (herramientas de uso)

MongoDB Atlas

Instalación MongoDB en Windows

Instalación MongoDB Mac/Linux

Mongo Shell, configuración de clientes

MongoDB + Drivers

Operaciones CRUD

Bases de datos, Colecciones y Documentos en MongoDB

Operaciones CRUD desde la consola de MongoDB

Operaciones CRUD desde Compass

Esquemas y relaciones

Tipos de datos

¿Qué son los esquemas y las relaciones?

Relaciones entre documentos

Profundización de queries dentro de MongoDB

Operadores para realizar queries y proyecciones