Introducción a MongoDB para principiantes con Node.js

    Introducción

    En este artículo, vamos a hablar sobre cómo usar el MongoDB base de datos con Node.js. Hay dos formas de hacer esto, incluido el enfoque popular: usar una biblioteca de modelado de objetos. Mangosta es un ejemplo de una biblioteca de este tipo en Node.js, sin embargo, usaremos el controlador oficial de MongoDB para Node.js.

    En este artículo, nos conectaremos a un servidor MongoDB, crearemos documentos, los recuperaremos de la base de datos y finalmente eliminaremos algunos.

    Esto se hará a través de algunos scripts, aunque normalmente los integraría con un servidor web / aplicación en lugar de tenerlos en scripts independientes.

    ¿Qué es MongoDB?

    MongoDB es un sistema de gestión de bases de datos (DBMS) multiplataforma (se ejecuta en varios sistemas operativos). MongoDB también es una base de datos NoSQL, lo que significa que no usa SQL para realizar operaciones en una base de datos.

    MongoDB usa documentos que están en formato similar a JSON, conocido como BSON, que es la codificación binaria de JSON.

    Está desarrollado como un proyecto de código abierto por MongoDB Inc. bajo la licencia pública del lado del servidor.

    Node y MongoDB funcionan muy bien juntos, en parte porque Mongo usa un motor JavaScript integrado en la base de datos, ya que JavaScript es bueno para manejar objetos JSON.

    En comparación con otras bases de datos, como MySQL, MongoDB es rápido para almacenar ciertos tipos de datos y se puede escalar automáticamente. Es muy sencillo de implementar y poner en marcha.

    Dado que Mongo es una base de datos NoSQL, tiene su propia forma de almacenar datos. Estas son algunas de las construcciones que componen la estructura de la base de datos:

    • Base de datos: El contenedor que contiene un conjunto de colecciones.
    • Colección: Un conjunto de documentos. Esto es similar a una tabla en una base de datos SQL. Sin embargo, a diferencia de una base de datos SQL, una colección no tiene una estructura establecida ni tipos de datos preconfigurados.
    • Documentos: Un objeto similar a JSON. Esto es similar a una fila en una base de datos SQL. Un objeto JSON también puede contener objetos secundarios, una matriz, etc.
    • _carné de identidad: Campo único obligatorio en cada documento. Separa un documento de otro, por lo que podemos identificar cada documento de forma independiente. Si no se proporciona este valor, MongoDB asigna automáticamente un valor aleatorio para el campo.

    Configuración del proyecto

    Comencemos con el proyecto y saltemos el npm indicaciones:

    $ npm init -y
    

    Luego, instalemos el controlador oficial de MongoDB:

    $ npm install --save mongodb
    

    Para conectarse realmente a la base de datos, deberá asegurarse de que su servicio MongoDB se esté ejecutando en segundo plano o en su máquina de desarrollo. Ejecuta el comando mongo en su símbolo del sistema para ingresar al shell de Mongo:

    Ejecutando el comando show dbs; presentará una lista de las bases de datos actuales:

    Puede salir del shell ejecutando el exit mando.

    A diferencia de las bases de datos SQL, que requieren la creación de una base de datos antes de su uso, no es necesario crear una base de datos o una colección de antemano. Se crearán automáticamente cuando sea necesario.

    Implementación de operaciones CRUD

    Con nuestro proyecto inicializado y MongoDB instalado, podemos empezar a escribir algo de lógica CRUD.

    Conectarse a la base de datos

    Por supuesto, para usar MongoDB en código, necesitamos importar el módulo:

    const mongodb = require('mongodb');
    

    Luego, creemos una instancia de un cliente:

    const MongoClient = mongodb.MongoClient;
    

    El cliente necesita saber dónde conectarse, por lo que le proporcionaremos un url y dbName:

    // Connection URL
    const url="mongodb://localhost:27017";
    
    // Database Name
    const dbName="userdb";
    

    Finalmente, intentemos conectarnos a la base de datos:

    // Use the connect method to create a connection w/ the database
    MongoClient.connect(url, (err, client) => {
        if (err) {
            throw err;
            return;
        }
    
        console.log('Database connection successful');
    
        // This objects holds the refrence to the db
        const db = client.db(dbName);
    
        client.close();
    });
    

    Si se ha conectado correctamente a la base de datos, debería ver el resultado:

    Database connection successful
    

    De lo contrario, recibirá un mensaje de error. Compruebe si el servidor está en funcionamiento y si el nombre de usuario y la contraseña son correctos en ese caso.

    Como puede ver en el ejemplo, el MongoClient.connect El método toma dos parámetros, la URL de la base de datos y la función de devolución de llamada.

    La función de devolución de llamada tiene dos parámetros: err y client.

    El primer parámetro contendría un error si hay algún problema de red o cualquier otro problema con la conexión a la base de datos. Si no hay problemas, el error será null.

    El segundo parámetro es el objeto cliente, que utilizamos para interactuar con la base de datos.

    los db propiedad de la client contiene una referencia a la base de datos. Para realizar cualquier acción en esa base de datos, usamos esta referencia.

    Crear un documento

    Para realizar cualquier acción en la base de datos, debes estar conectado a ella, obviamente. Con Mongo, hay dos formas de insertar documentos en la base de datos. La primera forma es agregar un solo documento a la vez. Podemos usar el insertOne() método para lograr esto:

    const collection = db.collection('userdb');
    
    // Insert one document
    collection.insertOne({
        firstName: 'john',
        lastName: 'doe',
        age: 21,
        hobbies: [
            'Reading books',
            'Collecting stamps'
        ]
    }, (err, result) => {
        if (err) {
            console.log(err);
            return;
        }
        
        console.log(result.result);
    });
    

    El parámetro de resultado de la devolución de llamada contiene información sobre la consulta. Tiene un campo llamado result que se parece a:

    result: { n: 1, ok: 1 }
    

    n es el número de documentos insertados. ok es el estado del mando.

    No tiene que crear explícitamente una base de datos llamada userdb, o una colección llamada users antes de insertar el documento. La base de datos y la colección se crearán automáticamente.

    El segundo método le permite agregar varios documentos a la vez. Podemos usar el insertMany() método para lograr esto:

    // Insert multiple documents
    collection.insertMany([
        {
            firstName: 'john',
            lastName: 'doe',
            age: 21,
            hobbies: [
                'Reading books',
                'Collecting stamps'
            ]
        }, {
            firstName: 'anna',
            lastName: 'dias',
            age: 20,
            hobbies: []
        }
    ], (err, result) => {
        if (err) {
            console.log(err);
            return;
        }
        
        console.log(result.ops);
    });
    

    Ejecutar este fragmento de código producirá:

    [ { _id: 1,
        firstName: 'john',
        lastName: 'doe',
        age: 21,
        hobbies: [ 'Reading books', 'Collecting stamps' ] },
      { _id: 2,
        firstName: 'anna',
        lastName: 'dias',
        age: 20,
        hobbies: [] } ]
    

    Dado que no hemos definido un _id para cualquiera de estos documentos, podemos buscar el asignado _id desde el result['ops'] objeto si alguna vez necesitamos acceder a la generada _id.

    Además de eso, puede definir el _id usted mismo:

    // Insert one document
    collection.insertOne({
        _id: 'someuniqueid',    // Our specified ID
        firstName: 'john',
        lastName: 'doe',
        age: 21,
        hobbies: [
            'Reading books',
            'Collecting stamps'
        ]
    }, (err, result) => {
        if (err) {
            console.log(err);
            return;
        }
        
        console.log(result.result);
    });
    
    

    Recuperando documentos

    Recuperar todos los documentos

    Primero, veamos cómo obtener todos los documentos de una colección:

    // Find all documents
    collection.find({}).toArray((err, docs) => {
        if (err) {
            throw err;
        }
        console.log(docs)
    });
    

    Ejecutar este fragmento de código nos dará:

    [{ _id: 1,
        firstName: 'john',
        lastName: 'doe',
        age: 21,
        hobbies: [ 'Reading books', 'Collecting stamps' ] },
      { _id: 2,
        firstName: 'anna',
        lastName: 'dias',
        age: 20,
        hobbies: [] } ]
    

    Como puede ver en el ejemplo, hemos pasado un objeto vacío ({}) como la consulta.

    Según la documentación, el toArray() El método devuelve una matriz que contiene todos los documentos de un cursor. El método itera el cursor por completo, carga todos los documentos en la RAM y agota el cursor.

    Los documentos recuperados por la colección serán asignados al docs parámetro en la función de devolución de llamada.

    Buscar documentos con un filtro de consulta

    El siguiente método para encontrar un documento es utilizar un filtro de consulta. Por ejemplo, la siguiente consulta selecciona los usuarios con el nombre john:

    {
        'firstName': 'john'
    }
    

    Y para hacer esto en código:

    collection.find({
        firstName: 'john'
    }).toArray((err, docs) => {
        if (err) {
            throw err;
        }
        console.log(docs)
    });
    

    Este código resultará en:

    [{ _id: 1,
        firstName: 'john',
        lastName: 'doe',
        age: 21,
        hobbies: [ 'Reading books', 'Collecting stamps' ] } ]
    

    Evidentemente, todos los registros con la firstName john se devuelven.

    Actualizar un documento

    La siguiente operación de la que vamos a hablar es la actualización de un documento. Para actualizar un solo documento, similar a recuperar un documento, podemos usar el updateOne() método:

    collection.updateOne(
        // The query filter
        {
            firstName: 'john'
        },
        // The update values
        {
            $set: {
                lastName: 'well',
                edited: true
            }
        },
        (err, result) => {
            if (err) {
                throw err;
            }
            console.log(result.result);
        }
    );
    

    Este código da como resultado:

    { n: 1, nModified: 1, ok: 1 }
    

    Como puede ver en el ejemplo, el updateOne() El método acepta tres parámetros. El primero es el filtro de consultas. El segundo son los valores de actualización. La tercera es la función de devolución de llamada, que acepta el error y los resultados como parámetros.

    Nuevamente, los resultados aquí nos notifican el estado (ok), el número de documentos seleccionados para la actualización (n) y el número de documentos actualizados (nModified).

    n puede ser mayor que nModified, si un campo se actualiza con el valor que ya tenía.

    Usando esta consulta, hemos seleccionado un documento donde el campo firstName es john y hemos cambiado el lastName de ese documento a well. Además, hemos agregado un campo llamado edited y configurarlo como true. Observe cómo no hemos necesitado especificar o seguir ningún esquema durante todo este proceso. Mongo simplemente acepta cualquier dato que le envíe.

    Si está utilizando el updateOne() método, la consulta seleccionará el primer documento con el campo coincidente. Si hay varios documentos con un campo del mismo valor, utilice el updateMany() El método los actualizará todos, lo que en algunos casos puede no ser lo que queremos hacer.

    Nota: Si está utilizando updateOne() , lo ideal es que la consulta solo seleccione un documento. De lo contrario, no podemos predecir el documento que podría actualizarse. Así que tenga esto en cuenta y tenga cuidado al utilizar un filtro de consulta que podría coincidir con varios documentos.

    También podemos editar todos los documentos que cumplan la condición de que el campo firstName es john:

    collection.updateMany(
        // The query filter
        {
            firstName: 'john'
        },
        // The update values
        {
            $set: {
                lastName: 'well',
                edited: true
            }
        },
        (err, result) => {
            if (err) {
                throw err;
            }
            console.log(result.result);
        }
    );
    

    los updateMany() El método es similar al updateOne() , excepto que actualiza todos los documentos que coinciden con el filtro de consulta.

    Eliminar un documento

    Podemos usar el deleteOne() o deleteMany() métodos para eliminar un documento de una colección:

    collection.deleteOne(
        // The query filter
        {
            firstName: 'john'
        },
        (err, result) => {
            if (err) {
                throw err;
            }
            console.log(result.result);
        }
    );
    

    Este código da como resultado:

    { n: 1, ok: 1 }
    

    Nuevamente, de manera similar a los ejemplos anteriores, el primer parámetro aceptado es la consulta de filtro y el segundo parámetro es la función de devolución de llamada. La función de devolución de llamada devuelve un error o un resultado.

    La ejecución de este fragmento de código eliminará un documento que coincida con la consulta, en este caso, un documento en el que firstName el campo es john. Nuevamente, esto solo eliminará el primer documento que coincida con la consulta.

    También puede utilizar el deleteMany método para eliminar todos los documentos seleccionados:

    collection.deleteMany(
        // The query filter
        {
            firstName: 'john'
        },
        (err, result) => {
            if (err) {
                throw err;
            }
            console.log(result.result);
        }
    );
    

    Conclusión

    MongoDB es una popular base de datos NoSQL y liviana que es realmente fácil de implementar y usar con Node. Escribimos una aplicación de node muy simple que interactúa con un MongoDB para crear, recuperar y eliminar colecciones.

    Como siempre, el código fuente está disponible en GitHub.

    Rate this post
    Etiquetas:

    Deja una respuesta

    Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *