2 OperacionesCRUDMongoDB

We make
it happen
Operaciones CRUD en
MongoDB
eae.es
Para modificar título del PPT, cambiar pie de página
Índice
01. Operaciones de Lectura

02. Operaciones de Escritura
2
2. Operaciones de lectura
eae.es
3
Filtrar o recuperar los documentos de una colección bajo unas
determinadas condiciones.
1. Operaciones
de lectura Seleccionar campos de un documento.
Mongodb no tiene un lenguaje SQL, llama a métodos o funciones

de un driver.
Si ejecutamos db.coleccion.findOne() en el shell la llamada se

traduce en un mensaje que se envía al servidor con una estructura
definida que se define en el MongDB Wire Protocol (MWP)
Driver/consola y el servidor utilizan mensajes del MWP, los

mensajes que se intercambian tienen una estructura fija para cada
tipo de operación.
Métodos find() y findOne()
• Métodos find() devuelve un cursor y findOne() que devuelve un

documento
db.coleccion.find(criterio, proyeccion)
• Donde tanto criterio como proyección son documentos JSON
Proyección: Sintaxis {campo:key}

o {key : 1 o true}: para obtener el valor de ese campo. (_id se incluyepor defecto)
o {key : 0 ó false}: para que no devuelva el valor de ese campo (valor por defecto)
Operaciones de lectura
• Consulta en Mongo DB
db.users.find( {status: “D”},  Criterio Selección

{_id: 0, username: 1} )  Proyección
• Consulta en Base de datos relacional
SELECT username  Proyección

FROM users
WHERE status = 'D'  Criterio Selección
>db.lecturer.find()  Devuelve todos
{ "_id" : ObjectId("53172c1ea85874ad0f8f1c6e"), "a" : 1,

"b" : ISODate("2014-03-05T13:52:30.038Z"), "c" : true, "d" :
"documento 1" }
{ "_id" : ObjectId("53172c1ea85874ad0f8f1c6f"), "a" : 2,

"documento 2" } (muestra resultados de 20 en 20)
>db.lecturer.find({a:61})
{ "_id" : ObjectId("53172c1ea85874ad0f8f1caa"), "a" : 61,
"documento 61" }
> db.lecturer.find({a:61}, {a:1})

{"_id" : ObjectId("53172c1ea85874ad0f8f1caa"), "a" : 61 }
> db.lecturer.find({a:61}, {a:1, _id:0})

{ "a" : 61 }
Operadores de
1. Operaciones de comparación
lectura
Operadores
sobre arrays
Filtrar Operador
Documentos elemMatch
Operadores de
proyección
Otro operadores
Operadores de comparación
• Sintaxis
find({key: {$operador: value}})
• Operadores disponibles
$eq, $gt, $gte, $lt, $lte, $ne, $or, $and, $not, $nor
• Ejemplos
>find({key1: value1, key2: value2})
db.lecturer.find( {$and: [{ a: {$gt : 20}}, {b: {$lt : 30} } ] })
>find({$or: [{expresión1}, {expresión2}]})
db.lecturer.find( {$or: [{a: {$gt : 20}}, {b: {$lt : 30}} ] })
Operadores sobre arrays

• Sintaxis
find({key: {$operador: [value1, value2, …, valuen ]}})
• Operadores disponibles
$all, $size, $in, $nin
• Ejemplos
>db.coleccion.find( {campo : {$in : ["Valor1" , "Valor 2"]} } )
>db.coleccion.find( {campo : {$nin : ["Valor1" , "Valor 2"]} } )
>db.coleccion.find( {campo : {$all : ["Valor1" , "Valor 2"]} } )
>db.coleccion.find( {campo : {$size : 4 } )
Otros operadores
• $exists, $type
db.coleccion.find( {campo : { $exists:true} ) Únicamente mostrará
los documentos cuyo campo exista.
db.coleccion.find( {campo : { $type: BSON Type} ) Sólo mostrará

los documentos cuyo campo sea del tipo indicado.
Se sustituirá por un número asociado a cada tipo
https://docs.mongodb.com/manual/reference/bson-types/
• $mod, $regex, $text, $where

db.coleccion.find( {campo : { $regex : 'ˆA'} )
db.coleccion.find( {campo : { $mod: [ 4, 0 ] } } )
Notacion del punto

• Forma en la que accedemos a un campo de un subdocumento.
• Condiciones sobre claves cuyo valor es un subdocumento
{ "_id" : ObjectId("53172c1ea85874ad0f8f1c6e"),
"campo1" : 1,
"campo2" :{ "c1" : 4,
"c2" : “valor2“,
"c3" : “valor3“,
"c4" : “valor4“}
}
>db.coleccion.find( {“campo2.c1” : { $gt:5} })

Notacion del punto

• Condiciones sobre claves que contiene un array y sus elementos son
subdocumentos
"campo1" : 1,
"campo2" :[ { "c1" : 1, "c2" : “valor2“ },
{ "c1" : 2, "c2" : “valor3“ },
{ "c1" : 3, "c2" : “valor4“ }
]
}
>db.coleccion.find( {“campo2.c2” : “valor2” , “campo2.c1” : { $gt:5}})

Operador $elemMatch
• Permite imponer condiciones sobre los campos que están dentro de un
documento.
"campo1" : 1,
"campo2" :[ { "c1" : 1, "c2" : “valor2“ },
{ "c1" : 2, "c2" : “valor3“ },
{ "c1" : 3, "c2" : “valor4“ }
]
}
>db.coleccion.find( {campo2 : {$elemMatch:{“c1”: 2,c2:”valor2”} } })

Cursores
• Los cursores son generados en el servidor y el shell o la aplicación a
través del driver se encargan de ir consumiendo los datos del cursor.
• Por defecto se consumen de 20 en 20 documentos, se puede modificar

cambiando el valor del parámetro shellBatchSize
DBQuery.shellBatchSize = 10
• Los cursores ocupan recursos en el servidor, tras 10 minutos de

inactividad el cursor se elimina o se cierran si se han recorrido
completamente.
Cursores
• Las operaciones de tipo find (), aggregate (), listIndexes y listCollections
devuelven un máximo de 16 megabytes por lote.
• Al crear un cursor los documentos se envían por lotes.
• El primer lote que se envía esta compuesto por 101 documentos.
• En el shell automáticamente se muestran 20, pulsando «it» vamos

mostrando los documentos hasta que consume todos los del primer lote.
• Cuando se consumen todos los documentos del primer lote se pide nuevo
lote al cursor, pero ya los siguientes lotes serán de 16 MB
Cursores
• Aislamiento, los cursores no están aislados con respecto a las

operaciones de escritura
• Por ejemplo:
• Si se realiza una petición al servidor, nos devuelve el
primer lote, pero si antes de solicitar el segundo lote se
ha eliminado un registro de éste por una operación de
borrado, el documento desaparecerá del segundo lote.
Cursores
• Hay métodos para obtener información del cursor.
• cursor.hasNext()
• cursor.next()
• cursor.count()
• cursor.length()
• cursor.forEach() cursor.toArray()
• Hay que tener cuidado con las funciones que consumen todo el cursor,
ya que se traen todos los documentos que éste contiene y puede generar
problemas de memoria si el número de documentos es muy elevado.
Ordenar, limitar y saltar

• Ordenación: Se utiliza el método sort al cual le indicaremos por que
campo queremos ordenar y si será ascendente ( 1 ) o descendente (-1)
>db.coleccion.find( {campo1 : valor} , { _id : 0 } ).sort(

{campo2 : 1 } )
• Limitar: Se utiliza el método limit con el número de documentos que

queremos mostrar
db.coleccion.find( {campo1 : valor} , { _id : 0 }

).sort( {campo2 : 1 } ).limit(5)
Ordenar, limitar y saltar

• Saltar: Se utiliza el método skip con número de elemento que queremos
no mostrar
db.coleccion.find( {campo1 : valor} , { _id : 0 }
).sort( {campo2 : 1 } ).limit(5).skip(5)
• Da igual en que orden se pongan que siempre devolverá el mismo

resultado.
• Se genera un mensaje al servidor con el MWP donde se envían siempre
con un orden establecido aunque nosotros lo pongamos con un orden
diferente.
• sort({key1: 1, key2: -1}) 1º
• skip(n) 2º
• limit(n) 3º
2. Operaciones de escritura
eae.es
22
• Con mongoDB se van a poder

realizar las siguientes operaciones
de escritura.
a
Inserciones
Al insertar el número de campos no siempre debe coincidir

db.coleccion.insert( { campo1: "valor", campo2: 15 } )
db.coleccion.insert( { campo1: "valor"} )
El _id se genera automáticamente como campo de tipo ObjectId pero tambien lo

podemos indicar
db.coleccion.insert( { _id:0, campo1: "valor"} )
También se pueden insertar varios documentos a la vez
db.coleccion.insert({ campo1: "valor", campo2: 15 } ,

{ _id:0, campo1: "valor"} )
Inserciones
Al insertar el número de campos no siempre debe coincidir
db.coleccion.insert( { campo1: "valor", campo2: 15 } )
db.coleccion.insert( { campo1: "valor"} )
El _id se genera automáticamente como campo de tipo ObjectId pero tambien lo

podemos indicar
db.coleccion.insert( { _id:0, campo1: "valor"} )
También se pueden insertar varios documentos a la vez
db.coleccion.insert({ campo1: "valor", campo2: 15 } ,

{ _id:0, campo1: "valor"} )
Actualizaciones
• Las actualizaciones son atómicas por cada documento
individual
• Por defecto actualiza sólo 1 documento, en caso de querer
actualizar más de uno hay que indicárselo
• Mantiene el orden de los campos
Actualizaciones Sustitutivas
• Sustituye por completo un documento de una colección. No es lo
más normal
db.coleccion.update ( criterio , documento )
>var cliente = db.gimnasio3.findOne();

>cliente.fechaAlta = new Date();
(Modifico el valor de la variable no el registro de la base de datos)
• Indicamos que documento queremos modificar mediante una

condición y un documento JSON que es el que sustituirá al
original
>db.gimansio3.update( {idCliente : 1}, cliente );
Actualización modificativa
• Modifica uno de los valores de un documento.
db.coleccion.update ( criterio , expresion )
• La expresión llevará los campos a modificar con el operador
$set con el campo que queremos modificar y su nuevo valor
• Actualizando un campo
• >db.coleccion.update( {campo1 : 1}, {$set: {
campo2: valor } );
• Actualizando varios campos
• >db.coleccion.update( {campo1 : 1}, {$set: {
campo2: valor , campo3:valor} );
• Para insertar un nuevo campo con poner el nombre del campo
que no existe y su valor es suficiente, al ejecutarse se añadirá ese
campo.
Operadores de escritura
Los operadores de escritura disponibles son
$inc, $mul, $rename, $setOnInsert, $set, $unset,

$min, $max, $currentDate
$, $addToSet, $pop, $pull, $pullAll, $push, $pushAll
$each, $slice, $sort, $position
$bit
$isolated
• Operador $inc o de incremento aumenta el valor de un campo el numero
de veces que le indiques
{$inc: {campo : 1 }}, si el campo no existiera lo crea y le asocia
el valor del incremento
• Operador $unset. Elimina un campo
{$unset: {campo : "" }}
• Operador $rename. Modifica el nombre de un campo
{$rename: {campo : "nuevoNombre" }}
• Operador $mul multiplicador
{$mul: {campo : 1.1 }}
• Operadores $min y $max, modifica un campo SOLO en el caso de que el
valor que le pasamos sea mayor ($max) o menor ($min) de lo que ya
existe para ese campo
{$max: {campo : 10 }} Si el valor real es 11, no lo actualizaría.

{$max: {campo : 20 }} Si el valor real es 11, si lo actualizaría.
• Operador $currentDate, actualiza un campo fecha con la fecha actual.
• Hay tres formas de utilizarlo

{$currentDate : {fechaNacimiento : true} }
{$currentDate : {fechaNacimiento : {$type: "date"} } }

 Fecha, hora
{$currentDate :{fechaNacimiento : {$type: "timestamp"}} }

 Segundos transcurridos desde 1970
Operadores actualización arrays
• Operador $push, añade al final del array el elemento que le pasamos

{$push: {array : "valor" }}
• Operador $addToSet, igual que push pero en este caso si el elemento ya

existe no lo añade
{$addToSet: {array : " valor" }}
• Operador $pop sirve para eliminar el primero o el último

{$pop: {array : -1 }} Elimina el primer elemento del array
{$pop: {array : 1 }}  Elimina el último elemento del array
• Operador $pushAll
{$pushAll: {array : ["valor1", "valor2"] }}  Hasta versión 2.4 a
partir de ese momento es recomendable utilizar el operador $each
• Operador $each
{$push: {array : {$each : ["valor1", "valor2"]} } }
• Operador $pullAll, elimina los valores que le pasamos

{$pullAll: {array : ["valor1", "valor2"] } }
• Operador $pull, elimina los valores que le pasamos que cumplan una
determinada condición con el operador $in
{$pull:
{array :
{$in : ["valor1", "valor2"] }
}
}

• Modificadores del operador $push
• $slice, es un, me puedo quedar con la parte inicial o final del

array que le paso para guardar. Va asociado siempre a $each
…{$push: { Añade al final del array

nombrearray : {
$each : ["valor1", "valor2"],  Estos valores
$slice : -3  quédate con los 3 últimos
}
}}
• Es decir añade los elementos que se le pasan y de todos los que hay en el
array se queda con aquellos que ordena el operador

• En caso de no tener documentos en el array
…{$push: { Añade al final del array
nombrearray : {
$each : [],  No se le pasa nada
$sort : 1  1 ASC, -1 DESC
} }}
• En caso de no tener documentos en el array
…{$push: {nombrearray : {
$each : [],  No se le pasa nada
$sort : { campo : 1 } Ordenará por el campo del
documento que le indiques
} }}

• Operador $position, se utiliza para cambiar el comportamiento
estándar de $push y poder decir donde se agregan los elementos.
…{$push: {
nombrearray : {
$each : ["valor1", "valor2"],
$position: 1  Añade en la posición 1 en vez de en la última
}
}
}
Operador $
• Sirve para modificar el primer elemento de un array que cumpla
una condición
Modifica la primera ocurrencia que cumpla la condición

db.coleccion.update( { campo1 : valor1, array : valor2 } , { $set: {
"array.$" : "valor 3" } } )
Modifica la posición 2
db.coleccion.update( { campo1 : valor1, array : valor2 } , { $set: {
"array.2" : "valor 3" } } )
Operador $
Añade un nuevo campo en el primer subdocumento del

array de los documentos filtrados y que además dicho
subdocumento cumpla la condición impuesta.
db.coleccion.update( { campo1 : valor1, "array.campo1" :

{$gt : 50} } , { $set: { "array.$.nuevocampo" : "valor" } } )
Operación upsert
• Operación en la que primero se intenta actualizar un
documento existente y si no se puede se realiza una
inserción
db.coleccion.update (criterio, expresion, { upsert :

true })
• Si no coincide ningún documento con la condición

del criterio inserta la expresión con los campos que
conforman el criterio y la expresión.
Actualizaciones multiples
• Por defecto solo modifica el primer documento que
cumpla las condiciones.
db.coleccion.update (criterio, expresion, { multi :

true })
• Las modificaciones son atómicas por documento, o

se realizan las modificaciones en todos los campos
de un documento o no se hace en ninguno.
Eliminar documentos
• Para eliminar los documentos de una colección
db.coleccion.remove(criterio)
• Si queremos eliminar todos los documentos
db.coleccion.remove({condicion})  Obtener los
documentos y eliminarlos uno a uno
db.coleccion.drop()  Elimina la colección entera,
es más rápida pero también elimina los índices y habrá
que regenerarlos.
Recuperar y modificar documentos

• En la misma operación recuperamos o bien antes o bien después de
modificar o eliminar un documento.
• La operación es findAndModify, también son operaciones atómicas
db.coleccion.findAndModify(
query: {criterio filtrado},  Condición
sort:{ criterio ordenación},  Ordenamiento
remove: <boolean> o update: {actualización}  Son excluyentes y uno de los
dos obligatorio
new: <boolean>  Controlo si devuelvo antes de actualizar o
después; true: después; false: antes
fields : {proyección}  solo devuelve los campos que me interesan
upsert : <boolean>  A true, si no encuentra hace insert
)
Recuperar y modificar documentos

• En la misma operación recuperamos o bien antes o bien después de
modificar o eliminar un documento.
• La operación es findAndModify, también son operaciones atómicas
db.coleccion.findAndModify(
query: {criterio filtrado},  Condición
sort:{ criterio ordenación},  Ordenamiento
remove: <boolean> o update: {actualización}  Son excluyentes y uno de los
dos obligatorio
new: <boolean>  Controlo si devuelvo antes de actualizar o
después; true: después; false: antes
fields : {proyección}  solo devuelve los campos que me interesan
upsert : <boolean>  A true, si no encuentra hace insert
)
Operaciones masivas de escritura

• Se pueden realizar inserciones masivas basada en los
métodos insert, update y delete que tienen integrada
comprobación de errores.
• Hay dos tipos de operaciones masivas de escritura
o Ordenadas: función initializeOrderedBulkOp(), las operaciones
se ejecutan en el orden que se han incluido y si hay un fallo el resto
no se ejecuta.
o Desordenadas: función initializeUnorderedBulkOp(), las
operaciones se ejecutan en paralelo siempre que se pueda, y
aunque haya un error se continua hasta el final
Operaciones masivas de escritura

• Ej.
var masivo = db.coleccion.initializeOrderedBulkOp()
masivo.insert(documento)
masivo.find(criterio filtrado).remove()
masivo.find(criterio filtrado).removeOne()
masivo.find(criterio filtrado).replaceOne(documento)
masivo.find(criterio filtrado).update(documento)
masivo.find(criterio filtrado).upsert().replaceOne(documento)
masivo.find(criterio filtrado).upsert().updateOne(campos o doc)
masivo.find(criterio filtrado).upsert().update(campos)
masivo.execute()  Se ejecutan en este momento dependiendo del
tipo de operación masiva utilizada
We make
it happen
FIN UNIDAD
Click para editar el tercer nivel
eae.es

2 OperacionesCRUDMongoDB

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

2 OperacionesCRUDMongoDB

Cargado por

Copyright:

Formatos disponibles

We make

01. Operaciones de Lectura

Mongodb no tiene un lenguaje SQL, llama a métodos o funciones

Si ejecutamos db.coleccion.findOne() en el shell la llamada se

Driver/consola y el servidor utilizan mensajes del MWP, los

Métodos find() y findOne()

• Métodos find() devuelve un cursor y findOne() que devuelve un

• Donde tanto criterio como proyección son documentos JSON

Proyección: Sintaxis {campo:key}

db.users.find( {status: “D”},  Criterio Selección

• Consulta en Base de datos relacional

SELECT username  Proyección

>db.lecturer.find()  Devuelve todos

{ "_id" : ObjectId("53172c1ea85874ad0f8f1c6e"), "a" : 1,

{ "_id" : ObjectId("53172c1ea85874ad0f8f1c6f"), "a" : 2,

> db.lecturer.find({a:61}, {a:1})

> db.lecturer.find({a:61}, {a:1, _id:0})

Operadores sobre arrays

db.coleccion.find( {campo : { $type: BSON Type} ) Sólo mostrará

• $mod, $regex, $text, $where

Notacion del punto

>db.coleccion.find( {“campo2.c1” : { $gt:5} })

Notacion del punto

>db.coleccion.find( {“campo2.c2” : “valor2” , “campo2.c1” : { $gt:5}})

>db.coleccion.find( {campo2 : {$elemMatch:{“c1”: 2,c2:”valor2”} } })

• Por defecto se consumen de 20 en 20 documentos, se puede modificar

• Los cursores ocupan recursos en el servidor, tras 10 minutos de

• El primer lote que se envía esta compuesto por 101 documentos.

• En el shell automáticamente se muestran 20, pulsando «it» vamos

• Aislamiento, los cursores no están aislados con respecto a las

Ordenar, limitar y saltar

>db.coleccion.find( {campo1 : valor} , { _id : 0 } ).sort(

• Limitar: Se utiliza el método limit con el número de documentos que

db.coleccion.find( {campo1 : valor} , { _id : 0 }

Ordenar, limitar y saltar

• Da igual en que orden se pongan que siempre devolverá el mismo

• Con mongoDB se van a poder

Al insertar el número de campos no siempre debe coincidir

El _id se genera automáticamente como campo de tipo ObjectId pero tambien lo

db.coleccion.insert( { _id:0, campo1: "valor"} )

También se pueden insertar varios documentos a la vez

db.coleccion.insert({ campo1: "valor", campo2: 15 } ,

El _id se genera automáticamente como campo de tipo ObjectId pero tambien lo

db.coleccion.insert( { _id:0, campo1: "valor"} )

También se pueden insertar varios documentos a la vez

db.coleccion.insert({ campo1: "valor", campo2: 15 } ,

>var cliente = db.gimnasio3.findOne();

• Indicamos que documento queremos modificar mediante una

$inc, $mul, $rename, $setOnInsert, $set, $unset,

{$max: {campo : 10 }} Si el valor real es 11, no lo actualizaría.

• Hay tres formas de utilizarlo

{$currentDate : {fechaNacimiento : {$type: "date"} } }

{$currentDate :{fechaNacimiento : {$type: "timestamp"}} }

• Operador $push, añade al final del array el elemento que le pasamos

• Operador $addToSet, igual que push pero en este caso si el elemento ya

• Operador $pop sirve para eliminar el primero o el último

• Operador $pullAll, elimina los valores que le pasamos

Operadores actualización arrays

• $slice, es un, me puedo quedar con la parte inicial o final del

…{$push: { Añade al final del array

Operadores actualización arrays

Operadores actualización arrays