UNIR

Actividad 2:
Laboratorio - Uso de
MongoDB

BASES DE DATOS PARA EL BIG DATA

MARIA BELEN BENALCAZAR TOVAR
20 DE ENERO DE 2022
 Maria Belén Benalcázar Tovar

TABLA DE CONTENIDO

1. Carga de Datos ............................................................................................................................. 1

2. Exploración de Colecciones ........................................................................................................ 1

Exploración preliminar de las colecciones ................................................................................. 1

Limpieza de las colecciones ....................................................................................................... 4

Preguntas del Laboratorio.......................................................................................................... 6

3. Consultas de la colección 1 ......................................................................................................... 9

4. Consultas de la colección 2 ....................................................................................................... 11

5. Referencias bibliográficas ......................................................................................................... 15

Bases de datos para el Big Data |i

 Uso de MongoDB Maria Belén Benalcázar Tovar

Actividad 2: Laboratorio - Uso de MongoDB

1. Carga de Datos

Para el presente laboratorio se creó el directorio C:\MongoDB\visa01_lab\ como repositorio

de los todos los archivos necesarios para su desarrollo. Sin embargo en el script se presentan los
comandos para la importación desde el directorio .\bin de MongoDB. Se cargan las dos
colecciones books y companies con el comando mongoimport desde Símbolos del sistema.

mongoimport --verbose --db miscelanea --collection books --file

C:\MongoDB\visa01_lab\act-2-books.json

Figura 1. Carga de datos colección books

mongoimport --verbose --db miscelanea --collection companies --file

C:\MongoDB\visa01_lab\act-2-companies.json

Figura 2. Carga de datos de la colección companies

2. Exploración de Colecciones

Exploración preliminar de las colecciones

Usando el comando findOne se muestra un documento de la colección books.

db.books.findOne()

Figura 3. Documento de la colección books obtenido desde la terminal de MongoDB

Bases de datos para el Big Data |1

Uso de MongoDB Maria Belén Benalcázar Tovar

Se obtiene el resultado tanto en la terminal de MongoDB (Figura 3) como usando NoSQLBooster

(Figura 4). Se usa este último porque permite mejor visibilidad e incluye el tipo de datos. El
documento mostrado tiene 9 campos, dos de los cuales son de tipo array.

Figura 4. Documento desde la colección companies usando NoSQLBooster

De igual manera con el comando findOne se exploran los campos de la colección companies. El
documento mostrado tiene 36 campos, de los cuales varios son de tipo array.

Figura 5. Documento de la colección companies obtenido usando NoSQLBooster

Bases de datos para el Big Data |2

Uso de MongoDB Maria Belén Benalcázar Tovar

Figura 6. Documento de la colección companies obtenido desde la terminal de MongoDB

Bases de datos para el Big Data |3

Uso de MongoDB Maria Belén Benalcázar Tovar

Limpieza de las colecciones

Se valida si existen documentos duplicados en la colección books, tomando como base los campos
title e isbn, que son características únicas de los libros y el campo status. Para ello se usa
agregación y el resultado muestra 2 documentos repetidos. Si no cumplen esta condición se
consideran libros distintos ya que si el isbn es diferente puede tratarse de otro formato del libro.

db.books.aggregate([
{$group: {
_id: {title: "$title"},
uniqueIds: {$addToSet: "$_id"}, authors: {$addToSet: "$authors"},
pageCount: {$addToSet: "$pageCount"},
count: {$sum: 1}}},
{$match: {
count: {$gt: 1}
}
}
]);

Bases de datos para el Big Data |4

Uso de MongoDB Maria Belén Benalcázar Tovar

Figura 7. Libros con título duplicado de la colección books

A partir de la consulta anterior, se ejecuta la consulta para eliminar uno de los dos documentos
repetidos usando la instrucción forEach de JavaScript.

db.books.aggregate([
{$group: {_id: {title: "$title",isbn:"$isbn",status:"$status"},
dups: {$addToSet: "$_id"}, pageCount: {$addToSet: "$pageCount"},
count: {$sum: 1}}},
{$match: {count: {$gt: 1}}}
]).forEach(function(doc){
doc.dups.shift();
db.books.remove({_id:{$in: doc.dups}
})
})

Al igual que en la colección books en la colección companies existen registros que se podrían
considerar duplicados si tuvieran todos los campos iguales. Se realiza la consulta por el campo
name, encontrando 907 registros.

db.companies.aggregate([
{$group: {_id: {name: "$name"}, count: {$sum: 1}}},
{$match: {count: {$gt: 1}}},
{$count: "name"}
])

Figura 8. Número de compañías duplicadas por el campo name

Previo a realizar una limpieza se realiza una nueva evaluación pero incluyendo los campos más
relevantes para considerar documentos duplicados. Se obtiene el mismo número de documentos
(907).

db.companies.aggregate([
{$group: {_id: {name: "$name", category_code:"$category_code",
number_of_employees:"$number_of_employees",
tag_list:"$tag_list", email_address:"$email_address",
acquisition:"$acquisition", offices:"$offices",
founded_year:"$founded_year", homepage_url:"$homepage_url"},
count: {$sum: 1}}},
{$match: {count: {$gt: 1}}},
{$count: "name"}
])

Figura 9. Número de compañías duplicadas considerando 9 c ampos

Bases de datos para el Big Data |5

Uso de MongoDB Maria Belén Benalcázar Tovar

Por lo antes expuesto se modifica la consulta anterior para eliminar las compañías duplicadas.

db.companies.aggregate([
{$group: {_id: {name: "$name", category_code:"$category_code",
number_of_employees:"$number_of_employees",
tag_list:"$tag_list", email_address:"$email_address",
acquisition:"$acquisition", offices:"$offices",
founded_year:"$founded_year", homepage_url:"$homepage_url"},
count: {$sum: 1},dups:{$addToSet:"$_id"}}},
{$match: {count: {$gt: 1}}},
]).forEach(function(doc){
doc.dups.shift();
db.companies.remove({
_id:{$in: doc.dups}
})
})

Preguntas del Laboratorio

a. Identifica todas las distintas categorías (categories) de la colección books.

Usando el comando distinct se obtienen las diferentes categorías de la colección books.

Existen 38 categorías de tipo string, incluyendo una categoría vacía.

db.books.distinct("categories")

Figura 10. Consulta del campo categories de la colección books

Bases de datos para el Big Data |6

Uso de MongoDB Maria Belén Benalcázar Tovar

Figura 11. Cuenta del número de categorías

b. Identifica los distintos estados (status) de la colección books.

Existen 2 estados posibles para los libros: MEAP y PUBLISH.

db.books.distinct("status")

Figura 12. Consulta de los distintos estados (status) de la colección books

c. Describe brevemente qué arroja la siguiente consulta:

db.getCollection('books').find({longDescription: {$gte: "A", $lt: "B"}},
{title: 1, longDescription: 1})

La consulta devuelve los campos title y longDescription de la colección books, de los

documentos cuyo campo longDescription inicia con “A”.

db.getCollection('books').find({longDescription: {$gte: "A", $lt: "B"}},

{title: 1, longDescription: 1}).pretty()

Figura 13. Resultado de la consulta de campo longDescription de la colección books.

d. Utiliza la condición de la consulta anterior para recuperar aquellos libros que posean
exactamente 2 autores y que estén publicados. Muestra solo los campos: title,
longDescription, status y authors.

Tomando la condición anterior se añade el filtro solicitado al comando find para ajustarlo a
las condiciones planteadas.

db.getCollection('books').find({longDescription: {$gte: "A", $lt:

"B"},authors: {$size:2},status:"PUBLISH"}, {_id:0, title: 1, longDescription:
1, authors:1, status:1}).pretty()

Bases de datos para el Big Data |7

Uso de MongoDB Maria Belén Benalcázar Tovar

Figura 14. Resultado de la consulta que muestra libros publicados con 2 autores

Figura 15. Resultado de la consulta que muestra libros publicados con 2 autores sin .pretty()

e. Describe brevemente qué ocurre si a la consulta del punto anterior, le añades al final la
siguiente instrucción: .toArray()

La función muestra la colección como un array y esto hace que también se muestre de forma
ordenada, similar al método pretty(). Sin embargo, la ventaja de esta instrucción es que el
resultado podría asignarse a una variable.

db.getCollection('books').find({longDescription: {$gte: "A", $lt:

"B"},authors: {$size:2},status:"PUBLISH"}, {_id:0,title: 1, longDescription:
1, authors:1, status:1}).toArray()

Bases de datos para el Big Data |8

 Uso de MongoDB Maria Belén Benalcázar Tovar

Figura 16. Resultado de la consulta mostrado como array

f. Qué ocurre si también le añades lo siguiente: .forEach(function(valor, indice,

array){print("Titulo: " + valor.title + "Autho 1: " + valor.authors[0] + "
Author 2: " + valor.authors[1] + " Registro No. " + indice);}). ¿Para qué
crees que sería útil esto último?

Al añadir el ultimo código se usa la instrucción forEach de JavaScript para recorrer los
campos de cada documento (elemento) del array y concatenarlos en una cadena de todos los
campos consultados con sus respectivas etiquetas. Esto podría ser útil para presentar los
datos de una forma más clara al usuario.

db.getCollection('books').find({longDescription: {$gte: "A", $lt:

"B"},authors: {$size:2},status:{$eq: "PUBLISH"}}, {_id:0, title: 1,
longDescription: 1, status: 1, authors: 1}).toArray().forEach(function(valor,
indice, array){print("Titulo: " + valor.title + " Autho 1: " +
valor.authors[0] + " Author 2: " + valor.authors[1] + " Registro No. " +
indice);})

Figura 17. Consulta que imprime la concatenación de los campos.

3. Consultas de la colección 1

a. ¿Cuál es el tamaño de la colección (en bytes)?

La colección tiene un tamaño de 516861 bytes, considerando que se eliminaron 2 documentos.

db.books.dataSize()

Bases de datos para el Big Data |9

Uso de MongoDB Maria Belén Benalcázar Tovar

Figura 18. Consulta que muestra el tamaño de la colección books

b. ¿Cuántos libros tiene la colección?

La base de datos tiene 429 libros de los cuales son únicos 427. Dos libros tienen el mismo
nombre, pero distinto isbn.

db.books.count()

Figura 19. Consulta del número de documentos de la colección books

db.books.distinct("title").length

Figura 20. Consulta de los diferentes títulos de libros de la colección books

c. ¿Cuántos libros tienen 200 o más páginas? 264

263 libros de la colección books tienen 200 páginas o más.

db.books.find({pageCount:{$gte:200}}).count()

Figura 21. Consulta que devuelve los libros con 200 o más páginas

d. ¿Cuántos libros tienen entre 300 y 600 páginas? [300, 600]

Existen 215 libros que tienen entre 300 y 600 páginas.

db.books.find({pageCount:{$gte:300,$lte:600}}).count()

Figura 22. Consulta de devuelve los libros que tienen entre 300 y 600 páginas

e. ¿Cuántos libros tienen 0 páginas y cuántos no?

Existen 165 libros con 0 páginas y 264 con número distinto a 0.

db.books.aggregate([
{$facet: {
result1: [
{$match: {pageCount:{$eq:0}}},
{$count:"ZeroPages"},
],
result2: [
{$match: {pageCount:{$ne:0}}},
{$count:"NonZeroPages"},
]

Bases de datos para el Big Data |10

 Uso de MongoDB Maria Belén Benalcázar Tovar

}},
{$project: {
ZeroPages: {$arrayElemAt: ["$result1.ZeroPages", 0]},
NonZeroPages: {$arrayElemAt: ["$result2.NonZeroPages", 0]}
}},
]);

Figura 23. Consulta que devuelve los libros con 0 páginas y las que no

f. ¿Cuántos libros han sido publicados y cuántos no?

Existen 361 libros publicados y 68 no publicados.

db.books.aggregate([{$group:{_id:"$status",count:{$count:{}}}}])

Figura 24. Consulta que devuelve el número de libros publicados y no publicados

4. Consultas de la colección 2

a. ¿Cuál es el tamaño de la colección (en bytes)?

El tamaño de la colección companies es de 69037271 bytes (65.5 MB).

db.companies.dataSize()

Figura 25. Tamaño de la colección companies

b. ¿Cuántas compañías tiene la colección?

La colección tiene 17893 documentos que coindice con el número de compañías únicas.

db.companies.count()

Figura 26. Número de documentos de la colección companies

Bases de datos para el Big Data |11

Uso de MongoDB Maria Belén Benalcázar Tovar

db.companies.distinct("name").length

Figura 27. Compañías distintas de la colección companies

c. ¿Cuántas compañías se fundaron en los años 1996, 1997, 2001 y 2005 respectivamente?

De acuerdo al campo founded_year existen la distribución para los años es la siguiente:

 1996: 207 compañías fundadas.
 1997: 191 compañías fundadas.
 2001: 444 compañías fundadas.
 2005: 910 compañías fundadas.

db.companies.aggregate([
{$facet: {
1996: [
{$match: {"founded_year": {"$eq": 1996}}},
{$count: "1996"}],
1997: [
{$match: {"founded_year": {"$eq": 1997}}},
{$count: "1997"}],
2001: [
{$match: {"founded_year": {"$eq": 2001}}},
{$count: "2001"}],
2005: [
{$match: {"founded_year": {"$eq": 2005}}},
{$count: "2005"}],
}},
{$project: {
"1996": {$arrayElemAt: ["$1996.1996", 0]},
"1997": {$arrayElemAt: ["$1997.1997", 0]},
"2001": {$arrayElemAt: ["$2001.2001", 0]},
"2005": {$arrayElemAt: ["$2005.2005", 0]},
}}
])

Figura 28. Consulta de las compañías fundadas en los años 1996, 1997, 2001 y 2005

Bases de datos para el Big Data |12

Uso de MongoDB Maria Belén Benalcázar Tovar

d. Lista las compañías que se dedican a “web” o “mobile” y recupera: nombre, descripción,
número de empleados, email, año, mes y día de su fundación.

Para mostrar el listado solicitado se filtra por el campo category_code, usando el operador
$or para obtener las dos condiciones.

db.companies.find(
{$or: [{category_code:{$eq:"web"}}, {category_code:{$eq:"mobile"}}]},
{_id:0, name:1, description:1, number_of_employees:1, email_address:1,
founded_year:1, founded_month:1, founded_day:1}).pretty()

Figura 29. Compañías que se dedican a web o mobile.

e. Lista las compañías que se dedican a videojuegos y muéstralas en orden descendente según
el año en que fueron fundadas.

Se usa un filtro en el comando find, evaluando si el campo category_code es “games_video”.

Para ordenar se usa el comando sort y el valor -1 para indicar orden descendente.

db.companies.find({category_code:"games_video"}, {_id:0,name:1,
founded_year:1}).sort({ founded_year:-1 }).pretty()

Figura 30. Compañías dedicadas a videojuegos ordenadas por año de fundación descendente

f. ¿Cuántas compañías tienen 600 o más empleados?

De acuerdo con el resultado de la consulta, 294 compañías tienen 600 empleados o más.

db.companies.find({number_of_employees:{$gte:600}}).count()

Figura 31. Compañías que tienen 600 empleados o más

g. Recupera el nombre, la URL, el usuario de Twitter y el número de empleados de las compañías

c. ¿Alguna empresa se dedica a videojuegos y a la música a la vez?

Bases de datos para el Big Data |13

Uso de MongoDB Maria Belén Benalcázar Tovar

Para la presente consulta se usa un filtro anidado usando los operadores $and y $or. De
acuerdo a los datos de la colección no existe ninguna empresa que se dedique a videojuegos y
a la música a la vez, ya que el campo es de tipo string y no array.

db.companies.find(
{$and:[{
founded_year:{$gte:2001,$lte:2005}},
{number_of_employees:{$gte:500}},
{$or:[
{category_code:{$eq:"games_video"}},{category_code:{$eq:"music"}}
]}]},
{_id:0, name:1, homepage_url:1, twitter_username:1,
number_of_employees:1, category_code:1,founded_year:1}).pretty()

Figura 32. Compañías fundadas entre el 2001 y 2005, con más de 500 empleados

h. Lista las empresas que cuentan con única y exclusivamente 2 oficinas en la ciudad de San
Francisco.

Ya que el campo offices es un array de documentos la opción acertada para la consulta es usar
agregación y evaluar el campo offices.city en miras a obtener la respuesta.

db.companies.aggregate([
{$project:{name:1,_id:0,offices:1,officesNum: {"$size": "$offices" }}},
{$match:{"officesNum": 2}},
{$unwind:"$offices"},
{$match:{"offices.city":"San Francisco"}},
{$group:{_id: "$name" ,cnt: { $sum: 1 }}},
{$match:{ cnt: 2 }},
{$project:{_id:1}}
])

Figura 33. Compañías que tienen únicamente 2 oficinas en San Francisco

La limpieza de datos simplificó esta consulta ya que no es necesario agrupar por name.

Bases de datos para el Big Data |14

 Uso de MongoDB Maria Belén Benalcázar Tovar

i. Lista el nombre, el mes y día de adquisición de las empresas de videojuegos que hayan sido
adquiridas en el año 2007 por un precio igual o superior a los 10 millones de dólares y que
tengan oficinas en la ciudad de Culver City.

Para la consulta solicitada se usa el comando find con un filtro anidado.

db.companies.find(
{$and:[
{category_code:"games_video"},
{offices:{$elemMatch:{city : "Culver City"}}},
{"acquisition.acquired_year" : 2007},
{"acquisition.price_amount" : {$gte:10000000}}
]}
,{name:1,"acquisition.acquired_month":1,"acquisition.acquired_day":1,_id:0}
).pretty()

Figura 34. Compañías de videojuegos de Culver City adquiridas en el 2007 por más de 10M

5. Referencias bibliográficas

MongoDB. (2022). Aggregation — MongoDB Manual. Obtenido de

https://docs.mongodb.com/manual/aggregation/

Bases de datos para el Big Data |15