3 Operaciones Básicas en MongoDB¶

Introducción¶

Todos los comandos para operar con esta base de datos se escriben en minúsculas, lo más comunes son:

show databases. Listar base de datos.
db. Mostrar la base de datos actual.
show collections. Mostrar las colecciones de la base de datos actual.
use [data name]. Usa una base de datos. Si no existe no importa, porque se creará en el momento que se añada un objeto JSON. use my_data_base
count, size, length. Devuelve el nº de documentos de loas colecciones. db.my_coleccion.count()

¡Cuidado!

El método count está actualmente deprecated, sus alternativas son:

db.collection.countDocuments()
db.collection.estimatedDocumentCount()

Para añadir comentarios utilizamos los caracteres // de comentario de Java.

Veamos un ejemplo, creamos una base de datos llamada my_first_database

use my_first_database

Listamos las bases de datos para comprar que se ha creado:

show databases

Como puedes comprobar aún no aparece en la lista, esto se debe porque hasta que no tengamos unos datos no se crea de forma oficial.

A continuación, comprobamos el nombre de la base de datos actual.

db

Crear Registros¶

Métodos deprecated

En versiones anteriores de MongoDB se usaban los métodos save() e insert() para crear registros, actualmente dichos métodos están deprecated.

Los métodos para insertar registros son:

db.collection.insertOne(). Para insertar un valor
db.collection.insertMany(). Para insertar varios valores
db.collection.bulkWrite(). Toma un array y lo inserta.
db.collection.updateOne(). Actualiza un único elemento.
db.collection.updateMany(). Actualiza varios elementos.
db.collection.findOneAndUpdate(). Localiza un elemento y luego lo actualiza.

Identificador de Objetos¶

Los identificadores de cada registro son únicos. Se asignan automáticamente al crear el documento, se generan de forma rápida y ordenada. También se pueden crear de forma manual. Es un número hexadecimal que consta de 12 bytes, los 4 primeros son una marca de tiempo, los 3 siguientes la identificación de la máquina, 2 bytes de identificador de proceso y un contador de 3 bytes empezando en un número aleatorio. El ObjectId o _id, es como si fuese la clave del documento, no se repetirá en una colección. Si un documento no tiene _id MongoDB se lo asignará automáticamente, es lo que ocurre cuando insertamos y no indicamos el identificador.

Que el ObjectId esté compuesto de esa manera, nos da algunas funcionalidades muy útiles. La primera es que nos puede dar una indicación de el orden de creación de los documentos. No es algo del todo fiable si estamos tratando con documentos creados en el mismo margen de tiempo, pero sí en tramos de tiempo más largos.

También nos sirve para obtener la fecha de creación del documento.

Vamos a crear un amigo:

friend1 = {name: 'Ana', phone: 658963145, curso: '2DAM', nota: 7.5}

Insertamos a dicho amigo:

db.friends.insertOne(friend1);

Importante

No hemos creado la colección friends pero al usar uno de los métodos de creación se crea en caso de que no exista.

Ahora, volvemos a listar las bases de datos:

show databases

Ahora, en la lista, si aparece la base de datos que hemos creado al principio.

Ahora, insertamos usuarios con insertMany:

db.friends.insertMany([
    {name: 'Lucas', phone: 722589636, curso: '1DAM', nota: 6.9},
    {name: 'Lucía', phone: 733256985, curso: '2DAM', nota: 7.0}
]);

Consultar registros¶

Para consultar todos los elementos de una colección utilizaremos la orden find(). De esta forma se mostrarán los identificativos (_id) de cada objeto JSON, únicos de cada colección, y el resto de campos.

Si queremos mostrar la salida ordenada por algún campo, se usa junto con find() el método sort({campo: X}), siendo campo el nombre del campo por el que quieres ordenar y X siendo 1, si quieres que se de forma ascendente, o -1, descendente.

Si se desean hacer búsquedas de documentos que cumplan una o varias condiciones, utilizamos el siguiente formato: db.collection.find(filtro, campo)

En filtro indicamos la condición de búsqueda, podemos añadir los pares nombre:valor a buscar. Si omitimos este, o pasa un documento vacío ({}) parámetro devuelve todos los documentos.
En campos se especifican los campos a devolver de los documentos que coinciden con el filtro de la consulta. Para mostrar todos los campos omitimos este parámetros. Si se desean devolver uno o más campos escribiremos {campo: 1} o {campo: true}, y si no queremos usamos {campo: 0} o {campo: false}.

Se pueden hacer consultas más complejas añadiendo selectores de búsqueda:

$eq, igual a un valor.
$gt***, mayor que y ***$gte mayor o igual que.
$lt, menor que, y lte, menor o igual que.
$ne, distinto a un valor.
$in***, entre una lista de valores y ***$nin, no está entre la lista de valores.

También podemos realizar búsquedas con selectores de búsquedas lógicos:

$or. condición1 O condición2. Devuelve todos los documentos que cumplen una de las dos condiciones.
$and. condición1 Y condición2. Devuelve todos los registros que cumplen ambas condiciones. Este operador se maneja de forma implícita y no es necesario especificarlo.
$not. Representa la negación.
$exists. Permite filtrar la búsqueda tomando en cuenta la existencia de la expresión.

A continuación, vamos a listar todos los registros de la colección:

db.friends.find();

Vamos a mostrar la misma salida anterior, pero ordenada por notas, primero de forma ascendente:

db.friends.find().sort({nota: 1});

Luego, descendente:

db.friends.find().sort({nota: -1});

Ahora, vamos a consultar todos los amigos cuyo curso sea "2DAM":

db.friends.find({curso: "2DAM"});

Bien, ahora vamos a buscar a los amigos, cuyo curso sea "2DAM" y su nombre "Ana":

db.friends.find({curso: "2DAM", name: "Ana"});

Vamos a probar la misma búsqueda anterior pero solo quiero mostrar la nota:

db.friends.find({curso: "2DAM", name: "Ana"}, {nota: true});

Ahora vamos a mostrar cuántos amigos pertenecen a "2DAM":

db.friends.find({curso: "2DAM"}).size();

Vamos a mostrar todos los amigos cuyas notas sean igual a 7:

db.friends.find({nota: {$eq: 7}});

Ahora las que sea de mayor o igual que 7:

db.friends.find({nota: {$gte: 7}});

Ahora todos los amigos que no estén en segundos:

db.friends.find({curso: {$ne: "2DAM"}});

Mostramos todos los amigos cuyas notas sean 6, 7 u 8. Mostramos solo el nombre:

db.friends.find({nota: {$in: {6, 7, 8}}}, {name: true})

Buscamos todos los amigos que sean de 2DAM o se llamen Lucas:

db.friends.find({$or: [ {curso: "2DAM"}, {name: "Lucas"}]});

Ahora mostramos todos los amigos que sean de 2DAM y se llamen Ana;

db.friends.find({$and: [ {name: "Ana"}, {curso: "2DAM"}]});

Esta sentencia también se puede escribir así:

db.friends.find({name: "Ana", curso: "2DAM"});

Vamos a insertar un amigo con nota null:

db.friends.insertOne({name: "Rubén", phone: 695362523, curso: "1DAM", nota: null});

Ahora otro, sin nota directamente:

db.friends.insertOne({name: "Selena", phone: 123456789, curso: "2DAM"})

Mostramos los amigos que tienen nota:

db.friends.find({nota: {$exists:true}})

Ahora, aquellos que no tienen, se pueden hacer de dos formas, con $not o con $exists: false

db.friends.find({nota: {$exists:false}})

db.friends.find({nota: {$not: {$exists:true}}});

Podemos entender que un amigo no tiene nota, cuando está no exista o cuando sea null, entonces vamos a mostrar todos los amigos que realmente tengan nota:

db.friends.find( {nota: {$exists:true}, nota: {$ne: null}  } )

Actualizar registros¶

Para actualizar datos utilizaremos el comando .update, con este formato:

db.collection.update(
 filter,
    changes,
    {
     upsert: boolean,
     multi: boolean
    }
)

En filter, se indica la condición para localizar los registros o documentos a modificar.

En changes, se especifican los cambios que se desean hacer. Hay que tener cuidado al utilizar esta orden, ya que cambiará el contenido del documento.

¡CUIDADO!

Si indicamos solo un campo a modificar y no el resto de campos, el campo indicado se modificará pero los demás SERÁN ELIMINADOS AUTOMÁTICAMENTE.

Por ende, nos encontramos con dos tipos de cambios: cambiar el documento completo o modificando solo los campos especificados, para ello utilizamos los parámetros upsert y multi, ambos son opcionales y su valor por defecto es false.

upsert. Si asignamos true a este parámetro, se indica que si el filtro de búsqueda no encuentra ningún resultado, entonces, el cambio debe ser insertado como un nuevo registro.
multi. En caso de que el filtro de búsqueda devuelva más de un resultado, si lo ponemos a true, el cambio se realizará a todos los resultados, de lo contrario solo se cambiará al primero que encuentre, es decir, al que tenga menor identificativo de objeto, _id.

El comando update cuenta con una serie de operadores para realizar actualizadores más complejas. Algunos de estos operadores son los siguientes:

$set. Permite actualizar con nuevas propiedades a un documento, o conjunto. Si el documento ya tiene ese campo, no lo añade, si no que lo cambia en caso de que sea distinto.
$unset. Permite eliminar propiedad de un documento.
$inc. Incrementa en una cantidad numérica especificada en el valor del campo incrementar
$rename. Renombra campos del documento.

Vamos a actualizar los datos de Lucas:

db.friends.update({name: "Lucas"}, {name: "Lucas", phone: 685967412, curso: "2DAM"})

Fíjate que el campo de nota de Lucas ha desaparecido.

Vamos a actualizar a Sonia cambiándole el teléfono a 689234567, como no existe lo creará.

db.friends.update({name: "Sonia"}, {name: "Sonia", phone: "689234567"}, {upsert: true})

Vamos a actualizar la edad de Sonia, teniendo en cuenta que es un campo que no existe se debe usar con $set:

db.friends.update({name:"Sonia"}, { $set: {edad: 24}})

Vamos a cambiar el curso a Ana y Lucía, como es una propiedad que ya existe, y es el último campo que se desea cambiar, también usaremos $set:

db.friends.update({name: "Ana"}, { $set: {curso: "1DAM"}})
db.friends.update({name: "Lucía"}, { $set: {curso: "1DAM"}})

Como podemos observar solo ha cambiado el campo "curso" y no el resto de ellos.

Ahora, vamos a actualizar al amigo Rubén, eliminándole la nota:

db.friends.update({name: "Rubén"}, {$unset: {nota: 7}})

Fíjate, que hemos indicado nota 7, y a pesar que dicho amigo no tiene nota 7 si no null, también será eliminada.

Vamos a sumarle uno a la edad de Sonia

db.friends.update({name: "Sonia"}, {$inc: {edad: 1}})

Ahora vamos a cambiar el nombre del campo edad de Sonia, y lo ponemos en inglés:

db.friends.update({name: "Sonia"}, {$rename: {edad: 'age'}})

Vamos a incrementarle un 1 a todos aquellos amigos que estén en el curso 1DAM:

db.friends.update({curso: "1DAM"}, { $inc: {nota:1}})

Como podemos observar, solo cambia el primer amigo que encuentra con esa condición, para ello es importante, usar la propiedad multi a true:

db.friends.update({curso: "1DAM"}, {$inc: {nota: 1}}, {multi: true})

Ahora si se le ha cambiado a todos, incluso a aquellos amigos que no tenía el campo nota.

Ahora vamos a añadirle la población a aquellos alumnos que sean de 2DAM.

db.friends.update({curso: "2DAM"}, { $set: {poblacion: "Talavera"}}, {multi:true})

Operaciones con Arrays¶

Para consultar un elemento de un campo de tipo array, solo será necesario escribir el nombre del campo-array y el valor que se desea buscar.

Existen también operadores de modificación para los campos que sean arrays:

$push. Añade un elemento a un array.
$addToSet. Agrega elementos a un array solo sí estos no existen.
***$each.*** Se usa en conjunto con *$addToSet* o $push para indicar que se añaden varios elementos al array.
$pop. Elimina el primer o último valor del array. Con valor -1 borra el primero, con otro valor el último.
$pull. Elimina los valores de un array que cumplan con el filtro indicado.

Creamos la colección libro e insertamos tres libros, cada uno de ellos con un campo de tipo array que almacenará los temas del libro:

db.books.insertMany(
    [
        {code: 1, name: "Acceso a Datos", pvp: 35, editorial: "Garceta", temas: ["Base de datos", "Hibernate", "Neodatis"]},
        {code: 2, name: "Entornos de desarrollo", pvp: 27, editorial: "Garceta", temas: ["UML", "Subversión", "ERMaster"]},
        {code: 3, name: "Programación de Servicios", pvp: 25, editorial: "Garceta", temas: ["SOCKET", "Multihilo"]}
   ]
);

Consultamos:

Libros que tengan el tema UML:
```
db.books.find({temas: "UML"})
```

Libros que tengan el tema UML o Neodatis:

db.books.find({ $or: [{temas: "UML"}, {temas: "Neodatis"}]})

Libros de la editorial Garceta, con pvp mayor que 25 y que tengan el tema UML o Neodatis:

db.books.find({ editorial: "Garceta", pvp: {$gt: 25}, $or: [{temas: "UML"}, {temas: "Neodatis"}]})

Ahora, vamos a actualizar:

Añadimos el tema MongoDB al libro que tenga código 1.

db.books.update({codigo: 1}, {$push: {temas: "MongoDB"}})

Vamos a agregar el tema "Bases de Datos" a todos los libros que tengan el campo "temas":

db.books.update({temas: {$exists:true}}, {$addToSet: {temas: "Bases de Datos"}}, {multi: true})

A continuación añadimos al libro de código 1 los temas "JSON" y "XML"

db.books.update({code:1}, {$push: {temas: {$each: ["JSON", "XML"]}}})

Ahora, añadimos los temas "Eclipse" y "Developper" a los libros de código 2 (usamos $addToSet):
```
db.books.update({code: 2}, {$addToSet: {temas: {$each: ["Eclipse", "Developper"]}}})
```
Ahora eliminamos el primer tema del libro con código 3:
```
db.books.update({code: 3}, {$pop: {temas: -1}})
```

Borramos de todos los libros, los elementos "Base de Datos y JSON"

db.books.update({}, {$pull: {temas: { $in: ["Base de datos", "JSON"]}}}, {multi: true})

Borrar registros¶

Para borrar registros podemos usar las órdenes remove o drop. Se puede eliminar documentos que cumplan una condición, o todos los documentos de la colección o la colección completa.

Para borrar un documentos o registro que cumpla una condición utilizaremos la orden remove({valor})
Para eliminar todos los elementos de la colección escribimos remove({})
Para eliminar una colección se usa drop()

Eliminamos a Ana:

db.friends.remove({name: "Ana"})