content/blog/mdad/mongodb-operaciones-basicas-y-arquitectura/index.md (view raw)
1+++
2title = "MongoDB: Operaciones Básicas y Arquitectura"
3date = 2020-03-05T03:00:53+00:00
4updated = 2020-03-20T11:42:15+00:00
5+++
6
7Este es el segundo post en la serie sobre MongoDB, con una breve descripción de las operaciones básicas (tales como inserción, recuperación e indexado), y ejecución por completo junto con el modelo de datos y arquitectura.
8
9Otros posts en esta serie:
10
11* [MongoDB: Introducción](/blog/mdad/mongodb-introduction/)
12* [MongoDB: Operaciones Básicas y Arquitectura](/blog/mdad/mongodb-operaciones-basicas-y-arquitectura/) (este post)
13
14Este post está hecho en colaboración con un compañero, y en él veremos algunos ejemplos de las operaciones básicas ([CRUD](https://stackify.com/what-are-crud-operations/)) sobre MongoDB.
15
16----------
17
18Empezaremos viendo cómo creamos una nueva base de datos dentro de MongoDB y una nueva colección donde poder insertar nuestros documentos.
19
20## Creación de una base de datos e inserción de un primer documento
21
22Podemos ver las bases de datos que tenemos disponibles ejecutando el comando:
23
24```
25> show databases
26admin 0.000GB
27config 0.000GB
28local 0.000GB
29```
30
31Para crear una nueva base de datos, o utilizar una de las que tenemos creadas ejecutamos `use` junto con el nombre que le vamos a dar:
32
33```
34> use new_DB
35switched to db new_DB
36```
37
38Una vez hecho esto, podemos ver que si volvemos a ejecutar «show databases», la nueva base de datos no aparece. Esto es porque para que Mongo registre una base de datos en la lista de las existentes, necesitamos insertar al menos un nuevo documento en una colección de esta. Lo podemos hacer de la siguiente forma:
39
40```
41> db.movie.insert({"name":"tutorials point"})
42WriteResult({ "nInserted" : 1 })
43
44> show databases
45admin 0.000GB
46config 0.000GB
47local 0.000GB
48movie 0.000GB
49```
50
51Al igual que podemos ver las bases de datos existentes, también podemos consultar las colecciones que existen dentro de estas. Siguiendo la anterior ejecución, si ejecutamos:
52
53```
54> show collections
55movie
56```
57
58### Borrar base de datos
59
60Para borrar una base de datos tenemos que ejecutar el siguiente comando:
61
62```
63> db.dropDatabase()
64{ "dropped" : "new_DB", "ok" : 1 }
65```
66
67### Crear colección
68
69Para crear una colección podemos hacerlo de dos formas. O bien mediante el comando:
70
71```
72db.createCollection(<nombre de la colección>, opciones)
73```
74
75Donde el primer parámetro es el nombre que le queremos asignar a la colección, y los siguientes, todos opcionales, pueden ser (entre otros):
76
77<table class="">
78 <thead>
79 <tr>
80 <th>
81 Campo
82 </th>
83 <th>
84 Tipo
85 </th>
86 <th>
87 Descripción
88 </th>
89 </tr>
90 </thead>
91 <tbody>
92 <tr>
93 <td>
94 <code>
95 capped
96 </code>
97 </td>
98 <td>
99 Booleano
100 </td>
101 <td>
102 Si es
103 <code>
104 true
105 </code>
106 ,
107 permite una colección limitada. Una colección limitada es una colección
108 de tamaño fijo que sobrescribe automáticamente sus entradas más
109antiguas cuando alcanza su tamaño máximo. Si especifica
110 <code>
111 true
112 </code>
113 , también debe especificar el parámetro de
114 <code>
115 size
116 </code>
117 .
118 </td>
119 </tr>
120 <tr>
121 <td>
122 <code>
123 autoIndexId
124 </code>
125 </td>
126 <td>
127 Booleano
128 </td>
129 <td>
130 Si es
131 <code>
132 true
133 </code>
134 crea automáticamente un índice en el campo
135 <code>
136 _id
137 </code>
138 . Por defecto es
139 <code>
140 false
141 </code>
142 </td>
143 </tr>
144 <tr>
145 <td>
146 <code>
147 size
148 </code>
149 </td>
150 <td>
151 Número
152 </td>
153 <td>
154 Especifica el tamaño máximo en bytes para una colección limitada. Es obligatorio si el campo
155 <code>
156 capped
157 </code>
158 está a
159 <code>
160 true
161 </code>
162 .
163 </td>
164 </tr>
165 <tr>
166 <td>
167 <code>
168 max
169 </code>
170 </td>
171 <td>
172 Número
173 </td>
174 <td>
175 Especifica el número máximo de documentos que están permitidos en la colección limitada.
176 </td>
177 </tr>
178 </tbody>
179</table>
180
181```
182> use test
183switched to db test
184
185> db.createCollection("mycollection")
186{ "ok" : 1 }
187
188> db.createCollection("mycol", {capped : true, autoIndexId: true, size: 6142800, max: 10000})
189{
190 "note" : "the autoIndexId option is deprecated and will be removed in a future release",
191 "ok" : 1
192}
193
194> show collections
195mycol
196mycollection
197```
198
199Como se ha visto anteriormente al crear la base de datos, podemos insertar un documento en una colección sin que la hayamos creado anteriormente. Esto es porque MongoDB crea automáticamente una colección cuando insertas algún documento en ella:
200
201```
202> db.tutorialspoint.insert({"name":"tutorialspoint"})
203WriteResult({ "nInserted" : 1 })
204
205> show collections
206mycol
207mycollection
208tutorialspoint
209```
210
211### Borrar colección
212
213Para borrar una colección basta con situarnos en la base de datos que la contiene, y ejecutar lo siguiente:
214
215```
216db.<nombre_de_la_colección>.drop()
217```
218
219```
220> db.mycollection.drop()
221true
222
223> show collections
224mycol
225tutorialspoint
226```
227
228### Insertar documento
229
230Para insertar datos en una colección de MongoDB necesitaremos usar el método `insert()` o `save()`.
231
232Ejemplo del método `insert`:
233
234```
235> db.colection.insert({
236... title: 'Esto es una prueba para MDAD',
237... description: 'MongoDB es una BD no SQL',
238... by: 'Classmate and Me',
239... tags: ['mongodb', 'database'],
240... likes: 100
241... })
242WriteResults({ "nInserted" : 1 })
243```
244
245En este ejemplo solo se ha insertado un único documento, pero podemos insertar los que queramos separándolos de la siguiente forma:
246
247```
248db.collection.insert({documento}, {documento2}, {documento3})
249```
250
251No hace falta especificar un ID ya que el propio mongo asigna un ID a cada documento automáticamente, aunque nos da la opción de poder asignarle uno mediante el atributo `_id` en la inserción de los datos
252
253Como se indica en el título de este apartado también se puede insertar mediante el método `db.coleccion.save(documento)`, funcionando este como el método `insert`.
254
255### Método `find()`
256
257El método find en MongoDB es el que nos permite realizar consultas a las colecciones de nuestra base de datos:
258
259```
260db.<nombre_de_la_colección>.find()
261```
262
263Este método mostrará de una forma no estructurada todos los documentos de la colección. Si le añadimos la función `pretty` a este método, se mostrarán de una manera más «bonita».
264
265```
266> db.colection.find()
267{ "_id": ObjectId("5e738f0989f85a7eafdf044a"), "title" : "Esto es una prueba para MDAD", "description" : "MongoDB es una BD no SQL", "by" : "Classmate and Me", "tags" : [ "mongodb", "database" ], "likes" : 100 }
268
269> db.colection.find().pretty()
270{
271 "_id": ObjectId("5e738f0989f85a7eafdf044a"),
272 "title" : "Esto es una prueba para MDAD",
273 "description" : "MongoDB es una BD no SQL",
274 "by" : "Classmate and Me",
275 "tags" : [
276 "mongodb",
277 "database"
278 ],
279 "likes" : 100
280}
281```
282
283Los equivalentes del `where` en las bases de datos relacionales son:
284
285<table class="">
286 <thead>
287 <tr>
288 <th>
289 Operación
290 </th>
291 <th>
292 Sintaxis
293 </th>
294 <th>
295 Ejemplo
296 </th>
297 <th>
298 Equivalente en RDBMS
299 </th>
300 </tr>
301 </thead>
302 <tbody>
303 <tr>
304 <td>
305 Igual
306 </td>
307 <td>
308 <code>
309 {<clave>:<valor>}
310 </code>
311 </td>
312 <td>
313 <code>
314 db.mycol.find({"by":"Classmate and Me"})
315 </code>
316 </td>
317 <td>
318 <code>
319 where by = 'Classmate and Me'
320 </code>
321 </td>
322 </tr>
323 <tr>
324 <td>
325 Menor que
326 </td>
327 <td>
328 <code>
329 {<clave>:{$lt:<valor>}}
330 </code>
331 </td>
332 <td>
333 <code>
334 db.mycol.find({"likes":{$lt:60}})
335 </code>
336 </td>
337 <td>
338 <code>
339 where likes < 60
340 </code>
341 </td>
342 </tr>
343 <tr>
344 <td>
345 Menor o igual que
346 </td>
347 <td>
348 <code>
349 {<clave>:{$lte:<valor>}}
350 </code>
351 </td>
352 <td>
353 <code>
354 db.mycol.find({"likes":{$lte:60}})
355 </code>
356 </td>
357 <td>
358 <code>
359 where likes <= 60
360 </code>
361 </td>
362 </tr>
363 <tr>
364 <td>
365 Mayor que
366 </td>
367 <td>
368 <code>
369 {<clave>:{$gt:<valor>}}
370 </code>
371 </td>
372 <td>
373 <code>
374 db.mycol.find({"likes":{$gt:60}})
375 </code>
376 </td>
377 <td>
378 <code>
379 where likes > 60
380 </code>
381 </td>
382 </tr>
383 <tr>
384 <td>
385 Mayor o igual que
386 </td>
387 <td>
388 <code>
389 {<clave>:{$gte:<valor>}}
390 </code>
391 </td>
392 <td>
393 <code>
394 db.mycol.find({"likes":{$gte:60}})
395 </code>
396 </td>
397 <td>
398 <code>
399 where likes >= 60
400 </code>
401 </td>
402 </tr>
403 <tr>
404 <td>
405 No igual
406 </td>
407 <td>
408 <code>
409 {<clave>:{$ne:<valor>}}
410 </code>
411 </td>
412 <td>
413 <code>
414 db.mycol.find({"likes":{$ne:60}})
415 </code>
416 </td>
417 <td>
418 <code>
419 where likes != 60
420 </code>
421 </td>
422 </tr>
423 </tbody>
424</table>
425
426En el método `find()` podemos añadir condiciones AND y OR de la siguiente manera:
427
428```
429(AND)
430> db.colection.find({$and:[{"by":"Classmate and Me"},{"title": "Esto es una prueba para MDAD"}]}).pretty()
431
432(OR)
433> db.colection.find({$or:[{"by":"Classmate and Me"},{"title": "Esto es una prueba para MDAD"}]}).pretty()
434
435(Ambos a la vez)
436> db.colection.find({"likes": {$gt:10}, $or: [{"by": "Classmate and Me"}, {"title": "Esto es una prueba para MDAD"}]}).pretty()
437```
438
439La última llamada con ambos a la vez equivalente en una consulta SQL a:
440
441```
442where likes>10 AND (by = 'Classmate and Me' OR title = 'Esto es una prueba para MDAD')
443```
444
445### Actualizar un documento
446
447En MongoDB se hace utilizando el método `update`:
448
449```
450db.<nombre_colección>.update(<criterio_de_selección>, <dato_actualizado>)
451```
452
453Para este ejemplo vamos a actualizar el documento que hemos insertado en el apartado anterior:
454
455```
456> db.colection.update({'title':'Esto es una prueba para MDAD'},{$set:{'title':'Título actualizado'}})
457WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
458> db.colection.find().pretty()
459{
460 "_id": ObjectId("5e738f0989f85a7eafdf044a"),
461 "title" : "Título actualizado",
462 "description" : "MongoDB es una BD no SQL",
463 "by" : "Classmate and Me",
464 "tags" : [
465 "mongodb",
466 "database"
467 ],
468 "likes" : 100
469}
470```
471
472Anteriormente se ha mencionado el método `save()` para la inserción de documentos, pero también podemos utilizarlo para sustituir documentos enteros por uno nuevo:
473
474```
475> db.<nombre_de_la_colección>.save({_id:ObjectId(), <nuevo_documento>})
476```
477
478Con nuestro documento:
479
480```
481> db.colection.save(
482... {
483... "_id": ObjectId("5e738f0989f85a7eafdf044a"), "title": "Este es el nuevo título", "by": "MDAD"
484... }
485... )
486WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
487
488> db.colection.find()
489{
490 "_id": ObjectId("5e738f0989f85a7eafdf044a"),
491 "title": "Este es el nuevo título",
492 "by": "MDAD"
493}
494```
495
496### Borrar documento
497
498Para borrar un documento utilizaremos el método `remove()` de la siguiente manera:
499
500```
501db.<nombre_de_la_colección>.remove(<criterio_de_borrado>)
502```
503
504Considerando la colección del apartado anterior borraremos el único documento que tenemos:
505
506```
507> db.colection.remove({'title': 'Este es el nuevo título'})
508WriteResult({ "nRemoved" : 1 })
509> db.colection.find().pretty()
510>
511```
512
513Para borrar todos los documentos de una colección usamos:
514
515```
516db.<colección>.remove({})
517```
518
519### Indexación
520
521MongDB nos permite crear índices sobre atributos de una colección de la siguiente forma:
522
523```
524db.<colección>.createIndex( {<atributo>:<opciones>})
525```
526
527Como ejemplo:
528
529```
530> db.mycol.createIndex({"title":1})
531{
532 "createdCollectionAutomatically" : false,
533 "numIndexesBefore" : 1,
534 "numIndexesAfter" : 2,
535 "ok" : 1
536}
537```
538
539Si queremos más de un atributo en el índice lo haremos así:
540
541```
542> db.mycol.ensureIndex({"title":1,"description":-1})
543```
544
545Los valores que puede tomar son `+1` para ascendente o `-1` para descendente.
546
547### Referencias
548
549* Manual MongoDB. (n.d.). [https://docs.mongodb.com/manual/](https://docs.mongodb.com/manual/)
550* MongoDB Tutorial – Tutorialspoint. (n.d.). – [https://www.tutorialspoint.com/mongodb/index.htm](https://www.tutorialspoint.com/mongodb/index.htm)