Asignatura: Bases de datos para el Big Data
Carrera: Máster Universitario en análisis y visualización de datos masivos
Profesor: Dr. Marlon Cárdenas
Tarea: Actividad grupal: Uso avanzado de bases de datos NoSQL
Integrantes
• KERLY REYES
• ANDRÉS MACÍAS
• GIORGIA CONGACHA
• PATRICIO VALLEJO
• RICARDO ALMEIDA
Fecha: 22/02/2022
2
Índice
1. Inicia la monitorización en MongoDB ............................................................................................... 1
2. Importar la base de datos ................................................................................................................... 3
3. Exportar la base de datos ................................................................................................................... 5
4. Restaurar una base de datos .............................................................................................................. 6
5. Caso de uso .......................................................................................................................................... 7
6. Alcance del contrato ........................................................................................................................... 8
7. Actualizaciones .................................................................................................................................. 13
8. Neo4J modelo de datos .................................................................................................................... 24
1
1. Inicia la monitorización en MongoDB
a. Visualizar las estadísticas
mongostat –-discover
b. Visualiza el top de las operaciones
mongotop 5
2
c. Consolas activas
Tened estas dos consolas siempre activas y visibles mientras realizáis los siguientes puntos. Interpretad su
salida y describid brevemente qué muestran cuando se ejecutan dichas instrucciones (utiliza capturas para
ilustrar tu respuesta).
3
2. Importar la base de datos
a. Cread la base de datos inspections y dentro de ella la colección que corresponda a los
datos del fichero act-grupal-city_inspections.json.
mongoimport --verbose --db inspections --collection act-grupal-city_inspections --
file ./act-grupal-city_inspections.json
La captura nos indica que se la sentencia ejecutada está escribiendo en 15ms y que se está realizando
recuentos de operaciones de inserciones en la base.
b. Cread la base de datos countries
FOR %i IN (./act-grupal-countries*.json) DO mongoimport --db countries --collection
%~ni --file %i
4
La captura nos indica que no se logró registrar monitoreos de la consulta realizada.
5
3. Exportar la base de datos
a. Export colección inspections
mongoexport --collection=act-grupal-city_inspections --db=inspections --
out=inspections.json
La captura nos indica que se la sentencia ejecutada está leyendo en 72ms, pero no se observa recuentos de
operaciones.
6
4. Restaurar una base de datos
a. Restaurar una base de datos con dump
Para restaurar una base de datos, debéis indicar la ruta del directorio dump donde se almacenan los ficheros
de la base de datos (json y bson).
dump
people
--people.bson
--people.metadata.json
b. Descompresión de Ficheros
Descomprimid el fichero act-grupal-people.zip y ubicad los ficheros en la estructura de directorios indicada
en el paso anterior.
mongorestore --port 27017 ./dump
La captura nos indica que se la sentencia ejecutada está escribiendo en 1203ms, y se observa recuentos de
operaciones de inserción.
7
5. Caso de uso
Contratan a vuestro equipo para actualizar las restricciones de ciertos locales con terrazas en Madrid por
cuestiones del Covid-19. Los datos para actualizar están en el fichero llamado act-grupal-
openDataLocalesMadrid.cvs y se os pide que consolidéis dichos cambios en una base de datos MongoDB
llamada Madrid con la colección Terrazas
8
6. Alcance del contrato
a. Convertir csv a Json
b. Descargar fichero
9
c. Editar fichero
d. Guardad el fichero en una ruta conocida y cambiad su extensión a formato .js. ¿Sabéis
qué tipo de fichero es un .js?
Es un archivo de texto plano que contiene scripts de javascripts
e. Cliente mongo
load('./fichero.js')
10
La captura nos indica que no se logró registrar monitoreos de la consulta realizada.
datos_insertar[0]
f. Describir brevemente qué hacen las instrucciones anteriores.
Load: Carga y ejecuta un archivo JavaScript.
datos_insertar[0]: Muestra los datos del fichero de la posición 0 del array.
g. Con lo que habéis hecho antes, ¿podríais realizar un insert masivo?
db.Terrazas.insertMany(datos_insertar)
11
La captura nos indica que se la sentencia ejecutada está escribiendo en 74ms, y no se observa recuentos de
operaciones de inserción.
db.Terrazas.find().limit(2).pretty()
12
h. Alternativa que evite realizar los pasos anteriores en la terminal
Se podría utilizar el comando –eval que sirve para ejecutar y evaluar una expresión JavaScript. (MongoDB,
2021)
mongo PruebaMadrid --eval
"load('./fichero.js');db.Terrazas.insertMany(datos_insertar)"
13
7. Actualizaciones
a. Los locales del barrio Guindalera de Salamanca, por motivos de la desescalada no
podrán abrir y tendrán que permanecer cerrados. Cambiar la situación del local a
Cerrado utilizando el id correspondiente.
db.Terrazas.updateMany(
{desc_situacion_local: "Abierto", desc_barrio_local:"GUINDALERA" ,
desc_distrito_local: "SALAMANCA"},
{
$set: { "desc_situacion_local": "Cerrado"}
}
);
La captura nos indica que se la sentencia ejecutada está escribiendo en 18ms, y no se observa recuentos de
operaciones de actualización.
• Recordar que debéis constatar los tipos de situaciones que existan y seguir con la
misma codificación.
• A estos mismos locales, cambiar la situación de la terraza a cerrada siguiendo las
mismas premisas anteriores.
db.Terrazas.updateMany(
{
desc_situacion_local: "Cerrado",desc_barrio_local: "GUINDALERA",
desc_distrito_local: "SALAMANCA",
}
,{
$set: { "desc_situacion_terraza": "Cerrado"
, "id_situacion_terraza": 4 }
}
);
14
La captura nos indica que se la sentencia ejecutada está escribiendo en 42ms, y se observa recuentos de
operaciones de actualización.
b. A todas las terrazas que se ubiquen en la acera, añadir un campo llamado inspeccionar y
establecer el siguiente valor: Si dispone de más de 10 mesas, true. Si dispone de menos de
10 mesas, false.
db.Terrazas.updateMany(
{
desc_ubicacion_terraza: "Acera"
, $or: [{mesas_es: { $lt:10}} , {mesas_aux_es:{$lt:10}} ,{mesas_aux_ra:{$lt:10}}
,{mesas_ra:{$lt:10}}
]},
[{
$set: { "inspeccionar": false}
}
]
,{ multi: true }
);
15
La captura nos indica que se la sentencia ejecutada está escribiendo en 814ms, y no se observa recuentos de
operaciones de actualización.
db.Terrazas.updateMany(
{
desc_ubicacion_terraza: "Acera"
, $or: [{mesas_es: { $gte:10}} , {mesas_aux_es:{$gte:10}} ,{mesas_aux_ra:{$gte:10}}
,{mesas_ra:{$gte:10}}
]},
[{
$set: { "inspeccionar": true}
}
]
,{ multi: true }
);
16
La captura nos indica que se la sentencia ejecutada está escribiendo en 135ms, y se observa recuentos de
operaciones de actualización.
c. A las terrazas que se deban inspeccionar, asignar 2 mesas auxiliares y 8 sillas disponibles
(tanto en período estacional como el resto del año).
db.Terrazas.updateMany(
{
inspeccionar: true },
{
$set: { "mesas_aux_es": 2 , "mesas_aux_ra":2, "sillas_es":8, "sillas_ra":8}
}
);
17
La captura nos indica que se la sentencia ejecutada está escribiendo en 62ms, y se observa recuentos de
operaciones de actualización.
d. A las terrazas que no deban ser inspeccionadas, añadir el campo estado con el valor:
• 1 si el número de sillas es menor que 10.
• 2 si el número de sillas está entre 10 y 20.
• 3 si cuenta con más de 20 sillas.
db.Terrazas.updateMany(
{},
[
{ $set: { sillas_ra: { $switch: {
branches: [
{ case: { $eq: [ "sillas_ra" , "A" ] }, then: 1 }
,{ case: { $eq: [ "sillas_ra" , "B" ] }, then: 2 }
,{ case: { $eq: [ "sillas_ra" , "C" ] }, then: 3 }
,{ case: { $eq: [ "sillas_ra" , "D" ] }, then: 4 }
,{ case: { $eq: [ "sillas_ra" , "E" ] }, then: 5 }
,{ case: { $eq: [ "sillas_ra" , "F" ] }, then: 6 }
,{ case: { $eq: [ "sillas_ra" , "G" ] }, then: 7 }
,{ case: { $eq: [ "sillas_ra" , "H" ] }, then: 8 }
,{ case: { $eq: [ "sillas_ra" , "I" ] }, then: 9 }
,{ case: { $eq: [ "sillas_ra" , "J" ] }, then: 10 }
,{ case: { $eq: [ "sillas_ra" , "K" ] }, then: 11 }
,{ case: { $eq: [ "sillas_ra" , "L" ] }, then: 12 }
],
default: 0
} } } }
]
);
18
La captura nos indica que se la sentencia ejecutada está escribiendo en 254ms, y se observa recuentos de
operaciones de actualización.
db.Terrazas.updateMany(
{"inspeccionar": false},
[
{ $set: { estado: { $switch: {
branches: [
{ case: { $lt: [ "$sillas_es" , 10 ] }, then: 1 }
,{ case: { $lt: [ "$sillas_ra" , 10 ] }, then: 1 }
,{ case: { $gt: [ "$sillas_es" , 20 ] }, then: 3 }
,{ case: { $gt: [ "$sillas_ra" , 20 ] }, then: 3 }
],
default: 2
} } } }
]
);
19
La captura nos indica que se la sentencia ejecutada está escribiendo en 89ms, y no se observa recuentos de
operaciones de actualización.
e. De lunes a jueves, ningún local podrá cerrar más allá de las 00:00:00, actualizar el
horario de cierre a esta nueva hora límite.
db.Terrazas.updateMany(
{
},
{
$set: { "hora_fin_LJ_es": "00:00:00", "hora_fin_LJ_ra": "00:00:00" }
}
);
La captura nos indica que se la sentencia ejecutada está escribiendo en 147ms, y no se observa recuentos de
operaciones de actualización.
20
f. De viernes a sábado, los locales que cierren a las 2:30:00, ahora tendrán que hacerlo a las
2:00:00.
db.Terrazas.updateMany(
{
$or: [{hora_fin_VS_es: "2:30:00"} , {hora_fin_VS_ra: "2:30:00"} ]
},
{
$set: { "hora_fin_VS_es": "2:00:00", "hora_fin_VS_ra": "2:00:00" }
}
);
La captura nos indica que se la sentencia ejecutada está escribiendo en 75ms, y no se observa recuentos de
operaciones de actualización.
g. A todos los locales que estén sobre la calle Alcalá en Madrid se les debe inspeccionar.
db.Terrazas.updateMany(
{
DESC_CLASE:"CALLE", DESC_NOMBRE:"ALCALA"
},
{
$set: { "inspeccionar": true}
}
);
21
La captura nos indica que se la sentencia ejecutada está escribiendo en 7ms, y no se observa recuentos de
operaciones de actualización.
h. A todos los locales con terrazas abiertas, añadir un campo revision cuyo valor sea un
documento con la siguiente información: {prox_inspeccion: 10, puntuacion: 80,
comentario: “separar las mesas”}
db.Terrazas.updateMany(
{
desc_situacion_terraza:"Abierta"
},
{
$set: { "revision": {prox_inspeccion: 10, puntuacion: 80, comentario: "separar las
mesas"} }
}
);
22
La captura nos indica que se la sentencia ejecutada está escribiendo en 205ms, y se observa recuentos de
operaciones de actualización.
i. Crear una nueva colección llamada zona1, con todos los locales que pertenezcan al
distrito de Villaverde.
db.Terrazas.aggregate(
[
{$match: { desc_distrito_local: "VILLAVERDE" } },
{ $out: "zona1" }
]
);
La captura nos indica que se la sentencia ejecutada está leyendo en 1ms, y no se observa recuentos de
operaciones de lectura.
23
j. Crear una nueva colección llamada zona2, con todos los locales que pertenezcan al
distrito de Salamanca y barrio Castellana.
db.Terrazas.aggregate(
[
{$match: { desc_distrito_local: "SALAMANCA" , desc_barrio_local:"CASTELLANA" } },
{ $out: "zona2" }
]
);
La captura nos indica que no se logró registrar monitoreos de la consulta realizada
24
8. Neo4J modelo de datos
a. Un grafo genérico que represente vuestro modelo (nodos, relaciones y atributos; se deben
reflejar todos los campos utilizados).
b. Una breve descripción del modelo propuesto.
El modelo propuesto nos permitirá identificar los diferentes locales que se encuentran en algún distrito y
cuál es la situación de las terrazas y en qué periodo se habilitan.
Para la creación del modelo se procedió a generar colecciones en MongoDB
25
db.Terrazas.aggregate([
{$group: {_id : {id_distrito_local :
'$id_distrito_local',desc_distrito_local:'$desc_distrito_local'}, total:{$sum :1}}},
{$project : {id_distrito_local : '$_id.id_distrito_local', desc_distrito_local :
'$_id.desc_distrito_local', _id : 0}},
{ $out: "DISTRITO_LOCAL" }
]);
db.Terrazas.aggregate([
{$group: {_id : {id_situacion_terraza :
'$id_situacion_terraza',desc_situacion_terraza:'$desc_situacion_terraza'},
total:{$sum :1}}},
{$project : {id_situacion_terraza : '$_id.id_situacion_terraza',
desc_situacion_terraza : '$_id.desc_situacion_terraza', _id : 0}}
,{ $out: "SITUACION_TERRAZA" }
]);
db.Terrazas.aggregate([
{$group: {_id : {id_periodo_terraza :
'$id_periodo_terraza',desc_periodo_terraza:'$desc_periodo_terraza'}, total:{$sum
:1}}},
{$project : {id_periodo_terraza : '$_id.id_periodo_terraza', desc_periodo_terraza :
'$_id.desc_periodo_terraza', _id : 0}}
,{ $out: "PERIODO_TERRAZA" }
]);
db.Terrazas.find({},{_id:0,id_local:1,Nombre:1,desc_barrio_local:1,id_distrito_local:
1,id_situacion_terraza:1,id_periodo_terraza:1});
db.Terrazas.aggregate([
{$project:
{_id:0,id_local:1,Nombre:1,desc_barrio_local:1,id_distrito_local:1,id_situacion_terra
za:1,id_periodo_terraza:1}}
, { $out: "LOCALES" }
]);
db.Terrazas.aggregate([
{$project: {_id:0,id_local:1,id_distrito_local:1}}
, { $out: "estaEnDistrito" }
]);
db.Terrazas.aggregate([
{$project: {_id:0,id_local:1,id_situacion_terraza:1}}
, { $out: "tieneEstadoTerraza" }
]);
db.Terrazas.aggregate([
{$project: {_id:0,id_local:1,id_periodo_terraza:1}}
, { $out: "tieneTerrazaPeriodo" }
]);
26
c. La descripción del proceso utilizado para cargar los datos en Neo4J a partir de los datos
en MongoDB.
Para realizar la carga de los datos desde MongoDB a Neo4j se procedió a utilizar el procedimiento
mongodb.get de la librería APOC, que permite realizar una operación de búsqueda y obtención de las bases
y colecciones que se encuentran en mongodb (Neo4j, 2022), una vez realizada la conexión se procedió a
crear los Nodos, atributos y relaciones.
A continuación, se detalla los códigos utilizados para la generación de los mismos.
Generación de Nodos y atributos
CALL apoc.mongodb.get("localhost","Madrid","DISTRITO_LOCAL",{}) YIELD value as dist
CREATE (dl:DISTRITO_LOCAL {id_distrito_local: dist.id_distrito_local,
desc_distrito_local: dist.desc_distrito_local})
CALL apoc.mongodb.get("localhost","Madrid","SITUACION_TERRAZA",{}) YIELD value as
situ
CREATE (st:SITUACION_TERRAZA {id_situacion_terraza:situ.id_situacion_terraza,
desc_situacion_terraza:situ.desc_situacion_terraza})
CALL apoc.mongodb.get("localhost","Madrid","PERIODO_TERRAZA",{}) YIELD value as
periodo
CREATE (pt:PERIODO_TERRAZA {id_periodo_terraza:periodo.id_periodo_terraza,
desc_periodo_terraza:periodo.desc_periodo_terraza})
CALL apoc.mongodb.get("localhost","Madrid","LOCALES",{}) YIELD value as local
CREATE (pt:LOCALES {id_local:local.id_local, Nombre:local.Nombre})
27
Generación de Relaciones
CALL apoc.mongodb.get("localhost","Madrid","estaEnDistrito",{}) YIELD value as lt
match(e:LOCALES),(a:DISTRITO_LOCAL) where e.id_local= lt.id_local
and a.id_distrito_local=lt.id_distrito_local
create (e)-[ed:estaEnDistrito]->(a) return ed
CALL apoc.mongodb.get("localhost","Madrid","tieneEstadoTerraza",{}) YIELD value as lt
match(e:LOCALES),(a:SITUACION_TERRAZA) where e.id_local= lt.id_local and
a.id_situacion_terraza=lt.id_situacion_terraza
create (e)-[t:tieneEstadoTerraza]->(a) return t
CALL apoc.mongodb.get("localhost","Madrid","tieneTerrazaPeriodo",{}) YIELD value as
lt
match(e:LOCALES),(a:PERIODO_TERRAZA) where e.id_local= lt.id_local and
a.id_periodo_terraza=lt.id_periodo_terraza
create (e)-[p:tieneTerrazaPeriodo]->(a) return p
28
d. Una consulta CQL y capturas con la visualización del grafo generado con los datos.
MATCH (p:LOCALES)-[estaEnDistrito]->(a:DISTRITO_LOCAL)
WHERE p.Nombre="BAR - RESTAURANTE"
MATCH (p)-[tieneTerrazaPeriodo]->(t: PERIODO_TERRAZA)
WHERE t.desc_periodo_terraza="Anual"
RETURN a,p,t
29
9. Bibliografía
MongoDB, I. (2021). docs.mongodb. Obtenido de
https://docs.mongodb.com/v4.0/reference/command/eval/
Neo4j, I. (2022). Neo4j Labs Docs. Obtenido de
https://neo4j.com/labs/apoc/4.0/overview/apoc.mongodb/apoc.mongodb.get/
