Poppy Cooke

Poppy Cooke

1658786100

Comment utiliser Sequelize avec Node et MySQL

Découvrez comment installer et configurer Sequelize avec MySQL. Utilisation de Sequelize pour créer des bases de données et des modèles, ainsi que pour effectuer des opérations d'insertion, de sélection, de suppression, etc. 

Sequelize est un mappeur relationnel d'objet basé sur Node.js qui facilite le travail avec les bases de données MySQL , MariaDB , SQLite , PostgreSQL , etc. Un mappeur relationnel d'objet exécute des fonctions telles que la gestion des enregistrements de base de données en représentant les données sous forme d'objets. Sequelize dispose d'un mécanisme de migration puissant qui peut transformer les schémas de base de données existants en nouvelles versions. Dans l'ensemble, Sequelize offre une excellente prise en charge de la synchronisation des bases de données, du chargement rapide, des associations, des transactions et des migrations de bases de données tout en réduisant le temps de développement et en empêchant les injections SQL.

Dans ce didacticiel, vous allez installer et configurer Sequelize avec MySQL sur votre environnement de développement local. Ensuite, vous utiliserez Sequelize pour créer des bases de données et des modèles, ainsi que pour effectuer les opérations insert, selectet delete. Ensuite, vous allez créer des associations Sequelize pour les relations un-à-un , un-à-plusieurs et plusieurs-à-plusieurs . Enfin, vous créerez des requêtes brutes Sequelize pour les remplacements de tableaux et d'objets.

Ce tutoriel a été testé sur Node.js version 14.17.6 et npmversion 6.14.15 sur macOS Catalina.

Étape 1 - Installation et configuration de Sequelize

Dans cette étape, vous allez installer Sequelize et créer la connexion à votre base de données MySQL. Pour ce faire, vous allez d'abord créer une application Node.js. Ensuite, vous installerez Sequelize, configurerez la base de données MySQL et développerez une application simple.

Installation de Sequelize

Commencez par créer un dossier de projet. Dans cet exemple, vous pouvez utiliser hello-world. Une fois le dossier créé, accédez au dossier à l'aide du terminal :

mkdir hello-world
cd hello-world

Créez ensuite un exemple d'application Node.js à l'aide de la commande suivante :

npm init

Ensuite, vous serez invité à répondre à quelques questions de configuration. Utilisez la sortie suivante pour votre configuration. Appuyez sur ENTERpour utiliser la valeur par défaut affichée et veillez à définir le point d'entrée principal sur server.js. Cela crée une structure de projet facile à gérer.

La sortie se présentera comme suit, qui remplira le package.jsonfichier :

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

Créez ensuite un server.jsfichier vide dans le dossier du projet :

touch server.js

Après avoir suivi les étapes précédentes, votre structure de dossier finale ressemblera à ceci :

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

Vous pouvez maintenant installer Sequelize avec la commande suivante :

npm i sequelize@6.11.0

Remarque : Cette commande installe la version 6.11.0. Si vous devez installer la dernière version, exécutez npm i sequelize.

Après ces mises à jour, le package.jsonfichier ressemble maintenant à ceci :

{
  "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"
  }
}

Dans la dependenciessection, vous verrez maintenant une dépendance Sequelize.

Vous avez configuré le projet et installé Sequelize. Ensuite, vous allez créer un exemple de base de données auquel vous connecter.

Création d'un exemple de base de données

Dans le cadre des prérequis, vous avez installé et configuré MySQL, ce qui comprenait la création d'un utilisateur. Vous allez maintenant créer une base de données vide.

Pour ce faire, vous devez d'abord vous connecter à votre instance MySQL. Si vous exécutez à distance, vous pouvez utiliser votre outil préféré. Si vous utilisez une instance MySQL exécutée localement, vous pouvez utiliser la commande suivante, en remplaçant votre_nom d'utilisateur par votre nom d'utilisateur MySQL :

mysql -u your_username -p

-uest le nom d'utilisateur et l' -poption est transmise si le compte est sécurisé par un mot de passe.

Le serveur MySQL vous demandera le mot de passe de votre base de données. Saisissez votre mot de passe et appuyez sur ENTER.

Une fois connecté, créez une base de données appelée hello_world_dbà l'aide de la commande suivante :

CREATE DATABASE hello_world_db;

Pour vérifier si vous avez créé la base de données avec succès, vous pouvez utiliser cette commande :

SHOW DATABASES;

Votre sortie ressemblera à ceci :

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

Après avoir créé l'exemple de base de données, déconnectez-vous du serveur MySQL :

mysql> QUIT

Maintenant, vous devez installer un pilote manuel pour la base de données de votre choix. Comme Sequelize ne fournit que des fonctionnalités ORM, il n'inclut pas les pilotes de base de données intégrés. Par conséquent, vous devrez installer les pilotes selon vos préférences. Pour ce faire, accédez au répertoire du projet à l'aide du terminal et installez le pilote MySQL sur le projet à l'aide de la commande suivante :

npm install --save mysql2

Dans ce cas, vous utilisez le pilote pour MySQL.

Remarque : étant donné que ce didacticiel utilise MySQL comme base de données, vous utilisez un pilote pour cela. En fonction de votre base de données, vous pouvez installer manuellement le pilote comme suit :

  • 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

Maintenant que vous disposez d'un exemple de base de données, vous pouvez créer votre première application Sequelize avec une connectivité de base de données.

Connexion à la base de données MySQL

Dans cette section, vous allez connecter l'application Node.js à la base de données MySQL à l'aide de Sequelize.

Pour vous connecter à la base de données, ouvrez-la server.jspour modification à l'aide de nanoou de votre éditeur de code préféré :

nano server.js

Ici, vous allez créer une connexion à la base de données dans votre application à l'aide d'une instance Sequelize. Dans la new Sequelize()méthode, transmettez les paramètres du serveur MySQL et les informations d'identification de la base de données comme suit, en remplaçant DATABASE_USERNAMEet DATABASE_PASSWORDpar les informations d'identification de votre utilisateur MySQL :

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

hostest l'endroit où le serveur MySQL est hébergé, vous devrez donc fournir une URL de serveur ou une adresse IP. Si vous utilisez un serveur MySQL installé localement, vous pouvez remplacer DATABASE_HOSTpar localhostou 127.0.0.1comme valeur.

De même, si vous utilisez un serveur distant, assurez-vous de remplacer les valeurs de connexion à la base de données en conséquence par les détails appropriés du serveur distant.

Remarque : Si vous utilisez un autre logiciel de serveur de base de données, vous pouvez remplacer le paramètre de dialecte en conséquence. `dialecte : 'mysql', 'mariadb', 'postgres', 'mssql'.

Ensuite, appelez une méthode basée sur les promesses authenticate() pour instancier une connexion de base de données à l'application. Pour ce faire, ajoutez le bloc de code suivant à votre server.jsfichier :

...

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

La authenticate()méthode est utilisée pour se connecter à la base de données et teste si les informations d'identification données sont correctes. Ici, la connexion à la base de données est ouverte par défaut et la même connexion peut être utilisée pour toutes les requêtes. Chaque fois que vous devez fermer la connexion, appelez la sequelize.close()méthode après cet authenticate()appel. Pour en savoir plus sur Sequelize, veuillez consulter leur guide de démarrage .

La plupart des méthodes fournies par Sequelize sont asynchrones. Cela signifie que vous pouvez exécuter des processus dans votre application pendant qu'un bloc de code asynchrone est dans son temps d'exécution. De plus, après l'exécution réussie du bloc de code asynchrone, il renvoie une promesse , qui est la valeur renvoyée à la fin d'un processus. Par conséquent, dans les blocs de code asynchrones, vous pouvez utiliser then(), catch()et finally()pour renvoyer les données traitées.

À ce stade, le server.jsfichier ressemblera à ceci :

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);
});

Enregistrez et fermez votre fichier.

Dans le répertoire du projet, exécutez l' server.jsapplication en exécutant la commande suivante :

node server.js

Votre sortie ressemblera à ceci :

Output
Connection has been established successfully!

Vous avez créé la connexion à la base de données avec succès.

Au cours de cette étape, vous avez installé Sequelize, créé un exemple de base de données et utilisé Sequelize pour vous connecter à la base de données. Ensuite, vous travaillerez avec des modèles dans Sequelize.

Étape 2 - Création d'une table de base de données à l'aide de Sequelize

Maintenant que vous avez créé un exemple de base de données MySQL, vous pouvez utiliser Sequelize pour créer une table et la remplir avec des données. Dans Sequelize, les tables de base de données sont appelées modèles . Un modèle est une abstraction qui représente une table de la base de données. Les modèles définissent plusieurs éléments à séquençage, tels que le nom de la table, les détails des colonnes et les types de données. Dans cette étape, vous allez créer un modèle Sequelize pour les données du livre.

Pour commencer, créez un nouveau fichier appelé book.model.jsdans le répertoire du projet :

nano book.model.js

Semblable à l'étape précédente, ajoutez un code Sequelize pour l'initiation de la base de données avec une nouvelle importation pour DataTypesen haut du fichier :

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

Sequelize contient de nombreux types de données intégrés. Pour accéder à ces types de données, vous ajoutez une importation pour DataTypes. Ce didacticiel fait référence à certains types de données fréquemment utilisés, tels que STRING, INTEGERet DATEONLY. Pour en savoir plus sur les autres types de données pris en charge, vous pouvez vous référer à la documentation officielle de Sequelize .

Ensuite, incluez les lignes que vous avez utilisées précédemment pour créer une connexion à votre base de données MySQL, en mettant à jour vos informations d'identification MySQL en conséquence :

...

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);
});

Ensuite, vous allez créer un modèle appelé books, qui comprend title, author, release_dateet subjectID. Pour ce faire, utilisez la sequelize.define()méthode comme indiqué :

...

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,
   }
});

La sequelize.define()méthode définit un nouveau modèle, qui représente une table dans la base de données. Ce bloc de code crée une table appelée bookset stocke les enregistrements de livre selon les title, author, release_dateet subject.

Dans ce code, allowNullindique que la valeur de la colonne de modèle ne peut pas être null. De même, si vous devez définir une telle valeur, vous pouvez utiliser defaultValue: "value".

Ensuite, vous ajouterez le bookmodèle à votre base de données. Pour ce faire, vous utiliserez la sync()méthode suivante :

...

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

Dans la sync()méthode, vous demandez à Sequelize de faire quelques choses sur la base de données. Avec cet appel, Sequelize effectuera automatiquement une requête SQL vers la base de données et créera une table, en imprimant le message Book table created successfully!.

Comme mentionné, la méthode sync () est une méthode basée sur des promesses, ce qui signifie qu'elle peut également effectuer une gestion des erreurs. Dans ce bloc de code, vous vérifierez si la table est créée avec succès. Sinon, il renverra une erreur via la méthode catch et l'imprimera sur la sortie.

Remarque : Vous pouvez gérer la synchronisation des modèles en passant des forceparamètres pour forcer la création d'une nouvelle table si elle n'existe pas, ou bien en utiliser une existante. Voici quelques exemples qui peuvent vous être utiles lorsque vous travaillez avec Sequelize :

  • model.sync(): Ceci crée la table si elle n'existe pas déjà.
  • model.sync({ force: true }): Cela crée la table en la supprimant si la même table existe déjà.

Le code final ressemblera à ceci :

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);
});

Enregistrez et fermez votre fichier.

Exécutez votre application à l'aide de la commande suivante :

node book.model.js

Vous obtiendrez le résultat suivant dans votre ligne de commande :

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!

Dans la sortie, vous verrez que le journal de retour contient le message, Book table created successfully!. Vous pouvez le vérifier en vérifiant votre base de données pour voir la nouvelle bookstable créée dans la base de hello_world_dbdonnées.

Pour vérifier la création de la nouvelle table, connectez-vous à votre instance MySQL :

mysql -u YOUR_USERNAME -p

Après avoir saisi votre mot de passe, accédez à l'exemple de base de données :

USE hello_world_db;

Et puis exécutez la commande pour afficher les tables :

SHOW TABLES;

Votre sortie ressemblera à ceci :

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

Enfin, déconnectez-vous du serveur MySQL :

mysql> QUIT

Vous avez vérifié que la bookcréation du modèle a réussi. En utilisant ce processus, vous pouvez créer n'importe quel nombre de modèles en suivant la même procédure.

Au cours de cette étape, vous avez créé un modèle dans une base de données et commencé à travailler avec un modèle à l'aide de méthodes intégrées. Vous avez également utilisé des types de données pris en charge par Sequelize pour définir votre modèle. Ensuite, vous travaillerez avec des requêtes de modèle de base.

Étape 3 - Utilisation de Sequelize pour les requêtes de base de données

Dans cette étape, vous utiliserez les requêtes intégrées Sequelize pour l'insertion, la sélection, la sélection avec des clauses conditionnelles et la suppression.

Insertion d'un nouvel enregistrement

À l'étape précédente, vous avez créé un bookmodèle dans la base de données. Dans cette section, vous allez insérer des données dans ce modèle.

Pour commencer, copiez le contenu de book.model.jsl'étape précédente. Créez un nouveau fichier appelé book.controller.jspour gérer la logique de requête. Ajoutez le code de book.model.jsà book.controller.js.

Dans book.controller.js, recherchez la sync()méthode. Dans la sync()méthode, ajoutez les lignes suivantes en surbrillance :

...

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);
});

Ici, vous insérez un nouvel enregistrement de livre dans le booksmodèle que vous avez déjà créé à l'aide de la sync()méthode, qui prend en charge l'ajout de nouveaux enregistrements aux modèles créés précédemment. Une fois que la méthode sync() s'exécute avec succès, elle exécute la then()méthode. Dans la then()méthode, vous appelez create()la méthode pour insérer les nouveaux enregistrements dans le modèle.

Vous utilisez la create()méthode pour transmettre les données que vous devez ajouter à la base de données en tant qu'objet. La section de code en surbrillance insérera une nouvelle entrée dans votre bookstable existante. Dans cet exemple, vous ajoutez Clean Codepar Robert Cecil Martin, qui a été classé avec l' subjectID de 3. Vous pouvez utiliser le même code, mis à jour avec les informations d'autres livres, pour ajouter de nouveaux enregistrements à votre base de données.

Enregistrez et fermez le fichier.

Exécutez l'application à l'aide de la commande suivante :

node book.controller.js

Votre sortie ressemblera à ce qui suit :

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,
   ...
}

Vous avez inséré un nouvel enregistrement dans le modèle que vous avez créé dans la base de données. Vous pouvez continuer à ajouter plusieurs enregistrements en utilisant le même processus.

Sélection de tous les enregistrements

Dans cette section, vous allez sélectionner et obtenir tous les enregistrements de livres de la base de données à l'aide de la findAll()méthode. Pour ce faire, ouvrez book.controller.jset supprimez d'abord la Book.create()méthode précédente. Dans la sync()méthode, ajoutez la Book.findAll()méthode comme indiqué :

...

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);
});

...

Enregistrez et fermez le fichier.

Ensuite, relancez l'application à l'aide de la commande suivante :

node book.controller.js

Votre sortie ressemblera à ce qui suit :

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 sortie contient toutes les données du livre sous la forme d'un objet tableau. Vous avez utilisé avec succès la méthode Sequelize findAll()pour renvoyer toutes les données de livre à partir de la base de données.

Sélection avec la whereclause

Dans cette section, vous sélectionnerez des valeurs avec des conditions à l'aide de la whereclause. La whereclause est utilisée pour spécifier une condition lors de la récupération des données. Pour ce didacticiel, vous obtiendrez un livre par un ID d'enregistrement spécifique à partir de la base de données à l'aide de la findOne()méthode.

Pour ce faire, ouvrez book.controller.jspour modification, supprimez la findAll()méthode et ajoutez les lignes suivantes :

...

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);
});

Ici, vous sélectionnez un enregistrement de livre spécifique dans la base de données en utilisant la findOne()méthode avec l' whereoption. Dans cet exemple, vous récupérez les données du livre dont idest égal à 1.

Enregistrez et fermez le fichier.

Ensuite, lancez l'application :

node book.controller.js

Votre sortie ressemblera à ce qui suit :

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
  },
  ...
}

Vous avez utilisé avec succès des whereclauses pour obtenir des données à partir de modèles Sequelize. Vous pouvez utiliser la whereclause dans l'application de base de données pour capturer des données conditionnelles.

Suppression d'un enregistrement

Pour supprimer un enregistrement spécifique du modèle de base de données, vous utilisez la destroy()méthode avec l' whereoption. Pour ce faire, ouvrez book.controller.js, supprimez la findOne()méthode et ajoutez les lignes suivantes en surbrillance :

...
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);
});

Ici, vous supprimez un enregistrement de livre de la base de données en utilisant la destroy()méthode avec l' whereoption et en passant le iddu livre à supprimer. Vous allez supprimer la notice du livre dont idest égal à 2.

Enregistrez et fermez le fichier.

Ensuite, lancez l'application :

node book.controller.js

Votre sortie ressemblera à ceci :

Output
Successfully deleted record.

L'enregistrement a été supprimé.

Au cours de cette étape, vous avez testé votre modèle de base de données et l'interrogation du modèle. Vous avez lancé la base de données, créé des modèles, inséré des enregistrements, récupéré des enregistrements, récupéré des enregistrements avec des conditions à l'aide de la whereclause et supprimé des enregistrements sélectionnés. Avec cette connaissance de Sequelize, vous allez maintenant créer des associations dans Sequelize. Après cela, vous serez en mesure de définir et de travailler avec une variété de relations à l'aide de modèles Sequelize.

Étape 4 - Création d'associations à l'aide de Sequelize

Dans cette étape, vous utiliserez les types d'associations standard pris en charge par Sequelize : les associations one-to-one , one-to-many et many-to-many . Vous utiliserez des exemples de données sur les étudiants, les cours et les niveaux scolaires.

Sequelize utilise des types d'association basés sur les relations de base de données suivantes :

relation un à un : une relation un à un signifie qu'un enregistrement dans une table est associé à exactement un enregistrement dans une autre table. En termes de Sequelize, vous pouvez utiliserbelongsTo()ethasOne()des associations pour créer ce type de relation.

relation un-à-plusieurs : une relation un-à-plusieurs signifie qu'un enregistrement dans une table est associé à plusieurs enregistrements dans une autre table. Avec Sequelize, vous pouvez utiliserhasMany()des méthodes d'associations pour créer ce type de relation.

relation plusieurs à plusieurs : une relation plusieurs à plusieurs signifie que plusieurs enregistrements d'une table sont associés à plusieurs enregistrements d'une autre table. Avec Sequelize, vous pouvez utiliserbelongsToMany()des associations pour créer ce type de relation.

Avant de créer ces associations, vous allez d'abord créer une nouvelle base de données appelée student_dbet ajouter de nouveaux modèles et quelques exemples de données pour les étudiants, les cours et le niveau scolaire.

Pour créer la base de données, suivez le même processus à l'Étape 1 — Installation et configuration de Sequelize pour vous connecter à MySQL et créer une base de données appelée student_db. Une fois la nouvelle base de données créée, déconnectez-vous de MySQL. Ensuite, vous commencerez à créer des associations de base de données.

Créer une relation individuelle avecbelongsTo()

Dans cette section, vous allez créer une relation un-à-un à l'aide de modèles Sequelize. Imaginez que vous souhaitiez obtenir les détails d'un élève ainsi que son niveau scolaire. Puisqu'un élève ne peut avoir qu'un seul niveau scolaire, ce type d'association est une relation un à un et vous pouvez utiliser la belongsTo()méthode.

Remarque : il existe une différence entre belongsTo()et hasOne(). belongsTo()ajoutera le foreignKeysur la table source, tandis que hasOne()l'ajoutera à la table cible. Dans tous les cas, si les deux relations sont utilisées en même temps, cela fonctionnera comme des relations séquentielles bidirectionnelles bidirectionnelles.

La belongsTo()méthode vous permet de créer une relation un à un entre deux modèles Sequelize. Dans cet exemple, vous utilisez les modèles Studentet .Grade

Créez un nouveau fichier nommé one_to_one.js. Comme vous l'avez fait dans la section précédente, Connexion à la base de données MySQL , incluez les lignes pour créer une connexion à la base de données et authentifiez votre utilisateur MySQL en haut du fichier. Assurez-vous de mettre à jour les informations d'identification MySQL si nécessaire :

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);
});

Dans cette section, vous allez créer trois modèles dans la nouvelle base de student_dbdonnées : Student, Gradeet Course. Vous commencerez par créer les modèles Studentet . GradePlus tard dans cette étape, vous créerez le Coursesmodèle.

Pour le Studentmodèle, ajoutez le bloc de code suivant à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
   }
});

Ce modèle étudiant contient deux colonnes : student_idet name.

Ensuite, ajoutez un bloc de code pour le Grademodèle :

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

Le Grademodèle contient la colonne grade.

Pour démontrer les associations, vous devrez ajouter des exemples de données à la base de données. Pour cela, vous utiliserez la bulk()méthode. Plutôt que d'insérer des données dans les lignes une par une, la bulkCreate()méthode vous permet d'insérer plusieurs lignes dans vos modèles de base de données à la fois.

Alors maintenant, importez les données Gradeet Studentdans leurs modèles respectifs dans la base de données comme indiqué :

...
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);
});

Ici, vous fournissez des exemples de données et importez les données dans les modèles Studentet . GradeUne fois votre base de données, vos modèles et vos exemples de données en place, vous êtes prêt à créer des associations.

Dans one-to-one.js, ajoutez la ligne suivante sous le student_databloc :

...
Student.belongsTo(Grade);

Ensuite, vous devrez vérifier si l'association fonctionne correctement. Pour ce faire, vous pouvez récupérer toutes les données des élèves avec les niveaux scolaires associés en passant le includeparamètre à l'intérieur de la findAll()méthode.

Puisque vous devez obtenir le niveau scolaire de l'étudiant, vous passerez Gradepour le modèle. Dans la sequelize.sync()méthode, ajoutez les lignes en surbrillance comme indiqué :

...
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);
});

Le code complet ressemble à ceci :

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);
});

Enregistrez et fermez votre fichier.

Exécutez le fichier à l'aide de la commande suivante :

node one_to_one.js

La sortie sera longue et vous verrez toutes les données des élèves avec les niveaux scolaires. Voici un extrait de la sortie montrant les données des étudiants :

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:
...

Selon les outils de ligne de commande que vous utilisez, la sortie peut être imprimée sous forme de vue développée ou non. S'il s'agit d'une vue développée, il imprime l' gradeobjet développé comme sortie.

Dans cette section, vous avez créé une relation un-à-un à l'aide de l' Student.belongsTo(Grade);appel de méthode et obtenu les détails en fonction de l'association que vous avez créée.

Créer une relation un-à-plusieurs avechasMany()

Dans cette section, vous allez créer une relation un-à-plusieurs à l'aide de modèles Sequelize. Imaginez que vous vouliez que tous les élèves soient associés à un niveau scolaire sélectionné. Étant donné qu'un niveau scolaire spécifique peut avoir plusieurs élèves, il s'agit d'une relation un-à-plusieurs.

Pour commencer, copiez le contenu de one_to_one.jsdans un nouveau fichier appelé one_to_many.js. Dans one_to_many.js, supprimez les lignes après le student_databloc. Votre one_to_many.jsfichier ressemblera à ceci :

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}
]

Après le student_databloc, utilisez la hasMany()méthode pour créer une nouvelle relation :

...
Grade.hasMany(Student)

La hasMany()méthode vous permet de créer une relation un-à-plusieurs entre deux modèles Sequelize. Ici, vous utilisez les modèles Gradeet .Student

Ensuite, ajoutez la sequelize.sync()méthode avec la findAll()méthode sous la hasMany()ligne :

...
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);
});

Ici, vous essayez d'accéder à tous les élèves d'un niveau particulier, dans ce cas, tous les élèves du niveau 9. Vous avez également ajouté le Studentmodèle dans l' includeoption.

Voici le code complet :

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);
});

Enregistrez et fermez votre fichier.

Exécutez le fichier avec la commande suivante :

node one_to_many.js

La sortie ressemblera à ce qui suit. Ce sera assez long, mais tous les élèves en grade 9seront renvoyés comme suit :

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 },
...

Dans cette section, vous avez créé une relation un-à-plusieurs à l'aide de l' Grade.hasMany(Student);appel de méthode. Dans la sortie, vous avez récupéré les détails en fonction de l'association que vous avez créée.

Création de relations plusieurs-à-plusieurs avecbelongsToMany()

Dans cette section, vous allez créer des relations plusieurs à plusieurs à l'aide de modèles Sequelize. À titre d'exemple, imaginez une situation où les étudiants sont inscrits à des cours. Un étudiant peut s'inscrire à plusieurs cours et un cours peut avoir plusieurs étudiants. Il s'agit d'une relation plusieurs à plusieurs. Pour implémenter cela à l'aide de Sequelize, vous utiliserez les modèles Student, Courseet StudentCourseavec la belongsToMany()méthode .

Pour commencer, créez un fichier appelé many_to_many.jset ajoutez les blocs de code d'initiation et d'authentification de la base de données comme suit. (Vous pouvez réutiliser les blocs de code de l' one_to_many.jsexemple précédent.) Assurez-vous de mettre à jour les valeurs de connexion à la base de données en surbrillance si nécessaire.

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);
});

Ensuite, vous allez créer les modèles de base de données pour les relations plusieurs-à-plusieurs : Studentet Course. Ensuite, vous ajouterez des exemples de données à ces modèles.

...

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},
]

Ici, vous créez les modèles Studentet Courseet fournissez des exemples de données. Vous définissez également un courseID, que vous utiliserez pour récupérer les étudiants en fonction de ce type de relation.

Enfin, vous avez défini un nouveau modèle appelé StudentCourse, qui gère les données de relation entre Studentet Course. Dans cet exemple, studentId 1est inscrit dans courseId 1et courseId 2.

Vous avez terminé l'initialisation de la base de données et ajouté des exemples de données à la base de données. Ensuite, créez des relations plusieurs à plusieurs en utilisant la belongsToMany()méthode comme indiqué :

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

Dans la belongsToMany()méthode, vous transmettez la throughconfiguration avec le nom du modèle comme option de configuration. Dans ce cas, c'est StudentCourse. C'est la table qui gère les relations plusieurs-à-plusieurs.

Enfin, vous pouvez vérifier le bon fonctionnement de l'association en récupérant toutes les données des cours avec les étudiants associés. Vous ferez cela en passant le includeparamètre à l'intérieur de la findAll()méthode. Ajoutez les lignes suivantes à 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);
});

Le code complet ressemble à ceci :

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);
});

Enregistrez et fermez le fichier.

Exécutez le fichier à l'aide de la commande suivante :

node many_to_many.js

La sortie sera longue, mais ressemblera à ce qui suit :

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:
...

Comme vous pouvez le voir dans cette sortie, les cours avec les étudiants associés ont été récupérés. Dans le coursesbloc, vous verrez des idvaleurs distinctes qui indiquent chaque cours. Par exemple, id: 1est connecté au course_name: Sciencepour le cours de sciences, tandis que id: 2est le cours de mathématiques, etc.

Dans la base de données, vous pouvez voir les trois tables générées avec les exemples de données que vous avez insérés.

Dans cette étape, vous avez utilisé Sequelize pour créer des associations un-à-un, un-à-plusieurs et plusieurs-à-plusieurs. Ensuite, vous travaillerez avec des requêtes brutes.

Étape 5 - Travailler avec des requêtes brutes

Dans cette étape, vous travaillerez avec des requêtes brutes dans Sequelize. Dans les étapes précédentes, vous avez utilisé les méthodes intégrées Sequelize, telles que insert()et findAll(), pour gérer l'insertion et la sélection de données dans la base de données. Vous avez peut-être remarqué que ces méthodes suivent un modèle spécifique pour écrire une requête. Cependant, avec l'utilisation de requêtes brutes, vous n'avez pas à vous soucier des méthodes et des modèles intégrés de Sequelize. En utilisant votre connaissance des requêtes SQL, vous pouvez effectuer une gamme de requêtes dans Sequelize, des plus simples aux plus avancées.

Voici un exemple de requêtes brutes qui effectuent l'action de sélectionner toutes les valeurs d'une table particulière, de supprimer les valeurs sélectionnées en fonction de la condition et de mettre à jour la table avec les valeurs données.

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

Dans Sequelize, les requêtes brutes peuvent être utilisées avec principalement deux méthodologies : le remplacement de tableau et le remplacement d'objet. Lorsque vous transmettez des valeurs à la requête SQL, vous pouvez utiliser un tableau ou un objet pour effectuer ce remplacement.

Avant d'écrire une requête brute, vous devrez d'abord fournir des données sur les étudiants dans un exemple de base de données. Après la section précédente, Création d'un exemple de base de données , connectez-vous à MySQL, créez une base de données appelée sample_student_dbet déconnectez-vous de MySQL.

Ensuite, vous allez ajouter des données brutes pour commencer à travailler avec des requêtes brutes. Créez un nouveau fichier appelé add_student_records.jset ajoutez les blocs de code suivants, qui contiennent les méthodes Sequelize décrites précédemment de authenticate(), sync()et 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);
});

Ici, vous lancez la connexion à la base de données, créez le modèle et insérez quelques enregistrements d'étudiants dans la nouvelle base de données.

Enregistrez et fermez le fichier.

Ensuite, exécutez ce script à l'aide de la commande suivante :

node add_student_records.js

La sortie sera quelque chose de similaire à ce qui suit. Ce sera assez long, mais tous les dossiers étudiants que vous aurez insérés seront retournés comme suit. Notez que comme il s'agit d'une valeur UUID ( Universally Unique Identifiersstudent_id ) générée automatiquement , elle sera différente selon l'utilisateur.

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
    },

…

Dans la section suivante, vous appliquerez des requêtes brutes à l'aide de l'une des student_idsorties du bloc de code ci-dessus. Copiez-le afin que vous l'ayez pour les sections suivantes, où vous utiliserez la query()méthode pour les remplacements de tableaux et d'objets.

Remplacement de baie

Dans cette section, vous utiliserez la query()méthode de remplacement d'un tableau. Avec cette méthode, Sequelize peut exécuter des requêtes SQL brutes ou déjà préparées.

Pour commencer, copiez le contenu du server.jsfichier de l' étape 1 , car cela inclut la Sequelize()méthode d'initialisation et l'initialisation de la base de données. Collez le contenu dans un nouveau fichier nommé array_raw_query.js. Mettez à jour le nom de la base de donnéessample_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);
});

À la fin du fichier, ajoutez le bloc de code suivant pour un remplacement de tableau, en veillant à remplacer REPLACE_STUDENT_IDpar la student_idvaleur que vous avez copiée dans la section précédente.

...
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);
});

Pour le remplacement de tableau, vous transmettez la query()méthode avec la requête SQL et l'objet de configuration. Il contient la replacementsvaleur et le type. ?Pour les remplacements, vous transmettez des données sous forme de tableau et saisissez ces valeurs à l'aide du symbole de point d'interrogation ( ).

Ensuite, puisque vous avez besoin d'obtenir des données sur un étudiant spécifique, le student_idest passé comme deuxième paramètre. Après cela, vous transmettez la type: sequelize.QueryTypes.SELECTpaire clé-valeur, que vous pouvez utiliser pour sélectionner des données dans la base de données.

Il existe également d'autres types, tels que QueryTypes.UPDATEet QueryTypes.DELETE. Selon les besoins, vous pouvez sélectionner le type qui convient à votre objectif.

Ce qui suit montre le bloc de code complet. Ici, vous vous connectez à la base de données et récupérez les données des étudiants sélectionnés à l'aide d'une requête brute.

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);
});

Enregistrez et fermez votre fichier.

Ensuite, vous pouvez exécuter ce script à l'aide de la commande suivante :

node array_raw_query.js

Vous verrez une sortie semblable à la suivante :

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 } ]

En raison du sélectionné student_id, vos valeurs de sortie peuvent différer.

Remplacement d'objet

En surface, le remplacement d'objet est similaire au remplacement de tableau, mais le modèle de transmission des données à la requête brute est différent. Dans l'option de remplacement, vous transmettez des données en tant qu'objet et dans l'option de requête, vous utilisez des valeurs telles que :key.

Pour commencer, créez un nouveau fichier appelé object_raw_query.jset collez les blocs de code complets du server.jsfichier, en mettant à jour la base de données vers 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);
});

Ajoutez ensuite le bloc de code suivant à la fin du nouveau object_raw_query.jsfichier :

...
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);
});

Ici, vous obtenez des données d'étudiants sélectionnés en utilisant la méthode de remplacement d'objet. Vous créez un replacementobjet, en définissant le idcomme les informations sur l'étudiant que vous souhaitez récupérer : { id: 'REPLACE_STUDENT_ID' }.

Dans le query(), vous indiquez : 'SELECT * FROM students WHERE student_id = :id'. En utilisant la query()méthode, vous transmettez la valeur de remplacement en tant qu'objet, c'est pourquoi cette méthode est connue sous le nom de remplacement d'objet.

Voici le code complet :

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);
});

Enregistrez et fermez le fichier.

Ensuite, exécutez ce script à l'aide de la commande suivante :

node object_raw_query.js

La sortie ressemblera à ce qui suit :

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 } ]

En raison du sélectionné student_id, vos valeurs de sortie peuvent différer.

Au cours de cette étape, vous avez travaillé avec des requêtes brutes Sequelize en utilisant deux méthodologies différentes : le remplacement de tableau et le remplacement d'objet.

Conclusion

Dans ce didacticiel, vous avez installé et configuré Sequelize. Vous avez également créé et travaillé avec des modèles, ce qui est l'un des composants obligatoires de Sequelize. Enfin, vous avez créé différents types d'associations et travaillé avec des requêtes brutes à l'aide d'exemples pratiques.

Ensuite, vous pouvez utiliser différents types de données pour créer des modèles de base de données. Vous pouvez également mettre à jour et supprimer des enregistrements dans des bases de données avec des méthodes intégrées et des requêtes brutes.

Source de l'article original sur https://www.digitalocean.com

#sequelize #node #mysql #database 

What is GEEK

Buddha Community

Comment utiliser Sequelize avec Node et 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

Poppy Cooke

Poppy Cooke

1658786100

Comment utiliser Sequelize avec Node et MySQL

Découvrez comment installer et configurer Sequelize avec MySQL. Utilisation de Sequelize pour créer des bases de données et des modèles, ainsi que pour effectuer des opérations d'insertion, de sélection, de suppression, etc. 

Sequelize est un mappeur relationnel d'objet basé sur Node.js qui facilite le travail avec les bases de données MySQL , MariaDB , SQLite , PostgreSQL , etc. Un mappeur relationnel d'objet exécute des fonctions telles que la gestion des enregistrements de base de données en représentant les données sous forme d'objets. Sequelize dispose d'un mécanisme de migration puissant qui peut transformer les schémas de base de données existants en nouvelles versions. Dans l'ensemble, Sequelize offre une excellente prise en charge de la synchronisation des bases de données, du chargement rapide, des associations, des transactions et des migrations de bases de données tout en réduisant le temps de développement et en empêchant les injections SQL.

Dans ce didacticiel, vous allez installer et configurer Sequelize avec MySQL sur votre environnement de développement local. Ensuite, vous utiliserez Sequelize pour créer des bases de données et des modèles, ainsi que pour effectuer les opérations insert, selectet delete. Ensuite, vous allez créer des associations Sequelize pour les relations un-à-un , un-à-plusieurs et plusieurs-à-plusieurs . Enfin, vous créerez des requêtes brutes Sequelize pour les remplacements de tableaux et d'objets.

Ce tutoriel a été testé sur Node.js version 14.17.6 et npmversion 6.14.15 sur macOS Catalina.

Étape 1 - Installation et configuration de Sequelize

Dans cette étape, vous allez installer Sequelize et créer la connexion à votre base de données MySQL. Pour ce faire, vous allez d'abord créer une application Node.js. Ensuite, vous installerez Sequelize, configurerez la base de données MySQL et développerez une application simple.

Installation de Sequelize

Commencez par créer un dossier de projet. Dans cet exemple, vous pouvez utiliser hello-world. Une fois le dossier créé, accédez au dossier à l'aide du terminal :

mkdir hello-world
cd hello-world

Créez ensuite un exemple d'application Node.js à l'aide de la commande suivante :

npm init

Ensuite, vous serez invité à répondre à quelques questions de configuration. Utilisez la sortie suivante pour votre configuration. Appuyez sur ENTERpour utiliser la valeur par défaut affichée et veillez à définir le point d'entrée principal sur server.js. Cela crée une structure de projet facile à gérer.

La sortie se présentera comme suit, qui remplira le package.jsonfichier :

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

Créez ensuite un server.jsfichier vide dans le dossier du projet :

touch server.js

Après avoir suivi les étapes précédentes, votre structure de dossier finale ressemblera à ceci :

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

Vous pouvez maintenant installer Sequelize avec la commande suivante :

npm i sequelize@6.11.0

Remarque : Cette commande installe la version 6.11.0. Si vous devez installer la dernière version, exécutez npm i sequelize.

Après ces mises à jour, le package.jsonfichier ressemble maintenant à ceci :

{
  "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"
  }
}

Dans la dependenciessection, vous verrez maintenant une dépendance Sequelize.

Vous avez configuré le projet et installé Sequelize. Ensuite, vous allez créer un exemple de base de données auquel vous connecter.

Création d'un exemple de base de données

Dans le cadre des prérequis, vous avez installé et configuré MySQL, ce qui comprenait la création d'un utilisateur. Vous allez maintenant créer une base de données vide.

Pour ce faire, vous devez d'abord vous connecter à votre instance MySQL. Si vous exécutez à distance, vous pouvez utiliser votre outil préféré. Si vous utilisez une instance MySQL exécutée localement, vous pouvez utiliser la commande suivante, en remplaçant votre_nom d'utilisateur par votre nom d'utilisateur MySQL :

mysql -u your_username -p

-uest le nom d'utilisateur et l' -poption est transmise si le compte est sécurisé par un mot de passe.

Le serveur MySQL vous demandera le mot de passe de votre base de données. Saisissez votre mot de passe et appuyez sur ENTER.

Une fois connecté, créez une base de données appelée hello_world_dbà l'aide de la commande suivante :

CREATE DATABASE hello_world_db;

Pour vérifier si vous avez créé la base de données avec succès, vous pouvez utiliser cette commande :

SHOW DATABASES;

Votre sortie ressemblera à ceci :

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

Après avoir créé l'exemple de base de données, déconnectez-vous du serveur MySQL :

mysql> QUIT

Maintenant, vous devez installer un pilote manuel pour la base de données de votre choix. Comme Sequelize ne fournit que des fonctionnalités ORM, il n'inclut pas les pilotes de base de données intégrés. Par conséquent, vous devrez installer les pilotes selon vos préférences. Pour ce faire, accédez au répertoire du projet à l'aide du terminal et installez le pilote MySQL sur le projet à l'aide de la commande suivante :

npm install --save mysql2

Dans ce cas, vous utilisez le pilote pour MySQL.

Remarque : étant donné que ce didacticiel utilise MySQL comme base de données, vous utilisez un pilote pour cela. En fonction de votre base de données, vous pouvez installer manuellement le pilote comme suit :

  • 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

Maintenant que vous disposez d'un exemple de base de données, vous pouvez créer votre première application Sequelize avec une connectivité de base de données.

Connexion à la base de données MySQL

Dans cette section, vous allez connecter l'application Node.js à la base de données MySQL à l'aide de Sequelize.

Pour vous connecter à la base de données, ouvrez-la server.jspour modification à l'aide de nanoou de votre éditeur de code préféré :

nano server.js

Ici, vous allez créer une connexion à la base de données dans votre application à l'aide d'une instance Sequelize. Dans la new Sequelize()méthode, transmettez les paramètres du serveur MySQL et les informations d'identification de la base de données comme suit, en remplaçant DATABASE_USERNAMEet DATABASE_PASSWORDpar les informations d'identification de votre utilisateur MySQL :

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

hostest l'endroit où le serveur MySQL est hébergé, vous devrez donc fournir une URL de serveur ou une adresse IP. Si vous utilisez un serveur MySQL installé localement, vous pouvez remplacer DATABASE_HOSTpar localhostou 127.0.0.1comme valeur.

De même, si vous utilisez un serveur distant, assurez-vous de remplacer les valeurs de connexion à la base de données en conséquence par les détails appropriés du serveur distant.

Remarque : Si vous utilisez un autre logiciel de serveur de base de données, vous pouvez remplacer le paramètre de dialecte en conséquence. `dialecte : 'mysql', 'mariadb', 'postgres', 'mssql'.

Ensuite, appelez une méthode basée sur les promesses authenticate() pour instancier une connexion de base de données à l'application. Pour ce faire, ajoutez le bloc de code suivant à votre server.jsfichier :

...

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

La authenticate()méthode est utilisée pour se connecter à la base de données et teste si les informations d'identification données sont correctes. Ici, la connexion à la base de données est ouverte par défaut et la même connexion peut être utilisée pour toutes les requêtes. Chaque fois que vous devez fermer la connexion, appelez la sequelize.close()méthode après cet authenticate()appel. Pour en savoir plus sur Sequelize, veuillez consulter leur guide de démarrage .

La plupart des méthodes fournies par Sequelize sont asynchrones. Cela signifie que vous pouvez exécuter des processus dans votre application pendant qu'un bloc de code asynchrone est dans son temps d'exécution. De plus, après l'exécution réussie du bloc de code asynchrone, il renvoie une promesse , qui est la valeur renvoyée à la fin d'un processus. Par conséquent, dans les blocs de code asynchrones, vous pouvez utiliser then(), catch()et finally()pour renvoyer les données traitées.

À ce stade, le server.jsfichier ressemblera à ceci :

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);
});

Enregistrez et fermez votre fichier.

Dans le répertoire du projet, exécutez l' server.jsapplication en exécutant la commande suivante :

node server.js

Votre sortie ressemblera à ceci :

Output
Connection has been established successfully!

Vous avez créé la connexion à la base de données avec succès.

Au cours de cette étape, vous avez installé Sequelize, créé un exemple de base de données et utilisé Sequelize pour vous connecter à la base de données. Ensuite, vous travaillerez avec des modèles dans Sequelize.

Étape 2 - Création d'une table de base de données à l'aide de Sequelize

Maintenant que vous avez créé un exemple de base de données MySQL, vous pouvez utiliser Sequelize pour créer une table et la remplir avec des données. Dans Sequelize, les tables de base de données sont appelées modèles . Un modèle est une abstraction qui représente une table de la base de données. Les modèles définissent plusieurs éléments à séquençage, tels que le nom de la table, les détails des colonnes et les types de données. Dans cette étape, vous allez créer un modèle Sequelize pour les données du livre.

Pour commencer, créez un nouveau fichier appelé book.model.jsdans le répertoire du projet :

nano book.model.js

Semblable à l'étape précédente, ajoutez un code Sequelize pour l'initiation de la base de données avec une nouvelle importation pour DataTypesen haut du fichier :

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

Sequelize contient de nombreux types de données intégrés. Pour accéder à ces types de données, vous ajoutez une importation pour DataTypes. Ce didacticiel fait référence à certains types de données fréquemment utilisés, tels que STRING, INTEGERet DATEONLY. Pour en savoir plus sur les autres types de données pris en charge, vous pouvez vous référer à la documentation officielle de Sequelize .

Ensuite, incluez les lignes que vous avez utilisées précédemment pour créer une connexion à votre base de données MySQL, en mettant à jour vos informations d'identification MySQL en conséquence :

...

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);
});

Ensuite, vous allez créer un modèle appelé books, qui comprend title, author, release_dateet subjectID. Pour ce faire, utilisez la sequelize.define()méthode comme indiqué :

...

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,
   }
});

La sequelize.define()méthode définit un nouveau modèle, qui représente une table dans la base de données. Ce bloc de code crée une table appelée bookset stocke les enregistrements de livre selon les title, author, release_dateet subject.

Dans ce code, allowNullindique que la valeur de la colonne de modèle ne peut pas être null. De même, si vous devez définir une telle valeur, vous pouvez utiliser defaultValue: "value".

Ensuite, vous ajouterez le bookmodèle à votre base de données. Pour ce faire, vous utiliserez la sync()méthode suivante :

...

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

Dans la sync()méthode, vous demandez à Sequelize de faire quelques choses sur la base de données. Avec cet appel, Sequelize effectuera automatiquement une requête SQL vers la base de données et créera une table, en imprimant le message Book table created successfully!.

Comme mentionné, la méthode sync () est une méthode basée sur des promesses, ce qui signifie qu'elle peut également effectuer une gestion des erreurs. Dans ce bloc de code, vous vérifierez si la table est créée avec succès. Sinon, il renverra une erreur via la méthode catch et l'imprimera sur la sortie.

Remarque : Vous pouvez gérer la synchronisation des modèles en passant des forceparamètres pour forcer la création d'une nouvelle table si elle n'existe pas, ou bien en utiliser une existante. Voici quelques exemples qui peuvent vous être utiles lorsque vous travaillez avec Sequelize :

  • model.sync(): Ceci crée la table si elle n'existe pas déjà.
  • model.sync({ force: true }): Cela crée la table en la supprimant si la même table existe déjà.

Le code final ressemblera à ceci :

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);
});

Enregistrez et fermez votre fichier.

Exécutez votre application à l'aide de la commande suivante :

node book.model.js

Vous obtiendrez le résultat suivant dans votre ligne de commande :

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!

Dans la sortie, vous verrez que le journal de retour contient le message, Book table created successfully!. Vous pouvez le vérifier en vérifiant votre base de données pour voir la nouvelle bookstable créée dans la base de hello_world_dbdonnées.

Pour vérifier la création de la nouvelle table, connectez-vous à votre instance MySQL :

mysql -u YOUR_USERNAME -p

Après avoir saisi votre mot de passe, accédez à l'exemple de base de données :

USE hello_world_db;

Et puis exécutez la commande pour afficher les tables :

SHOW TABLES;

Votre sortie ressemblera à ceci :

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

Enfin, déconnectez-vous du serveur MySQL :

mysql> QUIT

Vous avez vérifié que la bookcréation du modèle a réussi. En utilisant ce processus, vous pouvez créer n'importe quel nombre de modèles en suivant la même procédure.

Au cours de cette étape, vous avez créé un modèle dans une base de données et commencé à travailler avec un modèle à l'aide de méthodes intégrées. Vous avez également utilisé des types de données pris en charge par Sequelize pour définir votre modèle. Ensuite, vous travaillerez avec des requêtes de modèle de base.

Étape 3 - Utilisation de Sequelize pour les requêtes de base de données

Dans cette étape, vous utiliserez les requêtes intégrées Sequelize pour l'insertion, la sélection, la sélection avec des clauses conditionnelles et la suppression.

Insertion d'un nouvel enregistrement

À l'étape précédente, vous avez créé un bookmodèle dans la base de données. Dans cette section, vous allez insérer des données dans ce modèle.

Pour commencer, copiez le contenu de book.model.jsl'étape précédente. Créez un nouveau fichier appelé book.controller.jspour gérer la logique de requête. Ajoutez le code de book.model.jsà book.controller.js.

Dans book.controller.js, recherchez la sync()méthode. Dans la sync()méthode, ajoutez les lignes suivantes en surbrillance :

...

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);
});

Ici, vous insérez un nouvel enregistrement de livre dans le booksmodèle que vous avez déjà créé à l'aide de la sync()méthode, qui prend en charge l'ajout de nouveaux enregistrements aux modèles créés précédemment. Une fois que la méthode sync() s'exécute avec succès, elle exécute la then()méthode. Dans la then()méthode, vous appelez create()la méthode pour insérer les nouveaux enregistrements dans le modèle.

Vous utilisez la create()méthode pour transmettre les données que vous devez ajouter à la base de données en tant qu'objet. La section de code en surbrillance insérera une nouvelle entrée dans votre bookstable existante. Dans cet exemple, vous ajoutez Clean Codepar Robert Cecil Martin, qui a été classé avec l' subjectID de 3. Vous pouvez utiliser le même code, mis à jour avec les informations d'autres livres, pour ajouter de nouveaux enregistrements à votre base de données.

Enregistrez et fermez le fichier.

Exécutez l'application à l'aide de la commande suivante :

node book.controller.js

Votre sortie ressemblera à ce qui suit :

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,
   ...
}

Vous avez inséré un nouvel enregistrement dans le modèle que vous avez créé dans la base de données. Vous pouvez continuer à ajouter plusieurs enregistrements en utilisant le même processus.

Sélection de tous les enregistrements

Dans cette section, vous allez sélectionner et obtenir tous les enregistrements de livres de la base de données à l'aide de la findAll()méthode. Pour ce faire, ouvrez book.controller.jset supprimez d'abord la Book.create()méthode précédente. Dans la sync()méthode, ajoutez la Book.findAll()méthode comme indiqué :

...

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);
});

...

Enregistrez et fermez le fichier.

Ensuite, relancez l'application à l'aide de la commande suivante :

node book.controller.js

Votre sortie ressemblera à ce qui suit :

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 sortie contient toutes les données du livre sous la forme d'un objet tableau. Vous avez utilisé avec succès la méthode Sequelize findAll()pour renvoyer toutes les données de livre à partir de la base de données.

Sélection avec la whereclause

Dans cette section, vous sélectionnerez des valeurs avec des conditions à l'aide de la whereclause. La whereclause est utilisée pour spécifier une condition lors de la récupération des données. Pour ce didacticiel, vous obtiendrez un livre par un ID d'enregistrement spécifique à partir de la base de données à l'aide de la findOne()méthode.

Pour ce faire, ouvrez book.controller.jspour modification, supprimez la findAll()méthode et ajoutez les lignes suivantes :

...

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);
});

Ici, vous sélectionnez un enregistrement de livre spécifique dans la base de données en utilisant la findOne()méthode avec l' whereoption. Dans cet exemple, vous récupérez les données du livre dont idest égal à 1.

Enregistrez et fermez le fichier.

Ensuite, lancez l'application :

node book.controller.js

Votre sortie ressemblera à ce qui suit :

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
  },
  ...
}

Vous avez utilisé avec succès des whereclauses pour obtenir des données à partir de modèles Sequelize. Vous pouvez utiliser la whereclause dans l'application de base de données pour capturer des données conditionnelles.

Suppression d'un enregistrement

Pour supprimer un enregistrement spécifique du modèle de base de données, vous utilisez la destroy()méthode avec l' whereoption. Pour ce faire, ouvrez book.controller.js, supprimez la findOne()méthode et ajoutez les lignes suivantes en surbrillance :

...
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);
});

Ici, vous supprimez un enregistrement de livre de la base de données en utilisant la destroy()méthode avec l' whereoption et en passant le iddu livre à supprimer. Vous allez supprimer la notice du livre dont idest égal à 2.

Enregistrez et fermez le fichier.

Ensuite, lancez l'application :

node book.controller.js

Votre sortie ressemblera à ceci :

Output
Successfully deleted record.

L'enregistrement a été supprimé.

Au cours de cette étape, vous avez testé votre modèle de base de données et l'interrogation du modèle. Vous avez lancé la base de données, créé des modèles, inséré des enregistrements, récupéré des enregistrements, récupéré des enregistrements avec des conditions à l'aide de la whereclause et supprimé des enregistrements sélectionnés. Avec cette connaissance de Sequelize, vous allez maintenant créer des associations dans Sequelize. Après cela, vous serez en mesure de définir et de travailler avec une variété de relations à l'aide de modèles Sequelize.

Étape 4 - Création d'associations à l'aide de Sequelize

Dans cette étape, vous utiliserez les types d'associations standard pris en charge par Sequelize : les associations one-to-one , one-to-many et many-to-many . Vous utiliserez des exemples de données sur les étudiants, les cours et les niveaux scolaires.

Sequelize utilise des types d'association basés sur les relations de base de données suivantes :

relation un à un : une relation un à un signifie qu'un enregistrement dans une table est associé à exactement un enregistrement dans une autre table. En termes de Sequelize, vous pouvez utiliserbelongsTo()ethasOne()des associations pour créer ce type de relation.

relation un-à-plusieurs : une relation un-à-plusieurs signifie qu'un enregistrement dans une table est associé à plusieurs enregistrements dans une autre table. Avec Sequelize, vous pouvez utiliserhasMany()des méthodes d'associations pour créer ce type de relation.

relation plusieurs à plusieurs : une relation plusieurs à plusieurs signifie que plusieurs enregistrements d'une table sont associés à plusieurs enregistrements d'une autre table. Avec Sequelize, vous pouvez utiliserbelongsToMany()des associations pour créer ce type de relation.

Avant de créer ces associations, vous allez d'abord créer une nouvelle base de données appelée student_dbet ajouter de nouveaux modèles et quelques exemples de données pour les étudiants, les cours et le niveau scolaire.

Pour créer la base de données, suivez le même processus à l'Étape 1 — Installation et configuration de Sequelize pour vous connecter à MySQL et créer une base de données appelée student_db. Une fois la nouvelle base de données créée, déconnectez-vous de MySQL. Ensuite, vous commencerez à créer des associations de base de données.

Créer une relation individuelle avecbelongsTo()

Dans cette section, vous allez créer une relation un-à-un à l'aide de modèles Sequelize. Imaginez que vous souhaitiez obtenir les détails d'un élève ainsi que son niveau scolaire. Puisqu'un élève ne peut avoir qu'un seul niveau scolaire, ce type d'association est une relation un à un et vous pouvez utiliser la belongsTo()méthode.

Remarque : il existe une différence entre belongsTo()et hasOne(). belongsTo()ajoutera le foreignKeysur la table source, tandis que hasOne()l'ajoutera à la table cible. Dans tous les cas, si les deux relations sont utilisées en même temps, cela fonctionnera comme des relations séquentielles bidirectionnelles bidirectionnelles.

La belongsTo()méthode vous permet de créer une relation un à un entre deux modèles Sequelize. Dans cet exemple, vous utilisez les modèles Studentet .Grade

Créez un nouveau fichier nommé one_to_one.js. Comme vous l'avez fait dans la section précédente, Connexion à la base de données MySQL , incluez les lignes pour créer une connexion à la base de données et authentifiez votre utilisateur MySQL en haut du fichier. Assurez-vous de mettre à jour les informations d'identification MySQL si nécessaire :

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);
});

Dans cette section, vous allez créer trois modèles dans la nouvelle base de student_dbdonnées : Student, Gradeet Course. Vous commencerez par créer les modèles Studentet . GradePlus tard dans cette étape, vous créerez le Coursesmodèle.

Pour le Studentmodèle, ajoutez le bloc de code suivant à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
   }
});

Ce modèle étudiant contient deux colonnes : student_idet name.

Ensuite, ajoutez un bloc de code pour le Grademodèle :

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

Le Grademodèle contient la colonne grade.

Pour démontrer les associations, vous devrez ajouter des exemples de données à la base de données. Pour cela, vous utiliserez la bulk()méthode. Plutôt que d'insérer des données dans les lignes une par une, la bulkCreate()méthode vous permet d'insérer plusieurs lignes dans vos modèles de base de données à la fois.

Alors maintenant, importez les données Gradeet Studentdans leurs modèles respectifs dans la base de données comme indiqué :

...
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);
});

Ici, vous fournissez des exemples de données et importez les données dans les modèles Studentet . GradeUne fois votre base de données, vos modèles et vos exemples de données en place, vous êtes prêt à créer des associations.

Dans one-to-one.js, ajoutez la ligne suivante sous le student_databloc :

...
Student.belongsTo(Grade);

Ensuite, vous devrez vérifier si l'association fonctionne correctement. Pour ce faire, vous pouvez récupérer toutes les données des élèves avec les niveaux scolaires associés en passant le includeparamètre à l'intérieur de la findAll()méthode.

Puisque vous devez obtenir le niveau scolaire de l'étudiant, vous passerez Gradepour le modèle. Dans la sequelize.sync()méthode, ajoutez les lignes en surbrillance comme indiqué :

...
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);
});

Le code complet ressemble à ceci :

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);
});

Enregistrez et fermez votre fichier.

Exécutez le fichier à l'aide de la commande suivante :

node one_to_one.js

La sortie sera longue et vous verrez toutes les données des élèves avec les niveaux scolaires. Voici un extrait de la sortie montrant les données des étudiants :

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:
...

Selon les outils de ligne de commande que vous utilisez, la sortie peut être imprimée sous forme de vue développée ou non. S'il s'agit d'une vue développée, il imprime l' gradeobjet développé comme sortie.

Dans cette section, vous avez créé une relation un-à-un à l'aide de l' Student.belongsTo(Grade);appel de méthode et obtenu les détails en fonction de l'association que vous avez créée.

Créer une relation un-à-plusieurs avechasMany()

Dans cette section, vous allez créer une relation un-à-plusieurs à l'aide de modèles Sequelize. Imaginez que vous vouliez que tous les élèves soient associés à un niveau scolaire sélectionné. Étant donné qu'un niveau scolaire spécifique peut avoir plusieurs élèves, il s'agit d'une relation un-à-plusieurs.

Pour commencer, copiez le contenu de one_to_one.jsdans un nouveau fichier appelé one_to_many.js. Dans one_to_many.js, supprimez les lignes après le student_databloc. Votre one_to_many.jsfichier ressemblera à ceci :

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}
]

Après le student_databloc, utilisez la hasMany()méthode pour créer une nouvelle relation :

...
Grade.hasMany(Student)

La hasMany()méthode vous permet de créer une relation un-à-plusieurs entre deux modèles Sequelize. Ici, vous utilisez les modèles Gradeet .Student

Ensuite, ajoutez la sequelize.sync()méthode avec la findAll()méthode sous la hasMany()ligne :

...
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);
});

Ici, vous essayez d'accéder à tous les élèves d'un niveau particulier, dans ce cas, tous les élèves du niveau 9. Vous avez également ajouté le Studentmodèle dans l' includeoption.

Voici le code complet :

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);
});

Enregistrez et fermez votre fichier.

Exécutez le fichier avec la commande suivante :

node one_to_many.js

La sortie ressemblera à ce qui suit. Ce sera assez long, mais tous les élèves en grade 9seront renvoyés comme suit :

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 },
...

Dans cette section, vous avez créé une relation un-à-plusieurs à l'aide de l' Grade.hasMany(Student);appel de méthode. Dans la sortie, vous avez récupéré les détails en fonction de l'association que vous avez créée.

Création de relations plusieurs-à-plusieurs avecbelongsToMany()

Dans cette section, vous allez créer des relations plusieurs à plusieurs à l'aide de modèles Sequelize. À titre d'exemple, imaginez une situation où les étudiants sont inscrits à des cours. Un étudiant peut s'inscrire à plusieurs cours et un cours peut avoir plusieurs étudiants. Il s'agit d'une relation plusieurs à plusieurs. Pour implémenter cela à l'aide de Sequelize, vous utiliserez les modèles Student, Courseet StudentCourseavec la belongsToMany()méthode .

Pour commencer, créez un fichier appelé many_to_many.jset ajoutez les blocs de code d'initiation et d'authentification de la base de données comme suit. (Vous pouvez réutiliser les blocs de code de l' one_to_many.jsexemple précédent.) Assurez-vous de mettre à jour les valeurs de connexion à la base de données en surbrillance si nécessaire.

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);
});

Ensuite, vous allez créer les modèles de base de données pour les relations plusieurs-à-plusieurs : Studentet Course. Ensuite, vous ajouterez des exemples de données à ces modèles.

...

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},
]

Ici, vous créez les modèles Studentet Courseet fournissez des exemples de données. Vous définissez également un courseID, que vous utiliserez pour récupérer les étudiants en fonction de ce type de relation.

Enfin, vous avez défini un nouveau modèle appelé StudentCourse, qui gère les données de relation entre Studentet Course. Dans cet exemple, studentId 1est inscrit dans courseId 1et courseId 2.

Vous avez terminé l'initialisation de la base de données et ajouté des exemples de données à la base de données. Ensuite, créez des relations plusieurs à plusieurs en utilisant la belongsToMany()méthode comme indiqué :

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

Dans la belongsToMany()méthode, vous transmettez la throughconfiguration avec le nom du modèle comme option de configuration. Dans ce cas, c'est StudentCourse. C'est la table qui gère les relations plusieurs-à-plusieurs.

Enfin, vous pouvez vérifier le bon fonctionnement de l'association en récupérant toutes les données des cours avec les étudiants associés. Vous ferez cela en passant le includeparamètre à l'intérieur de la findAll()méthode. Ajoutez les lignes suivantes à 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);
});

Le code complet ressemble à ceci :

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);
});

Enregistrez et fermez le fichier.

Exécutez le fichier à l'aide de la commande suivante :

node many_to_many.js

La sortie sera longue, mais ressemblera à ce qui suit :

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:
...

Comme vous pouvez le voir dans cette sortie, les cours avec les étudiants associés ont été récupérés. Dans le coursesbloc, vous verrez des idvaleurs distinctes qui indiquent chaque cours. Par exemple, id: 1est connecté au course_name: Sciencepour le cours de sciences, tandis que id: 2est le cours de mathématiques, etc.

Dans la base de données, vous pouvez voir les trois tables générées avec les exemples de données que vous avez insérés.

Dans cette étape, vous avez utilisé Sequelize pour créer des associations un-à-un, un-à-plusieurs et plusieurs-à-plusieurs. Ensuite, vous travaillerez avec des requêtes brutes.

Étape 5 - Travailler avec des requêtes brutes

Dans cette étape, vous travaillerez avec des requêtes brutes dans Sequelize. Dans les étapes précédentes, vous avez utilisé les méthodes intégrées Sequelize, telles que insert()et findAll(), pour gérer l'insertion et la sélection de données dans la base de données. Vous avez peut-être remarqué que ces méthodes suivent un modèle spécifique pour écrire une requête. Cependant, avec l'utilisation de requêtes brutes, vous n'avez pas à vous soucier des méthodes et des modèles intégrés de Sequelize. En utilisant votre connaissance des requêtes SQL, vous pouvez effectuer une gamme de requêtes dans Sequelize, des plus simples aux plus avancées.

Voici un exemple de requêtes brutes qui effectuent l'action de sélectionner toutes les valeurs d'une table particulière, de supprimer les valeurs sélectionnées en fonction de la condition et de mettre à jour la table avec les valeurs données.

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

Dans Sequelize, les requêtes brutes peuvent être utilisées avec principalement deux méthodologies : le remplacement de tableau et le remplacement d'objet. Lorsque vous transmettez des valeurs à la requête SQL, vous pouvez utiliser un tableau ou un objet pour effectuer ce remplacement.

Avant d'écrire une requête brute, vous devrez d'abord fournir des données sur les étudiants dans un exemple de base de données. Après la section précédente, Création d'un exemple de base de données , connectez-vous à MySQL, créez une base de données appelée sample_student_dbet déconnectez-vous de MySQL.

Ensuite, vous allez ajouter des données brutes pour commencer à travailler avec des requêtes brutes. Créez un nouveau fichier appelé add_student_records.jset ajoutez les blocs de code suivants, qui contiennent les méthodes Sequelize décrites précédemment de authenticate(), sync()et 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);
});

Ici, vous lancez la connexion à la base de données, créez le modèle et insérez quelques enregistrements d'étudiants dans la nouvelle base de données.

Enregistrez et fermez le fichier.

Ensuite, exécutez ce script à l'aide de la commande suivante :

node add_student_records.js

La sortie sera quelque chose de similaire à ce qui suit. Ce sera assez long, mais tous les dossiers étudiants que vous aurez insérés seront retournés comme suit. Notez que comme il s'agit d'une valeur UUID ( Universally Unique Identifiersstudent_id ) générée automatiquement , elle sera différente selon l'utilisateur.

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
    },

…

Dans la section suivante, vous appliquerez des requêtes brutes à l'aide de l'une des student_idsorties du bloc de code ci-dessus. Copiez-le afin que vous l'ayez pour les sections suivantes, où vous utiliserez la query()méthode pour les remplacements de tableaux et d'objets.

Remplacement de baie

Dans cette section, vous utiliserez la query()méthode de remplacement d'un tableau. Avec cette méthode, Sequelize peut exécuter des requêtes SQL brutes ou déjà préparées.

Pour commencer, copiez le contenu du server.jsfichier de l' étape 1 , car cela inclut la Sequelize()méthode d'initialisation et l'initialisation de la base de données. Collez le contenu dans un nouveau fichier nommé array_raw_query.js. Mettez à jour le nom de la base de donnéessample_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);
});

À la fin du fichier, ajoutez le bloc de code suivant pour un remplacement de tableau, en veillant à remplacer REPLACE_STUDENT_IDpar la student_idvaleur que vous avez copiée dans la section précédente.

...
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);
});

Pour le remplacement de tableau, vous transmettez la query()méthode avec la requête SQL et l'objet de configuration. Il contient la replacementsvaleur et le type. ?Pour les remplacements, vous transmettez des données sous forme de tableau et saisissez ces valeurs à l'aide du symbole de point d'interrogation ( ).

Ensuite, puisque vous avez besoin d'obtenir des données sur un étudiant spécifique, le student_idest passé comme deuxième paramètre. Après cela, vous transmettez la type: sequelize.QueryTypes.SELECTpaire clé-valeur, que vous pouvez utiliser pour sélectionner des données dans la base de données.

Il existe également d'autres types, tels que QueryTypes.UPDATEet QueryTypes.DELETE. Selon les besoins, vous pouvez sélectionner le type qui convient à votre objectif.

Ce qui suit montre le bloc de code complet. Ici, vous vous connectez à la base de données et récupérez les données des étudiants sélectionnés à l'aide d'une requête brute.

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);
});

Enregistrez et fermez votre fichier.

Ensuite, vous pouvez exécuter ce script à l'aide de la commande suivante :

node array_raw_query.js

Vous verrez une sortie semblable à la suivante :

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 } ]

En raison du sélectionné student_id, vos valeurs de sortie peuvent différer.

Remplacement d'objet

En surface, le remplacement d'objet est similaire au remplacement de tableau, mais le modèle de transmission des données à la requête brute est différent. Dans l'option de remplacement, vous transmettez des données en tant qu'objet et dans l'option de requête, vous utilisez des valeurs telles que :key.

Pour commencer, créez un nouveau fichier appelé object_raw_query.jset collez les blocs de code complets du server.jsfichier, en mettant à jour la base de données vers 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);
});

Ajoutez ensuite le bloc de code suivant à la fin du nouveau object_raw_query.jsfichier :

...
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);
});

Ici, vous obtenez des données d'étudiants sélectionnés en utilisant la méthode de remplacement d'objet. Vous créez un replacementobjet, en définissant le idcomme les informations sur l'étudiant que vous souhaitez récupérer : { id: 'REPLACE_STUDENT_ID' }.

Dans le query(), vous indiquez : 'SELECT * FROM students WHERE student_id = :id'. En utilisant la query()méthode, vous transmettez la valeur de remplacement en tant qu'objet, c'est pourquoi cette méthode est connue sous le nom de remplacement d'objet.

Voici le code complet :

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);
});

Enregistrez et fermez le fichier.

Ensuite, exécutez ce script à l'aide de la commande suivante :

node object_raw_query.js

La sortie ressemblera à ce qui suit :

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 } ]

En raison du sélectionné student_id, vos valeurs de sortie peuvent différer.

Au cours de cette étape, vous avez travaillé avec des requêtes brutes Sequelize en utilisant deux méthodologies différentes : le remplacement de tableau et le remplacement d'objet.

Conclusion

Dans ce didacticiel, vous avez installé et configuré Sequelize. Vous avez également créé et travaillé avec des modèles, ce qui est l'un des composants obligatoires de Sequelize. Enfin, vous avez créé différents types d'associations et travaillé avec des requêtes brutes à l'aide d'exemples pratiques.

Ensuite, vous pouvez utiliser différents types de données pour créer des modèles de base de données. Vous pouvez également mettre à jour et supprimer des enregistrements dans des bases de données avec des méthodes intégrées et des requêtes brutes.

Source de l'article original sur https://www.digitalocean.com

#sequelize #node #mysql #database 

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