Iara  Simões

Iara Simões

1658793420

Cómo usar Sequelize con Node y MySQL

Aprenda a instalar y configurar Sequelize con MySQL. Uso de Sequelize para crear bases de datos y modelos, así como realizar operaciones de inserción, selección, eliminación y más 

Sequelize es un mapeador relacional de objetos basado en Node.js que facilita el trabajo con bases de datos MySQL , MariaDB , SQLite , PostgreSQL y más. Un mapeador relacional de objetos realiza funciones como manejar registros de bases de datos al representar los datos como objetos. Sequelize tiene un poderoso mecanismo de migración que puede transformar esquemas de bases de datos existentes en nuevas versiones. En general, Sequelize brinda un excelente soporte para la sincronización de bases de datos, la carga rápida, las asociaciones, las transacciones y las migraciones de bases de datos, al tiempo que reduce el tiempo de desarrollo y evita las inyecciones de SQL.

En este tutorial, instalará y configurará Sequelize con MySQL en su entorno de desarrollo local. A continuación, utilizará Sequelize para crear bases de datos y modelos, así como para realizar las operaciones insert, selecty delete. Luego, creará asociaciones Sequelize para relaciones uno a uno , uno a muchos y muchos a muchos . Por último, creará consultas sin formato Sequelize para reemplazos de matrices y objetos.

Este tutorial se probó en Node.js versión 14.17.6 y npmversión 6.14.15 en macOS Catalina.

Paso 1: Instalación y configuración de Sequelize

En este paso, instalará Sequelize y creará la conexión a su base de datos MySQL. Para hacerlo, primero creará una aplicación Node.js. Luego, instalará Sequelize, configurará la base de datos MySQL y desarrollará una aplicación simple.

Instalación de Sequelize

Comience creando una carpeta de proyecto. En este ejemplo, puede utilizar hello-world. Una vez que se crea la carpeta, navegue a la carpeta usando la terminal:

mkdir hello-world
cd hello-world

Luego, cree una aplicación Node.js de muestra con el siguiente comando:

npm init

A continuación, se le pedirá que responda algunas preguntas de configuración. Utilice el siguiente resultado para su configuración. Presione ENTERpara usar el valor predeterminado que se muestra y asegúrese de configurar el punto de entrada principal como server.js. Esto crea una estructura de proyecto que es fácil de mantener.

La salida se verá de la siguiente manera, que llenará el package.jsonarchivo:

{
  "name": "hello-world",
  "version": "1.0.0",
  "description": "",
  "main": "server.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "",
  "license": "ISC"
}

A continuación, cree un server.jsarchivo vacío dentro de la carpeta del proyecto:

touch server.js

Después de seguir los pasos anteriores, la estructura de carpetas final se verá así:

hello-world/
├─ package.json
├─ server.js

Ahora puedes instalar Sequelize con el siguiente comando:

npm i sequelize@6.11.0

Nota: este comando instala la versión 6.11.0. Si necesita instalar la última versión, ejecute npm i sequelize.

Después de estas actualizaciones, el package.jsonarchivo ahora se ve así:

{
  "name": "hello-world",
  "version": "1.0.0",
  "description": "",
  "main": "server.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "start": "node server.js"
  },
  "author": "",
  "license": "ISC",
  "dependencies": {
    "sequelize": "^6.11.0"
  }
}

En la dependenciessección, ahora verá una dependencia Sequelize.

Ha configurado el proyecto e instalado Sequelize. A continuación, creará una base de datos de muestra a la que conectarse.

Creación de una base de datos de muestra

Como parte de los requisitos previos, instaló y configuró MySQL, lo que incluyó la creación de un usuario. Ahora creará una base de datos vacía.

Para hacerlo, primero debe iniciar sesión en su instancia de MySQL. Si está ejecutando de forma remota, puede usar su herramienta preferida. Si está utilizando una instancia de MySQL que se ejecuta localmente, puede usar el siguiente comando, reemplazando your_username con su nombre de usuario de MySQL:

mysql -u your_username -p

-ues nombre de usuario y la -popción se pasa si la cuenta está protegida con una contraseña.

El servidor MySQL le pedirá la contraseña de su base de datos. Escribe tu contraseña y presiona ENTER.

Una vez que haya iniciado sesión, cree una base de datos llamada hello_world_dbcon el siguiente comando:

CREATE DATABASE hello_world_db;

Para verificar si ha creado la base de datos con éxito, puede usar este comando:

SHOW DATABASES;

Tu salida será similar a esta:

+--------------------+
|      Database      |
+--------------------+
| hello_world_db     |
| information_schema |
| mysql              |
| performance_schema |
| sys                |
+--------------------+

Después de crear la base de datos de muestra, desconéctese del servidor MySQL:

mysql> QUIT

Ahora, debe instalar un controlador manual para la base de datos que elija. Como Sequelize solo proporciona funciones de ORM, no incluye controladores de base de datos integrados. Por lo tanto, deberá instalar los controladores según sus preferencias. Para hacer eso, navegue al directorio del proyecto usando la terminal e instale el controlador MySQL en el proyecto usando el siguiente comando:

npm install --save mysql2

En este caso, está utilizando el controlador para MySQL.

Nota: Dado que este tutorial usa MySQL como base de datos, está usando un controlador para eso. Dependiendo de su base de datos, puede instalar manualmente el controlador de la siguiente manera:

  • npm install --save pg pg-hstore # Postgres
  • npm install --save mysql2
  • npm install --save mariadb
  • npm install --save sqlite3
  • npm install --save tedious # Microsoft SQL Server

Ahora que tiene una base de datos de muestra, puede crear su primera aplicación Sequelize con conectividad de base de datos.

Conexión a la base de datos MySQL

En esta sección, conectará la aplicación Node.js a la base de datos MySQL mediante Sequelize.

Para conectarse a la base de datos, abra server.jspara editar usando nanoo su editor de código preferido:

nano server.js

Aquí, creará una conexión de base de datos en su aplicación utilizando una instancia de Sequelize. En el new Sequelize()método, pase los parámetros del servidor MySQL y las credenciales de la base de datos de la siguiente manera, reemplazando DATABASE_USERNAMEy DATABASE_PASSWORDcon las credenciales de su usuario MySQL:

const Sequelize = require("sequelize");
const sequelize = new Sequelize(
 'hello_world_db',
 'DATABASE_USERNAME',
 'DATABASE_PASSWORD',
  {
    host: 'DATABASE_HOST',
    dialect: 'mysql'
  }
);

hostes donde se aloja el servidor MySQL, por lo que deberá proporcionar una URL del servidor o una dirección IP. Si está utilizando un servidor MySQL instalado localmente, puede reemplazarlo DATABASE_HOSTcon localhosto 127.0.0.1como valor.

Del mismo modo, si está utilizando un servidor remoto, asegúrese de reemplazar los valores de conexión de la base de datos en consecuencia con los detalles del servidor remoto apropiado.

Nota: si está utilizando cualquier otro software de servidor de base de datos, puede reemplazar el parámetro de dialecto según corresponda. `dialecto: 'mysql', 'mariadb', 'postgres', 'mssql'.

A continuación, llame a un método basado en promesas para instanciar una conexión de base de datos a la aplicación. authenticate()Para hacer eso, agregue el siguiente bloque de código a su server.jsarchivo:

...

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

El authenticate()método se utiliza para conectarse con la base de datos y comprueba si las credenciales proporcionadas son correctas. Aquí, la conexión de la base de datos está abierta de forma predeterminada y se puede utilizar la misma conexión para todas las consultas. Siempre que necesite cerrar la conexión, llame al sequelize.close()método después de esta authenticate()llamada. Para obtener más información sobre Sequelize, consulte su guía de inicio .

La mayoría de los métodos proporcionados por Sequelize son asincrónicos. Eso significa que puede ejecutar procesos en su aplicación mientras un bloque de código asíncrono está en su tiempo de ejecución. Además, después de la ejecución exitosa del bloque de código asíncrono, devuelve una promesa , que es el valor devuelto al final de un proceso. Por lo tanto, en bloques de código asincrónico, puede usar then(), catch()y finally()para devolver los datos procesados.

En este punto, el server.jsarchivo tendrá el siguiente aspecto:

const Sequelize = require("sequelize");

const sequelize = new Sequelize(
   'hello_world_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
  );

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

Guarde y cierre su archivo.

En el directorio del proyecto, ejecute la server.jsaplicación ejecutando el siguiente comando:

node server.js

Su salida se verá así:

Output
Connection has been established successfully!

Ha creado la conexión a la base de datos con éxito.

En este paso, instaló Sequelize, creó una base de datos de muestra y usó Sequelize para conectarse con la base de datos. A continuación, trabajará con modelos en Sequelize.

Paso 2: Crear una tabla de base de datos usando Sequelize

Ahora que ha creado una base de datos MySQL de muestra, puede usar Sequelize para crear una tabla y llenarla con datos. En Sequelize, las tablas de la base de datos se conocen como modelos . Un modelo es una abstracción que representa una tabla de la base de datos. Los modelos definen varias cosas para Sequelize, como el nombre de la tabla, los detalles de la columna y los tipos de datos. En este paso, creará un modelo Sequelize para datos de libros.

Para comenzar, cree un nuevo archivo llamado book.model.jsen el directorio del proyecto:

nano book.model.js

Similar al paso anterior, agregue un código Sequelize para el inicio de la base de datos con una nueva importación DataTypesen la parte superior del archivo:

const { Sequelize, DataTypes } = require("sequelize");

Sequelize contiene muchos tipos de datos integrados. Para acceder a esos tipos de datos, agrega una importación para DataTypes. Este tutorial hace referencia a algunos tipos de datos de uso frecuente, como STRING, INTEGERy DATEONLY. Para obtener más información sobre otros tipos de datos admitidos, puede consultar la documentación oficial de Sequelize .

Luego, incluye las líneas que usaste anteriormente para crear una conexión a tu base de datos MySQL, actualizando tus credenciales de MySQL en consecuencia:

...

const sequelize = new Sequelize(
   'hello_world_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
  );

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

A continuación, creará un modelo denominado books, que incluye title, author, release_datee subjectID. Para hacer eso, use el sequelize.define()método como se muestra:

...

const Book = sequelize.define("books", {
   title: {
     type: DataTypes.STRING,
     allowNull: false
   },
   author: {
     type: DataTypes.STRING,
     allowNull: false
   },
   release_date: {
     type: DataTypes.DATEONLY,
   },
   subject: {
     type: DataTypes.INTEGER,
   }
});

El sequelize.define()método define un nuevo modelo, que representa una tabla en la base de datos. Este bloque de código crea una tabla llamada booksy almacena los registros contables de acuerdo con title, author, release_datey subject.

En este código, allowNullmuestra que el valor de la columna del modelo no puede ser null. Del mismo modo, si necesita establecer dicho valor, puede usar defaultValue: "value".

A continuación, agregará el bookmodelo a su base de datos. Para hacer eso, usará el sync()método de la siguiente manera:

...

sequelize.sync().then(() => {
   console.log('Book table created successfully!');
}).catch((error) => {
   console.error('Unable to create table : ', error);
});

En el sync()método, le pide a Sequelize que haga algunas cosas en la base de datos. Con esta llamada, Sequelize realizará automáticamente una consulta SQL a la base de datos y creará una tabla, imprimiendo el mensaje Book table created successfully!.

Como se mencionó, el método sync() es un método basado en promesas, lo que significa que también puede realizar el manejo de errores. En este bloque de código, verificará si la tabla se creó correctamente. De lo contrario, devolverá un error a través del método catch y lo imprimirá en la salida.

Nota: Puede administrar la sincronización del modelo pasando forceparámetros para forzar la creación de una nueva tabla si no existe, o bien usar una existente. Aquí hay algunos ejemplos, que pueden serle útiles mientras trabaja con Sequelize:

  • model.sync(): Esto crea la tabla si aún no existe.
  • model.sync({ force: true }): Esto crea la tabla soltándola si ya existe la misma tabla.

El código final se verá así:

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'hello_world_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
  );

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

const Book = sequelize.define("books", {
   title: {
     type: DataTypes.STRING,
     allowNull: false
   },
   author: {
     type: DataTypes.STRING,
     allowNull: false
   },
   release_date: {
     type: DataTypes.DATEONLY,
   },
   subject: {
     type: DataTypes.INTEGER,
   }
});

sequelize.sync().then(() => {
   console.log('Book table created successfully!');
}).catch((error) => {
   console.error('Unable to create table : ', error);
});

Guarde y cierre su archivo.

Ejecute su aplicación usando el siguiente comando:

node book.model.js

Obtendrá el siguiente resultado en su línea de comando:

Output
Executing (default): SELECT 1+1 AS result
Executing (default): CREATE TABLE IF NOT EXISTS `books` (`id` INTEGER NOT NULL auto_increment , `title` VARCHAR(255) NOT NULL, `author` VARCHAR(255) NOT NULL, `release_date` DATE, `subject` INTEGER, `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL, PRIMARY KEY (`id`)) ENGINE=InnoDB;
Connection has been established successfully.
Executing (default): SHOW INDEX FROM `books`
Book table created successfully!

En el resultado, verá que el registro de devolución contiene el mensaje Book table created successfully!. Puede verificar esto revisando su base de datos para ver la nueva bookstabla creada en la base de hello_world_dbdatos.

Para verificar la creación de la nueva tabla, inicie sesión en su instancia de MySQL:

mysql -u YOUR_USERNAME -p

Después de ingresar su contraseña, cambie a la base de datos de muestra:

USE hello_world_db;

Y luego ejecute el comando para mostrar las tablas:

SHOW TABLES;

Tu salida será similar a esta:

+---------------------------+
| Tables_in_hello_world_db |
+---------------------------+
| books                     |
+---------------------------+
1 row in set (0.00 sec)

Finalmente, desconéctese del servidor MySQL:

mysql> QUIT

Ha verificado que la bookcreación del modelo fue exitosa. Usando este proceso, puede crear cualquier número de modelos siguiendo el mismo procedimiento.

En este paso, creó un modelo en una base de datos e inició el trabajo con un modelo utilizando métodos integrados. También usó tipos de datos compatibles con Sequelize para definir su modelo. A continuación, trabajará con consultas de modelos básicos.

Paso 3: Uso de Sequelize para consultas de bases de datos

En este paso, utilizará las consultas integradas de Sequelize para inserción, selección, selección con cláusulas condicionales y eliminación.

Insertar un nuevo registro

En el paso anterior, creó un bookmodelo dentro de la base de datos. En esta sección, insertará datos en este modelo.

Para comenzar, copie el contenido del book.model.jspaso anterior. Cree un nuevo archivo llamado book.controller.jspara manejar la lógica de consulta. Agregue el código de book.model.jsa book.controller.js.

En book.controller.js, busque el sync()método. En el sync()método, agregue las siguientes líneas resaltadas:

...

sequelize.sync().then(() => {
   console.log('Book table created successfully!');

   Book.create({
       title: "Clean Code",
       author: "Robert Cecil Martin",
       release_date: "2021-12-14",
       subject: 3
   }).then(res => {
       console.log(res)
   }).catch((error) => {
       console.error('Failed to create a new record : ', error);
   });

}).catch((error) => {
   console.error('Unable to create table : ', error);
});

Aquí, inserta un nuevo registro de libro en el booksmodelo que ya ha creado utilizando el sync()método, que admite agregar nuevos registros a modelos creados previamente. Una vez que el método sync() se ejecuta con éxito, ejecuta el then()método. Dentro del then()método, llamas create()al método para insertar los nuevos registros en el modelo.

Utiliza el create()método para pasar los datos que necesita agregar a la base de datos como un objeto. La sección resaltada del código insertará una nueva entrada en su bookstabla existente. En este ejemplo, agrega Clean Codepor Robert Cecil Martin, que se ha categorizado con el subjectID de 3. Puede usar el mismo código, actualizado con información de otros libros, para agregar nuevos registros a su base de datos.

Guarde y cierre el archivo.

Ejecute la aplicación usando el siguiente comando:

node book.controller.js

Su salida será similar a la siguiente:

Output
books {
  dataValues:
   { id: 1,
     title: 'Clean Code',
     author: 'Robert Cecil Martin',
     release_date: '2021-12-14',
     subject: 3,
     updatedAt: 2021-12-14T10:12:16.644Z,
   ...
}

Insertó un nuevo registro en el modelo que creó en la base de datos. Puede continuar agregando varios registros utilizando el mismo proceso.

Selección de todos los registros

En esta sección, seleccionará y obtendrá todos los registros contables de la base de datos utilizando el findAll()método. Para hacer eso, primero abra book.controller.jsy elimine el Book.create()método anterior. En el sync()método, agregue el Book.findAll()método como se muestra:

...

sequelize.sync().then(() => {

    Book.findAll().then(res => {
        console.log(res)
    }).catch((error) => {
        console.error('Failed to retrieve data : ', error);
    });

}).catch((error) => {
    console.error('Unable to create table : ', error);
});

...

Guarde y cierre el archivo.

A continuación, vuelva a ejecutar la aplicación con el siguiente comando:

node book.controller.js

Su salida será similar a la siguiente:

Output
[
  books {
    dataValues: {
      id: 1,
      title: 'Clean Code',
      author: 'Robert Cecil Martin',
      release_date: '2020-01-01',
      subject: 3,
      createdAt: 2021-02-22T09:13:55.000Z,
      updatedAt: 2021-02-22T09:13:55.000Z
    },
    _previousDataValues: {
      id: 1,
      title: 'Clean Code',
      author: 'Robert Cecil Martin',
      release_date: '2020-01-01',
      subject: 3,
      createdAt: 2021-02-22T09:13:55.000Z,
      updatedAt: 2021-02-22T09:13:55.000Z
    },
...
]

La salida contiene todos los datos del libro como un objeto de matriz. Usó con éxito el método Sequelize findAll()para devolver todos los datos de libros de la base de datos.

Seleccionar con la wherecláusula

En esta sección, seleccionará valores con condiciones utilizando la wherecláusula. La wherecláusula se utiliza para especificar una condición al obtener datos. Para este tutorial, obtendrá un libro por un ID de registro específico de la base de datos utilizando el findOne()método.

Para hacer eso, abra book.controller.jspara editar, elimine el findAll()método y agregue las siguientes líneas:

...

sequelize.sync().then(() => {

    Book.findOne({
        where: {
            id : "1"
        }
    }).then(res => {
        console.log(res)
    }).catch((error) => {
        console.error('Failed to retrieve data : ', error);
    });

}).catch((error) => {
    console.error('Unable to create table : ', error);
});

Aquí, selecciona un registro de libro específico de la base de datos utilizando el findOne()método con la whereopción. En este ejemplo, está recuperando los datos del libro cuyo ides igual a 1.

Guarde y cierre el archivo.

A continuación, ejecute la aplicación:

node book.controller.js

Su salida será similar a la siguiente:

Output
books {
  dataValues: {
    id: 1,
    title: 'Clean Code',
    author: 'Robert Cecil Martin',
    release_date: '2020-01-01',
    subject: 'Science',
    createdAt: 2021-02-22T09:13:55.000Z,
    updatedAt: 2021-02-22T09:13:55.000Z
  },
  ...
}

Ha utilizado con éxito wherecláusulas para obtener datos de los modelos de Sequelize. Puede utilizar la wherecláusula en la aplicación de la base de datos para capturar datos condicionales.

Eliminación de un registro

Para eliminar un registro específico del modelo de base de datos, utilice el destroy()método con la whereopción. Para hacerlo, abra book.controller.js, elimine el findOne()método y agregue las siguientes líneas resaltadas:

...
sequelize.sync().then(() => {

  Book.destroy({
      where: {
        id: 2
      }
  }).then(() => {
      console.log("Successfully deleted record.")
  }).catch((error) => {
      console.error('Failed to delete record : ', error);
  });

}).catch((error) => {
    console.error('Unable to create table : ', error);
});

Aquí, elimina un registro de libro de la base de datos utilizando el destroy()método con la whereopción y pasando el iddel libro para eliminar. Vas a quitar el registro del libro cuyos idiguales 2.

Guarde y cierre el archivo.

A continuación, ejecute la aplicación:

node book.controller.js

Su salida se verá como la siguiente:

Output
Successfully deleted record.

El registro ha sido eliminado.

En este paso, experimentó con su modelo de base de datos y consulta de modelos. Usted inició la base de datos, creó modelos, insertó registros, recuperó registros, recuperó registros con condiciones utilizando la wherecláusula y eliminó registros seleccionados. Con este conocimiento de Sequelize, ahora creará asociaciones en Sequelize. Después de eso, podrá definir y trabajar con una variedad de relaciones usando modelos Sequelize.

Paso 4: crear asociaciones usando Sequelize

En este paso, utilizará los tipos de asociación estándar que admite Sequelize: asociaciones de uno a uno , de uno a muchos y de muchos a muchos . Utilizará datos de muestra sobre estudiantes, cursos y niveles de grado.

Sequelize utiliza tipos de asociación basados ​​en las siguientes relaciones de base de datos:

Relación uno a uno : una relación uno a uno significa que un registro en una tabla está asociado con exactamente un registro en otra tabla. En términos de Sequelize, puede usarbelongsTo()yhasOne()asociaciones para crear este tipo de relación.

Relación de uno a muchos : una relación de uno a muchos significa que un registro en una tabla está asociado con varios registros en otra tabla. Con Sequelize, puede usarhasMany()métodos de asociación para crear este tipo de relación.

Relación de muchos a muchos : una relación de muchos a muchos significa que múltiples registros en una tabla están asociados con múltiples registros en otra tabla. Con Sequelize, puede usarbelongsToMany()asociaciones para crear este tipo de relación.

Antes de crear estas asociaciones, primero creará una nueva base de datos llamada student_dby agregará nuevos modelos y algunos datos de muestra para estudiantes, cursos y nivel de grado.

Para crear la base de datos, siga el mismo proceso en el Paso 1: Instalar y configurar Sequelize para iniciar sesión en MySQL y crear una base de datos llamada student_db. Una vez que se haya creado la nueva base de datos, cierre la sesión de MySQL. A continuación, comenzará a crear asociaciones de bases de datos.

Crear una relación uno a uno conbelongsTo()

En esta sección, creará una relación uno a uno usando modelos Sequelize. Imagine que desea obtener los detalles de un estudiante junto con su nivel de grado. Dado que un estudiante solo puede tener un nivel de grado, este tipo de asociación es una relación de uno a uno y puede usar el belongsTo()método.

Nota: Hay una diferencia entre belongsTo()y hasOne(). belongsTo()agregará el foreignKeyen la tabla de origen, mientras hasOne()que lo agregará a la tabla de destino. En cualquier caso, si se utilizan ambas relaciones a la vez, funcionará como Sequelize relaciones uno a uno bidireccionales.

El belongsTo()método le permite crear una relación uno a uno entre dos modelos de Sequelize. En este ejemplo, está utilizando los modelos Studenty .Grade

Cree un nuevo archivo llamado one_to_one.js. Como hizo en la sección anterior, Conexión a la base de datos MySQL , incluya las líneas para crear una conexión a la base de datos y autentique a su usuario MySQL en la parte superior del archivo. Asegúrese de actualizar las credenciales de MySQL según sea necesario:

const { Sequelize, DataTypes } = require("sequelize");

const sequelize = new Sequelize(
   'student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
  );

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

En esta sección, creará tres modelos en la nueva base de student_dbdatos: Student, Gradey Course. Comenzará creando los modelos Studenty . GradeMás adelante en este paso, creará el Coursesmodelo.

Para el Studentmodelo, agregue el siguiente bloque de código a one_to_one.js:

...
const Student = sequelize.define("students", {
   student_id: {
       type: DataTypes.UUID,
       defaultValue: DataTypes.UUIDV4,
       primaryKey: true,
   },
   name: {
       type: DataTypes.STRING,
       allowNull: false
   }
});

Este modelo de estudiante contiene dos columnas: student_idy name.

A continuación, agregue un bloque de código para el Grademodelo:

...
const Grade = sequelize.define("grades", {
   grade: {
       type: DataTypes.INTEGER,
       allowNull: false
   }
});

El Grademodelo contiene la columna grade.

Para demostrar las asociaciones, deberá agregar datos de muestra a la base de datos. Para eso, usarás el bulk()método. En lugar de insertar datos en las filas una por una, el bulkCreate()método le permite insertar varias filas en los modelos de su base de datos a la vez.

Así que ahora, importe los datos Gradey Studenta sus respectivos modelos en la base de datos como se muestra:

...
const grade_data = [{grade : 9}, {grade : 10}, {grade : 11}]

const student_data = [
   {name : "John Baker", gradeId: 2},
   {name : "Max Butler", gradeId: 1},
   {name : "Ryan Fisher", gradeId: 3},
   {name : "Robert Gray", gradeId: 2},
   {name : "Sam Lewis", gradeId: 1}
]

sequelize.sync({ force: true }).then(() => {
   Grade.bulkCreate(grade_data, { validate: true }).then(() => {
       Student.bulkCreate(student_data, { validate: true }).then(() => {
           …
       }).catch((err) => { console.log(err); });
   }).catch((err) => { console.log(err); });
}).catch((error) => {
   console.error('Unable to create the table : ', error);
});

Aquí, proporciona datos de muestra e importa los datos en los modelos Studenty . GradeCon su base de datos, modelos y datos de muestra en su lugar, está listo para crear asociaciones.

En one-to-one.js, agregue la siguiente línea debajo del student_databloque:

...
Student.belongsTo(Grade);

A continuación, deberá comprobar si la asociación funciona correctamente. Para hacer eso, puede recuperar los datos de todos los estudiantes con los niveles de grado asociados pasando el includeparámetro dentro del findAll()método.

Dado que necesita obtener el nivel de grado del estudiante, pasará Gradecomo modelo. En el sequelize.sync()método, agregue las líneas resaltadas como se muestra:

...
sequelize.sync({ force: true }).then(() => {
   Grade.bulkCreate(grade_data, { validate: true }).then(() => {
       Student.bulkCreate(student_data, { validate: true }).then(() => {
           Student.findAll({
               include: [{
                   model: Grade
               }]
           }).then(result => {
               console.log(result)
           }).catch((error) => {
               console.error('Failed to retrieve data : ', error);
           });
       }).catch((err) => { console.log(err); });
   }).catch((err) => { console.log(err); });
}).catch((error) => {
   console.error('Unable to create the table : ', error);
});

El código completo se parece a lo siguiente:

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
  );
sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

const Student = sequelize.define("students", {
   student_id: {
       type: DataTypes.UUID,
       defaultValue: DataTypes.UUIDV4,
       primaryKey: true,
   },
   name: {
       type: DataTypes.STRING,
       allowNull: false
   }
});

const Grade = sequelize.define("grades", {
   grade: {
       type: DataTypes.INTEGER,
       allowNull: false
   }
});

const grade_data = [{grade : 9}, {grade : 10}, {grade : 11}]

const student_data = [
   {name : "John Baker", gradeId: 2},
   {name : "Max Butler", gradeId: 1},
   {name : "Ryan Fisher", gradeId: 3},
   {name : "Robert Gray", gradeId: 2},
   {name : "Sam Lewis", gradeId: 1}
]

// One-To-One association
Student.belongsTo(Grade);

sequelize.sync({ force: true }).then(() => {
   Grade.bulkCreate(grade_data, { validate: true }).then(() => {
       Student.bulkCreate(student_data, { validate: true }).then(() => {
           Student.findAll({
               include: [{
                   model: Grade
               }]
           }).then(result => {
               console.log(result)
           }).catch((error) => {
               console.error('Failed to retrieve data : ', error);
           });
       }).catch((err) => { console.log(err); });
   }).catch((err) => { console.log(err); });
}).catch((error) => {
   console.error('Unable to create the table : ', error);
});

Guarde y cierre su archivo.

Ejecute el archivo usando el siguiente comando:

node one_to_one.js

La salida será larga y verá todos los datos de los estudiantes con los niveles de grado. Aquí hay un fragmento de la salida que muestra los datos de los estudiantes:

Output
students {
    dataValues:
   { student_id: '3e786a8f-7f27-4c59-8e9c-a8c606892288',
       name: 'Sam Lewis',
       createdAt: 2021-12-16T08:49:38.000Z,
       updatedAt: 2021-12-16T08:49:38.000Z,
       gradeId: 1,
       grade: [grades] },
    _previousDataValues:
...

Dependiendo de las herramientas de la línea de comandos que esté utilizando, la salida puede imprimirse como una vista ampliada o no. Si es una vista expandida, imprime el gradeobjeto expandido como salida.

En esta sección, creó una relación uno a uno mediante la Student.belongsTo(Grade);llamada al método y obtuvo los detalles de acuerdo con la asociación que creó.

Crear una relación de uno a muchos conhasMany()

En esta sección, creará una relación de uno a varios utilizando modelos Sequelize. Imagine que le gustaría asociar a todos los estudiantes con un nivel de grado seleccionado. Dado que un nivel de grado específico puede tener varios estudiantes, esta es una relación de uno a muchos.

Para comenzar, copie el contenido de one_to_one.jsen un nuevo archivo llamado one_to_many.js. En one_to_many.js, elimine las líneas después del student_databloque. Su one_to_many.jsarchivo se verá así:

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
  );

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

const Student = sequelize.define("students", {
   student_id: {
       type: DataTypes.UUID,
       defaultValue: DataTypes.UUIDV4,
       primaryKey: true,
   },
   name: {
       type: DataTypes.STRING,
       allowNull: false
   }
});
const Grade = sequelize.define("grades", {
   grade: {
       type: DataTypes.INTEGER,
       allowNull: false
   }
});

const grade_data = [ {grade : 9}, {grade : 10}, {grade : 11}]

const student_data = [
   {name : "John Baker", gradeId: 2},
   {name : "Max Butler", gradeId: 1},
   {name : "Ryan Fisher", gradeId: 3},
   {name : "Robert Gray", gradeId: 2},
   {name : "Sam Lewis", gradeId: 1}
]

Después del student_databloque, use el hasMany()método para crear una nueva relación:

...
Grade.hasMany(Student)

El hasMany()método le permite crear una relación de uno a muchos entre dos modelos de Sequelize. Aquí, está utilizando los modelos Gradey .Student

A continuación, agregue el sequelize.sync()método con el findAll()método debajo de la hasMany()línea:

...
sequelize.sync({ force: true }).then(() => {
   Grade.bulkCreate(grade_data, { validate: true }).then(() => {
       Student.bulkCreate(student_data, { validate: true }).then(() => {
           Grade.findAll({
               where: {
                   grade: 9
               },
               include: [{
                   model: Student
               }]
           }).then(result => {
               console.dir(result, { depth: 5 });
           }).catch((error) => {
               console.error('Failed to retrieve data : ', error);
           });
       }).catch((err) => { console.log(err); });
   }).catch((err) => { console.log(err); });
}).catch((error) => {
   console.error('Unable to create table : ', error);
});

Aquí está tratando de acceder a todos los estudiantes en un nivel de grado en particular; en este caso, todos los estudiantes en el grado 9. También agregó el Studentmodelo en la includeopción.

Aquí está el código completo:

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
  );

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

const Student = sequelize.define("students", {
   student_id: {
       type: DataTypes.UUID,
       defaultValue: DataTypes.UUIDV4,
       primaryKey: true,
   },
   name: {
       type: DataTypes.STRING,
       allowNull: false
   }
});
const Grade = sequelize.define("grades", {
   grade: {
       type: DataTypes.INTEGER,
       allowNull: false
   }
});

const grade_data = [ {grade : 9}, {grade : 10}, {grade : 11}]

const student_data = [
   {name : "John Baker", gradeId: 2},
   {name : "Max Butler", gradeId: 1},
   {name : "Ryan Fisher", gradeId: 3},
   {name : "Robert Gray", gradeId: 2},
   {name : "Sam Lewis", gradeId: 1}
]

// One-To-Many relationship
Grade.hasMany(Student);

sequelize.sync({ force: true }).then(() => {
   Grade.bulkCreate(grade_data, { validate: true }).then(() => {
       Student.bulkCreate(student_data, { validate: true }).then(() => {
           Grade.findAll({
               where: {
                   grade: 9
               },
               include: [{
                   model: Student
               }]
           }).then(result => {
               console.dir(result, { depth: 5 });
           }).catch((error) => {
               console.error('Failed to retrieve data : ', error);
           });
       }).catch((err) => { console.log(err); });
   }).catch((err) => { console.log(err); });
}).catch((error) => {
   console.error('Unable to create table : ', error);
});

Guarde y cierre su archivo.

Ejecute el archivo con el siguiente comando:

node one_to_many.js

La salida será similar a la siguiente. Será bastante largo, pero todos los estudiantes en grado 9serán devueltos de la siguiente manera:

Output
[ grades {
    dataValues:
     { id: 1,
       grade: 9,
       createdAt: 2021-12-20T05:12:31.000Z,
       updatedAt: 2021-12-20T05:12:31.000Z,
       students:
        [ students {
            dataValues:
             { student_id: '8a648756-4e22-4bc0-8227-f590335f9965',
               name: 'Sam Lewis',
               createdAt: 2021-12-20T05:12:31.000Z,
               updatedAt: 2021-12-20T05:12:31.000Z,
               gradeId: 1 },
...
          students {
            dataValues:
             { student_id: 'f0304585-91e5-4efc-bdca-501b3dc77ee5',
               name: 'Max Butler',
               createdAt: 2021-12-20T05:12:31.000Z,
               updatedAt: 2021-12-20T05:12:31.000Z,
               gradeId: 1 },
...

En esta sección, creó una relación de uno a varios mediante la Grade.hasMany(Student);llamada al método. En el resultado, recuperó los detalles según la asociación que creó.

Creación de relaciones de muchos a muchos conbelongsToMany()

En esta sección, creará relaciones de muchos a muchos usando modelos Sequelize. Como ejemplo, imagine una situación en la que los estudiantes están inscritos en cursos. Un estudiante puede inscribirse en muchos cursos y un curso puede tener muchos estudiantes. Esta es una relación de muchos a muchos. Para implementar esto usando Sequelize, usará los modelos Student, Coursey StudentCoursecon el belongsToMany()método.

Para comenzar, cree un archivo llamado many_to_many.jsy agregue los bloques de código de inicio y autenticación de la base de datos de la siguiente manera. (Puede reutilizar los bloques de código del one_to_many.jsejemplo anterior). Asegúrese de actualizar los valores de conexión de la base de datos resaltados según sea necesario.

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
);

sequelize.authenticate().then(() => {
    console.log('Connection has been established successfully.');
}).catch((error) => {
    console.error('Unable to connect to the database: ', error);
});

A continuación, creará los modelos de base de datos para relaciones de muchos a muchos: Studenty Course. Luego agregará algunos datos de muestra a esos modelos.

...

const Student = sequelize.define("students", {
    student_id: {
        type: DataTypes.UUID,
        defaultValue: DataTypes.UUIDV4,
    },
    name: {
        type: DataTypes.STRING,
        allowNull: false
    }
});

const Course = sequelize.define("courses", {
    course_name: {
        type: DataTypes.STRING,
        allowNull: false
    }
});

const StudentCourse = sequelize.define('StudentCourse', {
    id: {
      type: DataTypes.INTEGER,
      primaryKey: true,
      autoIncrement: true,
      allowNull: false
    }
  });

const course_data = [
    {course_name : "Science"},
    {course_name : "Maths"},
    {course_name : "History"}
]

const student_data = [
    {name : "John Baker", courseId: 2},
    {name : "Max Butler", courseId: 1},
    {name : "Ryan Fisher", courseId: 3},
    {name : "Robert Gray", courseId: 2},
    {name : "Sam Lewis", courseId: 1}
]

const student_course_data = [
    {studentId : 1, courseId: 1},
    {studentId : 2, courseId: 1},
    {studentId : 2, courseId: 3},
    {studentId : 3, courseId: 2},
    {studentId : 1, courseId: 2},
]

Aquí, crea los modelos y y proporciona algunos datos de muestra Student. CourseTambién establece un courseID, que usará para recuperar estudiantes de acuerdo con este tipo de relación.

Finalmente, definió un nuevo modelo llamado StudentCourse, que administra los datos de relación entre Studenty Course. En este ejemplo, studentId 1está inscrito en courseId 1y courseId 2.

Ha completado el inicio de la base de datos y ha agregado datos de muestra a la base de datos. A continuación, cree relaciones de varios a varios utilizando el belongsToMany()método que se muestra a continuación:

...
Course.belongsToMany(Student, { through: 'StudentCourse'})
Student.belongsToMany(Course, { through: 'StudentCourse'})

Dentro del belongsToMany()método, pasas la throughconfiguración con el nombre del modelo como opción de configuración. En este caso, es StudentCourse. Esta es la tabla que gestiona las relaciones de muchos a muchos.

Finalmente, puede verificar si la asociación funciona correctamente recuperando todos los datos del curso con los estudiantes asociados. Lo harás pasando el includeparámetro dentro del findAll()método. Agregue las siguientes líneas a many_to_many.js:

...
sequelize.sync({ force: true }).then(() => {
    Course.bulkCreate(course_data, { validate: true }).then(() => {
        Student.bulkCreate(student_data, { validate: true }).then(() => {
            StudentCourse.bulkCreate(student_course_data, { validate: true }).then(() => {
                Course.findAll({
                    include: {
                        model: Student,
                    },
                }).then(result => {
                    console.log(result);
                }).catch((error) => {
                    console.error('Failed to retrieve data : ', error);
                });
            }).catch((error) => {
                console.log(error);
            });
        }).catch((error) => {
            console.log(error);
        });
    }).catch((error) => {
        console.log(error);
    });
}).catch((error) => {
    console.error('Unable to create table : ', error);
});

El código completo se parece a lo siguiente:

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
);

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

const Student = sequelize.define("students", {
    student_id: {
       type: DataTypes.UUID,
       defaultValue: DataTypes.UUIDV4,
    },
    name: {
       type: DataTypes.STRING,
       allowNull: false
    }
});

const Course = sequelize.define("courses", {
    course_name: {
        type: DataTypes.STRING,
        allowNull: false
    }
});

const StudentCourse = sequelize.define('StudentCourse', {
    id: {
      type: DataTypes.INTEGER,
      primaryKey: true,
      autoIncrement: true,
      allowNull: false
    }
  });

const course_data = [
    {course_name : "Science"},
    {course_name : "Maths"},
    {course_name : "History"}
]

const student_data = [
    {name : "John Baker", courseId: 2},
    {name : "Max Butler", courseId: 1},
    {name : "Ryan Fisher", courseId: 3},
    {name : "Robert Gray", courseId: 2},
    {name : "Sam Lewis", courseId: 1}
]

const student_course_data = [
    {studentId : 1, courseId: 1},
    {studentId : 2, courseId: 1},
    {studentId : 2, courseId: 3},
    {studentId : 3, courseId: 2},
    {studentId : 1, courseId: 2},
]

Course.belongsToMany(Student, { through: 'StudentCourse'})
Student.belongsToMany(Course, { through: 'StudentCourse'})

sequelize.sync({ force: true }).then(() => {
    Course.bulkCreate(course_data, { validate: true }).then(() => {
        Student.bulkCreate(student_data, { validate: true }).then(() => {
            StudentCourse.bulkCreate(student_course_data, { validate: true }).then(() => {
                Course.findAll({
                    include: {
                        model: Student,
                    },
                }).then(result => {
                    console.log(result);
                }).catch((error) => {
                    console.error('Failed to retrieve data : ', error);
                });
            }).catch((error) => {
                console.log(error);
            });
        }).catch((error) => {
            console.log(error);
        });
    }).catch((error) => {
        console.log(error);
    });
}).catch((error) => {
    console.error('Unable to create table : ', error);
});

Guarde y cierre el archivo.

Ejecute el archivo usando el siguiente comando:

node many_to_many.js

La salida será larga, pero se verá similar a lo siguiente:

Output[ courses {
    dataValues:
     { id: 1,
       course_name: 'Science',
       createdAt: 2022-05-11T04:27:37.000Z,
       updatedAt: 2022-05-11T04:27:37.000Z,
       students: [Array] },
    _previousDataValues:
     { id: 1,
       course_name: 'Science',
       createdAt: 2022-05-11T04:27:37.000Z,
       updatedAt: 2022-05-11T04:27:37.000Z,
       students: [Array] },
    _changed: Set {},
    _options:
     { isNewRecord: false,
       _schema: null,
       _schemaDelimiter: '',
       include: [Array],
       includeNames: [Array],
       includeMap: [Object],
       includeValidated: true,
       attributes: [Array],
       raw: true },
    isNewRecord: false,
    students: [ [students], [students] ] },
  courses {
    dataValues:
     { id: 2,
       course_name: 'Maths',
       createdAt: 2022-05-11T04:27:37.000Z,
       updatedAt: 2022-05-11T04:27:37.000Z,
       students: [Array] },
    _previousDataValues:
...

Como puede ver en este resultado, se recuperaron los cursos con estudiantes asociados. Dentro del coursesbloque, verá idvalores separados que indican cada curso. Por ejemplo, id: 1está conectado a course_name: Sciencepara la clase de Ciencias, mientras que está conectado a la clase de id: 2Matemáticas, y así sucesivamente.

En la base de datos, puede ver las tres tablas generadas con los datos de muestra que insertó.

En este paso, usó Sequelize para crear asociaciones de uno a uno, de uno a muchos y de muchos a muchos. A continuación, trabajará con consultas sin procesar.

Paso 5: trabajar con consultas sin formato

En este paso, trabajará con consultas sin procesar en Sequelize. En los pasos anteriores, usó los métodos integrados de Sequelize, como insert()y findAll(), para manejar la inserción y selección de datos de la base de datos. Es posible que haya notado que esos métodos siguen un patrón específico para escribir una consulta. Sin embargo, con el uso de consultas sin procesar, no necesita preocuparse por los métodos y patrones integrados de Sequelize. Usando su conocimiento de las consultas SQL, puede realizar una variedad de consultas en Sequelize, desde simples hasta más avanzadas.

Este es un ejemplo de consultas sin procesar que realizan la acción de seleccionar todos los valores de una tabla en particular, eliminar los valores seleccionados de acuerdo con la condición y actualizar la tabla con los valores dados.

SELECT * FROM table_name;
DELETE FROM table_name WHERE condition;
UPDATE table_name SET y = 42 WHERE x = 12;

En Sequelize, las consultas sin procesar se pueden usar principalmente con dos metodologías: reemplazo de matrices y reemplazo de objetos. Cuando está pasando valores a la consulta SQL, puede usar una matriz o un objeto para hacer ese reemplazo.

Antes de escribir una consulta sin procesar, primero deberá proporcionar los datos de los estudiantes en una base de datos de muestra. Siguiendo la sección anterior, Creación de una base de datos de muestra , inicie sesión en MySQL, cree una base de datos llamada sample_student_dby cierre sesión en MySQL.

A continuación, agregará algunos datos sin procesar para comenzar a trabajar con consultas sin procesar. Cree un nuevo archivo llamado add_student_records.jsy agregue los siguientes bloques de código, que contienen los métodos Sequelize de authenticate(), sync()y bulkCreate().

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'sample_student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
   );

sequelize.authenticate().then(() => {
    console.log('Connection has been established successfully.');
}).catch((error) => {
    console.error('Unable to connect to the database: ', error);
});

const Student = sequelize.define("students", {
    student_id: {
        type: DataTypes.UUID,
        defaultValue: DataTypes.UUIDV4,
        primaryKey: true,
    },
    name: {
        type: DataTypes.STRING,
        allowNull: false
    }
});

const student_data = [
    {name : "John Baker"},
    {name : "Max Butler"},
    {name : "Ryan Fisher"},
    {name : "Robert Gray"},
    {name : "Sam Lewis"}
]

sequelize.sync({ force: true }).then(() => {

    Student.bulkCreate(student_data, { validate: true }).then((result) => {
        console.log(result);
    }).catch((error) => {
        console.log(error);
    });

}).catch((error) => {
    console.error('Unable to create table : ', error);
});

Aquí, inicia la conexión de la base de datos, crea el modelo e inserta algunos registros de estudiantes dentro de la nueva base de datos.

Guarde y cierre el archivo.

A continuación, ejecute este script con el siguiente comando:

node add_student_records.js

La salida será algo similar a lo siguiente. Será bastante largo, pero todos los registros de estudiantes que insertó se devolverán de la siguiente manera. Tenga en cuenta que dado que es un valor UUID ( Universally Unique Identifiersstudent_id ) generado automáticamente , será diferente según el usuario.

Output
Executing (default): SELECT 1+1 AS result
Executing (default): DROP TABLE IF EXISTS `students`;
Connection has been established successfully.
Executing (default): DROP TABLE IF EXISTS `students`;
Executing (default): CREATE TABLE IF NOT EXISTS `students` (`student_id` CHAR(36) BINARY , `name` VARCHAR(255) NOT NULL, `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL, PRIMARY KEY (`student_id`)) ENGINE=InnoDB;
Executing (default): SHOW INDEX FROM `students`
Executing (default): INSERT INTO `students` (`student_id`,`name`,`createdAt`,`updatedAt`) VALUES ('45d1f26c-ba76-431f-ac5f-f41282351710','John Baker','2022-06-03 07:27:49','2022-06-03 07:27:49'),('1cb4e34d-bfcf-4a97-9624-e400b9a1a5f2','Max Butler','2022-06-03 07:27:49','2022-06-03 07:27:49'),('954c576b-ba1c-4dbc-a5c6-8eaf22bbbb04','Ryan Fisher','2022-06-03 07:27:49','2022-06-03 07:27:49'),('e0f15cd3-0025-4032-bfe8-774e38e14c5f','Robert Gray','2022-06-03 07:27:49','2022-06-03 07:27:49'),('826a0ec9-edd0-443f-bb12-068235806659','Sam Lewis','2022-06-03 07:27:49','2022-06-03 07:27:49');
[
  students {
    dataValues: {
      student_id: '45d1f26c-ba76-431f-ac5f-f41282351710'`,
      name: 'John Baker',
      createdAt: 2022-06-03T07:27:49.453Z,
      updatedAt: 2022-06-03T07:27:49.453Z
    },
    _previousDataValues: {
      name: 'John Baker',
      student_id: '45d1f26c-ba76-431f-ac5f-f41282351710',
      createdAt: 2022-06-03T07:27:49.453Z,
      updatedAt: 2022-06-03T07:27:49.453Z
    },

…

En la siguiente sección, aplicará consultas sin formato utilizando una de las student_idsalidas en el bloque de código anterior. Cópielo para que lo tenga para las siguientes secciones, donde usará el query()método para reemplazos de arreglos y objetos.

Reemplazo de matriz

En esta sección, utilizará el query()método para reemplazar una matriz. Con este método, Sequelize puede ejecutar consultas SQL sin procesar o ya preparadas.

Para comenzar, copie el contenido del server.jsarchivo del Paso 1 , ya que incluye el Sequelize()método de inicio y el inicio de la base de datos. Pegue el contenido en un nuevo archivo llamado array_raw_query.js. Actualice el nombre de la base de datos a sample_student_db:

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'sample_student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
   );

sequelize.authenticate().then(() => {
    console.log('Connection has been established successfully.');
}).catch((error) => {
    console.error('Unable to connect to the database: ', error);
});

Al final del archivo, agregue el siguiente bloque de código para un reemplazo de matriz, asegurándose de reemplazarlo REPLACE_STUDENT_IDcon el student_idvalor que copió en la sección anterior.

...
sequelize.query(
    'SELECT * FROM students WHERE student_id = ?',
    {
      replacements: ['REPLACE_STUDENT_ID'],
      type: sequelize.QueryTypes.SELECT
    }
).then(result => {
    console.log(result);
}).catch((error) => {
    console.error('Failed to insert data : ', error);
});

Para el reemplazo de matrices, pasa el query()método con la consulta SQL y el objeto de configuración. Contiene el replacementsvalor y el tipo. Para los reemplazos, pasa datos como una matriz y captura esos valores usando el símbolo de signo de interrogación ( ?).

A continuación, dado que necesita obtener datos sobre un estudiante específico, student_idse pasa como el segundo parámetro. Después de eso, pasa el type: sequelize.QueryTypes.SELECTpar clave-valor, que puede usar para seleccionar datos de la base de datos.

También hay otros tipos, como QueryTypes.UPDATEy QueryTypes.DELETE. Dependiendo del requisito, puede seleccionar el tipo que se adapte a su propósito.

A continuación se muestra el bloque de código completo. Aquí se conecta a la base de datos y recupera los datos de los estudiantes seleccionados mediante una consulta sin procesar.

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'sample_student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
   );

sequelize.authenticate().then(() => {
    console.log('Connection has been established successfully.');
}).catch((error) => {
    console.error('Unable to connect to the database: ', error);
});

sequelize.query(
    'SELECT * FROM students WHERE student_id = ?',
    {
      replacements: ['REPLACE_STUDENT_ID'],
      type: sequelize.QueryTypes.SELECT
    }
).then(result => {
    console.log(result);
}).catch((error) => {
    console.error('Failed to insert data : ', error);
});

Guarde y cierre su archivo.

A continuación, puede ejecutar este script con el siguiente comando:

node array_raw_query.js

Verá un resultado similar al siguiente:

Output
Connection has been established successfully.
[ { student_id: 'STUDENT_ID_YOU_RETRIEVED',
    name: 'Robert Gray',
    createdAt: 2022-05-06T13:14:50.000Z,
    updatedAt: 2022-05-06T13:14:50.000Z } ]

Debido a la selección student_id, sus valores de salida pueden diferir.

Reemplazo de objetos

En la superficie, el reemplazo de objetos es similar al reemplazo de matrices, pero el patrón de pasar datos a la consulta sin procesar es diferente. En la opción de reemplazo, pasa datos como un objeto, y en la opción de consulta, usa valores como :key.

Para comenzar, cree un nuevo archivo llamado object_raw_query.jsy pegue los bloques de código completos del server.jsarchivo, actualizando la base de datos a sample_student_db.

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'sample_student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
   );

sequelize.authenticate().then(() => {
    console.log('Connection has been established successfully.');
}).catch((error) => {
    console.error('Unable to connect to the database: ', error);
});

Luego, agregue el siguiente bloque de código al final del nuevo object_raw_query.jsarchivo:

...
sequelize.query(
  'SELECT * FROM students WHERE student_id = :id',
  {
    replacements: { id: 'REPLACE_STUDENT_ID' },
    type: sequelize.QueryTypes.SELECT
  }
 ).then(result => {
    console.log(result);
}).catch((error) => {
    console.error('Failed to insert data : ', error);
});

Aquí, obtiene datos de estudiantes seleccionados utilizando el método de reemplazo de objetos. Usted crea un replacementobjeto, configurando idcomo la información del estudiante que desea recuperar: { id: 'REPLACE_STUDENT_ID' }.

En el query(), indicas: 'SELECT * FROM students WHERE student_id = :id'. Con el query()método, pasa el valor de reemplazo como un objeto, por lo que este método se conoce como reemplazo de objetos.

Aquí está el código completo:

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'sample_student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
   );

sequelize.authenticate().then(() => {
    console.log('Connection has been established successfully.');
}).catch((error) => {
    console.error('Unable to connect to the database: ', error);
});

sequelize.query(
  'SELECT * FROM students WHERE student_id = :id',
  {
    replacements: { id: 'REPLACE_STUDENT_ID' },
    type: sequelize.QueryTypes.SELECT
  }
 ).then(result => {
    console.log(result);
}).catch((error) => {
    console.error('Failed to insert data : ', error);
});

Guarde y cierre el archivo.

A continuación, ejecute este script con el siguiente comando:

node object_raw_query.js

La salida será similar a la siguiente:

Output
Connection has been established successfully.
[ { student_id: 'STUDENT_ID_YOU_RETRIEVED',
    name: 'Robert Gray',
    createdAt: 2022-05-06T13:14:50.000Z,
    updatedAt: 2022-05-06T13:14:50.000Z } ]

Debido a la selección student_id, sus valores de salida pueden diferir.

En este paso, trabajó con consultas sin procesar de Sequelize usando dos metodologías diferentes: reemplazo de matrices y reemplazo de objetos.

Conclusión

En este tutorial, instaló y configuró Sequelize. También creó y trabajó con modelos, que es uno de los componentes obligatorios de Sequelize. Finalmente, creó diferentes tipos de asociaciones y trabajó con consultas sin formato utilizando ejemplos prácticos.

A continuación, puede usar diferentes tipos de datos para crear modelos de bases de datos. También puede actualizar y eliminar registros en bases de datos con métodos integrados y consultas sin procesar.

Fuente del artículo original en https://www.digitalocean.com

#sequelize #nodo #mysql 

What is GEEK

Buddha Community

Cómo usar Sequelize con Node y MySQL
Joe  Hoppe

Joe Hoppe

1595905879

Best MySQL DigitalOcean Performance – ScaleGrid vs. DigitalOcean Managed Databases

HTML to Markdown

MySQL is the all-time number one open source database in the world, and a staple in RDBMS space. DigitalOcean is quickly building its reputation as the developers cloud by providing an affordable, flexible and easy to use cloud platform for developers to work with. MySQL on DigitalOcean is a natural fit, but what’s the best way to deploy your cloud database? In this post, we are going to compare the top two providers, DigitalOcean Managed Databases for MySQL vs. ScaleGrid MySQL hosting on DigitalOcean.

At a glance – TLDR
ScaleGrid Blog - At a glance overview - 1st pointCompare Throughput
ScaleGrid averages almost 40% higher throughput over DigitalOcean for MySQL, with up to 46% higher throughput in write-intensive workloads. Read now

ScaleGrid Blog - At a glance overview - 2nd pointCompare Latency
On average, ScaleGrid achieves almost 30% lower latency over DigitalOcean for the same deployment configurations. Read now

ScaleGrid Blog - At a glance overview - 3rd pointCompare Pricing
ScaleGrid provides 30% more storage on average vs. DigitalOcean for MySQL at the same affordable price. Read now

MySQL DigitalOcean Performance Benchmark
In this benchmark, we compare equivalent plan sizes between ScaleGrid MySQL on DigitalOcean and DigitalOcean Managed Databases for MySQL. We are going to use a common, popular plan size using the below configurations for this performance benchmark:

Comparison Overview
ScaleGridDigitalOceanInstance TypeMedium: 4 vCPUsMedium: 4 vCPUsMySQL Version8.0.208.0.20RAM8GB8GBSSD140GB115GBDeployment TypeStandaloneStandaloneRegionSF03SF03SupportIncludedBusiness-level support included with account sizes over $500/monthMonthly Price$120$120

As you can see above, ScaleGrid and DigitalOcean offer the same plan configurations across this plan size, apart from SSD where ScaleGrid provides over 20% more storage for the same price.

To ensure the most accurate results in our performance tests, we run the benchmark four times for each comparison to find the average performance across throughput and latency over read-intensive workloads, balanced workloads, and write-intensive workloads.

Throughput
In this benchmark, we measure MySQL throughput in terms of queries per second (QPS) to measure our query efficiency. To quickly summarize the results, we display read-intensive, write-intensive and balanced workload averages below for 150 threads for ScaleGrid vs. DigitalOcean MySQL:

ScaleGrid MySQL vs DigitalOcean Managed Databases - Throughput Performance Graph

For the common 150 thread comparison, ScaleGrid averages almost 40% higher throughput over DigitalOcean for MySQL, with up to 46% higher throughput in write-intensive workloads.

#cloud #database #developer #digital ocean #mysql #performance #scalegrid #95th percentile latency #balanced workloads #developers cloud #digitalocean droplet #digitalocean managed databases #digitalocean performance #digitalocean pricing #higher throughput #latency benchmark #lower latency #mysql benchmark setup #mysql client threads #mysql configuration #mysql digitalocean #mysql latency #mysql on digitalocean #mysql throughput #performance benchmark #queries per second #read-intensive #scalegrid mysql #scalegrid vs. digitalocean #throughput benchmark #write-intensive

Iara  Simões

Iara Simões

1658793420

Cómo usar Sequelize con Node y MySQL

Aprenda a instalar y configurar Sequelize con MySQL. Uso de Sequelize para crear bases de datos y modelos, así como realizar operaciones de inserción, selección, eliminación y más 

Sequelize es un mapeador relacional de objetos basado en Node.js que facilita el trabajo con bases de datos MySQL , MariaDB , SQLite , PostgreSQL y más. Un mapeador relacional de objetos realiza funciones como manejar registros de bases de datos al representar los datos como objetos. Sequelize tiene un poderoso mecanismo de migración que puede transformar esquemas de bases de datos existentes en nuevas versiones. En general, Sequelize brinda un excelente soporte para la sincronización de bases de datos, la carga rápida, las asociaciones, las transacciones y las migraciones de bases de datos, al tiempo que reduce el tiempo de desarrollo y evita las inyecciones de SQL.

En este tutorial, instalará y configurará Sequelize con MySQL en su entorno de desarrollo local. A continuación, utilizará Sequelize para crear bases de datos y modelos, así como para realizar las operaciones insert, selecty delete. Luego, creará asociaciones Sequelize para relaciones uno a uno , uno a muchos y muchos a muchos . Por último, creará consultas sin formato Sequelize para reemplazos de matrices y objetos.

Este tutorial se probó en Node.js versión 14.17.6 y npmversión 6.14.15 en macOS Catalina.

Paso 1: Instalación y configuración de Sequelize

En este paso, instalará Sequelize y creará la conexión a su base de datos MySQL. Para hacerlo, primero creará una aplicación Node.js. Luego, instalará Sequelize, configurará la base de datos MySQL y desarrollará una aplicación simple.

Instalación de Sequelize

Comience creando una carpeta de proyecto. En este ejemplo, puede utilizar hello-world. Una vez que se crea la carpeta, navegue a la carpeta usando la terminal:

mkdir hello-world
cd hello-world

Luego, cree una aplicación Node.js de muestra con el siguiente comando:

npm init

A continuación, se le pedirá que responda algunas preguntas de configuración. Utilice el siguiente resultado para su configuración. Presione ENTERpara usar el valor predeterminado que se muestra y asegúrese de configurar el punto de entrada principal como server.js. Esto crea una estructura de proyecto que es fácil de mantener.

La salida se verá de la siguiente manera, que llenará el package.jsonarchivo:

{
  "name": "hello-world",
  "version": "1.0.0",
  "description": "",
  "main": "server.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "",
  "license": "ISC"
}

A continuación, cree un server.jsarchivo vacío dentro de la carpeta del proyecto:

touch server.js

Después de seguir los pasos anteriores, la estructura de carpetas final se verá así:

hello-world/
├─ package.json
├─ server.js

Ahora puedes instalar Sequelize con el siguiente comando:

npm i sequelize@6.11.0

Nota: este comando instala la versión 6.11.0. Si necesita instalar la última versión, ejecute npm i sequelize.

Después de estas actualizaciones, el package.jsonarchivo ahora se ve así:

{
  "name": "hello-world",
  "version": "1.0.0",
  "description": "",
  "main": "server.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "start": "node server.js"
  },
  "author": "",
  "license": "ISC",
  "dependencies": {
    "sequelize": "^6.11.0"
  }
}

En la dependenciessección, ahora verá una dependencia Sequelize.

Ha configurado el proyecto e instalado Sequelize. A continuación, creará una base de datos de muestra a la que conectarse.

Creación de una base de datos de muestra

Como parte de los requisitos previos, instaló y configuró MySQL, lo que incluyó la creación de un usuario. Ahora creará una base de datos vacía.

Para hacerlo, primero debe iniciar sesión en su instancia de MySQL. Si está ejecutando de forma remota, puede usar su herramienta preferida. Si está utilizando una instancia de MySQL que se ejecuta localmente, puede usar el siguiente comando, reemplazando your_username con su nombre de usuario de MySQL:

mysql -u your_username -p

-ues nombre de usuario y la -popción se pasa si la cuenta está protegida con una contraseña.

El servidor MySQL le pedirá la contraseña de su base de datos. Escribe tu contraseña y presiona ENTER.

Una vez que haya iniciado sesión, cree una base de datos llamada hello_world_dbcon el siguiente comando:

CREATE DATABASE hello_world_db;

Para verificar si ha creado la base de datos con éxito, puede usar este comando:

SHOW DATABASES;

Tu salida será similar a esta:

+--------------------+
|      Database      |
+--------------------+
| hello_world_db     |
| information_schema |
| mysql              |
| performance_schema |
| sys                |
+--------------------+

Después de crear la base de datos de muestra, desconéctese del servidor MySQL:

mysql> QUIT

Ahora, debe instalar un controlador manual para la base de datos que elija. Como Sequelize solo proporciona funciones de ORM, no incluye controladores de base de datos integrados. Por lo tanto, deberá instalar los controladores según sus preferencias. Para hacer eso, navegue al directorio del proyecto usando la terminal e instale el controlador MySQL en el proyecto usando el siguiente comando:

npm install --save mysql2

En este caso, está utilizando el controlador para MySQL.

Nota: Dado que este tutorial usa MySQL como base de datos, está usando un controlador para eso. Dependiendo de su base de datos, puede instalar manualmente el controlador de la siguiente manera:

  • npm install --save pg pg-hstore # Postgres
  • npm install --save mysql2
  • npm install --save mariadb
  • npm install --save sqlite3
  • npm install --save tedious # Microsoft SQL Server

Ahora que tiene una base de datos de muestra, puede crear su primera aplicación Sequelize con conectividad de base de datos.

Conexión a la base de datos MySQL

En esta sección, conectará la aplicación Node.js a la base de datos MySQL mediante Sequelize.

Para conectarse a la base de datos, abra server.jspara editar usando nanoo su editor de código preferido:

nano server.js

Aquí, creará una conexión de base de datos en su aplicación utilizando una instancia de Sequelize. En el new Sequelize()método, pase los parámetros del servidor MySQL y las credenciales de la base de datos de la siguiente manera, reemplazando DATABASE_USERNAMEy DATABASE_PASSWORDcon las credenciales de su usuario MySQL:

const Sequelize = require("sequelize");
const sequelize = new Sequelize(
 'hello_world_db',
 'DATABASE_USERNAME',
 'DATABASE_PASSWORD',
  {
    host: 'DATABASE_HOST',
    dialect: 'mysql'
  }
);

hostes donde se aloja el servidor MySQL, por lo que deberá proporcionar una URL del servidor o una dirección IP. Si está utilizando un servidor MySQL instalado localmente, puede reemplazarlo DATABASE_HOSTcon localhosto 127.0.0.1como valor.

Del mismo modo, si está utilizando un servidor remoto, asegúrese de reemplazar los valores de conexión de la base de datos en consecuencia con los detalles del servidor remoto apropiado.

Nota: si está utilizando cualquier otro software de servidor de base de datos, puede reemplazar el parámetro de dialecto según corresponda. `dialecto: 'mysql', 'mariadb', 'postgres', 'mssql'.

A continuación, llame a un método basado en promesas para instanciar una conexión de base de datos a la aplicación. authenticate()Para hacer eso, agregue el siguiente bloque de código a su server.jsarchivo:

...

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

El authenticate()método se utiliza para conectarse con la base de datos y comprueba si las credenciales proporcionadas son correctas. Aquí, la conexión de la base de datos está abierta de forma predeterminada y se puede utilizar la misma conexión para todas las consultas. Siempre que necesite cerrar la conexión, llame al sequelize.close()método después de esta authenticate()llamada. Para obtener más información sobre Sequelize, consulte su guía de inicio .

La mayoría de los métodos proporcionados por Sequelize son asincrónicos. Eso significa que puede ejecutar procesos en su aplicación mientras un bloque de código asíncrono está en su tiempo de ejecución. Además, después de la ejecución exitosa del bloque de código asíncrono, devuelve una promesa , que es el valor devuelto al final de un proceso. Por lo tanto, en bloques de código asincrónico, puede usar then(), catch()y finally()para devolver los datos procesados.

En este punto, el server.jsarchivo tendrá el siguiente aspecto:

const Sequelize = require("sequelize");

const sequelize = new Sequelize(
   'hello_world_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
  );

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

Guarde y cierre su archivo.

En el directorio del proyecto, ejecute la server.jsaplicación ejecutando el siguiente comando:

node server.js

Su salida se verá así:

Output
Connection has been established successfully!

Ha creado la conexión a la base de datos con éxito.

En este paso, instaló Sequelize, creó una base de datos de muestra y usó Sequelize para conectarse con la base de datos. A continuación, trabajará con modelos en Sequelize.

Paso 2: Crear una tabla de base de datos usando Sequelize

Ahora que ha creado una base de datos MySQL de muestra, puede usar Sequelize para crear una tabla y llenarla con datos. En Sequelize, las tablas de la base de datos se conocen como modelos . Un modelo es una abstracción que representa una tabla de la base de datos. Los modelos definen varias cosas para Sequelize, como el nombre de la tabla, los detalles de la columna y los tipos de datos. En este paso, creará un modelo Sequelize para datos de libros.

Para comenzar, cree un nuevo archivo llamado book.model.jsen el directorio del proyecto:

nano book.model.js

Similar al paso anterior, agregue un código Sequelize para el inicio de la base de datos con una nueva importación DataTypesen la parte superior del archivo:

const { Sequelize, DataTypes } = require("sequelize");

Sequelize contiene muchos tipos de datos integrados. Para acceder a esos tipos de datos, agrega una importación para DataTypes. Este tutorial hace referencia a algunos tipos de datos de uso frecuente, como STRING, INTEGERy DATEONLY. Para obtener más información sobre otros tipos de datos admitidos, puede consultar la documentación oficial de Sequelize .

Luego, incluye las líneas que usaste anteriormente para crear una conexión a tu base de datos MySQL, actualizando tus credenciales de MySQL en consecuencia:

...

const sequelize = new Sequelize(
   'hello_world_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
  );

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

A continuación, creará un modelo denominado books, que incluye title, author, release_datee subjectID. Para hacer eso, use el sequelize.define()método como se muestra:

...

const Book = sequelize.define("books", {
   title: {
     type: DataTypes.STRING,
     allowNull: false
   },
   author: {
     type: DataTypes.STRING,
     allowNull: false
   },
   release_date: {
     type: DataTypes.DATEONLY,
   },
   subject: {
     type: DataTypes.INTEGER,
   }
});

El sequelize.define()método define un nuevo modelo, que representa una tabla en la base de datos. Este bloque de código crea una tabla llamada booksy almacena los registros contables de acuerdo con title, author, release_datey subject.

En este código, allowNullmuestra que el valor de la columna del modelo no puede ser null. Del mismo modo, si necesita establecer dicho valor, puede usar defaultValue: "value".

A continuación, agregará el bookmodelo a su base de datos. Para hacer eso, usará el sync()método de la siguiente manera:

...

sequelize.sync().then(() => {
   console.log('Book table created successfully!');
}).catch((error) => {
   console.error('Unable to create table : ', error);
});

En el sync()método, le pide a Sequelize que haga algunas cosas en la base de datos. Con esta llamada, Sequelize realizará automáticamente una consulta SQL a la base de datos y creará una tabla, imprimiendo el mensaje Book table created successfully!.

Como se mencionó, el método sync() es un método basado en promesas, lo que significa que también puede realizar el manejo de errores. En este bloque de código, verificará si la tabla se creó correctamente. De lo contrario, devolverá un error a través del método catch y lo imprimirá en la salida.

Nota: Puede administrar la sincronización del modelo pasando forceparámetros para forzar la creación de una nueva tabla si no existe, o bien usar una existente. Aquí hay algunos ejemplos, que pueden serle útiles mientras trabaja con Sequelize:

  • model.sync(): Esto crea la tabla si aún no existe.
  • model.sync({ force: true }): Esto crea la tabla soltándola si ya existe la misma tabla.

El código final se verá así:

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'hello_world_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
  );

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

const Book = sequelize.define("books", {
   title: {
     type: DataTypes.STRING,
     allowNull: false
   },
   author: {
     type: DataTypes.STRING,
     allowNull: false
   },
   release_date: {
     type: DataTypes.DATEONLY,
   },
   subject: {
     type: DataTypes.INTEGER,
   }
});

sequelize.sync().then(() => {
   console.log('Book table created successfully!');
}).catch((error) => {
   console.error('Unable to create table : ', error);
});

Guarde y cierre su archivo.

Ejecute su aplicación usando el siguiente comando:

node book.model.js

Obtendrá el siguiente resultado en su línea de comando:

Output
Executing (default): SELECT 1+1 AS result
Executing (default): CREATE TABLE IF NOT EXISTS `books` (`id` INTEGER NOT NULL auto_increment , `title` VARCHAR(255) NOT NULL, `author` VARCHAR(255) NOT NULL, `release_date` DATE, `subject` INTEGER, `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL, PRIMARY KEY (`id`)) ENGINE=InnoDB;
Connection has been established successfully.
Executing (default): SHOW INDEX FROM `books`
Book table created successfully!

En el resultado, verá que el registro de devolución contiene el mensaje Book table created successfully!. Puede verificar esto revisando su base de datos para ver la nueva bookstabla creada en la base de hello_world_dbdatos.

Para verificar la creación de la nueva tabla, inicie sesión en su instancia de MySQL:

mysql -u YOUR_USERNAME -p

Después de ingresar su contraseña, cambie a la base de datos de muestra:

USE hello_world_db;

Y luego ejecute el comando para mostrar las tablas:

SHOW TABLES;

Tu salida será similar a esta:

+---------------------------+
| Tables_in_hello_world_db |
+---------------------------+
| books                     |
+---------------------------+
1 row in set (0.00 sec)

Finalmente, desconéctese del servidor MySQL:

mysql> QUIT

Ha verificado que la bookcreación del modelo fue exitosa. Usando este proceso, puede crear cualquier número de modelos siguiendo el mismo procedimiento.

En este paso, creó un modelo en una base de datos e inició el trabajo con un modelo utilizando métodos integrados. También usó tipos de datos compatibles con Sequelize para definir su modelo. A continuación, trabajará con consultas de modelos básicos.

Paso 3: Uso de Sequelize para consultas de bases de datos

En este paso, utilizará las consultas integradas de Sequelize para inserción, selección, selección con cláusulas condicionales y eliminación.

Insertar un nuevo registro

En el paso anterior, creó un bookmodelo dentro de la base de datos. En esta sección, insertará datos en este modelo.

Para comenzar, copie el contenido del book.model.jspaso anterior. Cree un nuevo archivo llamado book.controller.jspara manejar la lógica de consulta. Agregue el código de book.model.jsa book.controller.js.

En book.controller.js, busque el sync()método. En el sync()método, agregue las siguientes líneas resaltadas:

...

sequelize.sync().then(() => {
   console.log('Book table created successfully!');

   Book.create({
       title: "Clean Code",
       author: "Robert Cecil Martin",
       release_date: "2021-12-14",
       subject: 3
   }).then(res => {
       console.log(res)
   }).catch((error) => {
       console.error('Failed to create a new record : ', error);
   });

}).catch((error) => {
   console.error('Unable to create table : ', error);
});

Aquí, inserta un nuevo registro de libro en el booksmodelo que ya ha creado utilizando el sync()método, que admite agregar nuevos registros a modelos creados previamente. Una vez que el método sync() se ejecuta con éxito, ejecuta el then()método. Dentro del then()método, llamas create()al método para insertar los nuevos registros en el modelo.

Utiliza el create()método para pasar los datos que necesita agregar a la base de datos como un objeto. La sección resaltada del código insertará una nueva entrada en su bookstabla existente. En este ejemplo, agrega Clean Codepor Robert Cecil Martin, que se ha categorizado con el subjectID de 3. Puede usar el mismo código, actualizado con información de otros libros, para agregar nuevos registros a su base de datos.

Guarde y cierre el archivo.

Ejecute la aplicación usando el siguiente comando:

node book.controller.js

Su salida será similar a la siguiente:

Output
books {
  dataValues:
   { id: 1,
     title: 'Clean Code',
     author: 'Robert Cecil Martin',
     release_date: '2021-12-14',
     subject: 3,
     updatedAt: 2021-12-14T10:12:16.644Z,
   ...
}

Insertó un nuevo registro en el modelo que creó en la base de datos. Puede continuar agregando varios registros utilizando el mismo proceso.

Selección de todos los registros

En esta sección, seleccionará y obtendrá todos los registros contables de la base de datos utilizando el findAll()método. Para hacer eso, primero abra book.controller.jsy elimine el Book.create()método anterior. En el sync()método, agregue el Book.findAll()método como se muestra:

...

sequelize.sync().then(() => {

    Book.findAll().then(res => {
        console.log(res)
    }).catch((error) => {
        console.error('Failed to retrieve data : ', error);
    });

}).catch((error) => {
    console.error('Unable to create table : ', error);
});

...

Guarde y cierre el archivo.

A continuación, vuelva a ejecutar la aplicación con el siguiente comando:

node book.controller.js

Su salida será similar a la siguiente:

Output
[
  books {
    dataValues: {
      id: 1,
      title: 'Clean Code',
      author: 'Robert Cecil Martin',
      release_date: '2020-01-01',
      subject: 3,
      createdAt: 2021-02-22T09:13:55.000Z,
      updatedAt: 2021-02-22T09:13:55.000Z
    },
    _previousDataValues: {
      id: 1,
      title: 'Clean Code',
      author: 'Robert Cecil Martin',
      release_date: '2020-01-01',
      subject: 3,
      createdAt: 2021-02-22T09:13:55.000Z,
      updatedAt: 2021-02-22T09:13:55.000Z
    },
...
]

La salida contiene todos los datos del libro como un objeto de matriz. Usó con éxito el método Sequelize findAll()para devolver todos los datos de libros de la base de datos.

Seleccionar con la wherecláusula

En esta sección, seleccionará valores con condiciones utilizando la wherecláusula. La wherecláusula se utiliza para especificar una condición al obtener datos. Para este tutorial, obtendrá un libro por un ID de registro específico de la base de datos utilizando el findOne()método.

Para hacer eso, abra book.controller.jspara editar, elimine el findAll()método y agregue las siguientes líneas:

...

sequelize.sync().then(() => {

    Book.findOne({
        where: {
            id : "1"
        }
    }).then(res => {
        console.log(res)
    }).catch((error) => {
        console.error('Failed to retrieve data : ', error);
    });

}).catch((error) => {
    console.error('Unable to create table : ', error);
});

Aquí, selecciona un registro de libro específico de la base de datos utilizando el findOne()método con la whereopción. En este ejemplo, está recuperando los datos del libro cuyo ides igual a 1.

Guarde y cierre el archivo.

A continuación, ejecute la aplicación:

node book.controller.js

Su salida será similar a la siguiente:

Output
books {
  dataValues: {
    id: 1,
    title: 'Clean Code',
    author: 'Robert Cecil Martin',
    release_date: '2020-01-01',
    subject: 'Science',
    createdAt: 2021-02-22T09:13:55.000Z,
    updatedAt: 2021-02-22T09:13:55.000Z
  },
  ...
}

Ha utilizado con éxito wherecláusulas para obtener datos de los modelos de Sequelize. Puede utilizar la wherecláusula en la aplicación de la base de datos para capturar datos condicionales.

Eliminación de un registro

Para eliminar un registro específico del modelo de base de datos, utilice el destroy()método con la whereopción. Para hacerlo, abra book.controller.js, elimine el findOne()método y agregue las siguientes líneas resaltadas:

...
sequelize.sync().then(() => {

  Book.destroy({
      where: {
        id: 2
      }
  }).then(() => {
      console.log("Successfully deleted record.")
  }).catch((error) => {
      console.error('Failed to delete record : ', error);
  });

}).catch((error) => {
    console.error('Unable to create table : ', error);
});

Aquí, elimina un registro de libro de la base de datos utilizando el destroy()método con la whereopción y pasando el iddel libro para eliminar. Vas a quitar el registro del libro cuyos idiguales 2.

Guarde y cierre el archivo.

A continuación, ejecute la aplicación:

node book.controller.js

Su salida se verá como la siguiente:

Output
Successfully deleted record.

El registro ha sido eliminado.

En este paso, experimentó con su modelo de base de datos y consulta de modelos. Usted inició la base de datos, creó modelos, insertó registros, recuperó registros, recuperó registros con condiciones utilizando la wherecláusula y eliminó registros seleccionados. Con este conocimiento de Sequelize, ahora creará asociaciones en Sequelize. Después de eso, podrá definir y trabajar con una variedad de relaciones usando modelos Sequelize.

Paso 4: crear asociaciones usando Sequelize

En este paso, utilizará los tipos de asociación estándar que admite Sequelize: asociaciones de uno a uno , de uno a muchos y de muchos a muchos . Utilizará datos de muestra sobre estudiantes, cursos y niveles de grado.

Sequelize utiliza tipos de asociación basados ​​en las siguientes relaciones de base de datos:

Relación uno a uno : una relación uno a uno significa que un registro en una tabla está asociado con exactamente un registro en otra tabla. En términos de Sequelize, puede usarbelongsTo()yhasOne()asociaciones para crear este tipo de relación.

Relación de uno a muchos : una relación de uno a muchos significa que un registro en una tabla está asociado con varios registros en otra tabla. Con Sequelize, puede usarhasMany()métodos de asociación para crear este tipo de relación.

Relación de muchos a muchos : una relación de muchos a muchos significa que múltiples registros en una tabla están asociados con múltiples registros en otra tabla. Con Sequelize, puede usarbelongsToMany()asociaciones para crear este tipo de relación.

Antes de crear estas asociaciones, primero creará una nueva base de datos llamada student_dby agregará nuevos modelos y algunos datos de muestra para estudiantes, cursos y nivel de grado.

Para crear la base de datos, siga el mismo proceso en el Paso 1: Instalar y configurar Sequelize para iniciar sesión en MySQL y crear una base de datos llamada student_db. Una vez que se haya creado la nueva base de datos, cierre la sesión de MySQL. A continuación, comenzará a crear asociaciones de bases de datos.

Crear una relación uno a uno conbelongsTo()

En esta sección, creará una relación uno a uno usando modelos Sequelize. Imagine que desea obtener los detalles de un estudiante junto con su nivel de grado. Dado que un estudiante solo puede tener un nivel de grado, este tipo de asociación es una relación de uno a uno y puede usar el belongsTo()método.

Nota: Hay una diferencia entre belongsTo()y hasOne(). belongsTo()agregará el foreignKeyen la tabla de origen, mientras hasOne()que lo agregará a la tabla de destino. En cualquier caso, si se utilizan ambas relaciones a la vez, funcionará como Sequelize relaciones uno a uno bidireccionales.

El belongsTo()método le permite crear una relación uno a uno entre dos modelos de Sequelize. En este ejemplo, está utilizando los modelos Studenty .Grade

Cree un nuevo archivo llamado one_to_one.js. Como hizo en la sección anterior, Conexión a la base de datos MySQL , incluya las líneas para crear una conexión a la base de datos y autentique a su usuario MySQL en la parte superior del archivo. Asegúrese de actualizar las credenciales de MySQL según sea necesario:

const { Sequelize, DataTypes } = require("sequelize");

const sequelize = new Sequelize(
   'student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
  );

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

En esta sección, creará tres modelos en la nueva base de student_dbdatos: Student, Gradey Course. Comenzará creando los modelos Studenty . GradeMás adelante en este paso, creará el Coursesmodelo.

Para el Studentmodelo, agregue el siguiente bloque de código a one_to_one.js:

...
const Student = sequelize.define("students", {
   student_id: {
       type: DataTypes.UUID,
       defaultValue: DataTypes.UUIDV4,
       primaryKey: true,
   },
   name: {
       type: DataTypes.STRING,
       allowNull: false
   }
});

Este modelo de estudiante contiene dos columnas: student_idy name.

A continuación, agregue un bloque de código para el Grademodelo:

...
const Grade = sequelize.define("grades", {
   grade: {
       type: DataTypes.INTEGER,
       allowNull: false
   }
});

El Grademodelo contiene la columna grade.

Para demostrar las asociaciones, deberá agregar datos de muestra a la base de datos. Para eso, usarás el bulk()método. En lugar de insertar datos en las filas una por una, el bulkCreate()método le permite insertar varias filas en los modelos de su base de datos a la vez.

Así que ahora, importe los datos Gradey Studenta sus respectivos modelos en la base de datos como se muestra:

...
const grade_data = [{grade : 9}, {grade : 10}, {grade : 11}]

const student_data = [
   {name : "John Baker", gradeId: 2},
   {name : "Max Butler", gradeId: 1},
   {name : "Ryan Fisher", gradeId: 3},
   {name : "Robert Gray", gradeId: 2},
   {name : "Sam Lewis", gradeId: 1}
]

sequelize.sync({ force: true }).then(() => {
   Grade.bulkCreate(grade_data, { validate: true }).then(() => {
       Student.bulkCreate(student_data, { validate: true }).then(() => {
           …
       }).catch((err) => { console.log(err); });
   }).catch((err) => { console.log(err); });
}).catch((error) => {
   console.error('Unable to create the table : ', error);
});

Aquí, proporciona datos de muestra e importa los datos en los modelos Studenty . GradeCon su base de datos, modelos y datos de muestra en su lugar, está listo para crear asociaciones.

En one-to-one.js, agregue la siguiente línea debajo del student_databloque:

...
Student.belongsTo(Grade);

A continuación, deberá comprobar si la asociación funciona correctamente. Para hacer eso, puede recuperar los datos de todos los estudiantes con los niveles de grado asociados pasando el includeparámetro dentro del findAll()método.

Dado que necesita obtener el nivel de grado del estudiante, pasará Gradecomo modelo. En el sequelize.sync()método, agregue las líneas resaltadas como se muestra:

...
sequelize.sync({ force: true }).then(() => {
   Grade.bulkCreate(grade_data, { validate: true }).then(() => {
       Student.bulkCreate(student_data, { validate: true }).then(() => {
           Student.findAll({
               include: [{
                   model: Grade
               }]
           }).then(result => {
               console.log(result)
           }).catch((error) => {
               console.error('Failed to retrieve data : ', error);
           });
       }).catch((err) => { console.log(err); });
   }).catch((err) => { console.log(err); });
}).catch((error) => {
   console.error('Unable to create the table : ', error);
});

El código completo se parece a lo siguiente:

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
  );
sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

const Student = sequelize.define("students", {
   student_id: {
       type: DataTypes.UUID,
       defaultValue: DataTypes.UUIDV4,
       primaryKey: true,
   },
   name: {
       type: DataTypes.STRING,
       allowNull: false
   }
});

const Grade = sequelize.define("grades", {
   grade: {
       type: DataTypes.INTEGER,
       allowNull: false
   }
});

const grade_data = [{grade : 9}, {grade : 10}, {grade : 11}]

const student_data = [
   {name : "John Baker", gradeId: 2},
   {name : "Max Butler", gradeId: 1},
   {name : "Ryan Fisher", gradeId: 3},
   {name : "Robert Gray", gradeId: 2},
   {name : "Sam Lewis", gradeId: 1}
]

// One-To-One association
Student.belongsTo(Grade);

sequelize.sync({ force: true }).then(() => {
   Grade.bulkCreate(grade_data, { validate: true }).then(() => {
       Student.bulkCreate(student_data, { validate: true }).then(() => {
           Student.findAll({
               include: [{
                   model: Grade
               }]
           }).then(result => {
               console.log(result)
           }).catch((error) => {
               console.error('Failed to retrieve data : ', error);
           });
       }).catch((err) => { console.log(err); });
   }).catch((err) => { console.log(err); });
}).catch((error) => {
   console.error('Unable to create the table : ', error);
});

Guarde y cierre su archivo.

Ejecute el archivo usando el siguiente comando:

node one_to_one.js

La salida será larga y verá todos los datos de los estudiantes con los niveles de grado. Aquí hay un fragmento de la salida que muestra los datos de los estudiantes:

Output
students {
    dataValues:
   { student_id: '3e786a8f-7f27-4c59-8e9c-a8c606892288',
       name: 'Sam Lewis',
       createdAt: 2021-12-16T08:49:38.000Z,
       updatedAt: 2021-12-16T08:49:38.000Z,
       gradeId: 1,
       grade: [grades] },
    _previousDataValues:
...

Dependiendo de las herramientas de la línea de comandos que esté utilizando, la salida puede imprimirse como una vista ampliada o no. Si es una vista expandida, imprime el gradeobjeto expandido como salida.

En esta sección, creó una relación uno a uno mediante la Student.belongsTo(Grade);llamada al método y obtuvo los detalles de acuerdo con la asociación que creó.

Crear una relación de uno a muchos conhasMany()

En esta sección, creará una relación de uno a varios utilizando modelos Sequelize. Imagine que le gustaría asociar a todos los estudiantes con un nivel de grado seleccionado. Dado que un nivel de grado específico puede tener varios estudiantes, esta es una relación de uno a muchos.

Para comenzar, copie el contenido de one_to_one.jsen un nuevo archivo llamado one_to_many.js. En one_to_many.js, elimine las líneas después del student_databloque. Su one_to_many.jsarchivo se verá así:

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
  );

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

const Student = sequelize.define("students", {
   student_id: {
       type: DataTypes.UUID,
       defaultValue: DataTypes.UUIDV4,
       primaryKey: true,
   },
   name: {
       type: DataTypes.STRING,
       allowNull: false
   }
});
const Grade = sequelize.define("grades", {
   grade: {
       type: DataTypes.INTEGER,
       allowNull: false
   }
});

const grade_data = [ {grade : 9}, {grade : 10}, {grade : 11}]

const student_data = [
   {name : "John Baker", gradeId: 2},
   {name : "Max Butler", gradeId: 1},
   {name : "Ryan Fisher", gradeId: 3},
   {name : "Robert Gray", gradeId: 2},
   {name : "Sam Lewis", gradeId: 1}
]

Después del student_databloque, use el hasMany()método para crear una nueva relación:

...
Grade.hasMany(Student)

El hasMany()método le permite crear una relación de uno a muchos entre dos modelos de Sequelize. Aquí, está utilizando los modelos Gradey .Student

A continuación, agregue el sequelize.sync()método con el findAll()método debajo de la hasMany()línea:

...
sequelize.sync({ force: true }).then(() => {
   Grade.bulkCreate(grade_data, { validate: true }).then(() => {
       Student.bulkCreate(student_data, { validate: true }).then(() => {
           Grade.findAll({
               where: {
                   grade: 9
               },
               include: [{
                   model: Student
               }]
           }).then(result => {
               console.dir(result, { depth: 5 });
           }).catch((error) => {
               console.error('Failed to retrieve data : ', error);
           });
       }).catch((err) => { console.log(err); });
   }).catch((err) => { console.log(err); });
}).catch((error) => {
   console.error('Unable to create table : ', error);
});

Aquí está tratando de acceder a todos los estudiantes en un nivel de grado en particular; en este caso, todos los estudiantes en el grado 9. También agregó el Studentmodelo en la includeopción.

Aquí está el código completo:

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
  );

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

const Student = sequelize.define("students", {
   student_id: {
       type: DataTypes.UUID,
       defaultValue: DataTypes.UUIDV4,
       primaryKey: true,
   },
   name: {
       type: DataTypes.STRING,
       allowNull: false
   }
});
const Grade = sequelize.define("grades", {
   grade: {
       type: DataTypes.INTEGER,
       allowNull: false
   }
});

const grade_data = [ {grade : 9}, {grade : 10}, {grade : 11}]

const student_data = [
   {name : "John Baker", gradeId: 2},
   {name : "Max Butler", gradeId: 1},
   {name : "Ryan Fisher", gradeId: 3},
   {name : "Robert Gray", gradeId: 2},
   {name : "Sam Lewis", gradeId: 1}
]

// One-To-Many relationship
Grade.hasMany(Student);

sequelize.sync({ force: true }).then(() => {
   Grade.bulkCreate(grade_data, { validate: true }).then(() => {
       Student.bulkCreate(student_data, { validate: true }).then(() => {
           Grade.findAll({
               where: {
                   grade: 9
               },
               include: [{
                   model: Student
               }]
           }).then(result => {
               console.dir(result, { depth: 5 });
           }).catch((error) => {
               console.error('Failed to retrieve data : ', error);
           });
       }).catch((err) => { console.log(err); });
   }).catch((err) => { console.log(err); });
}).catch((error) => {
   console.error('Unable to create table : ', error);
});

Guarde y cierre su archivo.

Ejecute el archivo con el siguiente comando:

node one_to_many.js

La salida será similar a la siguiente. Será bastante largo, pero todos los estudiantes en grado 9serán devueltos de la siguiente manera:

Output
[ grades {
    dataValues:
     { id: 1,
       grade: 9,
       createdAt: 2021-12-20T05:12:31.000Z,
       updatedAt: 2021-12-20T05:12:31.000Z,
       students:
        [ students {
            dataValues:
             { student_id: '8a648756-4e22-4bc0-8227-f590335f9965',
               name: 'Sam Lewis',
               createdAt: 2021-12-20T05:12:31.000Z,
               updatedAt: 2021-12-20T05:12:31.000Z,
               gradeId: 1 },
...
          students {
            dataValues:
             { student_id: 'f0304585-91e5-4efc-bdca-501b3dc77ee5',
               name: 'Max Butler',
               createdAt: 2021-12-20T05:12:31.000Z,
               updatedAt: 2021-12-20T05:12:31.000Z,
               gradeId: 1 },
...

En esta sección, creó una relación de uno a varios mediante la Grade.hasMany(Student);llamada al método. En el resultado, recuperó los detalles según la asociación que creó.

Creación de relaciones de muchos a muchos conbelongsToMany()

En esta sección, creará relaciones de muchos a muchos usando modelos Sequelize. Como ejemplo, imagine una situación en la que los estudiantes están inscritos en cursos. Un estudiante puede inscribirse en muchos cursos y un curso puede tener muchos estudiantes. Esta es una relación de muchos a muchos. Para implementar esto usando Sequelize, usará los modelos Student, Coursey StudentCoursecon el belongsToMany()método.

Para comenzar, cree un archivo llamado many_to_many.jsy agregue los bloques de código de inicio y autenticación de la base de datos de la siguiente manera. (Puede reutilizar los bloques de código del one_to_many.jsejemplo anterior). Asegúrese de actualizar los valores de conexión de la base de datos resaltados según sea necesario.

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
);

sequelize.authenticate().then(() => {
    console.log('Connection has been established successfully.');
}).catch((error) => {
    console.error('Unable to connect to the database: ', error);
});

A continuación, creará los modelos de base de datos para relaciones de muchos a muchos: Studenty Course. Luego agregará algunos datos de muestra a esos modelos.

...

const Student = sequelize.define("students", {
    student_id: {
        type: DataTypes.UUID,
        defaultValue: DataTypes.UUIDV4,
    },
    name: {
        type: DataTypes.STRING,
        allowNull: false
    }
});

const Course = sequelize.define("courses", {
    course_name: {
        type: DataTypes.STRING,
        allowNull: false
    }
});

const StudentCourse = sequelize.define('StudentCourse', {
    id: {
      type: DataTypes.INTEGER,
      primaryKey: true,
      autoIncrement: true,
      allowNull: false
    }
  });

const course_data = [
    {course_name : "Science"},
    {course_name : "Maths"},
    {course_name : "History"}
]

const student_data = [
    {name : "John Baker", courseId: 2},
    {name : "Max Butler", courseId: 1},
    {name : "Ryan Fisher", courseId: 3},
    {name : "Robert Gray", courseId: 2},
    {name : "Sam Lewis", courseId: 1}
]

const student_course_data = [
    {studentId : 1, courseId: 1},
    {studentId : 2, courseId: 1},
    {studentId : 2, courseId: 3},
    {studentId : 3, courseId: 2},
    {studentId : 1, courseId: 2},
]

Aquí, crea los modelos y y proporciona algunos datos de muestra Student. CourseTambién establece un courseID, que usará para recuperar estudiantes de acuerdo con este tipo de relación.

Finalmente, definió un nuevo modelo llamado StudentCourse, que administra los datos de relación entre Studenty Course. En este ejemplo, studentId 1está inscrito en courseId 1y courseId 2.

Ha completado el inicio de la base de datos y ha agregado datos de muestra a la base de datos. A continuación, cree relaciones de varios a varios utilizando el belongsToMany()método que se muestra a continuación:

...
Course.belongsToMany(Student, { through: 'StudentCourse'})
Student.belongsToMany(Course, { through: 'StudentCourse'})

Dentro del belongsToMany()método, pasas la throughconfiguración con el nombre del modelo como opción de configuración. En este caso, es StudentCourse. Esta es la tabla que gestiona las relaciones de muchos a muchos.

Finalmente, puede verificar si la asociación funciona correctamente recuperando todos los datos del curso con los estudiantes asociados. Lo harás pasando el includeparámetro dentro del findAll()método. Agregue las siguientes líneas a many_to_many.js:

...
sequelize.sync({ force: true }).then(() => {
    Course.bulkCreate(course_data, { validate: true }).then(() => {
        Student.bulkCreate(student_data, { validate: true }).then(() => {
            StudentCourse.bulkCreate(student_course_data, { validate: true }).then(() => {
                Course.findAll({
                    include: {
                        model: Student,
                    },
                }).then(result => {
                    console.log(result);
                }).catch((error) => {
                    console.error('Failed to retrieve data : ', error);
                });
            }).catch((error) => {
                console.log(error);
            });
        }).catch((error) => {
            console.log(error);
        });
    }).catch((error) => {
        console.log(error);
    });
}).catch((error) => {
    console.error('Unable to create table : ', error);
});

El código completo se parece a lo siguiente:

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
);

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

const Student = sequelize.define("students", {
    student_id: {
       type: DataTypes.UUID,
       defaultValue: DataTypes.UUIDV4,
    },
    name: {
       type: DataTypes.STRING,
       allowNull: false
    }
});

const Course = sequelize.define("courses", {
    course_name: {
        type: DataTypes.STRING,
        allowNull: false
    }
});

const StudentCourse = sequelize.define('StudentCourse', {
    id: {
      type: DataTypes.INTEGER,
      primaryKey: true,
      autoIncrement: true,
      allowNull: false
    }
  });

const course_data = [
    {course_name : "Science"},
    {course_name : "Maths"},
    {course_name : "History"}
]

const student_data = [
    {name : "John Baker", courseId: 2},
    {name : "Max Butler", courseId: 1},
    {name : "Ryan Fisher", courseId: 3},
    {name : "Robert Gray", courseId: 2},
    {name : "Sam Lewis", courseId: 1}
]

const student_course_data = [
    {studentId : 1, courseId: 1},
    {studentId : 2, courseId: 1},
    {studentId : 2, courseId: 3},
    {studentId : 3, courseId: 2},
    {studentId : 1, courseId: 2},
]

Course.belongsToMany(Student, { through: 'StudentCourse'})
Student.belongsToMany(Course, { through: 'StudentCourse'})

sequelize.sync({ force: true }).then(() => {
    Course.bulkCreate(course_data, { validate: true }).then(() => {
        Student.bulkCreate(student_data, { validate: true }).then(() => {
            StudentCourse.bulkCreate(student_course_data, { validate: true }).then(() => {
                Course.findAll({
                    include: {
                        model: Student,
                    },
                }).then(result => {
                    console.log(result);
                }).catch((error) => {
                    console.error('Failed to retrieve data : ', error);
                });
            }).catch((error) => {
                console.log(error);
            });
        }).catch((error) => {
            console.log(error);
        });
    }).catch((error) => {
        console.log(error);
    });
}).catch((error) => {
    console.error('Unable to create table : ', error);
});

Guarde y cierre el archivo.

Ejecute el archivo usando el siguiente comando:

node many_to_many.js

La salida será larga, pero se verá similar a lo siguiente:

Output[ courses {
    dataValues:
     { id: 1,
       course_name: 'Science',
       createdAt: 2022-05-11T04:27:37.000Z,
       updatedAt: 2022-05-11T04:27:37.000Z,
       students: [Array] },
    _previousDataValues:
     { id: 1,
       course_name: 'Science',
       createdAt: 2022-05-11T04:27:37.000Z,
       updatedAt: 2022-05-11T04:27:37.000Z,
       students: [Array] },
    _changed: Set {},
    _options:
     { isNewRecord: false,
       _schema: null,
       _schemaDelimiter: '',
       include: [Array],
       includeNames: [Array],
       includeMap: [Object],
       includeValidated: true,
       attributes: [Array],
       raw: true },
    isNewRecord: false,
    students: [ [students], [students] ] },
  courses {
    dataValues:
     { id: 2,
       course_name: 'Maths',
       createdAt: 2022-05-11T04:27:37.000Z,
       updatedAt: 2022-05-11T04:27:37.000Z,
       students: [Array] },
    _previousDataValues:
...

Como puede ver en este resultado, se recuperaron los cursos con estudiantes asociados. Dentro del coursesbloque, verá idvalores separados que indican cada curso. Por ejemplo, id: 1está conectado a course_name: Sciencepara la clase de Ciencias, mientras que está conectado a la clase de id: 2Matemáticas, y así sucesivamente.

En la base de datos, puede ver las tres tablas generadas con los datos de muestra que insertó.

En este paso, usó Sequelize para crear asociaciones de uno a uno, de uno a muchos y de muchos a muchos. A continuación, trabajará con consultas sin procesar.

Paso 5: trabajar con consultas sin formato

En este paso, trabajará con consultas sin procesar en Sequelize. En los pasos anteriores, usó los métodos integrados de Sequelize, como insert()y findAll(), para manejar la inserción y selección de datos de la base de datos. Es posible que haya notado que esos métodos siguen un patrón específico para escribir una consulta. Sin embargo, con el uso de consultas sin procesar, no necesita preocuparse por los métodos y patrones integrados de Sequelize. Usando su conocimiento de las consultas SQL, puede realizar una variedad de consultas en Sequelize, desde simples hasta más avanzadas.

Este es un ejemplo de consultas sin procesar que realizan la acción de seleccionar todos los valores de una tabla en particular, eliminar los valores seleccionados de acuerdo con la condición y actualizar la tabla con los valores dados.

SELECT * FROM table_name;
DELETE FROM table_name WHERE condition;
UPDATE table_name SET y = 42 WHERE x = 12;

En Sequelize, las consultas sin procesar se pueden usar principalmente con dos metodologías: reemplazo de matrices y reemplazo de objetos. Cuando está pasando valores a la consulta SQL, puede usar una matriz o un objeto para hacer ese reemplazo.

Antes de escribir una consulta sin procesar, primero deberá proporcionar los datos de los estudiantes en una base de datos de muestra. Siguiendo la sección anterior, Creación de una base de datos de muestra , inicie sesión en MySQL, cree una base de datos llamada sample_student_dby cierre sesión en MySQL.

A continuación, agregará algunos datos sin procesar para comenzar a trabajar con consultas sin procesar. Cree un nuevo archivo llamado add_student_records.jsy agregue los siguientes bloques de código, que contienen los métodos Sequelize de authenticate(), sync()y bulkCreate().

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'sample_student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
   );

sequelize.authenticate().then(() => {
    console.log('Connection has been established successfully.');
}).catch((error) => {
    console.error('Unable to connect to the database: ', error);
});

const Student = sequelize.define("students", {
    student_id: {
        type: DataTypes.UUID,
        defaultValue: DataTypes.UUIDV4,
        primaryKey: true,
    },
    name: {
        type: DataTypes.STRING,
        allowNull: false
    }
});

const student_data = [
    {name : "John Baker"},
    {name : "Max Butler"},
    {name : "Ryan Fisher"},
    {name : "Robert Gray"},
    {name : "Sam Lewis"}
]

sequelize.sync({ force: true }).then(() => {

    Student.bulkCreate(student_data, { validate: true }).then((result) => {
        console.log(result);
    }).catch((error) => {
        console.log(error);
    });

}).catch((error) => {
    console.error('Unable to create table : ', error);
});

Aquí, inicia la conexión de la base de datos, crea el modelo e inserta algunos registros de estudiantes dentro de la nueva base de datos.

Guarde y cierre el archivo.

A continuación, ejecute este script con el siguiente comando:

node add_student_records.js

La salida será algo similar a lo siguiente. Será bastante largo, pero todos los registros de estudiantes que insertó se devolverán de la siguiente manera. Tenga en cuenta que dado que es un valor UUID ( Universally Unique Identifiersstudent_id ) generado automáticamente , será diferente según el usuario.

Output
Executing (default): SELECT 1+1 AS result
Executing (default): DROP TABLE IF EXISTS `students`;
Connection has been established successfully.
Executing (default): DROP TABLE IF EXISTS `students`;
Executing (default): CREATE TABLE IF NOT EXISTS `students` (`student_id` CHAR(36) BINARY , `name` VARCHAR(255) NOT NULL, `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL, PRIMARY KEY (`student_id`)) ENGINE=InnoDB;
Executing (default): SHOW INDEX FROM `students`
Executing (default): INSERT INTO `students` (`student_id`,`name`,`createdAt`,`updatedAt`) VALUES ('45d1f26c-ba76-431f-ac5f-f41282351710','John Baker','2022-06-03 07:27:49','2022-06-03 07:27:49'),('1cb4e34d-bfcf-4a97-9624-e400b9a1a5f2','Max Butler','2022-06-03 07:27:49','2022-06-03 07:27:49'),('954c576b-ba1c-4dbc-a5c6-8eaf22bbbb04','Ryan Fisher','2022-06-03 07:27:49','2022-06-03 07:27:49'),('e0f15cd3-0025-4032-bfe8-774e38e14c5f','Robert Gray','2022-06-03 07:27:49','2022-06-03 07:27:49'),('826a0ec9-edd0-443f-bb12-068235806659','Sam Lewis','2022-06-03 07:27:49','2022-06-03 07:27:49');
[
  students {
    dataValues: {
      student_id: '45d1f26c-ba76-431f-ac5f-f41282351710'`,
      name: 'John Baker',
      createdAt: 2022-06-03T07:27:49.453Z,
      updatedAt: 2022-06-03T07:27:49.453Z
    },
    _previousDataValues: {
      name: 'John Baker',
      student_id: '45d1f26c-ba76-431f-ac5f-f41282351710',
      createdAt: 2022-06-03T07:27:49.453Z,
      updatedAt: 2022-06-03T07:27:49.453Z
    },

…

En la siguiente sección, aplicará consultas sin formato utilizando una de las student_idsalidas en el bloque de código anterior. Cópielo para que lo tenga para las siguientes secciones, donde usará el query()método para reemplazos de arreglos y objetos.

Reemplazo de matriz

En esta sección, utilizará el query()método para reemplazar una matriz. Con este método, Sequelize puede ejecutar consultas SQL sin procesar o ya preparadas.

Para comenzar, copie el contenido del server.jsarchivo del Paso 1 , ya que incluye el Sequelize()método de inicio y el inicio de la base de datos. Pegue el contenido en un nuevo archivo llamado array_raw_query.js. Actualice el nombre de la base de datos a sample_student_db:

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'sample_student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
   );

sequelize.authenticate().then(() => {
    console.log('Connection has been established successfully.');
}).catch((error) => {
    console.error('Unable to connect to the database: ', error);
});

Al final del archivo, agregue el siguiente bloque de código para un reemplazo de matriz, asegurándose de reemplazarlo REPLACE_STUDENT_IDcon el student_idvalor que copió en la sección anterior.

...
sequelize.query(
    'SELECT * FROM students WHERE student_id = ?',
    {
      replacements: ['REPLACE_STUDENT_ID'],
      type: sequelize.QueryTypes.SELECT
    }
).then(result => {
    console.log(result);
}).catch((error) => {
    console.error('Failed to insert data : ', error);
});

Para el reemplazo de matrices, pasa el query()método con la consulta SQL y el objeto de configuración. Contiene el replacementsvalor y el tipo. Para los reemplazos, pasa datos como una matriz y captura esos valores usando el símbolo de signo de interrogación ( ?).

A continuación, dado que necesita obtener datos sobre un estudiante específico, student_idse pasa como el segundo parámetro. Después de eso, pasa el type: sequelize.QueryTypes.SELECTpar clave-valor, que puede usar para seleccionar datos de la base de datos.

También hay otros tipos, como QueryTypes.UPDATEy QueryTypes.DELETE. Dependiendo del requisito, puede seleccionar el tipo que se adapte a su propósito.

A continuación se muestra el bloque de código completo. Aquí se conecta a la base de datos y recupera los datos de los estudiantes seleccionados mediante una consulta sin procesar.

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'sample_student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
   );

sequelize.authenticate().then(() => {
    console.log('Connection has been established successfully.');
}).catch((error) => {
    console.error('Unable to connect to the database: ', error);
});

sequelize.query(
    'SELECT * FROM students WHERE student_id = ?',
    {
      replacements: ['REPLACE_STUDENT_ID'],
      type: sequelize.QueryTypes.SELECT
    }
).then(result => {
    console.log(result);
}).catch((error) => {
    console.error('Failed to insert data : ', error);
});

Guarde y cierre su archivo.

A continuación, puede ejecutar este script con el siguiente comando:

node array_raw_query.js

Verá un resultado similar al siguiente:

Output
Connection has been established successfully.
[ { student_id: 'STUDENT_ID_YOU_RETRIEVED',
    name: 'Robert Gray',
    createdAt: 2022-05-06T13:14:50.000Z,
    updatedAt: 2022-05-06T13:14:50.000Z } ]

Debido a la selección student_id, sus valores de salida pueden diferir.

Reemplazo de objetos

En la superficie, el reemplazo de objetos es similar al reemplazo de matrices, pero el patrón de pasar datos a la consulta sin procesar es diferente. En la opción de reemplazo, pasa datos como un objeto, y en la opción de consulta, usa valores como :key.

Para comenzar, cree un nuevo archivo llamado object_raw_query.jsy pegue los bloques de código completos del server.jsarchivo, actualizando la base de datos a sample_student_db.

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'sample_student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
   );

sequelize.authenticate().then(() => {
    console.log('Connection has been established successfully.');
}).catch((error) => {
    console.error('Unable to connect to the database: ', error);
});

Luego, agregue el siguiente bloque de código al final del nuevo object_raw_query.jsarchivo:

...
sequelize.query(
  'SELECT * FROM students WHERE student_id = :id',
  {
    replacements: { id: 'REPLACE_STUDENT_ID' },
    type: sequelize.QueryTypes.SELECT
  }
 ).then(result => {
    console.log(result);
}).catch((error) => {
    console.error('Failed to insert data : ', error);
});

Aquí, obtiene datos de estudiantes seleccionados utilizando el método de reemplazo de objetos. Usted crea un replacementobjeto, configurando idcomo la información del estudiante que desea recuperar: { id: 'REPLACE_STUDENT_ID' }.

En el query(), indicas: 'SELECT * FROM students WHERE student_id = :id'. Con el query()método, pasa el valor de reemplazo como un objeto, por lo que este método se conoce como reemplazo de objetos.

Aquí está el código completo:

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'sample_student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
   );

sequelize.authenticate().then(() => {
    console.log('Connection has been established successfully.');
}).catch((error) => {
    console.error('Unable to connect to the database: ', error);
});

sequelize.query(
  'SELECT * FROM students WHERE student_id = :id',
  {
    replacements: { id: 'REPLACE_STUDENT_ID' },
    type: sequelize.QueryTypes.SELECT
  }
 ).then(result => {
    console.log(result);
}).catch((error) => {
    console.error('Failed to insert data : ', error);
});

Guarde y cierre el archivo.

A continuación, ejecute este script con el siguiente comando:

node object_raw_query.js

La salida será similar a la siguiente:

Output
Connection has been established successfully.
[ { student_id: 'STUDENT_ID_YOU_RETRIEVED',
    name: 'Robert Gray',
    createdAt: 2022-05-06T13:14:50.000Z,
    updatedAt: 2022-05-06T13:14:50.000Z } ]

Debido a la selección student_id, sus valores de salida pueden diferir.

En este paso, trabajó con consultas sin procesar de Sequelize usando dos metodologías diferentes: reemplazo de matrices y reemplazo de objetos.

Conclusión

En este tutorial, instaló y configuró Sequelize. También creó y trabajó con modelos, que es uno de los componentes obligatorios de Sequelize. Finalmente, creó diferentes tipos de asociaciones y trabajó con consultas sin formato utilizando ejemplos prácticos.

A continuación, puede usar diferentes tipos de datos para crear modelos de bases de datos. También puede actualizar y eliminar registros en bases de datos con métodos integrados y consultas sin procesar.

Fuente del artículo original en https://www.digitalocean.com

#sequelize #nodo #mysql 

How To Use Sequelize with Node and MySQL

Saiba como instalar e configurar o Sequelize com MySQL. Usando o Sequelize para criar bancos de dados e modelos, bem como realizar as operações de inserção, seleção, exclusão e muito mais 

O Sequelize é um Mapeador Relacional de Objetos baseado em Node.js que facilita o trabalho com bancos de dados MySQL , MariaDB , SQLite , PostgreSQL e muito mais. Um Mapeador Relacional de Objetos executa funções como manipulação de registros de banco de dados representando os dados como objetos. O Sequelize possui um poderoso mecanismo de migração que pode transformar esquemas de banco de dados existentes em novas versões. No geral, o Sequelize oferece excelente suporte para sincronização de banco de dados, carregamento antecipado, associações, transações e migrações de banco de dados, reduzindo o tempo de desenvolvimento e evitando injeções de SQL.

Neste tutorial, você instalará e configurará o Sequelize com MySQL em seu ambiente de desenvolvimento local. Em seguida, você usará o Sequelize para criar bancos de dados e modelos, bem como executar as operações insert, selecte delete. Em seguida, você criará associações Sequelize para relacionamentos um-para-um , um-para-muitos e muitos-para-muitos . Por fim, você criará consultas brutas Sequelize para substituições de arrays e objetos.

Este tutorial foi testado no Node.js versão 14.17.6 e npmversão 6.14.15 no macOS Catalina.

Etapa 1 — Instalando e configurando o Sequelize

Nesta etapa, você instalará o Sequelize e criará a conexão com seu banco de dados MySQL. Para fazer isso, primeiro você criará um aplicativo Node.js. Em seguida, você instalará o Sequelize, configurará o banco de dados MySQL e desenvolverá um aplicativo simples.

Instalando o Sequelize

Comece criando uma pasta de projeto. Neste exemplo, você pode usar hello-world. Depois que a pasta for criada, navegue até a pasta usando o terminal:

mkdir hello-world
cd hello-world

Em seguida, crie um aplicativo Node.js de amostra usando o seguinte comando:

npm init

Em seguida, você será solicitado a responder a algumas perguntas de configuração. Use a saída a seguir para sua configuração. Pressione ENTERpara usar o valor padrão exibido e certifique-se de definir o ponto de entrada principal como server.js. Isso cria uma estrutura de projeto que é fácil de manter.

A saída será a seguinte, que preencherá o package.jsonarquivo:

{
  "name": "hello-world",
  "version": "1.0.0",
  "description": "",
  "main": "server.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "",
  "license": "ISC"
}

Em seguida, crie um server.jsarquivo vazio dentro da pasta do projeto:

touch server.js

Depois de seguir as etapas anteriores, sua estrutura de pastas final ficará assim:

hello-world/
├─ package.json
├─ server.js

Agora você pode instalar o Sequelize com o seguinte comando:

npm i sequelize@6.11.0

Nota: Este comando instala a versão 6.11.0. Se você precisar instalar a versão mais recente, execute npm i sequelize.

Após essas atualizações, o package.jsonarquivo agora se parece com isso:

{
  "name": "hello-world",
  "version": "1.0.0",
  "description": "",
  "main": "server.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "start": "node server.js"
  },
  "author": "",
  "license": "ISC",
  "dependencies": {
    "sequelize": "^6.11.0"
  }
}

Na dependenciesseção, você verá agora uma dependência Sequelize.

Você configurou o projeto e instalou o Sequelize. Em seguida, você criará um banco de dados de amostra ao qual se conectar.

Criando um banco de dados de exemplo

Como parte dos pré-requisitos, você instalou e configurou o MySQL, o que incluiu a criação de um usuário. Agora você criará um banco de dados vazio.

Para fazer isso, primeiro, você precisa fazer login na sua instância MySQL. Se você estiver executando remotamente, poderá usar sua ferramenta preferida. Se você estiver usando uma instância MySQL em execução localmente, poderá usar o seguinte comando, substituindo your_username pelo seu nome de usuário MySQL:

mysql -u your_username -p

-ué o nome de usuário e a -popção é passada se a conta estiver protegida com uma senha.

O servidor MySQL solicitará a senha do seu banco de dados. Digite sua senha e pressione ENTER.

Assim que estiver logado, crie um banco de dados chamado hello_world_dbusando o seguinte comando:

CREATE DATABASE hello_world_db;

Para verificar se você criou o banco de dados com sucesso, você pode usar este comando:

SHOW DATABASES;

Sua saída será semelhante a esta:

+--------------------+
|      Database      |
+--------------------+
| hello_world_db     |
| information_schema |
| mysql              |
| performance_schema |
| sys                |
+--------------------+

Depois de criar o banco de dados de amostra, desconecte-se do servidor MySQL:

mysql> QUIT

Agora, você precisa instalar um driver manual para o banco de dados de sua escolha. Como o Sequelize fornece apenas recursos ORM, ele não inclui drivers de banco de dados integrados. Portanto, você precisará instalar os drivers de acordo com sua preferência. Para fazer isso, navegue até o diretório do projeto usando o terminal e instale o driver MySQL no projeto usando o seguinte comando:

npm install --save mysql2

Neste caso, você está usando o driver para MySQL.

Nota: Como este tutorial usa MySQL como banco de dados, você está usando um driver para isso. Dependendo do seu banco de dados, você pode instalar manualmente o driver da seguinte forma:

  • npm install --save pg pg-hstore # Postgres
  • npm install --save mysql2
  • npm install --save mariadb
  • npm install --save sqlite3
  • npm install --save tedious # Microsoft SQL Server

Agora que você tem um banco de dados de exemplo, pode criar seu primeiro aplicativo Sequelize com conectividade de banco de dados.

Conectando-se ao banco de dados MySQL

Nesta seção, você conectará o aplicativo Node.js ao banco de dados MySQL usando o Sequelize.

Para se conectar ao banco de dados, abra server.jspara edição usando nanoou seu editor de código preferido:

nano server.js

Aqui, você criará uma conexão de banco de dados em seu aplicativo usando uma instância do Sequelize. No new Sequelize()método, passe os parâmetros do servidor MySQL e as credenciais do banco de dados da seguinte forma, substituindo DATABASE_USERNAMEe DATABASE_PASSWORDpelas credenciais do seu usuário MySQL:

const Sequelize = require("sequelize");
const sequelize = new Sequelize(
 'hello_world_db',
 'DATABASE_USERNAME',
 'DATABASE_PASSWORD',
  {
    host: 'DATABASE_HOST',
    dialect: 'mysql'
  }
);

hosté onde o servidor MySQL está hospedado, então você precisará fornecer uma URL de servidor ou um endereço IP. Se você estiver usando um servidor MySQL instalado localmente, você pode substituir DATABASE_HOSTpor localhostou 127.0.0.1como o valor.

Da mesma forma, se você estiver usando um servidor remoto, certifique-se de substituir os valores de conexão do banco de dados de acordo com os detalhes apropriados do servidor remoto.

Nota: Se você estiver usando qualquer outro software de servidor de banco de dados, poderá substituir o parâmetro de dialeto adequadamente. `dialeto: 'mysql', 'mariadb', 'postgres', 'mssql'.

Em seguida, chame um método baseado em promessa authenticate() para instanciar uma conexão de banco de dados com o aplicativo. Para fazer isso, adicione o seguinte bloco de código ao seu server.jsarquivo:

...

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

O authenticate()método é usado para se conectar ao banco de dados e testa se as credenciais fornecidas estão corretas. Aqui, a conexão com o banco de dados é aberta por padrão e a mesma conexão pode ser usada para todas as consultas. Sempre que precisar fechar a conexão, chame o sequelize.close()método após essa authenticate()chamada. Para saber mais sobre o Sequelize, consulte o guia de primeiros passos .

A maioria dos métodos fornecidos pelo Sequelize são assíncronos. Isso significa que você pode executar processos em seu aplicativo enquanto um bloco de código assíncrono está em seu tempo de execução. Além disso, após a execução bem-sucedida do bloco de código assíncrono, ele retorna uma promessa , que é o valor retornado no final de um processo. Portanto, em blocos de código assíncrono, você pode usar then(), catch()e finally()para retornar os dados processados.

Neste ponto, o server.jsarquivo terá a seguinte aparência:

const Sequelize = require("sequelize");

const sequelize = new Sequelize(
   'hello_world_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
  );

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

Salve e feche seu arquivo.

No diretório do projeto, execute o server.jsaplicativo executando o seguinte comando:

node server.js

Sua saída ficará assim:

Output
Connection has been established successfully!

Você criou a conexão com o banco de dados com sucesso.

Nesta etapa, você instalou o Sequelize, criou um banco de dados de amostra e usou o Sequelize para se conectar ao banco de dados. Em seguida, você trabalhará com modelos no Sequelize.

Etapa 2 — Criando uma tabela de banco de dados usando o Sequelize

Agora que você criou um banco de dados MySQL de exemplo, você pode usar o Sequelize para criar uma tabela e preenchê-la com dados. No Sequelize, as tabelas de banco de dados são chamadas de modelos . Um modelo é uma abstração que representa uma tabela do banco de dados. Os modelos definem várias coisas para Sequelizar, como o nome da tabela, detalhes da coluna e tipos de dados. Nesta etapa, você criará um modelo Sequelize para dados do livro.

Para começar, crie um novo arquivo chamado book.model.jsno diretório do projeto:

nano book.model.js

Semelhante à etapa anterior, adicione um código Sequelize para inicialização do banco de dados com uma nova importação DataTypesna parte superior do arquivo:

const { Sequelize, DataTypes } = require("sequelize");

Sequelize contém muitos tipos de dados internos. Para acessar esses tipos de dados, você adiciona uma importação para DataTypes. Este tutorial se refere a alguns tipos de dados usados ​​com frequência, como STRING, INTEGERe DATEONLY. Para saber mais sobre outros tipos de dados suportados, você pode consultar a documentação oficial do Sequelize .

Em seguida, inclua as linhas que você usou anteriormente para criar uma conexão com seu banco de dados MySQL, atualizando suas credenciais do MySQL de acordo:

...

const sequelize = new Sequelize(
   'hello_world_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
  );

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

Em seguida, você criará um modelo chamado books, que inclui title, author, release_datee subjectID. Para fazer isso, use o sequelize.define()método como mostrado:

...

const Book = sequelize.define("books", {
   title: {
     type: DataTypes.STRING,
     allowNull: false
   },
   author: {
     type: DataTypes.STRING,
     allowNull: false
   },
   release_date: {
     type: DataTypes.DATEONLY,
   },
   subject: {
     type: DataTypes.INTEGER,
   }
});

O sequelize.define()método define um novo modelo, que representa uma tabela no banco de dados. Este bloco de código cria uma tabela chamada bookse armazena os registros do livro de acordo com o title, author, release_date, e subject.

Neste código, allowNullmostra que o valor da coluna do modelo não pode ser null. Da mesma forma, se você precisar definir esse valor, poderá usar defaultValue: "value".

Em seguida, você adicionará o bookmodelo ao seu banco de dados. Para fazer isso, você usará o sync()método da seguinte forma:

...

sequelize.sync().then(() => {
   console.log('Book table created successfully!');
}).catch((error) => {
   console.error('Unable to create table : ', error);
});

No sync()método, você está pedindo ao Sequelize para fazer algumas coisas no banco de dados. Com esta chamada, o Sequelize realizará automaticamente uma consulta SQL ao banco de dados e criará uma tabela, imprimindo a mensagem Book table created successfully!.

Como mencionado, o método sync() é um método baseado em promessa, o que significa que ele também pode realizar tratamento de erros. Neste bloco de código, você verificará se a tabela foi criada com sucesso. Caso contrário, ele retornará um erro por meio do método catch e o imprimirá na saída.

Nota: Você pode gerenciar a sincronização do modelo passando forceparâmetros para forçar a criação de uma nova tabela caso ela não exista, ou então usar uma existente. Aqui estão alguns exemplos, que podem ser úteis para você enquanto trabalha com o Sequelize:

  • model.sync(): Isso cria a tabela se ela ainda não existir.
  • model.sync({ force: true }): Isso cria a tabela, descartando-a se a mesma tabela já existir.

O código final ficará assim:

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'hello_world_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
  );

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

const Book = sequelize.define("books", {
   title: {
     type: DataTypes.STRING,
     allowNull: false
   },
   author: {
     type: DataTypes.STRING,
     allowNull: false
   },
   release_date: {
     type: DataTypes.DATEONLY,
   },
   subject: {
     type: DataTypes.INTEGER,
   }
});

sequelize.sync().then(() => {
   console.log('Book table created successfully!');
}).catch((error) => {
   console.error('Unable to create table : ', error);
});

Salve e feche seu arquivo.

Execute seu aplicativo usando o seguinte comando:

node book.model.js

Você obterá a seguinte saída em sua linha de comando:

Output
Executing (default): SELECT 1+1 AS result
Executing (default): CREATE TABLE IF NOT EXISTS `books` (`id` INTEGER NOT NULL auto_increment , `title` VARCHAR(255) NOT NULL, `author` VARCHAR(255) NOT NULL, `release_date` DATE, `subject` INTEGER, `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL, PRIMARY KEY (`id`)) ENGINE=InnoDB;
Connection has been established successfully.
Executing (default): SHOW INDEX FROM `books`
Book table created successfully!

Na saída, você verá que o log de retorno contém a mensagem Book table created successfully!. Você pode verificar isso verificando seu banco de dados para ver a nova bookstabela criada no banco de hello_world_dbdados.

Para verificar a criação da nova tabela, faça login na sua instância MySQL:

mysql -u YOUR_USERNAME -p

Depois de inserir sua senha, mude para o banco de dados de exemplo:

USE hello_world_db;

E, em seguida, execute o comando para mostrar as tabelas:

SHOW TABLES;

Sua saída será semelhante a esta:

+---------------------------+
| Tables_in_hello_world_db |
+---------------------------+
| books                     |
+---------------------------+
1 row in set (0.00 sec)

Finalmente, desconecte-se do servidor MySQL:

mysql> QUIT

Você verificou que a bookcriação do modelo foi bem-sucedida. Usando este processo, você pode criar qualquer número de modelos seguindo o mesmo procedimento.

Nesta etapa, você criou um modelo em um banco de dados e começou a trabalhar com um modelo usando métodos integrados. Você também usou tipos de dados compatíveis com Sequelize para definir seu modelo. Em seguida, você trabalhará com consultas de modelo básico.

Etapa 3 — Usando o Sequelize para consultas de banco de dados

Nesta etapa, você usará as consultas internas do Sequelize para inserção, seleção, seleção com cláusulas condicionais e exclusão.

Inserindo um novo registro

Na etapa anterior, você criou um bookmodelo dentro do banco de dados. Nesta seção, você inserirá dados nesse modelo.

Para começar, copie o conteúdo da book.model.jsetapa anterior. Crie um novo arquivo chamado book.controller.jspara manipular a lógica de consulta. Adicione o código de book.model.jspara book.controller.js.

Em book.controller.js, localize o sync()método. No sync()método, adicione as seguintes linhas destacadas:

...

sequelize.sync().then(() => {
   console.log('Book table created successfully!');

   Book.create({
       title: "Clean Code",
       author: "Robert Cecil Martin",
       release_date: "2021-12-14",
       subject: 3
   }).then(res => {
       console.log(res)
   }).catch((error) => {
       console.error('Failed to create a new record : ', error);
   });

}).catch((error) => {
   console.error('Unable to create table : ', error);
});

Aqui, você insere um novo registro de livro no booksmodelo que já criou usando o sync()método, que dá suporte à adição de novos registros a modelos criados anteriormente. Uma vez que o método sync() é executado com sucesso, ele executa o then()método. Dentro do then()método, você chama o create()método para inserir os novos registros no modelo.

Você usa o create()método para passar os dados que precisa adicionar ao banco de dados como um objeto. A seção destacada do código inserirá uma nova entrada em sua bookstabela existente. Neste exemplo, você adiciona Clean Codepor Robert Cecil Martin, que foi categorizado com o subjectID de 3. Você pode usar o mesmo código, atualizado com informações de outros livros, para adicionar novos registros ao seu banco de dados.

Salve e feche o arquivo.

Execute o aplicativo usando o seguinte comando:

node book.controller.js

Sua saída será semelhante à seguinte:

Output
books {
  dataValues:
   { id: 1,
     title: 'Clean Code',
     author: 'Robert Cecil Martin',
     release_date: '2021-12-14',
     subject: 3,
     updatedAt: 2021-12-14T10:12:16.644Z,
   ...
}

Você inseriu um novo registro no modelo criado no banco de dados. Você pode continuar adicionando vários registros usando o mesmo processo.

Selecionando todos os registros

Nesta seção, você selecionará e obterá todos os registros de livros do banco de dados usando o findAll()método. Para fazer isso, primeiro abra book.controller.jse remova o Book.create()método anterior. No sync()método, adicione o Book.findAll()método conforme mostrado:

...

sequelize.sync().then(() => {

    Book.findAll().then(res => {
        console.log(res)
    }).catch((error) => {
        console.error('Failed to retrieve data : ', error);
    });

}).catch((error) => {
    console.error('Unable to create table : ', error);
});

...

Salve e feche o arquivo.

Em seguida, execute o aplicativo novamente usando o seguinte comando:

node book.controller.js

Sua saída será semelhante à seguinte:

Output
[
  books {
    dataValues: {
      id: 1,
      title: 'Clean Code',
      author: 'Robert Cecil Martin',
      release_date: '2020-01-01',
      subject: 3,
      createdAt: 2021-02-22T09:13:55.000Z,
      updatedAt: 2021-02-22T09:13:55.000Z
    },
    _previousDataValues: {
      id: 1,
      title: 'Clean Code',
      author: 'Robert Cecil Martin',
      release_date: '2020-01-01',
      subject: 3,
      createdAt: 2021-02-22T09:13:55.000Z,
      updatedAt: 2021-02-22T09:13:55.000Z
    },
...
]

A saída contém todos os dados do livro como um objeto de matriz. Você usou com êxito o método Sequelize findAll()para retornar todos os dados do livro do banco de dados.

Selecionando com a whereCláusula

Nesta seção, você selecionará valores com condições usando a wherecláusula. A wherecláusula é usada para especificar uma condição ao buscar dados. Para este tutorial, você obterá um livro por um ID de registro específico do banco de dados usando o findOne()método.

Para fazer isso, abra book.controller.jspara edição, exclua o findAll()método e adicione as seguintes linhas:

...

sequelize.sync().then(() => {

    Book.findOne({
        where: {
            id : "1"
        }
    }).then(res => {
        console.log(res)
    }).catch((error) => {
        console.error('Failed to retrieve data : ', error);
    });

}).catch((error) => {
    console.error('Unable to create table : ', error);
});

Aqui, você seleciona um registro contábil específico do banco de dados usando o findOne()método com a whereopção. Neste exemplo, você está recuperando os dados do livro cujo idvalor é igual a 1.

Salve e feche o arquivo.

Em seguida, execute o aplicativo:

node book.controller.js

Sua saída será semelhante à seguinte:

Output
books {
  dataValues: {
    id: 1,
    title: 'Clean Code',
    author: 'Robert Cecil Martin',
    release_date: '2020-01-01',
    subject: 'Science',
    createdAt: 2021-02-22T09:13:55.000Z,
    updatedAt: 2021-02-22T09:13:55.000Z
  },
  ...
}

Você usou wherecláusulas com sucesso para obter dados de modelos do Sequelize. Você pode usar a wherecláusula no aplicativo de banco de dados para capturar dados condicionais.

Apagando um registro

Para excluir um registro específico do modelo de banco de dados, use o destroy()método com a whereopção. Para fazer isso, abra book.controller.js, remova o findOne()método e adicione as seguintes linhas destacadas:

...
sequelize.sync().then(() => {

  Book.destroy({
      where: {
        id: 2
      }
  }).then(() => {
      console.log("Successfully deleted record.")
  }).catch((error) => {
      console.error('Failed to delete record : ', error);
  });

}).catch((error) => {
    console.error('Unable to create table : ', error);
});

Aqui, você remove um registro de livro do banco de dados usando o destroy()método com a whereopção e passando o iddo livro a ser removido. Você vai remover o registro do livro cujo idigual a 2.

Salve e feche o arquivo.

Em seguida, execute o aplicativo:

node book.controller.js

Sua saída terá a seguinte aparência:

Output
Successfully deleted record.

O registro foi excluído.

Nesta etapa, você experimentou seu modelo de banco de dados e consulta de modelo. Você iniciou o banco de dados, criou modelos, inseriu registros, recuperou registros, recuperou registros com condições usando a wherecláusula e excluiu registros selecionados. Com esse conhecimento do Sequelize, você agora criará associações no Sequelize. Depois disso, você poderá definir e trabalhar com uma variedade de relacionamentos usando os modelos do Sequelize.

Passo 4 — Criando Associações Usando Sequelize

Nesta etapa, você usará os tipos de associação padrão que o Sequelize suporta: associações um para um , um para muitos e muitos para muitos . Você usará dados de amostra sobre alunos, cursos e níveis de escolaridade.

O Sequelize usa tipos de associação com base nos seguintes relacionamentos de banco de dados:

relacionamento um-para-um : Um relacionamento um-para-um significa que um registro em uma tabela está associado exatamente a um registro em outra tabela. Em termos de Sequelize, você pode usarbelongsTo()ehasOne()associações para criar esse tipo de relacionamento.

relacionamento um-para-muitos : Um relacionamento um-para-muitos significa que um registro em uma tabela está associado a vários registros em outra tabela. Com o Sequelize, você pode usarhasMany()métodos de associação para criar esse tipo de relacionamento.

relacionamento muitos para muitos : um relacionamento muitos para muitos significa que vários registros em uma tabela estão associados a vários registros em outra tabela. Com o Sequelize, você pode usarbelongsToMany()associações para criar esse tipo de relacionamento.

Antes de criar essas associações, você primeiro criará um novo banco de dados chamado student_dbe adicionará novos modelos e alguns dados de amostra para alunos, cursos e séries.

Para criar o banco de dados, siga o mesmo processo da Etapa 1 — Instalando e configurando o Sequelize para fazer login no MySQL e criar um banco de dados chamado student_db. Depois que o novo banco de dados for criado, saia do MySQL. Em seguida, você começará a criar associações de banco de dados.

Criando um relacionamento pessoal combelongsTo()

Nesta seção, você criará um relacionamento um para um usando os modelos do Sequelize. Imagine que você deseja obter os detalhes de um aluno junto com sua série. Como um aluno pode ter apenas uma série, esse tipo de associação é um relacionamento de um para um e você pode usar o belongsTo()método.

Nota: Há uma diferença entre belongsTo()e hasOne(). belongsTo()adicionará o foreignKeyna tabela de origem, enquanto hasOne()o adicionará à tabela de destino. De qualquer forma, se ambos os relacionamentos forem usados ​​ao mesmo tempo, funcionará como Sequelizar relacionamentos bidirecional um para um.

O belongsTo()método permite que você crie um relacionamento um para um entre dois modelos do Sequelize. Neste exemplo, você está usando os modelos Studente .Grade

Crie um novo arquivo chamado one_to_one.js. Como você fez na seção anterior, Conectando-se ao banco de dados MySQL , inclua as linhas para criar uma conexão com o banco de dados e autenticar seu usuário MySQL na parte superior do arquivo. Certifique-se de atualizar as credenciais do MySQL conforme necessário:

const { Sequelize, DataTypes } = require("sequelize");

const sequelize = new Sequelize(
   'student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
  );

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

Nesta seção, você criará três modelos no novo student_dbbanco de dados: Student, Grade, e Course. Você começará criando os modelos Studente . GradeMais adiante nesta etapa, você criará o Coursesmodelo.

Para o Studentmodelo, adicione o seguinte bloco de código a one_to_one.js:

...
const Student = sequelize.define("students", {
   student_id: {
       type: DataTypes.UUID,
       defaultValue: DataTypes.UUIDV4,
       primaryKey: true,
   },
   name: {
       type: DataTypes.STRING,
       allowNull: false
   }
});

Este modelo de aluno contém duas colunas: student_ide name.

Em seguida, adicione um bloco de código para o Grademodelo:

...
const Grade = sequelize.define("grades", {
   grade: {
       type: DataTypes.INTEGER,
       allowNull: false
   }
});

O Grademodelo contém a coluna grade.

Para demonstrar as associações, você precisará adicionar dados de amostra ao banco de dados. Para isso, você usará o bulk()método. Em vez de inserir dados nas linhas uma a uma, o bulkCreate()método permite inserir várias linhas em seus modelos de banco de dados de uma só vez.

Agora, importe os dados Gradee Studentpara seus respectivos modelos no banco de dados, conforme mostrado:

...
const grade_data = [{grade : 9}, {grade : 10}, {grade : 11}]

const student_data = [
   {name : "John Baker", gradeId: 2},
   {name : "Max Butler", gradeId: 1},
   {name : "Ryan Fisher", gradeId: 3},
   {name : "Robert Gray", gradeId: 2},
   {name : "Sam Lewis", gradeId: 1}
]

sequelize.sync({ force: true }).then(() => {
   Grade.bulkCreate(grade_data, { validate: true }).then(() => {
       Student.bulkCreate(student_data, { validate: true }).then(() => {
           …
       }).catch((err) => { console.log(err); });
   }).catch((err) => { console.log(err); });
}).catch((error) => {
   console.error('Unable to create the table : ', error);
});

Aqui, você fornece dados de amostra e importa os dados para os modelos Studente . GradeCom seu banco de dados, modelos e dados de amostra prontos, você está pronto para criar associações.

Em one-to-one.js, adicione a seguinte linha abaixo do student_databloco:

...
Student.belongsTo(Grade);

Em seguida, você precisará verificar se a associação está funcionando corretamente. Para fazer isso, você pode recuperar os dados de todos os alunos com níveis de notas associados passando o includeparâmetro dentro do findAll()método.

Como você precisa obter a nota do aluno, você passará Gradecomo modelo. No sequelize.sync()método, adicione as linhas destacadas conforme mostrado:

...
sequelize.sync({ force: true }).then(() => {
   Grade.bulkCreate(grade_data, { validate: true }).then(() => {
       Student.bulkCreate(student_data, { validate: true }).then(() => {
           Student.findAll({
               include: [{
                   model: Grade
               }]
           }).then(result => {
               console.log(result)
           }).catch((error) => {
               console.error('Failed to retrieve data : ', error);
           });
       }).catch((err) => { console.log(err); });
   }).catch((err) => { console.log(err); });
}).catch((error) => {
   console.error('Unable to create the table : ', error);
});

O código completo se parece com o seguinte:

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
  );
sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

const Student = sequelize.define("students", {
   student_id: {
       type: DataTypes.UUID,
       defaultValue: DataTypes.UUIDV4,
       primaryKey: true,
   },
   name: {
       type: DataTypes.STRING,
       allowNull: false
   }
});

const Grade = sequelize.define("grades", {
   grade: {
       type: DataTypes.INTEGER,
       allowNull: false
   }
});

const grade_data = [{grade : 9}, {grade : 10}, {grade : 11}]

const student_data = [
   {name : "John Baker", gradeId: 2},
   {name : "Max Butler", gradeId: 1},
   {name : "Ryan Fisher", gradeId: 3},
   {name : "Robert Gray", gradeId: 2},
   {name : "Sam Lewis", gradeId: 1}
]

// One-To-One association
Student.belongsTo(Grade);

sequelize.sync({ force: true }).then(() => {
   Grade.bulkCreate(grade_data, { validate: true }).then(() => {
       Student.bulkCreate(student_data, { validate: true }).then(() => {
           Student.findAll({
               include: [{
                   model: Grade
               }]
           }).then(result => {
               console.log(result)
           }).catch((error) => {
               console.error('Failed to retrieve data : ', error);
           });
       }).catch((err) => { console.log(err); });
   }).catch((err) => { console.log(err); });
}).catch((error) => {
   console.error('Unable to create the table : ', error);
});

Salve e feche seu arquivo.

Execute o arquivo usando o seguinte comando:

node one_to_one.js

A saída será longa e você verá os dados de todos os alunos com níveis de notas. Aqui está um trecho da saída mostrando os dados do aluno:

Output
students {
    dataValues:
   { student_id: '3e786a8f-7f27-4c59-8e9c-a8c606892288',
       name: 'Sam Lewis',
       createdAt: 2021-12-16T08:49:38.000Z,
       updatedAt: 2021-12-16T08:49:38.000Z,
       gradeId: 1,
       grade: [grades] },
    _previousDataValues:
...

Dependendo das ferramentas de linha de comando que você está usando, a saída pode ser impressa como uma exibição expandida ou não. Se for uma visualização expandida, imprime o gradeobjeto expandido como saída.

Nesta seção, você criou um relacionamento um para um usando a Student.belongsTo(Grade);chamada de método e obteve os detalhes de acordo com a associação criada.

Criando um relacionamento de um para muitos comhasMany()

Nesta seção, você criará um relacionamento um-para-muitos usando modelos do Sequelize. Imagine que você gostaria de associar todos os alunos a uma série selecionada. Como uma série específica pode ter vários alunos, essa é uma relação de um para muitos.

Para começar, copie o conteúdo de one_to_one.jsem um novo arquivo chamado one_to_many.js. Em one_to_many.js, remova as linhas após o student_databloco. Seu one_to_many.jsarquivo ficará assim:

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
  );

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

const Student = sequelize.define("students", {
   student_id: {
       type: DataTypes.UUID,
       defaultValue: DataTypes.UUIDV4,
       primaryKey: true,
   },
   name: {
       type: DataTypes.STRING,
       allowNull: false
   }
});
const Grade = sequelize.define("grades", {
   grade: {
       type: DataTypes.INTEGER,
       allowNull: false
   }
});

const grade_data = [ {grade : 9}, {grade : 10}, {grade : 11}]

const student_data = [
   {name : "John Baker", gradeId: 2},
   {name : "Max Butler", gradeId: 1},
   {name : "Ryan Fisher", gradeId: 3},
   {name : "Robert Gray", gradeId: 2},
   {name : "Sam Lewis", gradeId: 1}
]

Após o student_databloqueio, use o hasMany()método para criar um novo relacionamento:

...
Grade.hasMany(Student)

O hasMany()método permite que você crie um relacionamento um-para-muitos entre dois modelos do Sequelize. Aqui, você está usando os modelos Gradee .Student

Em seguida, adicione o sequelize.sync()método com o findAll()método abaixo da hasMany()linha:

...
sequelize.sync({ force: true }).then(() => {
   Grade.bulkCreate(grade_data, { validate: true }).then(() => {
       Student.bulkCreate(student_data, { validate: true }).then(() => {
           Grade.findAll({
               where: {
                   grade: 9
               },
               include: [{
                   model: Student
               }]
           }).then(result => {
               console.dir(result, { depth: 5 });
           }).catch((error) => {
               console.error('Failed to retrieve data : ', error);
           });
       }).catch((err) => { console.log(err); });
   }).catch((err) => { console.log(err); });
}).catch((error) => {
   console.error('Unable to create table : ', error);
});

Aqui você está tentando acessar todos os alunos em uma série específica—neste caso, todos os alunos na série 9. Você também adicionou o Studentmodelo na includeopção.

Aqui está o código completo:

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
  );

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

const Student = sequelize.define("students", {
   student_id: {
       type: DataTypes.UUID,
       defaultValue: DataTypes.UUIDV4,
       primaryKey: true,
   },
   name: {
       type: DataTypes.STRING,
       allowNull: false
   }
});
const Grade = sequelize.define("grades", {
   grade: {
       type: DataTypes.INTEGER,
       allowNull: false
   }
});

const grade_data = [ {grade : 9}, {grade : 10}, {grade : 11}]

const student_data = [
   {name : "John Baker", gradeId: 2},
   {name : "Max Butler", gradeId: 1},
   {name : "Ryan Fisher", gradeId: 3},
   {name : "Robert Gray", gradeId: 2},
   {name : "Sam Lewis", gradeId: 1}
]

// One-To-Many relationship
Grade.hasMany(Student);

sequelize.sync({ force: true }).then(() => {
   Grade.bulkCreate(grade_data, { validate: true }).then(() => {
       Student.bulkCreate(student_data, { validate: true }).then(() => {
           Grade.findAll({
               where: {
                   grade: 9
               },
               include: [{
                   model: Student
               }]
           }).then(result => {
               console.dir(result, { depth: 5 });
           }).catch((error) => {
               console.error('Failed to retrieve data : ', error);
           });
       }).catch((err) => { console.log(err); });
   }).catch((err) => { console.log(err); });
}).catch((error) => {
   console.error('Unable to create table : ', error);
});

Salve e feche seu arquivo.

Execute o arquivo com o seguinte comando:

node one_to_many.js

A saída será semelhante à seguinte. Será bastante longo, mas todos os alunos da série 9serão devolvidos da seguinte forma:

Output
[ grades {
    dataValues:
     { id: 1,
       grade: 9,
       createdAt: 2021-12-20T05:12:31.000Z,
       updatedAt: 2021-12-20T05:12:31.000Z,
       students:
        [ students {
            dataValues:
             { student_id: '8a648756-4e22-4bc0-8227-f590335f9965',
               name: 'Sam Lewis',
               createdAt: 2021-12-20T05:12:31.000Z,
               updatedAt: 2021-12-20T05:12:31.000Z,
               gradeId: 1 },
...
          students {
            dataValues:
             { student_id: 'f0304585-91e5-4efc-bdca-501b3dc77ee5',
               name: 'Max Butler',
               createdAt: 2021-12-20T05:12:31.000Z,
               updatedAt: 2021-12-20T05:12:31.000Z,
               gradeId: 1 },
...

Nesta seção, você criou um relacionamento um para muitos usando a Grade.hasMany(Student);chamada de método. Na saída, você recuperou os detalhes de acordo com a associação criada.

Criando relacionamentos muitos-para-muitos combelongsToMany()

Nesta seção, você criará relacionamentos muitos-para-muitos usando modelos do Sequelize. Como exemplo, imagine uma situação em que os alunos estão matriculados em cursos. Um aluno pode se matricular em vários cursos e um curso pode ter muitos alunos. Esta é uma relação de muitos para muitos. Para implementar isso usando o Sequelize, você usará os modelos Student, Coursee StudentCoursecom o belongsToMany()método .

Para começar, crie um arquivo chamado many_to_many.jse adicione os blocos de código de inicialização e autenticação do banco de dados da seguinte maneira. (Você pode reutilizar os blocos de código do one_to_many.jsexemplo anterior.) Certifique-se de atualizar os valores de conexão de banco de dados destacados conforme necessário.

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
);

sequelize.authenticate().then(() => {
    console.log('Connection has been established successfully.');
}).catch((error) => {
    console.error('Unable to connect to the database: ', error);
});

Em seguida, você criará os modelos de banco de dados para relacionamentos muitos para muitos: Studente Course. Em seguida, você adicionará alguns dados de amostra a esses modelos.

...

const Student = sequelize.define("students", {
    student_id: {
        type: DataTypes.UUID,
        defaultValue: DataTypes.UUIDV4,
    },
    name: {
        type: DataTypes.STRING,
        allowNull: false
    }
});

const Course = sequelize.define("courses", {
    course_name: {
        type: DataTypes.STRING,
        allowNull: false
    }
});

const StudentCourse = sequelize.define('StudentCourse', {
    id: {
      type: DataTypes.INTEGER,
      primaryKey: true,
      autoIncrement: true,
      allowNull: false
    }
  });

const course_data = [
    {course_name : "Science"},
    {course_name : "Maths"},
    {course_name : "History"}
]

const student_data = [
    {name : "John Baker", courseId: 2},
    {name : "Max Butler", courseId: 1},
    {name : "Ryan Fisher", courseId: 3},
    {name : "Robert Gray", courseId: 2},
    {name : "Sam Lewis", courseId: 1}
]

const student_course_data = [
    {studentId : 1, courseId: 1},
    {studentId : 2, courseId: 1},
    {studentId : 2, courseId: 3},
    {studentId : 3, courseId: 2},
    {studentId : 1, courseId: 2},
]

Aqui, você cria os modelos e e fornece alguns dados de exemplo Student. CourseVocê também define um courseID, que será usado para recuperar alunos de acordo com esse tipo de relacionamento.

Por fim, você definiu um novo modelo chamado StudentCourse, que gerencia os dados de relacionamento entre Studente Course. Neste exemplo, studentId 1está inscrito em courseId 1e courseId 2.

Você concluiu a inicialização do banco de dados e adicionou dados de amostra ao banco de dados. Em seguida, crie relacionamentos muitos para muitos usando o belongsToMany()método conforme mostrado:

...
Course.belongsToMany(Student, { through: 'StudentCourse'})
Student.belongsToMany(Course, { through: 'StudentCourse'})

Dentro do belongsToMany()método, você passa a throughconfiguração com o nome do modelo como opção de configuração. Neste caso, é StudentCourse. Esta é a tabela que gerencia os relacionamentos muitos-para-muitos.

Por fim, você pode verificar se a associação está funcionando corretamente, recuperando todos os dados do curso com os alunos associados. Você fará isso passando o includeparâmetro dentro do findAll()método. Adicione as seguintes linhas a many_to_many.js:

...
sequelize.sync({ force: true }).then(() => {
    Course.bulkCreate(course_data, { validate: true }).then(() => {
        Student.bulkCreate(student_data, { validate: true }).then(() => {
            StudentCourse.bulkCreate(student_course_data, { validate: true }).then(() => {
                Course.findAll({
                    include: {
                        model: Student,
                    },
                }).then(result => {
                    console.log(result);
                }).catch((error) => {
                    console.error('Failed to retrieve data : ', error);
                });
            }).catch((error) => {
                console.log(error);
            });
        }).catch((error) => {
            console.log(error);
        });
    }).catch((error) => {
        console.log(error);
    });
}).catch((error) => {
    console.error('Unable to create table : ', error);
});

O código completo se parece com o seguinte:

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
);

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

const Student = sequelize.define("students", {
    student_id: {
       type: DataTypes.UUID,
       defaultValue: DataTypes.UUIDV4,
    },
    name: {
       type: DataTypes.STRING,
       allowNull: false
    }
});

const Course = sequelize.define("courses", {
    course_name: {
        type: DataTypes.STRING,
        allowNull: false
    }
});

const StudentCourse = sequelize.define('StudentCourse', {
    id: {
      type: DataTypes.INTEGER,
      primaryKey: true,
      autoIncrement: true,
      allowNull: false
    }
  });

const course_data = [
    {course_name : "Science"},
    {course_name : "Maths"},
    {course_name : "History"}
]

const student_data = [
    {name : "John Baker", courseId: 2},
    {name : "Max Butler", courseId: 1},
    {name : "Ryan Fisher", courseId: 3},
    {name : "Robert Gray", courseId: 2},
    {name : "Sam Lewis", courseId: 1}
]

const student_course_data = [
    {studentId : 1, courseId: 1},
    {studentId : 2, courseId: 1},
    {studentId : 2, courseId: 3},
    {studentId : 3, courseId: 2},
    {studentId : 1, courseId: 2},
]

Course.belongsToMany(Student, { through: 'StudentCourse'})
Student.belongsToMany(Course, { through: 'StudentCourse'})

sequelize.sync({ force: true }).then(() => {
    Course.bulkCreate(course_data, { validate: true }).then(() => {
        Student.bulkCreate(student_data, { validate: true }).then(() => {
            StudentCourse.bulkCreate(student_course_data, { validate: true }).then(() => {
                Course.findAll({
                    include: {
                        model: Student,
                    },
                }).then(result => {
                    console.log(result);
                }).catch((error) => {
                    console.error('Failed to retrieve data : ', error);
                });
            }).catch((error) => {
                console.log(error);
            });
        }).catch((error) => {
            console.log(error);
        });
    }).catch((error) => {
        console.log(error);
    });
}).catch((error) => {
    console.error('Unable to create table : ', error);
});

Salve e feche o arquivo.

Execute o arquivo usando o seguinte comando:

node many_to_many.js

A saída será longa, mas será algo semelhante ao seguinte:

Output[ courses {
    dataValues:
     { id: 1,
       course_name: 'Science',
       createdAt: 2022-05-11T04:27:37.000Z,
       updatedAt: 2022-05-11T04:27:37.000Z,
       students: [Array] },
    _previousDataValues:
     { id: 1,
       course_name: 'Science',
       createdAt: 2022-05-11T04:27:37.000Z,
       updatedAt: 2022-05-11T04:27:37.000Z,
       students: [Array] },
    _changed: Set {},
    _options:
     { isNewRecord: false,
       _schema: null,
       _schemaDelimiter: '',
       include: [Array],
       includeNames: [Array],
       includeMap: [Object],
       includeValidated: true,
       attributes: [Array],
       raw: true },
    isNewRecord: false,
    students: [ [students], [students] ] },
  courses {
    dataValues:
     { id: 2,
       course_name: 'Maths',
       createdAt: 2022-05-11T04:27:37.000Z,
       updatedAt: 2022-05-11T04:27:37.000Z,
       students: [Array] },
    _previousDataValues:
...

Como você pode ver nesta saída, os cursos com alunos associados foram recuperados. Dentro do coursesbloco, você verá idvalores separados que indicam cada curso. Por exemplo, id: 1está conectado ao course_name: Sciencepara a aula de Ciências, enquanto id: 2é a aula de Matemática e assim por diante.

No banco de dados, você pode ver as três tabelas geradas com os dados de amostra inseridos.

Nesta etapa, você usou o Sequelize para criar associações um para um, um para muitos e muitos para muitos. Em seguida, você trabalhará com consultas brutas.

Etapa 5 — Trabalhando com consultas brutas

Nesta etapa, você trabalhará com consultas brutas no Sequelize. Nas etapas anteriores, você usou métodos internos do Sequelize, como insert()e findAll(), para manipular a inserção e a seleção de dados do banco de dados. Você deve ter notado que esses métodos seguem um padrão específico para escrever uma consulta. No entanto, com o uso de consultas brutas, você não precisa se preocupar com os métodos e padrões internos do Sequelize. Usando seu conhecimento de consultas SQL, você pode realizar uma variedade de consultas no Sequelize, das mais simples às mais avançadas.

Aqui está um exemplo de consultas brutas que realizam a ação de selecionar todos os valores de uma determinada tabela, excluindo os valores selecionados de acordo com a condição e atualizando a tabela com os valores fornecidos.

SELECT * FROM table_name;
DELETE FROM table_name WHERE condition;
UPDATE table_name SET y = 42 WHERE x = 12;

No Sequelize, consultas brutas podem ser usadas principalmente com duas metodologias: substituição de array e substituição de objeto. Ao passar valores para a consulta SQL, você pode usar uma matriz ou um objeto para fazer essa substituição.

Antes de escrever uma consulta bruta, primeiro você precisará fornecer os dados do aluno em um banco de dados de exemplo. Seguindo a seção anterior, Criando um banco de dados de exemplo , faça login no MySQL, crie um banco de dados chamado sample_student_dbe saia do MySQL.

Em seguida, você adicionará alguns dados brutos para começar a trabalhar com consultas brutas. Crie um novo arquivo chamado add_student_records.jse adicione os seguintes blocos de código, que contêm os métodos Sequelize discutidos anteriormente de authenticate(), sync()e bulkCreate().

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'sample_student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
   );

sequelize.authenticate().then(() => {
    console.log('Connection has been established successfully.');
}).catch((error) => {
    console.error('Unable to connect to the database: ', error);
});

const Student = sequelize.define("students", {
    student_id: {
        type: DataTypes.UUID,
        defaultValue: DataTypes.UUIDV4,
        primaryKey: true,
    },
    name: {
        type: DataTypes.STRING,
        allowNull: false
    }
});

const student_data = [
    {name : "John Baker"},
    {name : "Max Butler"},
    {name : "Ryan Fisher"},
    {name : "Robert Gray"},
    {name : "Sam Lewis"}
]

sequelize.sync({ force: true }).then(() => {

    Student.bulkCreate(student_data, { validate: true }).then((result) => {
        console.log(result);
    }).catch((error) => {
        console.log(error);
    });

}).catch((error) => {
    console.error('Unable to create table : ', error);
});

Aqui, você inicia a conexão com o banco de dados, cria o modelo e insere alguns registros de alunos dentro do novo banco de dados.

Salve e feche o arquivo.

Em seguida, execute este script usando o seguinte comando:

node add_student_records.js

A saída será algo semelhante ao seguinte. Será bastante longo, mas todos os registros de alunos inseridos serão devolvidos da seguinte forma. Observe que, como student_idé um valor UUID ( Identificadores Universais Universais ) gerado automaticamente, ele será diferente dependendo do usuário.

Output
Executing (default): SELECT 1+1 AS result
Executing (default): DROP TABLE IF EXISTS `students`;
Connection has been established successfully.
Executing (default): DROP TABLE IF EXISTS `students`;
Executing (default): CREATE TABLE IF NOT EXISTS `students` (`student_id` CHAR(36) BINARY , `name` VARCHAR(255) NOT NULL, `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL, PRIMARY KEY (`student_id`)) ENGINE=InnoDB;
Executing (default): SHOW INDEX FROM `students`
Executing (default): INSERT INTO `students` (`student_id`,`name`,`createdAt`,`updatedAt`) VALUES ('45d1f26c-ba76-431f-ac5f-f41282351710','John Baker','2022-06-03 07:27:49','2022-06-03 07:27:49'),('1cb4e34d-bfcf-4a97-9624-e400b9a1a5f2','Max Butler','2022-06-03 07:27:49','2022-06-03 07:27:49'),('954c576b-ba1c-4dbc-a5c6-8eaf22bbbb04','Ryan Fisher','2022-06-03 07:27:49','2022-06-03 07:27:49'),('e0f15cd3-0025-4032-bfe8-774e38e14c5f','Robert Gray','2022-06-03 07:27:49','2022-06-03 07:27:49'),('826a0ec9-edd0-443f-bb12-068235806659','Sam Lewis','2022-06-03 07:27:49','2022-06-03 07:27:49');
[
  students {
    dataValues: {
      student_id: '45d1f26c-ba76-431f-ac5f-f41282351710'`,
      name: 'John Baker',
      createdAt: 2022-06-03T07:27:49.453Z,
      updatedAt: 2022-06-03T07:27:49.453Z
    },
    _previousDataValues: {
      name: 'John Baker',
      student_id: '45d1f26c-ba76-431f-ac5f-f41282351710',
      createdAt: 2022-06-03T07:27:49.453Z,
      updatedAt: 2022-06-03T07:27:49.453Z
    },

…

Na próxima seção, você aplicará consultas brutas usando uma das student_idsaídas no bloco de código acima. Copie-o para baixo para que você o tenha nas próximas seções, onde você usará o query()método para substituições de arrays e objetos.

Substituição de matriz

Nesta seção, você usará o query()método para substituição de matriz. Com este método, o Sequelize pode executar consultas SQL brutas ou já preparadas.

Para começar, copie o conteúdo do server.jsarquivo da Etapa 1 , pois isso inclui o Sequelize()método de inicialização e a inicialização do banco de dados. Cole o conteúdo em um novo arquivo chamado array_raw_query.js. Atualize o nome do banco de dados para sample_student_db:

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'sample_student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
   );

sequelize.authenticate().then(() => {
    console.log('Connection has been established successfully.');
}).catch((error) => {
    console.error('Unable to connect to the database: ', error);
});

No final do arquivo, adicione o seguinte bloco de código para uma substituição de matriz, certificando-se de substituir REPLACE_STUDENT_IDpelo student_idvalor que você copiou na seção anterior.

...
sequelize.query(
    'SELECT * FROM students WHERE student_id = ?',
    {
      replacements: ['REPLACE_STUDENT_ID'],
      type: sequelize.QueryTypes.SELECT
    }
).then(result => {
    console.log(result);
}).catch((error) => {
    console.error('Failed to insert data : ', error);
});

Para substituição de array, você passa o query()método com a consulta SQL e o objeto de configuração. Ele contém o replacementsvalor e o tipo. ?Para substituições, você passa os dados como uma matriz e captura esses valores usando o símbolo de ponto de interrogação ( ).

Em seguida, como você precisa obter dados sobre um aluno específico, o student_idé passado como o segundo parâmetro. Depois disso, você passa o type: sequelize.QueryTypes.SELECTpar chave-valor, que pode ser usado para selecionar dados do banco de dados.

Existem alguns outros tipos também, como QueryTypes.UPDATEe QueryTypes.DELETE. Dependendo do requisito, você pode selecionar o tipo que se adequa à sua finalidade.

O seguinte mostra o bloco de código completo. Aqui você se conecta ao banco de dados e recupera os dados do aluno selecionado usando uma consulta bruta.

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'sample_student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
   );

sequelize.authenticate().then(() => {
    console.log('Connection has been established successfully.');
}).catch((error) => {
    console.error('Unable to connect to the database: ', error);
});

sequelize.query(
    'SELECT * FROM students WHERE student_id = ?',
    {
      replacements: ['REPLACE_STUDENT_ID'],
      type: sequelize.QueryTypes.SELECT
    }
).then(result => {
    console.log(result);
}).catch((error) => {
    console.error('Failed to insert data : ', error);
});

Salve e feche seu arquivo.

Em seguida, você pode executar este script usando o seguinte comando:

node array_raw_query.js

Você verá uma saída semelhante à seguinte:

Output
Connection has been established successfully.
[ { student_id: 'STUDENT_ID_YOU_RETRIEVED',
    name: 'Robert Gray',
    createdAt: 2022-05-06T13:14:50.000Z,
    updatedAt: 2022-05-06T13:14:50.000Z } ]

Devido ao selecionado student_id, seus valores de saída podem diferir.

Substituição de objetos

Na superfície, a substituição de objetos é semelhante à substituição de matrizes, mas o padrão de passagem de dados para a consulta bruta é diferente. Na opção de substituição, você passa os dados como um objeto e, na opção de consulta, usa valores como :key.

Para começar, crie um novo arquivo chamado object_raw_query.jse cole os blocos de código completos do server.jsarquivo, atualizando o banco de dados para sample_student_db.

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'sample_student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
   );

sequelize.authenticate().then(() => {
    console.log('Connection has been established successfully.');
}).catch((error) => {
    console.error('Unable to connect to the database: ', error);
});

Em seguida, adicione o seguinte bloco de código ao final do novo object_raw_query.jsarquivo:

...
sequelize.query(
  'SELECT * FROM students WHERE student_id = :id',
  {
    replacements: { id: 'REPLACE_STUDENT_ID' },
    type: sequelize.QueryTypes.SELECT
  }
 ).then(result => {
    console.log(result);
}).catch((error) => {
    console.error('Failed to insert data : ', error);
});

Aqui, você obtém dados de alunos selecionados usando o método de substituição de objetos. Você cria um replacementobjeto, definindo idcomo as informações do aluno que deseja recuperar: { id: 'REPLACE_STUDENT_ID' }.

No query(), você indica: 'SELECT * FROM students WHERE student_id = :id'. Usando o query()método, você passa o valor de substituição como um objeto, razão pela qual esse método é conhecido como substituição de objeto.

Aqui está o código completo:

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'sample_student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
   );

sequelize.authenticate().then(() => {
    console.log('Connection has been established successfully.');
}).catch((error) => {
    console.error('Unable to connect to the database: ', error);
});

sequelize.query(
  'SELECT * FROM students WHERE student_id = :id',
  {
    replacements: { id: 'REPLACE_STUDENT_ID' },
    type: sequelize.QueryTypes.SELECT
  }
 ).then(result => {
    console.log(result);
}).catch((error) => {
    console.error('Failed to insert data : ', error);
});

Salve e feche o arquivo.

Em seguida, execute este script usando o seguinte comando:

node object_raw_query.js

A saída será semelhante à seguinte:

Output
Connection has been established successfully.
[ { student_id: 'STUDENT_ID_YOU_RETRIEVED',
    name: 'Robert Gray',
    createdAt: 2022-05-06T13:14:50.000Z,
    updatedAt: 2022-05-06T13:14:50.000Z } ]

Devido ao selecionado student_id, seus valores de saída podem diferir.

Nesta etapa, você trabalhou com Sequelize consultas brutas usando duas metodologias diferentes: substituição de matriz e substituição de objeto.

Conclusão

Neste tutorial, você instalou e configurou o Sequelize. Você também criou e trabalhou com modelos, que é um dos componentes obrigatórios do Sequelize. Por fim, você criou diferentes tipos de associações e trabalhou com consultas brutas usando exemplos práticos.

Em seguida, você pode usar diferentes tipos de dados para criar modelos de banco de dados. Você também pode atualizar e excluir registros em bancos de dados com métodos internos e consultas brutas.

Fonte do artigo original em https://www.digitalocean.com

#sequelize #node #mysql #database 

许 志强

许 志强

1658800680

如何在 Node 和 MySQL 中使用 Sequelize

了解如何使用 MySQL 安裝和配置 Sequelize。使用 Sequelize 創建數據庫和模型,以及執行插入、選擇、刪除等操作 

Sequelize是一個基於Node.js的對象關係映射器,可以輕鬆使用MySQLMariaDBSQLitePostgreSQL數據庫等。對象關係映射器通過將數據表示為對象來執行諸如處理數據庫記錄之類的功能。Sequelize 具有強大的遷移機制,可以將現有的數據庫模式轉換為新版本。總體而言,Sequelize 為數據庫同步、預加載、關聯、事務和數據庫遷移提供了出色的支持,同時減少了開發時間並防止了 SQL 注入。

在本教程中,您將在本地開發環境中安裝和配置 Sequelize with MySQL。接下來,您將使用 Sequelize 創建數據庫和模型,以及執行insertselectdelete操作。然後,您將為一對一一對多多對多關係創建 Sequelize 關聯。最後,您將為數組和對象替換創建Sequelize 原始查詢

npm本教程在 macOS Catalina上的 Node.js 版本 14.17.6 和 6.14.15 版本上進行了測試。

第 1 步 — 安裝和配置 Sequelize

在此步驟中,您將安裝 Sequelize 並創建與 MySQL 數據庫的連接。為此,首先您將創建一個 Node.js 應用程序。然後,您將安裝 Sequelize、配置 MySQL 數據庫並開發一個簡單的應用程序。

安裝續集

首先創建一個項目文件夾。在此示例中,您可以使用hello-world. 創建文件夾後,使用終端導航到該文件夾:

mkdir hello-world
cd hello-world

然後,使用以下命令創建一個示例 Node.js 應用程序:

npm init

接下來,系統將提示您回答一些設置問題。使用以下輸出進行配置。按ENTER使用顯示的默認值並確保將主入口點設置為server.js。這創建了一個易於維護的項目結構。

輸出將如下所示,它將填充package.json文件:

{
  "name": "hello-world",
  "version": "1.0.0",
  "description": "",
  "main": "server.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "",
  "license": "ISC"
}

server.js接下來,在項目文件夾中創建一個空文件:

touch server.js

完成上述步驟後,您的最終文件夾結構將如下所示:

hello-world/
├─ package.json
├─ server.js

現在您可以使用以下命令安裝 Sequelize:

npm i sequelize@6.11.0

注意:此命令安裝版本 6.11.0。如果您需要安裝最新版本,請運行npm i sequelize.

在這些更新之後,package.json文件現在看起來像這樣:

{
  "name": "hello-world",
  "version": "1.0.0",
  "description": "",
  "main": "server.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "start": "node server.js"
  },
  "author": "",
  "license": "ISC",
  "dependencies": {
    "sequelize": "^6.11.0"
  }
}

在該dependencies部分中,您現在將看到 Sequelize 依賴項。

您已經設置了項目並安裝了 Sequelize。接下來,您將創建一個要連接的示例數據庫。

創建示例數據庫

作為先決條件的一部分,您安裝並配置了 MySQL,其中包括創建用戶。現在您將創建一個空數據庫。

為此,首先,您需要登錄到您的 MySQL 實例。如果您正在遠程運行,則可以使用您喜歡的工具。如果您使用的是本地運行的 MySQL 實例,則可以使用以下命令,將 your_username 替換為您的 MySQL 用戶名:

mysql -u your_username -p

-u是用戶名,-p如果帳戶受密碼保護,則傳遞該選項。

MySQL 服務器將詢問您的數據庫密碼。輸入您的密碼並按ENTER

hello_world_db登錄後,使用以下命令創建一個名為的數據庫:

CREATE DATABASE hello_world_db;

要驗證是否已成功創建數據庫,可以使用以下命令:

SHOW DATABASES;

您的輸出將與此類似:

+--------------------+
|      Database      |
+--------------------+
| hello_world_db     |
| information_schema |
| mysql              |
| performance_schema |
| sys                |
+--------------------+

創建示例數據庫後,斷開與 MySQL 服務器的連接:

mysql> QUIT

現在,您需要為您選擇的數據庫安裝手動驅動程序。由於 Sequelize 僅提供 ORM 功能,它不包含內置的數據庫驅動程序。因此,您需要根據自己的喜好安裝驅動程序。為此,請使用終端導航到項目目錄並使用以下命令將 MySQL 驅動程序安裝到項目中:

npm install --save mysql2

在本例中,您使用的是 MySQL 驅動程序。

注意:由於本教程使用 MySQL 作為數據庫,因此您使用的是驅動程序。根據您的數據庫,您可以像這樣手動安裝驅動程序:

  • npm install --save pg pg-hstore # Postgres
  • npm install --save mysql2
  • npm install --save mariadb
  • npm install --save sqlite3
  • npm install --save tedious # Microsoft SQL Server

現在您已經有了一個示例數據庫,您可以創建您的第一個具有數據庫連接性的 Sequelize 應用程序。

連接到 MySQL 數據庫

在本節中,您將使用 Sequelize 將 Node.js 應用程序連接到 MySQL 數據庫。

要連接到數據庫,請server.js使用nano或您首選的代碼編輯器打開進行編輯:

nano server.js

在這裡,您將使用 Sequelize 實例在應用程序中創建數據庫連接。在該new Sequelize()方法中,傳遞 MySQL 服務器參數和數據庫憑據,如下所示,將DATABASE_USERNAME和替換DATABASE_PASSWORD為您的 MySQL 用戶的憑據:

const Sequelize = require("sequelize");
const sequelize = new Sequelize(
 'hello_world_db',
 'DATABASE_USERNAME',
 'DATABASE_PASSWORD',
  {
    host: 'DATABASE_HOST',
    dialect: 'mysql'
  }
);

host是託管 MySQL 服務器的位置,因此您需要提供服務器 URL 或 IP 地址。如果您使用的是本地安裝的 MySQL 服務器,則可以替換DATABASE_HOSTlocalhost127.0.0.1作為值。

同樣,如果您使用的是遠程服務器,請確保將數據庫連接值相應地替換為適當的遠程服務器詳細信息。

注意:如果您使用任何其他數據庫服務器軟件,您可以相應地替換 dialect 參數。'方言:'mysql','mariadb','postgres','mssql'。

接下來,調用基於 Promise 的 authenticate()方法來實例化與應用程序的數據庫連接。為此,請將以下代碼塊添加到您的server.js文件中:

...

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

authenticate()方法用於連接數據庫並測試給定的憑據是否正確。這裡,數據庫連接默認是打開的,所有查詢都可以使用同一個連接。每當您需要關閉連接時,請sequelize.close()在此調用之後調用該方法authenticate()。要了解有關 Sequelize 的更多信息,請參閱他們的入門指南

Sequelize 提供的大部分方法都是異步的。這意味著您可以在異步代碼塊處於執行時間時在應用程序中運行進程。此外,在異步代碼塊成功執行後,它返回一個promise,這是進程結束時返回的值。因此,在異步代碼塊中,您可以使用then()catch()finally()來返回處理後的數據。

此時,server.js文件將如下所示:

const Sequelize = require("sequelize");

const sequelize = new Sequelize(
   'hello_world_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
  );

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

保存並關閉您的文件。

在項目目錄中,server.js通過運行以下命令運行應用程序:

node server.js

您的輸出將如下所示:

Output
Connection has been established successfully!

您已成功創建數據庫連接。

在此步驟中,您安裝了 Sequelize,創建了示例數據庫,並使用 Sequelize 連接數據庫。接下來,您將在 Sequelize 中使用模型。

第 2 步 — 使用 Sequelize 創建數據庫表

現在您已經創建了一個示例 MySQL 數據庫,您可以使用 Sequelize 創建一個表並用數據填充它。在 Sequelize 中,數據庫表被稱為模型。模型是表示數據庫表的抽象。模型為 Sequelize 定義了幾件事,例如表的名稱、列詳細信息和數據類型。在這一步中,您將為圖書數據創建一個 Sequelize 模型。

首先,book.model.js在項目目錄中創建一個名為的新文件:

nano book.model.js

與上一步類似,在文件頂部添加一個用於數據庫啟動的 Sequelize 代碼,並DataTypes在文件頂部添加一個新的 import for:

const { Sequelize, DataTypes } = require("sequelize");

Sequelize 包含許多內置數據類型。要訪問這些數據類型,您需要為DataTypes. 本教程引用了一些常用的數據類型,例如STRINGINTEGERDATEONLY。要了解更多關於其他支持的數據類型,可以參考官方Sequelize 文檔

然後,包括您之前用於創建與 MySQL 數據庫的連接的行,相應地更新您的 MySQL 憑據:

...

const sequelize = new Sequelize(
   'hello_world_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
  );

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

接下來,您將創建一個名為 的模型books,其中包括titleauthorrelease_datesubjectID。為此,請使用sequelize.define()如下所示的方法:

...

const Book = sequelize.define("books", {
   title: {
     type: DataTypes.STRING,
     allowNull: false
   },
   author: {
     type: DataTypes.STRING,
     allowNull: false
   },
   release_date: {
     type: DataTypes.DATEONLY,
   },
   subject: {
     type: DataTypes.INTEGER,
   }
});

sequelize.define()方法定義了一個新模型,它表示數據庫中的一個表。此代碼塊創建一個名為的表books,並根據titleauthorrelease_date和存儲書籍記錄subject

在此代碼中,allowNull表明模型列值不能為null. 同樣,如果您需要設置這樣的值,您可以使用defaultValue: "value".

接下來,您將book模型添加到您的數據庫中。為此,您將使用以下sync()方法:

...

sequelize.sync().then(() => {
   console.log('Book table created successfully!');
}).catch((error) => {
   console.error('Unable to create table : ', error);
});

在該sync()方法中,您要求 Sequelize 對數據庫執行一些操作。通過這個調用,Sequelize 將自動對數據庫執行 SQL 查詢並創建一個表,打印消息Book table created successfully!

如前所述,sync() 方法是基於 Promise 的方法,這意味著它還可以執行錯誤處理。在此代碼塊中,您將檢查表是否創建成功。如果沒有,它將通過 catch 方法返回錯誤並將其打印在輸出中。

注意:您可以通過傳遞參數來管理模型同步,force以在新表不存在時強制創建新表,否則使用現有表。以下是一些示例,在使用 Sequelize 時可能對您有所幫助:

  • model.sync():如果表不存在,則會創建該表。
  • model.sync({ force: true }):如果同一個表已經存在,這將通過刪除它來創建表。

最終代碼將如下所示:

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'hello_world_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
  );

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

const Book = sequelize.define("books", {
   title: {
     type: DataTypes.STRING,
     allowNull: false
   },
   author: {
     type: DataTypes.STRING,
     allowNull: false
   },
   release_date: {
     type: DataTypes.DATEONLY,
   },
   subject: {
     type: DataTypes.INTEGER,
   }
});

sequelize.sync().then(() => {
   console.log('Book table created successfully!');
}).catch((error) => {
   console.error('Unable to create table : ', error);
});

保存並關閉您的文件。

使用以下命令運行您的應用程序:

node book.model.js

您將在命令行中獲得以下輸出:

Output
Executing (default): SELECT 1+1 AS result
Executing (default): CREATE TABLE IF NOT EXISTS `books` (`id` INTEGER NOT NULL auto_increment , `title` VARCHAR(255) NOT NULL, `author` VARCHAR(255) NOT NULL, `release_date` DATE, `subject` INTEGER, `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL, PRIMARY KEY (`id`)) ENGINE=InnoDB;
Connection has been established successfully.
Executing (default): SHOW INDEX FROM `books`
Book table created successfully!

在輸出中,您將看到返回日誌包含消息Book table created successfully!. 您可以通過檢查數據庫以查看在數據庫books中創建的新表來驗證這一點hello_world_db

要驗證新表的創建,請登錄您的 MySQL 實例:

mysql -u YOUR_USERNAME -p

輸入密碼後,進入示例數據庫:

USE hello_world_db;

然後運行命令顯示表:

SHOW TABLES;

您的輸出將與此類似:

+---------------------------+
| Tables_in_hello_world_db |
+---------------------------+
| books                     |
+---------------------------+
1 row in set (0.00 sec)

最後,斷開與 MySQL 服務器的連接:

mysql> QUIT

您已驗證book模型創建成功。使用此過程,您可以按照相同的過程創建任意數量的模型。

在此步驟中,您在數據庫中創建了一個模型,並開始使用內置方法處理模型。您還使用 Sequelize 支持的數據類型來定義您的模型。接下來,您將使用基本模型查詢。

第 3 步 — 使用 Sequelize 進行數據庫查詢

在此步驟中,您將使用 Sequelize 內置查詢進行插入、選擇、帶條件子句的選擇和刪除。

插入新記錄

在上一步中,您在book數據庫中創建了一個模型。在本節中,您將向此模型中插入數據。

要開始,請複制book.model.js上一步的內容。創建一個名為book.controller.js處理查詢邏輯的新文件。將代碼添加book.model.jsbook.controller.js.

book.controller.js中,找到sync()方法。在該sync()方法中,添加以下突出顯示的行:

...

sequelize.sync().then(() => {
   console.log('Book table created successfully!');

   Book.create({
       title: "Clean Code",
       author: "Robert Cecil Martin",
       release_date: "2021-12-14",
       subject: 3
   }).then(res => {
       console.log(res)
   }).catch((error) => {
       console.error('Failed to create a new record : ', error);
   });

}).catch((error) => {
   console.error('Unable to create table : ', error);
});

在這裡,您使用該方法將新的書籍記錄插入到books您已經創建的模型中sync(),該方法支持將新記錄添加到先前創建的模型中。一旦 sync() 方法成功執行,它就會運行該then()方法。在then()方法內部,您調用create()方法將新記錄插入模型。

您使用該create()方法將需要添加到數據庫的數據作為對像傳遞。突出顯示的代碼部分將在現有books表中插入一個新條目。在此示例中,您添加Clean Codeby Robert Cecil Martin,它已使用subjectID進行分類3。您可以使用相同的代碼,使用其他書籍的信息進行更新,將新記錄添加到您的數據庫中。

保存並關閉文件。

使用以下命令運行應用程序:

node book.controller.js

您的輸出將類似於以下內容:

Output
books {
  dataValues:
   { id: 1,
     title: 'Clean Code',
     author: 'Robert Cecil Martin',
     release_date: '2021-12-14',
     subject: 3,
     updatedAt: 2021-12-14T10:12:16.644Z,
   ...
}

您在數據庫中創建的模型中插入了一條新記錄。您可以使用相同的流程繼續添加多條記錄。

選擇所有記錄

findAll()在本節中,您將使用該方法從數據庫中選擇並獲取所有書籍記錄。為此,首先打開book.controller.js並刪除以前的Book.create()方法。在sync()方法中,添加Book.findAll()如圖所示的方法:

...

sequelize.sync().then(() => {

    Book.findAll().then(res => {
        console.log(res)
    }).catch((error) => {
        console.error('Failed to retrieve data : ', error);
    });

}).catch((error) => {
    console.error('Unable to create table : ', error);
});

...

保存並關閉文件。

接下來,使用以下命令再次運行應用程序:

node book.controller.js

您的輸出將類似於以下內容:

Output
[
  books {
    dataValues: {
      id: 1,
      title: 'Clean Code',
      author: 'Robert Cecil Martin',
      release_date: '2020-01-01',
      subject: 3,
      createdAt: 2021-02-22T09:13:55.000Z,
      updatedAt: 2021-02-22T09:13:55.000Z
    },
    _previousDataValues: {
      id: 1,
      title: 'Clean Code',
      author: 'Robert Cecil Martin',
      release_date: '2020-01-01',
      subject: 3,
      createdAt: 2021-02-22T09:13:55.000Z,
      updatedAt: 2021-02-22T09:13:55.000Z
    },
...
]

輸出包含作為數組對象的所有書籍數據。您成功地使用 SequelizefindAll()方法從數據庫中返回所有圖書數據。

where子句選擇

在本節中,您將使用該where子句選擇帶有條件的值。該where子句用於在獲取數據時指定條件。findOne()在本教程中,您將使用該方法從數據庫中獲取具有特定記錄 ID 的書籍。

為此,打開book.controller.js進行編輯,刪除findAll()方法,然後添加以下行:

...

sequelize.sync().then(() => {

    Book.findOne({
        where: {
            id : "1"
        }
    }).then(res => {
        console.log(res)
    }).catch((error) => {
        console.error('Failed to retrieve data : ', error);
    });

}).catch((error) => {
    console.error('Unable to create table : ', error);
});

findOne()在這裡,您使用帶有where選項的方法從數據庫中選擇特定的書籍記錄。在此示例中,您正在檢索id等於的圖書數據1

保存並關閉文件。

接下來,運行應用程序:

node book.controller.js

您的輸出將類似於以下內容:

Output
books {
  dataValues: {
    id: 1,
    title: 'Clean Code',
    author: 'Robert Cecil Martin',
    release_date: '2020-01-01',
    subject: 'Science',
    createdAt: 2021-02-22T09:13:55.000Z,
    updatedAt: 2021-02-22T09:13:55.000Z
  },
  ...
}

您已成功使用where子句從 Sequelize 模型中獲取數據。您可以where在數據庫應用程序中使用該子句來捕獲條件數據。

刪除記錄

要從數據庫模型中刪除特定記錄,請使用destroy()帶有where選項的方法。為此,打開book.controller.js,刪除該findOne()方法,然後添加以下突出顯示的行:

...
sequelize.sync().then(() => {

  Book.destroy({
      where: {
        id: 2
      }
  }).then(() => {
      console.log("Successfully deleted record.")
  }).catch((error) => {
      console.error('Failed to delete record : ', error);
  });

}).catch((error) => {
    console.error('Unable to create table : ', error);
});

destroy()在這裡,您通過使用帶有where選項的方法並傳入要刪除的書籍的 來從數據庫中刪除書籍記錄id。您將刪除idequals的 book 記錄2

保存並關閉文件。

接下來,運行應用程序:

node book.controller.js

您的輸出將如下所示:

Output
Successfully deleted record.

該記錄已被刪除。

在這一步中,您試驗了數據庫模型和模型查詢。您啟動了數據庫,創建了模型,插入了記錄,檢索了記錄,使用該where子句檢索了帶有條件的記錄,並刪除了選定的記錄。有了 Sequelize 的這些知識,您現在將在 Sequelize 中創建關聯。之後,您將能夠使用 Sequelize 模型定義和處理各種關係。

第 4 步 — 使用 Sequelize 創建關聯

在此步驟中,您將使用 Sequelize 支持的標準關聯類型:一對一一對多多對多關聯。您將使用有關學生、課程和年級水平的示例數據。

Sequelize 使用基於以下數據庫關係的關聯類型:

一對一關係:一對一關係是指一個表中的一條記錄與另一個表中的一條記錄相關聯。在 Sequelize 方面,您可以使用belongsTo()hasOne()關聯來創建這種類型的關係。

一對多關係:一對多關係是指一個表中的一條記錄與另一個表中的多條記錄相關聯。使用 Sequelize,您可以使用hasMany()關聯方法來創建這種類型的關係。

多對多關係:多對多關係是指一張表中的多條記錄與另一張表中的多條記錄相關聯。使用 Sequelize,您可以使用belongsToMany()關聯來創建這種類型的關係。

在創建這些關聯之前,您將首先創建一個名為的新數據庫student_db,並為學生、課程和年級水平添加新模型和一些示例數據。

要創建數據庫,請按照步驟 1 - 安裝和配置 Sequelize 中的相同過程登錄 MySQL 並創建一個名為student_db. 創建新數據庫後,註銷 MySQL。接下來,您將開始創建數據庫關聯。

建立一對一的關係belongsTo()

在本節中,您將使用 Sequelize 模型創建一對一的關係。想像一下,您想獲取一名學生的詳細信息以及他們的年級。由於一個學生只能有一個年級,因此這種關聯是一對一的關係,您可以使用該belongsTo()方法。

注意:belongsTo()和之間有區別hasOne()belongsTo()foreignKey在源表上添加 ,而hasOne()將其添加到目標表中。在任何情況下,如果同時使用兩個關係,它將作為 Sequelize 雙向一對一關係。

belongsTo()方法允許您在兩個 Sequelize 模型之間創建一對一的關係。在此示例中,您使用的是StudentGrade模型。

創建一個名為one_to_one.js. 正如您在上一節中所做的那樣,連接到 MySQL 數據庫,包括創建與數據庫的連接並在文件頂部驗證您的 MySQL 用戶的行。請務必根據需要更新 MySQL 憑據:

const { Sequelize, DataTypes } = require("sequelize");

const sequelize = new Sequelize(
   'student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
  );

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

在本節中,您將在新student_db數據庫中創建三個模型:StudentGradeCourse。您將從創建StudentGrade模型開始。在此步驟的稍後部分,您將創建Courses模型。

對於Student模型,將以下代碼塊添加到one_to_one.js

...
const Student = sequelize.define("students", {
   student_id: {
       type: DataTypes.UUID,
       defaultValue: DataTypes.UUIDV4,
       primaryKey: true,
   },
   name: {
       type: DataTypes.STRING,
       allowNull: false
   }
});

此學生模型包含兩列:student_idname

接下來,為Grade模型添加一個代碼塊:

...
const Grade = sequelize.define("grades", {
   grade: {
       type: DataTypes.INTEGER,
       allowNull: false
   }
});

Grade模型包含列grade

為了演示關聯,您需要將示例數據添加到數據庫中。為此,您將使用該bulk()方法。該方法不是將數據一一插入到行中,而是bulkCreate()允許您一次將多行插入到數據庫模型中。

所以現在,將GradeStudent數據導入數據庫中各自的模型,如下所示:

...
const grade_data = [{grade : 9}, {grade : 10}, {grade : 11}]

const student_data = [
   {name : "John Baker", gradeId: 2},
   {name : "Max Butler", gradeId: 1},
   {name : "Ryan Fisher", gradeId: 3},
   {name : "Robert Gray", gradeId: 2},
   {name : "Sam Lewis", gradeId: 1}
]

sequelize.sync({ force: true }).then(() => {
   Grade.bulkCreate(grade_data, { validate: true }).then(() => {
       Student.bulkCreate(student_data, { validate: true }).then(() => {
           …
       }).catch((err) => { console.log(err); });
   }).catch((err) => { console.log(err); });
}).catch((error) => {
   console.error('Unable to create the table : ', error);
});

在這裡,您提供示例數據並將數據導入StudentGrade模型。準備好數據庫、模型和示例數據後,您就可以創建關聯了。

one-to-one.js中,在塊下方添加以下行student_data

...
Student.belongsTo(Grade);

接下來,您需要檢查關聯是否正常工作。為此,您可以通過在方法中傳遞include參數來檢索所有學生的數據以及相關的年級水平。findAll()

由於您需要獲取學生的年級水平,因此您將Grade作為模型通過。在該sequelize.sync()方法中,添加突出顯示的行,如下所示:

...
sequelize.sync({ force: true }).then(() => {
   Grade.bulkCreate(grade_data, { validate: true }).then(() => {
       Student.bulkCreate(student_data, { validate: true }).then(() => {
           Student.findAll({
               include: [{
                   model: Grade
               }]
           }).then(result => {
               console.log(result)
           }).catch((error) => {
               console.error('Failed to retrieve data : ', error);
           });
       }).catch((err) => { console.log(err); });
   }).catch((err) => { console.log(err); });
}).catch((error) => {
   console.error('Unable to create the table : ', error);
});

完整的代碼如下所示:

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
  );
sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

const Student = sequelize.define("students", {
   student_id: {
       type: DataTypes.UUID,
       defaultValue: DataTypes.UUIDV4,
       primaryKey: true,
   },
   name: {
       type: DataTypes.STRING,
       allowNull: false
   }
});

const Grade = sequelize.define("grades", {
   grade: {
       type: DataTypes.INTEGER,
       allowNull: false
   }
});

const grade_data = [{grade : 9}, {grade : 10}, {grade : 11}]

const student_data = [
   {name : "John Baker", gradeId: 2},
   {name : "Max Butler", gradeId: 1},
   {name : "Ryan Fisher", gradeId: 3},
   {name : "Robert Gray", gradeId: 2},
   {name : "Sam Lewis", gradeId: 1}
]

// One-To-One association
Student.belongsTo(Grade);

sequelize.sync({ force: true }).then(() => {
   Grade.bulkCreate(grade_data, { validate: true }).then(() => {
       Student.bulkCreate(student_data, { validate: true }).then(() => {
           Student.findAll({
               include: [{
                   model: Grade
               }]
           }).then(result => {
               console.log(result)
           }).catch((error) => {
               console.error('Failed to retrieve data : ', error);
           });
       }).catch((err) => { console.log(err); });
   }).catch((err) => { console.log(err); });
}).catch((error) => {
   console.error('Unable to create the table : ', error);
});

保存並關閉您的文件。

使用以下命令運行該文件:

node one_to_one.js

輸出會很長,您將看到所有學生的年級數據。這是顯示學生數據的輸出片段:

Output
students {
    dataValues:
   { student_id: '3e786a8f-7f27-4c59-8e9c-a8c606892288',
       name: 'Sam Lewis',
       createdAt: 2021-12-16T08:49:38.000Z,
       updatedAt: 2021-12-16T08:49:38.000Z,
       gradeId: 1,
       grade: [grades] },
    _previousDataValues:
...

根據您使用的命令行工具,輸出可能會打印為擴展視圖,也可能不打印。如果是展開視圖,則將展開的對像打印grade為輸出。

在本節中,您使用方法調用創建了一對一的關係,Student.belongsTo(Grade);並根據您創建的關聯獲取了詳細信息。

創建一個一對多的關係hasMany()

在本節中,您將使用 Sequelize 模型創建一對多關係。想像一下,您想讓所有學生與選定的年級相關聯。由於一個特定年級可以有多個學生,因此這是一對多的關係。

首先,將 的內容複製one_to_one.js到一個名為one_to_many.js. 在one_to_many.js中,刪除student_data塊之後的行。您的one_to_many.js文件將如下所示:

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
  );

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

const Student = sequelize.define("students", {
   student_id: {
       type: DataTypes.UUID,
       defaultValue: DataTypes.UUIDV4,
       primaryKey: true,
   },
   name: {
       type: DataTypes.STRING,
       allowNull: false
   }
});
const Grade = sequelize.define("grades", {
   grade: {
       type: DataTypes.INTEGER,
       allowNull: false
   }
});

const grade_data = [ {grade : 9}, {grade : 10}, {grade : 11}]

const student_data = [
   {name : "John Baker", gradeId: 2},
   {name : "Max Butler", gradeId: 1},
   {name : "Ryan Fisher", gradeId: 3},
   {name : "Robert Gray", gradeId: 2},
   {name : "Sam Lewis", gradeId: 1}
]

student_data塊之後,使用hasMany()方法創建一個新的關係:

...
Grade.hasMany(Student)

hasMany()方法允許您在兩個 Sequelize 模型之間創建一對多的關係。在這裡,您正在使用GradeStudent模型。

接下來,將sequelize.sync()方法添加findAll()到該行下方的方法中hasMany()

...
sequelize.sync({ force: true }).then(() => {
   Grade.bulkCreate(grade_data, { validate: true }).then(() => {
       Student.bulkCreate(student_data, { validate: true }).then(() => {
           Grade.findAll({
               where: {
                   grade: 9
               },
               include: [{
                   model: Student
               }]
           }).then(result => {
               console.dir(result, { depth: 5 });
           }).catch((error) => {
               console.error('Failed to retrieve data : ', error);
           });
       }).catch((err) => { console.log(err); });
   }).catch((err) => { console.log(err); });
}).catch((error) => {
   console.error('Unable to create table : ', error);
});

在這裡,您嘗試訪問特定年級的所有學生——在本例中,是年級的所有學生9。您還在選項中添加了Student模型include

這是完整的代碼:

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
  );

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

const Student = sequelize.define("students", {
   student_id: {
       type: DataTypes.UUID,
       defaultValue: DataTypes.UUIDV4,
       primaryKey: true,
   },
   name: {
       type: DataTypes.STRING,
       allowNull: false
   }
});
const Grade = sequelize.define("grades", {
   grade: {
       type: DataTypes.INTEGER,
       allowNull: false
   }
});

const grade_data = [ {grade : 9}, {grade : 10}, {grade : 11}]

const student_data = [
   {name : "John Baker", gradeId: 2},
   {name : "Max Butler", gradeId: 1},
   {name : "Ryan Fisher", gradeId: 3},
   {name : "Robert Gray", gradeId: 2},
   {name : "Sam Lewis", gradeId: 1}
]

// One-To-Many relationship
Grade.hasMany(Student);

sequelize.sync({ force: true }).then(() => {
   Grade.bulkCreate(grade_data, { validate: true }).then(() => {
       Student.bulkCreate(student_data, { validate: true }).then(() => {
           Grade.findAll({
               where: {
                   grade: 9
               },
               include: [{
                   model: Student
               }]
           }).then(result => {
               console.dir(result, { depth: 5 });
           }).catch((error) => {
               console.error('Failed to retrieve data : ', error);
           });
       }).catch((err) => { console.log(err); });
   }).catch((err) => { console.log(err); });
}).catch((error) => {
   console.error('Unable to create table : ', error);
});

保存並關閉您的文件。

使用以下命令運行該文件:

node one_to_many.js

輸出將類似於以下內容。這會很長,但所有年級的學生9將按如下方式返回:

Output
[ grades {
    dataValues:
     { id: 1,
       grade: 9,
       createdAt: 2021-12-20T05:12:31.000Z,
       updatedAt: 2021-12-20T05:12:31.000Z,
       students:
        [ students {
            dataValues:
             { student_id: '8a648756-4e22-4bc0-8227-f590335f9965',
               name: 'Sam Lewis',
               createdAt: 2021-12-20T05:12:31.000Z,
               updatedAt: 2021-12-20T05:12:31.000Z,
               gradeId: 1 },
...
          students {
            dataValues:
             { student_id: 'f0304585-91e5-4efc-bdca-501b3dc77ee5',
               name: 'Max Butler',
               createdAt: 2021-12-20T05:12:31.000Z,
               updatedAt: 2021-12-20T05:12:31.000Z,
               gradeId: 1 },
...

Grade.hasMany(Student);在本節中,您使用方法調用創建了一對多關係。在輸出中,您根據創建的關聯檢索了詳細信息。

創建多對多關係belongsToMany()

在本節中,您將使用 Sequelize 模型創建多對多關係。舉個例子,想像一下學生註冊課程的情況。一個學生可以註冊多門課程,一門課程可以有多個學生。這是一個多對多的關係。要使用 Sequelize 實現這一點,您將使用模型、StudentCourse方法。StudentCoursebelongsToMany()

首先,創建一個名為many_to_many.js並添加數據庫啟動和身份驗證代碼塊的文件,如下所示。(您可以重用前面one_to_many.js示例中的代碼塊。)確保根據需要更新突出顯示的數據庫連接值。

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
);

sequelize.authenticate().then(() => {
    console.log('Connection has been established successfully.');
}).catch((error) => {
    console.error('Unable to connect to the database: ', error);
});

接下來,您將為多對多關係創建數據庫模型:StudentCourse. 然後,您將向這些模型添加一些示例數據。

...

const Student = sequelize.define("students", {
    student_id: {
        type: DataTypes.UUID,
        defaultValue: DataTypes.UUIDV4,
    },
    name: {
        type: DataTypes.STRING,
        allowNull: false
    }
});

const Course = sequelize.define("courses", {
    course_name: {
        type: DataTypes.STRING,
        allowNull: false
    }
});

const StudentCourse = sequelize.define('StudentCourse', {
    id: {
      type: DataTypes.INTEGER,
      primaryKey: true,
      autoIncrement: true,
      allowNull: false
    }
  });

const course_data = [
    {course_name : "Science"},
    {course_name : "Maths"},
    {course_name : "History"}
]

const student_data = [
    {name : "John Baker", courseId: 2},
    {name : "Max Butler", courseId: 1},
    {name : "Ryan Fisher", courseId: 3},
    {name : "Robert Gray", courseId: 2},
    {name : "Sam Lewis", courseId: 1}
]

const student_course_data = [
    {studentId : 1, courseId: 1},
    {studentId : 2, courseId: 1},
    {studentId : 2, courseId: 3},
    {studentId : 3, courseId: 2},
    {studentId : 1, courseId: 2},
]

在這裡,您創建StudentCourse模型並提供一些示例數據。您還設置了 a courseID,您將使用它來根據此關係類型檢索學生。

最後,您定義了一個名為 的新模型,它管理和StudentCourse之間的關係數據。在此示例中,已註冊和。StudentCoursestudentId 1courseId 1courseId 2

您已完成數據庫啟動並將示例數據添加到數據庫。接下來,使用如圖所示的方法創建多對多關係belongsToMany()

...
Course.belongsToMany(Student, { through: 'StudentCourse'})
Student.belongsToMany(Course, { through: 'StudentCourse'})

在該方法中,您使用模型名稱作為配置選項belongsToMany()傳遞配置。through在這種情況下,它是StudentCourse。這是管理多對多關係的表。

最後,您可以通過檢索關聯學生的所有課程數據來檢查關聯是否正常工作。您將通過在方法中傳遞include參數來做到這一點。findAll()將以下行添加到many_to_many.js

...
sequelize.sync({ force: true }).then(() => {
    Course.bulkCreate(course_data, { validate: true }).then(() => {
        Student.bulkCreate(student_data, { validate: true }).then(() => {
            StudentCourse.bulkCreate(student_course_data, { validate: true }).then(() => {
                Course.findAll({
                    include: {
                        model: Student,
                    },
                }).then(result => {
                    console.log(result);
                }).catch((error) => {
                    console.error('Failed to retrieve data : ', error);
                });
            }).catch((error) => {
                console.log(error);
            });
        }).catch((error) => {
            console.log(error);
        });
    }).catch((error) => {
        console.log(error);
    });
}).catch((error) => {
    console.error('Unable to create table : ', error);
});

完整的代碼如下所示:

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
);

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

const Student = sequelize.define("students", {
    student_id: {
       type: DataTypes.UUID,
       defaultValue: DataTypes.UUIDV4,
    },
    name: {
       type: DataTypes.STRING,
       allowNull: false
    }
});

const Course = sequelize.define("courses", {
    course_name: {
        type: DataTypes.STRING,
        allowNull: false
    }
});

const StudentCourse = sequelize.define('StudentCourse', {
    id: {
      type: DataTypes.INTEGER,
      primaryKey: true,
      autoIncrement: true,
      allowNull: false
    }
  });

const course_data = [
    {course_name : "Science"},
    {course_name : "Maths"},
    {course_name : "History"}
]

const student_data = [
    {name : "John Baker", courseId: 2},
    {name : "Max Butler", courseId: 1},
    {name : "Ryan Fisher", courseId: 3},
    {name : "Robert Gray", courseId: 2},
    {name : "Sam Lewis", courseId: 1}
]

const student_course_data = [
    {studentId : 1, courseId: 1},
    {studentId : 2, courseId: 1},
    {studentId : 2, courseId: 3},
    {studentId : 3, courseId: 2},
    {studentId : 1, courseId: 2},
]

Course.belongsToMany(Student, { through: 'StudentCourse'})
Student.belongsToMany(Course, { through: 'StudentCourse'})

sequelize.sync({ force: true }).then(() => {
    Course.bulkCreate(course_data, { validate: true }).then(() => {
        Student.bulkCreate(student_data, { validate: true }).then(() => {
            StudentCourse.bulkCreate(student_course_data, { validate: true }).then(() => {
                Course.findAll({
                    include: {
                        model: Student,
                    },
                }).then(result => {
                    console.log(result);
                }).catch((error) => {
                    console.error('Failed to retrieve data : ', error);
                });
            }).catch((error) => {
                console.log(error);
            });
        }).catch((error) => {
            console.log(error);
        });
    }).catch((error) => {
        console.log(error);
    });
}).catch((error) => {
    console.error('Unable to create table : ', error);
});

保存並關閉文件。

使用以下命令運行該文件:

node many_to_many.js

輸出會很長,但看起來類似於以下內容:

Output[ courses {
    dataValues:
     { id: 1,
       course_name: 'Science',
       createdAt: 2022-05-11T04:27:37.000Z,
       updatedAt: 2022-05-11T04:27:37.000Z,
       students: [Array] },
    _previousDataValues:
     { id: 1,
       course_name: 'Science',
       createdAt: 2022-05-11T04:27:37.000Z,
       updatedAt: 2022-05-11T04:27:37.000Z,
       students: [Array] },
    _changed: Set {},
    _options:
     { isNewRecord: false,
       _schema: null,
       _schemaDelimiter: '',
       include: [Array],
       includeNames: [Array],
       includeMap: [Object],
       includeValidated: true,
       attributes: [Array],
       raw: true },
    isNewRecord: false,
    students: [ [students], [students] ] },
  courses {
    dataValues:
     { id: 2,
       course_name: 'Maths',
       createdAt: 2022-05-11T04:27:37.000Z,
       updatedAt: 2022-05-11T04:27:37.000Z,
       students: [Array] },
    _previousDataValues:
...

正如您在此輸出中看到的那樣,已檢索到具有關聯學生的課程。在該塊中,您將看到指示每門課程的courses單獨值。id例如,id: 1連接到course_name: Science科學課,而id: 2數學課,等等。

在數據庫中,您可以看到三個生成的表,其中包含您插入的示例數據。

在此步驟中,您使用 Sequelize 創建了一對一、一對多和多對多關聯。接下來,您將使用原始查詢。

第 5 步 — 使用原始查詢

在此步驟中,您將使用 Sequelize 中的原始查詢。在前面的步驟中,您使用了 Sequelize 內置方法(例如insert()and findAll())來處理數據庫中的數據插入和選擇。您可能已經註意到,這些方法遵循特定的模式來編寫查詢。但是,使用原始查詢,您無需擔心 Sequelize 內置方法和模式。使用您的 SQL 查詢知識,您可以在 Sequelize 中執行從簡單到更高級的一系列查詢。

下面是一個原始查詢示例,它執行從特定表中選擇所有值、根據條件刪除選定值以及使用給定值更新表的操作。

SELECT * FROM table_name;
DELETE FROM table_name WHERE condition;
UPDATE table_name SET y = 42 WHERE x = 12;

在 Sequelize 中,原始查詢主要可用於兩種方法:數組替換和對象替換。當您將值傳遞給 SQL 查詢時,您可以使用數組或對象來進行替換。

在編寫原始查詢之前,您首先需要在示例數據庫中提供學生數據。在上一節創建示例數據庫之後,登錄 MySQL,創建名為 的數據庫sample_student_db,然後退出 MySQL。

接下來,您將添加一些原始數據以開始使用原始查詢。創建一個名為的新文件add_student_records.js並添加以下代碼塊,其中包含前面討論的 Sequelize 方法authenticate()sync()bulkCreate().

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'sample_student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
   );

sequelize.authenticate().then(() => {
    console.log('Connection has been established successfully.');
}).catch((error) => {
    console.error('Unable to connect to the database: ', error);
});

const Student = sequelize.define("students", {
    student_id: {
        type: DataTypes.UUID,
        defaultValue: DataTypes.UUIDV4,
        primaryKey: true,
    },
    name: {
        type: DataTypes.STRING,
        allowNull: false
    }
});

const student_data = [
    {name : "John Baker"},
    {name : "Max Butler"},
    {name : "Ryan Fisher"},
    {name : "Robert Gray"},
    {name : "Sam Lewis"}
]

sequelize.sync({ force: true }).then(() => {

    Student.bulkCreate(student_data, { validate: true }).then((result) => {
        console.log(result);
    }).catch((error) => {
        console.log(error);
    });

}).catch((error) => {
    console.error('Unable to create table : ', error);
});

在這裡,您啟動數據庫連接,創建模型,並在新數據庫中插入一些學生記錄。

保存並關閉文件。

接下來,使用以下命令運行此腳本:

node add_student_records.js

輸出將類似於以下內容。它會很長,但是您插入的所有學生記錄都會返回如下。請注意,由於student_id是自動生成的 UUID(通用唯一標識符)值,因此會因用戶而異。

Output
Executing (default): SELECT 1+1 AS result
Executing (default): DROP TABLE IF EXISTS `students`;
Connection has been established successfully.
Executing (default): DROP TABLE IF EXISTS `students`;
Executing (default): CREATE TABLE IF NOT EXISTS `students` (`student_id` CHAR(36) BINARY , `name` VARCHAR(255) NOT NULL, `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL, PRIMARY KEY (`student_id`)) ENGINE=InnoDB;
Executing (default): SHOW INDEX FROM `students`
Executing (default): INSERT INTO `students` (`student_id`,`name`,`createdAt`,`updatedAt`) VALUES ('45d1f26c-ba76-431f-ac5f-f41282351710','John Baker','2022-06-03 07:27:49','2022-06-03 07:27:49'),('1cb4e34d-bfcf-4a97-9624-e400b9a1a5f2','Max Butler','2022-06-03 07:27:49','2022-06-03 07:27:49'),('954c576b-ba1c-4dbc-a5c6-8eaf22bbbb04','Ryan Fisher','2022-06-03 07:27:49','2022-06-03 07:27:49'),('e0f15cd3-0025-4032-bfe8-774e38e14c5f','Robert Gray','2022-06-03 07:27:49','2022-06-03 07:27:49'),('826a0ec9-edd0-443f-bb12-068235806659','Sam Lewis','2022-06-03 07:27:49','2022-06-03 07:27:49');
[
  students {
    dataValues: {
      student_id: '45d1f26c-ba76-431f-ac5f-f41282351710'`,
      name: 'John Baker',
      createdAt: 2022-06-03T07:27:49.453Z,
      updatedAt: 2022-06-03T07:27:49.453Z
    },
    _previousDataValues: {
      name: 'John Baker',
      student_id: '45d1f26c-ba76-431f-ac5f-f41282351710',
      createdAt: 2022-06-03T07:27:49.453Z,
      updatedAt: 2022-06-03T07:27:49.453Z
    },

…

在下一部分中,您將使用student_id上面代碼塊中的一個輸出應用原始查詢。將其複制下來,以便在接下來的部分使用該query()方法進行數組和對象替換。

陣列替換

在本節中,您將使用該query()方法進行數組替換。使用這種方法,Sequelize 可以執行原始的或已經準備好的 SQL 查詢。

要開始,請server.js步驟 1複製文件的內容,因為其中包括啟動Sequelize()方法和數據庫啟動。將內容粘貼到一個名為array_raw_query.js. 將數據庫名稱更新為sample_student_db

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'sample_student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
   );

sequelize.authenticate().then(() => {
    console.log('Connection has been established successfully.');
}).catch((error) => {
    console.error('Unable to connect to the database: ', error);
});

在文件末尾,為數組替換添加以下代碼塊,確保替換為您在上一節中復制REPLACE_STUDENT_ID的值。student_id

...
sequelize.query(
    'SELECT * FROM students WHERE student_id = ?',
    {
      replacements: ['REPLACE_STUDENT_ID'],
      type: sequelize.QueryTypes.SELECT
    }
).then(result => {
    console.log(result);
}).catch((error) => {
    console.error('Failed to insert data : ', error);
});

對於數組替換,您通過query()SQL 查詢和配置對像傳遞方法。它包含replacements值和類型。對於替換,您將數據作為數組傳遞並使用問號 ( ?) 符號捕獲這些值。

接下來,由於您需要獲取有關特定學生的數據,因此student_id將作為第二個參數傳遞。之後,您傳遞type: sequelize.QueryTypes.SELECT鍵值對,您可以使用它從數據庫中選擇數據。

還有一些其他類型,例如QueryTypes.UPDATEQueryTypes.DELETE。根據需要,您可以選擇適合您用途的類型。

下面顯示了完整的代碼塊。在這裡,您連接到數據庫並使用原始查詢檢索選定的學生數據。

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'sample_student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
   );

sequelize.authenticate().then(() => {
    console.log('Connection has been established successfully.');
}).catch((error) => {
    console.error('Unable to connect to the database: ', error);
});

sequelize.query(
    'SELECT * FROM students WHERE student_id = ?',
    {
      replacements: ['REPLACE_STUDENT_ID'],
      type: sequelize.QueryTypes.SELECT
    }
).then(result => {
    console.log(result);
}).catch((error) => {
    console.error('Failed to insert data : ', error);
});

保存並關閉您的文件。

接下來,您可以使用以下命令運行此腳本:

node array_raw_query.js

您將看到類似於以下內容的輸出:

Output
Connection has been established successfully.
[ { student_id: 'STUDENT_ID_YOU_RETRIEVED',
    name: 'Robert Gray',
    createdAt: 2022-05-06T13:14:50.000Z,
    updatedAt: 2022-05-06T13:14:50.000Z } ]

由於選擇了student_id,您的輸出值可能會有所不同。

對象替換

從表面上看,對象替換類似於數組替換,但將數據傳遞給原始查詢的模式不同。在替換選項中,您將數據作為對像傳遞,而在查詢選項中,您使用諸如:key.

首先,創建一個名為object_raw_query.js並粘貼文件中的完整代碼塊的新server.js文件,將數據庫更新為sample_student_db.

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'sample_student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
   );

sequelize.authenticate().then(() => {
    console.log('Connection has been established successfully.');
}).catch((error) => {
    console.error('Unable to connect to the database: ', error);
});

然後,將以下代碼塊添加到新object_raw_query.js文件的末尾:

...
sequelize.query(
  'SELECT * FROM students WHERE student_id = :id',
  {
    replacements: { id: 'REPLACE_STUDENT_ID' },
    type: sequelize.QueryTypes.SELECT
  }
 ).then(result => {
    console.log(result);
}).catch((error) => {
    console.error('Failed to insert data : ', error);
});

在這裡,您使用對象替換方法獲取選定的學生數據。您創建一個replacement對象,將 設置id為您希望檢索的學生信息:{ id: 'REPLACE_STUDENT_ID' }

在 中query(),您指出:'SELECT * FROM students WHERE student_id = :id'。使用該query()方法,您將替換值作為對像傳遞,這就是此方法被稱為對象替換的原因。

這是完整的代碼:

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'sample_student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
   );

sequelize.authenticate().then(() => {
    console.log('Connection has been established successfully.');
}).catch((error) => {
    console.error('Unable to connect to the database: ', error);
});

sequelize.query(
  'SELECT * FROM students WHERE student_id = :id',
  {
    replacements: { id: 'REPLACE_STUDENT_ID' },
    type: sequelize.QueryTypes.SELECT
  }
 ).then(result => {
    console.log(result);
}).catch((error) => {
    console.error('Failed to insert data : ', error);
});

保存並關閉文件。

接下來,使用以下命令運行此腳本:

node object_raw_query.js

輸出將類似於以下內容:

Output
Connection has been established successfully.
[ { student_id: 'STUDENT_ID_YOU_RETRIEVED',
    name: 'Robert Gray',
    createdAt: 2022-05-06T13:14:50.000Z,
    updatedAt: 2022-05-06T13:14:50.000Z } ]

由於選擇了student_id,您的輸出值可能會有所不同。

在此步驟中,您使用兩種不同的方法處理 Sequelize 原始查詢:數組替換和對象替換。

結論

在本教程中,您安裝並配置了 Sequelize。您還創建並使用了模型,這是 Sequelize 的必備組件之一。最後,您創建了不同類型的關聯並使用實際示例處理原始查詢。

接下來,您可以使用不同的數據類型來創建數據庫模型。您還可以使用內置方法和原始查詢更新和刪除數據庫中的記錄。

原文來源https://www.digitalocean.com

#sequelize #node #mysql #database 

Node.js Tutorials #4 - Node & MySQL - How to use Mysql database with Node.js

Node.js Tutorials #4 - Node & MySQL - How to use Mysql database with Node.js
Sample code in Node with writing SELECT, INSERT, UPDATE query with parameters

Node tutorials playlist - https://www.youtube.com/playlist?list=PLC8jf7P7lriyXGwAdPsmyBsZenxh-gJzl

00:00 Node & MySQL - Install MySQL
01:37 Node & MySQL - SELECT query
11:06 Node & MySQL - INSERT query
11:06 Node & MySQL - Multiple INSERT queries
21:59 Node & MySQL - UPDATE query
26:35 Node & MySQL - DELETE query

Basics of Node.js Tutorials #1 - Starting with Node - https://youtu.be/qO8X0t6YePE
Basics of Node.js Tutorials #2 - Node & Express - GET request - https://youtu.be/7Ryp2YeM_W8
Basics of Node.js Tutorials #3 - Node & Express - POST, PUT, DELETE request - https://youtu.be/3ItPpS_r2a8
Basics of Node.js Tutorials #4 - Node & MySQL - How to use Mysql database with Node.js - https://youtu.be/8Xdz0RP-kD4
Basics of Node.js Tutorials #5 - Node with Express & MySQL - Using Express with MySQL DB in Node.js - https://youtu.be/4DMxw123kw4
Node.js Tutorials #6 - Node & Express Middleware - Using Middleware with Express in Node.js - https://youtu.be/qch1mJQeYvU
Node.js Tutorials #7 - Node & Cookies - Using Cookes with Express in Node.js - Cookie-parser - https://youtu.be/Gm2VNzP4yok
Node.js Tutorials #8 - Node & JSONWebToken (JWT) - Using JSONWebToken (JWT) with Express in Node.js - https://youtu.be/UT1k0DYBBPk

#node.js #mysql #database #node