Segunda parte: Introducción a MongoDB

Antes de sumergirse en este artículo, es aconsejable revisar la introducción a la base de datos MongoDB disponible en el siguiente link. La lectura mencionada proporcionará un contexto valioso y una base sólida sobre los conceptos iniciales de esta base de datos. En esta ocasión, continuaremos explorando las características de MongoDB, enfocándonos en temas como relaciones, índices, marco de agregaciones y transacciones.

Relaciones

Aunque MongoDB es una base de datos NoSQL y se caracterizan por ser flexibles en cuanto a la estructuración y composición de sus datos, se pueden establecer relaciones entre los datos, no tan estrictos como en una base de datos relaciones, pero cumple con el objetivo de separar o organizar los datos según las entidades o campos definidos. En el caso de MongoDB, se pueden establecer relaciones de la siguiente manera:

Relaciones incrustadas

Esta forma de establecer relaciones se caracteriza por anidar otra estructura como JSON o listas con cualquier tipo de dato dentro del documento padre como se muestra a continuación:

{
    "_id": 1,
    "campo1": "valor1",
    "campo2": {
        "campo3": "valor2",
        "campo4": "valor3"
    }
}

Donde el campo2 alberga una estructura tipo JSON que contiene información como campo3 y campo4. En esta forma de definir relaciones, el campo campo2 representaría otra tabla si se hace la analogía contra una base de datos relacional.

Relaciones por referencias

Esta forma de establecer relaciones se caracteriza por agregar una referencia dentro de una documento como un identificador para representar una serie de datos que se encuentran en otro documento como se muestra a continuación:

//Documento de información 1
{
 "_id": 1,
 "campo1": "valor1",
 "campoReferenciaInformacion2": 1

}

//Documento de información 2
{
 "_id": 1,
 "campo1": "valor1",
 "campo2": "valor2"
}

Donde el documento de información 1 tiene definido un campo nombrado como campoReferenciaInformacion2, cuyo valor es una referencia que apunta a una serie de datos que se encuentran en el documento de información 2.

Nota: En MongoDB se puede establecer relaciones tipo uno a uno, uno a muchos o muchos a muchos.

Índices

Los índices son una funcionalidad poderosa que nos permite optimizar el rendimiento de las consultas. Consiste en estructuras de datos auxiliares que almacenan una gran cantidad de datos a partir de una configuración dada. La aplicación de índices puede afectar las operaciones de creación o modificaciones de datos si no se crean adecuadamente.

En MongoDB, la variedad de índices disponibles es una gran ventaja frente a otra base de datos NoSQL como CassandraDB o DynamoDB, debido a que su aplicabilidad es más restringida. A continuación, se presenta algunos de los tipos de índices disponibles más comunes en MongoDB:

Índice de campo único

índice que permite tomar como referencia un campo para realizar consultas a una determinada colección. Para crear un índice de este tipo, usaremos el siguiente comando:

db.my_collection.createIndex({
    campo1: 1
});

Índice de campo compuesto

índice que permite tomar como referencia varios campos para realizar consultas a una determinada colección. Para crear un índice de este tipo, usaremos el siguiente comando:

db.my_collection.createIndex({ 
    campo1: 1, 
    campo2: -1 
})

Donde el valor de 1 representa que los datos se ordenarán de forma ascendente y -1 de forma descendente.

Cabe destacar que el orden de la definición de los campos es importante debido a que este índice se basa en un prefijo para poder ser efectivo su aplicación. Además, se puede aplicar el índice solo definiendo primer campo, pero no si se define el segundo campo.

Nota: Se pueden asociar hasta 32 campos en un índice compuesto.

Índice de campo parcial

índice que permite tomar como referencia un campo para realizar consultas a una determinada colección, pero a diferencia del primer índice, agregar un condicional como configuración adicional. Para crear un índice de este tipo, usaremos el siguiente comando:

db.my_collection.createIndex(
    { campo1: 1 },
    { partialFilterExpression: { campo2: true } }
)

Donde el primer argumento indica que es un índice único. Sin embargo, si nos fijamos en el segundo argumento, se está estableciendo un condicional en el campo2 con un cierto valor.

Marco de agregación

También conocido como aggregation framework, es una poderosa herramienta que nos ofrece MongoDB para realizar procesamiento de datos de forma más simple y eficiente. A continuación, se presenta las principales características:

• Pipeline de agregación.
• Operadores agregados.
• Optimizado para grandes volúmenes de datos.

El marco de agregación nos ofrece los siguientes operadores:

Operador match

Se utiliza para filtrar documentos antes de pasar a las etapas de agregación subsiguientes. A continuación, se muestra un ejemplo de su uso:

db.my_collection.aggregate([{
    $match: {
        campo1: { $regex: /valor1/i }
    }
}])

Descomponiendo el comando, queda de la siguiente manera:

1. La función aggregate indica que se van a ejecutar una serie de operadores.
2. El operador $match indica que se va a realizar una operación de filtrado exacto sobre el campo1.
3. Finalmente, el operador $regex indica que se va a filtrar los valores del campo mediante una expresión regular.

Operador group

Agrupa documentos según un campo específico y permite realizar operaciones de agregación en esos grupos. A continuación, se muestra un ejemplo de su uso:

db.my_collection.aggregate([
    {
        $group: {
            _id: "$campo1",
            campo2: { $sum: "campo3" }
        }
    }
])

Descomponiendo el comando, queda de la siguiente manera:

1. La función aggregate indica que se van a ejecutar una serie de operadores.
2. El operador $group indica que se va a realizar una operación de agrupación mediante el campo1 de cada documento.
3. Finalmente, el campo2 contiene el operador $sum que suma todos los valores del campo3 que hay en cada documento dentro de una colección.

Operador project

Permite dar forma a los documentos, incluyendo, excluyendo o modificando campos durante la etapa de agregación. A continuación, se muestra un ejemplo de su uso:

db.my_collection.aggregate([
    {
        $project: {
            _id: 1,
            campo1: 1,
            campo2: 1,
            campo3: 1,
            campo4: { $multiply: ["$campo5", "$campo6"] }
        }
    }
])

Descomponiendo el comando, queda de la siguiente manera:

1. La función aggregate indica que se van a ejecutar una serie de operadores.
2. El operador $project indica que solo unos ciertos campos se van a retornar en la respuesta.
3. Finalmente, el operador $mutiply va a realizar una operación de multiplicación entre campo5 y campo6. Dicho resultado se almacena en el campo4.

Operador sort

Se utiliza para ordenar los documentos en una etapa de agregación. A continuación, se muestra un ejemplo de su uso:

db.my_collection.aggregate([
    {
        $sort: { campo1: -1 }
    },
    {
        $limit: 3
    }
])

Descomponiendo el comando, queda de la siguiente manera:

1. La función aggregate indica que se van a ejecutar una serie de operadores.
2. El operador $sort indica que se va a organizar el resultado de acuerdo a un campo y si será ascendente o descendente según como se configure.
3. Finalmente, el operador $limit va a realizar una operación para limitar los resultados.

Operador facet

Se utiliza para ejecutar varias operaciones de agregación al mismo tiempo. A continuación, se muestra un ejemplo de su uso:

db.my_collection.aggregate([
    {
        $facet: {
            "campo1": [
                {
                    $count: "campo2"
                }
            ],
            "campo3": [
                {
                    $group: {
                        _id: "$campo4", campo5: {
                            $push: "$campo6"
                        }
                    }
                },
                {
                    $project: {
                        campo4: "$_id", campo5: 1, _id: 0
                    }
                }
            ]
        }
    }
])

Descomponiendo el comando, queda de la siguiente manera:

1. La función aggregate indica que se van a ejecutar una serie de operadores.
2. El operador $facet indica que se va a ejecutar varias operaciones en paralelo
3. El contenido dentro del campo1 es el primer subflujo que se va a ejecutar y trata de contar cuántos documentos hay de acuerdo a un campo determinado.
4. El contenido dentro del campo3 es el segundo subflujo que se va a ejecutar y trata de agrupar un resultado de varios documentos mediante el campo4 y se realiza una acumulación en el campo5 mediante el campo6 usando el operador $push. Finalmente, se realiza una proyección obteniendo solo el campo4 y campo5 y se ignora el _id de cada documento.

Operador lookup

Se utiliza para vincular documentos de una colección con documentos de otra colección, dicha vinculación se hace mediante un campo que tenga los documentos involucrados(usualmente una clave foránea o identificador). A continuación, se muestra un ejemplo de su uso:

db.my_collection.aggregate([
    {
        $lookup: {
            from: "coleccion1",
            localField: "coleccionOrigenCampo1",
            foreignField: "coleccionDestinoCampo2",
            as: "resultadoColeccionDestino"
        }
    },
    {
        $unwind: "$resultadoColeccionDestino"
    }
])

Descomponiendo el comando, queda de la siguiente manera:

1. La función aggregate indica que se van a ejecutar una serie de operadores.
2. El operador $lookup indica que se va a unir mas información proveniente de otro documento de otra colección
3. el operador $lookup cuenta con los siguientes parámetros:

• from: indica el nombre de la colección destino.
• localField: indica un campo de la colección origen y que representa el identificador o clave foránea que está ligada al id de algún documento de la colección destino.
• foraingKey: indica el identificador de los documentos de la colección de destino que harán match con el localField.
• as: indica el nombre del campo que contendrá la información adicional proveniente de la otra colección.

Finalmente, el operador $unwind cambia el formato del campo que contiene la información adicional de la otra colección para que sea un objeto normal. Este operador es opcional.

Transacciones

Las transacciones se definen como una serie de operaciones consistentes que se ejecutan secuencialmente. En un principio, MongoDB no garantizaba que las transacciones se realizarán para diferentes colecciones, pero este problema se soluciono desde la versión 4.0.

Además, MongoDB tiene la capacidad de realizar transacciones distribuidas cuando hay varios nodos o servidores. A continuación, se mostrará dos ejemplos de transacciones con MongoDB:

Transacción no distribuida

session.startTransaction();
try {
    db.mi_coleccion_1.updateOne({ campo1: "valor1", campo2: { $gte: "valor2" } }, { $inc: { campo3: "valor3" } });
    db.mi_coleccion_2.insertOne({
        campo1: "valor1",
        campo2: "valor2",
        campo3: "valor3",
        fecha: new Date()
    });
    session.commitTransaction();
} catch (error) {
    session.abortTransaction();
    print("Error en la transacción")
}

Transacción distribuida

session.startTransaction({
    readConcern: { level: "snapshot" },
    writeConcern: { w: "majority" }
});
try {
    db.mi_coleccion_1.updateOne({ campo1: "valor1", campo2: { $gte: "valor2" } }, { $inc: { campo3: "valor3" } });
    db.mi_coleccion_2.insertOne({
        campo1: "valor1",
        campo2: "valor2",
        campo3: "valor3",
        fecha: new Date()
    });
    session.commitTransaction();
} catch (error) {
    session.abortTransaction();
    print("Error en la transacción")
}

Como se observa en los dos bloques de código, se realiza una operación de inserción y otra de actualización, todo esto encapsulado mediante un bloque try-catch y una función llamada session. Por otro lado, hay una leve diferencia entre los dos bloques de código y es con respecto a la manera en que se inicia una transacción. Para una transacción distribuida, se debe configurar los parámetros:

1. readConcern: este parámetro garantiza que la lectura de los datos durante la ejecución de una transacción sea consistente durante este proceso. En este ejemplo, está configurado como snapshot, esto significa que se creará una copia de los datos actuales y se usará esa copia para obtener datos durante la transacción.
2. writeConcern: este parámetro garantiza la confirmación de la escritura de los datos durante una transacción. En este ejemplo, está configurado como majority, esto significa que todos los nodos de una base de datos MongoDB deben confirmar los cambios para que la transacción sea considerada exitosa.

Nota: Hay diferentes configuraciones para definir la manera de iniciar una transacción. Se anexará en la sesión de referencias un enlace para revisar las diferentes configuraciones.

Conclusiones

1. MongoDB ofrece la posibilidad de establecer relaciones ya sea de manera incrustada o por medio de referencias.
2. MongoDB cuenta con una herramienta llamada marco de agregaciones que permite concatenar diferentes tipos de operadores, dando como resultado un flujo de transformación de datos muy potente.
3. MongoDB ofrece diferentes tipos de índices, potenciando sus capacidades de lectura.
4. MongoDB cuenta con diferentes configuraciones para realizar transacciones entre diferentes colecciones.

Referencias

1. https://www.mongodb.com/docs/manual/indexes/
2. https://www.mongodb.com/docs/manual/applications/data-models-relationships/
3. https://platzi.com/blog/mongodb-aggregation-framework-ejemplos-y-ejercicios/
4. https://www.geeksforgeeks.org/mongodb/transaction-in-mongodb/