Zenon  Pruschke

Zenon Pruschke

1658742600

So verwenden Sie Sequelize mit Node und MySQL

Erfahren Sie, wie Sie Sequelize mit MySQL installieren und konfigurieren. Verwenden von Sequelize zum Erstellen von Datenbanken und Modellen sowie zum Ausführen von Einfüge-, Auswahl-, Löschvorgängen und mehr 

Sequelize ist ein Node.js -basierter Object Relational Mapper, der die Arbeit mit MySQL- , MariaDB- , SQLite- , PostgreSQL - Datenbanken und mehr vereinfacht. Ein objektrelationaler Mapper führt Funktionen wie die Handhabung von Datenbankdatensätzen aus, indem er die Daten als Objekte darstellt. Sequelize verfügt über einen leistungsstarken Migrationsmechanismus, der vorhandene Datenbankschemata in neue Versionen umwandeln kann. Insgesamt bietet Sequelize hervorragende Unterstützung für Datenbanksynchronisierung, Eager Loading, Zuordnungen, Transaktionen und Datenbankmigrationen, während gleichzeitig die Entwicklungszeit verkürzt und SQL-Injektionen verhindert werden.

In diesem Tutorial installieren und konfigurieren Sie Sequelize mit MySQL in Ihrer lokalen Entwicklungsumgebung. Als Nächstes verwenden Sie Sequelize, um Datenbanken und Modelle zu erstellen und die Operationen insert, select, und auszuführen delete. Anschließend erstellen Sie Sequelize-Zuordnungen für Eins-zu- eins- , Eins -zu-viele- und Viele-zu-viele- Beziehungen. Schließlich erstellen Sie Sequelize-Rohabfragen für Array- und Objektersetzungen.

Dieses Tutorial wurde auf Node.js Version 14.17.6 und npmVersion 6.14.15 auf macOS Catalina getestet.

Schritt 1 – Installieren und Konfigurieren von Sequelize

In diesem Schritt installieren Sie Sequelize und stellen die Verbindung zu Ihrer MySQL-Datenbank her. Dazu erstellen Sie zunächst eine Node.js-Anwendung. Anschließend installieren Sie Sequelize, konfigurieren die MySQL-Datenbank und entwickeln eine einfache Anwendung.

Sequelize installieren

Beginnen Sie mit dem Erstellen eines Projektordners. In diesem Beispiel können Sie hello-world. Sobald der Ordner erstellt ist, navigieren Sie mit dem Terminal zu dem Ordner:

mkdir hello-world
cd hello-world

Erstellen Sie dann mit dem folgenden Befehl eine Node.js-Beispielanwendung:

npm init

Als Nächstes werden Sie aufgefordert, einige Einrichtungsfragen zu beantworten. Verwenden Sie die folgende Ausgabe für Ihre Konfiguration. Drücken ENTERSie , um den angezeigten Standardwert zu verwenden, und achten Sie darauf, den Haupteinstiegspunkt auf einzustellen server.js. Dadurch entsteht eine einfach zu pflegende Projektstruktur.

Die Ausgabe sieht wie folgt aus, wodurch die package.jsonDatei gefüllt wird:

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

Erstellen Sie als Nächstes eine leere server.jsDatei im Projektordner:

touch server.js

Nachdem Sie die vorherigen Schritte ausgeführt haben, sieht Ihre endgültige Ordnerstruktur folgendermaßen aus:

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

Jetzt können Sie Sequelize mit dem folgenden Befehl installieren:

npm i sequelize@6.11.0

Hinweis: Dieser Befehl installiert Version 6.11.0. Wenn Sie die neueste Version installieren müssen, führen Sie npm i sequelize.

Nach diesen Updates package.jsonsieht die Datei nun so aus:

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

In dem dependenciesAbschnitt sehen Sie nun eine Sequelize-Abhängigkeit.

Sie haben das Projekt eingerichtet und Sequelize installiert. Als Nächstes erstellen Sie eine Beispieldatenbank, zu der Sie eine Verbindung herstellen möchten.

Erstellen einer Beispieldatenbank

Als Teil der Voraussetzungen haben Sie MySQL installiert und konfiguriert, einschließlich der Erstellung eines Benutzers. Jetzt erstellen Sie eine leere Datenbank.

Dazu müssen Sie sich zunächst bei Ihrer MySQL-Instanz anmelden. Wenn Sie remote arbeiten, können Sie Ihr bevorzugtes Tool verwenden. Wenn Sie eine lokal ausgeführte MySQL-Instanz verwenden, können Sie den folgenden Befehl verwenden und dabei your_username durch Ihren MySQL-Benutzernamen ersetzen:

mysql -u your_username -p

-uBenutzername ist und die -pOption übergeben wird, wenn das Konto mit einem Passwort gesichert ist.

Der MySQL-Server wird Sie nach Ihrem Datenbankpasswort fragen. Geben Sie Ihr Passwort ein und drücken Sie ENTER.

Sobald Sie angemeldet sind, erstellen Sie eine Datenbank, die hello_world_dbmit dem folgenden Befehl aufgerufen wird:

CREATE DATABASE hello_world_db;

Um zu überprüfen, ob Sie die Datenbank erfolgreich erstellt haben, können Sie diesen Befehl verwenden:

SHOW DATABASES;

Ihre Ausgabe wird ungefähr so ​​​​aussehen:

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

Trennen Sie nach dem Erstellen der Beispieldatenbank die Verbindung zum MySQL-Server:

mysql> QUIT

Jetzt müssen Sie einen manuellen Treiber für die Datenbank Ihrer Wahl installieren. Da Sequelize nur ORM-Funktionen bietet, enthält es keine integrierten Datenbanktreiber. Daher müssen Sie Treiber nach Ihren Wünschen installieren. Navigieren Sie dazu mit dem Terminal zum Projektverzeichnis und installieren Sie den MySQL-Treiber mit dem folgenden Befehl im Projekt:

npm install --save mysql2

In diesem Fall verwenden Sie den Treiber für MySQL.

Hinweis: Da dieses Tutorial MySQL als Datenbank verwendet, verwenden Sie dafür einen Treiber. Abhängig von Ihrer Datenbank können Sie den Treiber wie folgt manuell installieren:

  • 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

Nachdem Sie nun über eine Beispieldatenbank verfügen, können Sie Ihre erste Sequelize-Anwendung mit Datenbankkonnektivität erstellen.

Verbindung zur MySQL-Datenbank herstellen

In diesem Abschnitt verbinden Sie die Node.js-Anwendung mithilfe von Sequelize mit der MySQL-Datenbank.

Um eine Verbindung zur Datenbank herzustellen, öffnen Sie server.jssie zur Bearbeitung mit nanooder Ihrem bevorzugten Code-Editor:

nano server.js

Hier erstellen Sie mithilfe einer Sequelize-Instanz eine Datenbankverbindung in Ihrer Anwendung. Übergeben Sie in der new Sequelize()Methode die MySQL-Serverparameter und Datenbankanmeldeinformationen wie folgt und ersetzen Sie DATABASE_USERNAMEund DATABASE_PASSWORDdurch die Anmeldeinformationen Ihres MySQL-Benutzers:

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

hostHier wird der MySQL-Server gehostet, daher müssen Sie eine Server-URL oder eine IP-Adresse angeben. Wenn Sie einen lokal installierten MySQL-Server verwenden, können Sie den Wert DATABASE_HOSTdurch localhostoder ersetzen.127.0.0.1

Wenn Sie einen Remote-Server verwenden, stellen Sie in ähnlicher Weise sicher, dass Sie die Datenbankverbindungswerte entsprechend durch die entsprechenden Details des Remote-Servers ersetzen.

Hinweis: Wenn Sie eine andere Datenbankserversoftware verwenden, können Sie den Dialektparameter entsprechend ersetzen. `Dialekt: 'mysql', 'mariadb', 'postgres', 'mssql'.

Rufen Sie als Nächstes eine Promise-basierte authenticate() Methode auf, um eine Datenbankverbindung mit der Anwendung zu instanziieren. Fügen Sie dazu den folgenden Codeblock zu Ihrer server.jsDatei hinzu:

...

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

Die authenticate()Methode wird verwendet, um sich mit der Datenbank zu verbinden und testet, ob die angegebenen Anmeldeinformationen korrekt sind. Hier ist die Datenbankverbindung standardmäßig geöffnet und es kann für alle Abfragen dieselbe Verbindung verwendet werden. Wann immer Sie die Verbindung schließen müssen, rufen Sie die sequelize.close()Methode nach diesem authenticate()Aufruf auf. Um mehr über Sequelize zu erfahren, lesen Sie bitte den Leitfaden „Erste Schritte“ .

Die meisten der von Sequelize bereitgestellten Methoden sind asynchron. Das bedeutet, dass Sie Prozesse in Ihrer Anwendung ausführen können, während sich ein asynchroner Codeblock in seiner Ausführungszeit befindet. Außerdem wird nach der erfolgreichen Ausführung des asynchronen Codeblocks ein Promise zurückgegeben, bei dem es sich um den Wert handelt, der am Ende eines Prozesses zurückgegeben wird. Daher können Sie in asynchronen Codeblöcken , und verwenden then(), um die verarbeiteten Daten zurückzugeben.catch()finally()

Zu diesem Zeitpunkt sieht die server.jsDatei wie folgt aus:

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

Speichern und schließen Sie Ihre Datei.

Führen Sie im Projektverzeichnis die server.jsAnwendung aus, indem Sie den folgenden Befehl ausführen:

node server.js

Ihre Ausgabe sieht folgendermaßen aus:

Output
Connection has been established successfully!

Sie haben die Datenbankverbindung erfolgreich erstellt.

In diesem Schritt haben Sie Sequelize installiert, eine Beispieldatenbank erstellt und Sequelize verwendet, um eine Verbindung mit der Datenbank herzustellen. Als Nächstes arbeiten Sie mit Modellen in Sequelize.

Schritt 2 – Erstellen einer Datenbanktabelle mit Sequelize

Nachdem Sie nun eine MySQL-Beispieldatenbank erstellt haben, können Sie mit Sequelize eine Tabelle erstellen und diese mit Daten füllen. In Sequelize werden Datenbanktabellen als Modelle bezeichnet . Ein Modell ist eine Abstraktion, die eine Tabelle der Datenbank darstellt. Modelle definieren mehrere Dinge, die sequenziert werden sollen, wie z. B. den Namen der Tabelle, Spaltendetails und Datentypen. In diesem Schritt erstellen Sie ein Sequelize-Modell für Buchdaten.

Erstellen Sie zunächst eine neue Datei mit dem Namen book.model.jsim Projektverzeichnis:

nano book.model.js

Fügen Sie ähnlich wie im vorherigen Schritt einen Sequelize-Code für die Datenbankinitiierung mit einem neuen Import für DataTypesoben in der Datei hinzu:

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

Sequelize enthält viele eingebaute Datentypen. Um auf diese Datentypen zuzugreifen, fügen Sie einen Import für DataTypes. Dieses Tutorial bezieht sich auf einige häufig verwendete Datentypen wie STRING, INTEGERund DATEONLY. Weitere Informationen zu anderen unterstützten Datentypen finden Sie in der offiziellen Sequelize-Dokumentation .

Fügen Sie dann die Zeilen hinzu, die Sie zuvor verwendet haben, um eine Verbindung zu Ihrer MySQL-Datenbank herzustellen, und aktualisieren Sie Ihre MySQL-Anmeldeinformationen entsprechend:

...

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

Als Nächstes erstellen Sie ein Modell namens books, das title, author, release_dateund subjectID enthält. Verwenden Sie sequelize.define()dazu die gezeigte Methode:

...

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

Die sequelize.define()Methode definiert ein neues Modell, das eine Tabelle in der Datenbank repräsentiert. Dieser Codeblock erstellt eine Tabelle mit dem Namen booksund speichert die Buchdatensätze gemäß title, author, release_dateund subject.

In diesem Code allowNullzeigt, dass der Modellspaltenwert nicht sein kann null. Wenn Sie einen solchen Wert festlegen müssen, können Sie ebenfalls defaultValue: "value".

Als Nächstes fügen Sie das bookModell Ihrer Datenbank hinzu. Dazu verwenden Sie die sync()Methode wie folgt:

...

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

In der sync()Methode bitten Sie Sequelize, einige Dinge mit der Datenbank zu tun. Bei diesem Aufruf führt Sequelize automatisch eine SQL-Abfrage an die Datenbank durch, erstellt eine Tabelle und gibt die Nachricht aus Book table created successfully!.

Wie bereits erwähnt, ist die sync()-Methode eine Promise-basierte Methode, was bedeutet, dass sie auch eine Fehlerbehandlung durchführen kann. In diesem Codeblock überprüfen Sie, ob die Tabelle erfolgreich erstellt wurde. Wenn nicht, gibt es einen Fehler über die catch-Methode zurück und gibt ihn auf der Ausgabe aus.

Hinweis: Sie können die Modellsynchronisierung verwalten, indem Sie forceParameter übergeben, um die Erstellung einer neuen Tabelle zu erzwingen, falls diese nicht vorhanden ist, oder eine vorhandene verwenden. Hier sind einige Beispiele, die Ihnen bei der Arbeit mit Sequelize hilfreich sein können:

  • model.sync(): Dies erstellt die Tabelle, falls sie noch nicht existiert.
  • model.sync({ force: true }): Dadurch wird die Tabelle erstellt, indem sie gelöscht wird, wenn dieselbe Tabelle bereits vorhanden ist.

Der endgültige Code sieht folgendermaßen aus:

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

Speichern und schließen Sie Ihre Datei.

Führen Sie Ihre Anwendung mit dem folgenden Befehl aus:

node book.model.js

Sie erhalten die folgende Ausgabe in Ihrer Befehlszeile:

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!

In der Ausgabe sehen Sie, dass das Rückgabeprotokoll die Nachricht enthält Book table created successfully!. Sie können dies überprüfen, indem Sie Ihre Datenbank überprüfen, um die neue booksTabelle zu sehen, die in der hello_world_dbDatenbank erstellt wurde.

Um die Erstellung der neuen Tabelle zu überprüfen, melden Sie sich bei Ihrer MySQL-Instanz an:

mysql -u YOUR_USERNAME -p

Wechseln Sie nach Eingabe Ihres Passwortes in die Musterdatenbank:

USE hello_world_db;

Führen Sie dann den Befehl aus, um Tabellen anzuzeigen:

SHOW TABLES;

Ihre Ausgabe wird ungefähr so ​​​​aussehen:

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

Trennen Sie abschließend die Verbindung zum MySQL-Server:

mysql> QUIT

Sie haben überprüft, dass die bookModellerstellung erfolgreich war. Mit diesem Prozess können Sie eine beliebige Anzahl von Modellen erstellen, indem Sie demselben Verfahren folgen.

In diesem Schritt haben Sie ein Modell in einer Datenbank erstellt und die Arbeit mit einem Modell unter Verwendung integrierter Methoden begonnen. Sie haben auch von Sequelize unterstützte Datentypen verwendet, um Ihr Modell zu definieren. Als Nächstes arbeiten Sie mit grundlegenden Modellabfragen.

Schritt 3 – Verwenden von Sequelize für Datenbankabfragen

In diesem Schritt verwenden Sie die integrierten Sequelize-Abfragen zum Einfügen, Auswählen, Auswählen mit Bedingungsklauseln und Löschen.

Einfügen eines neuen Datensatzes

Im vorherigen Schritt haben Sie ein bookModell in der Datenbank erstellt. In diesem Abschnitt fügen Sie Daten in dieses Modell ein.

Kopieren Sie zunächst den Inhalt von book.model.jsaus dem vorherigen Schritt. Erstellen Sie eine neue Datei mit dem Namen book.controller.js, um die Abfragelogik zu verarbeiten. Fügen Sie den Code von book.model.jsbis hinzu book.controller.js.

book.controller.jsSuchen Sie in die Methode sync(). Fügen Sie in der sync()Methode die folgenden hervorgehobenen Zeilen hinzu:

...

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

Hier fügen Sie einen neuen Buchdatensatz in das booksModell ein, das Sie bereits erstellt haben, indem Sie die sync()Methode verwenden, die das Hinzufügen neuer Datensätze zu zuvor erstellten Modellen unterstützt. Sobald die sync()-Methode erfolgreich ausgeführt wird, führt sie die then()Methode aus. Innerhalb der then()Methode rufen Sie die create()Methode auf, um die neuen Datensätze in das Modell einzufügen.

Sie verwenden die create()Methode, um die Daten, die Sie der Datenbank hinzufügen müssen, als Objekt zu übergeben. Der hervorgehobene Codeabschnitt fügt einen neuen Eintrag in Ihre vorhandene booksTabelle ein. In diesem Beispiel fügen Sie Clean Codeby hinzu Robert Cecil Martin, das mit der subjectID von kategorisiert wurde 3. Sie können denselben Code, aktualisiert mit Informationen für andere Bücher, verwenden, um Ihrer Datenbank neue Datensätze hinzuzufügen.

Speichern und schließen Sie die Datei.

Führen Sie die Anwendung mit dem folgenden Befehl aus:

node book.controller.js

Ihre Ausgabe sieht in etwa so aus:

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

Sie haben einen neuen Datensatz in das Modell eingefügt, das Sie in der Datenbank erstellt haben. Sie können weiterhin mehrere Datensätze mit demselben Verfahren hinzufügen.

Auswahl aller Datensätze

findAll()In diesem Abschnitt werden Sie mithilfe der Methode alle Buchdatensätze aus der Datenbank auswählen und abrufen . Öffnen book.controller.jsund entfernen Sie dazu zuerst die vorherige Book.create()Methode. Fügen Sie in der Methode sync()die Book.findAll()Methode wie gezeigt hinzu:

...

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

...

Speichern und schließen Sie die Datei.

Führen Sie als Nächstes die Anwendung mit dem folgenden Befehl erneut aus:

node book.controller.js

Ihre Ausgabe sieht in etwa so aus:

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

Die Ausgabe enthält alle Buchdaten als Array-Objekt. Sie haben die Sequelize- findAll()Methode erfolgreich verwendet, um alle Buchdaten aus der Datenbank zurückzugeben.

Auswählen mit der whereKlausel

In diesem Abschnitt wählen Sie Werte mit Bedingungen unter Verwendung der whereKlausel aus. Die whereKlausel wird verwendet, um eine Bedingung beim Abrufen von Daten anzugeben. findOne()Für dieses Lernprogramm erhalten Sie mithilfe der Methode ein Buch anhand einer bestimmten Datensatz-ID aus der Datenbank .

Öffnen Sie dazu book.controller.jszum Bearbeiten, löschen Sie die findAll()Methode und fügen Sie die folgenden Zeilen hinzu:

...

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

Hier wählen Sie mit der findOne()Methode mit der whereOption einen bestimmten Bucheintrag aus der Datenbank aus. In diesem Beispiel rufen Sie die Buchdaten ab, deren idWert gleich ist 1.

Speichern und schließen Sie die Datei.

Führen Sie als Nächstes die Anwendung aus:

node book.controller.js

Ihre Ausgabe sieht in etwa so aus:

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

Sie haben erfolgreich whereKlauseln verwendet, um Daten aus Sequelize-Modellen abzurufen. Sie können die whereKlausel in der Datenbankanwendung verwenden, um bedingte Daten zu erfassen.

Löschen eines Datensatzes

Um einen bestimmten Datensatz aus dem Datenbankmodell zu löschen, verwenden Sie die destroy()Methode mit der whereOption. Öffnen Sie dazu book.controller.js, entfernen Sie die findOne()Methode und fügen Sie die folgenden hervorgehobenen Zeilen hinzu:

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

Hier entfernen Sie einen Bucheintrag aus der Datenbank, indem Sie die destroy()Methode mit der whereOption verwenden und die iddes zu entfernenden Buchs übergeben. Sie werden den Bucheintrag entfernen, dessen idGleichheit 2.

Speichern und schließen Sie die Datei.

Führen Sie als Nächstes die Anwendung aus:

node book.controller.js

Ihre Ausgabe sieht wie folgt aus:

Output
Successfully deleted record.

Der Datensatz wurde gelöscht.

In diesem Schritt haben Sie mit Ihrem Datenbankmodell und Modellabfragen experimentiert. Sie haben die Datenbank initiiert, Modelle erstellt, Datensätze eingefügt, Datensätze abgerufen, Datensätze mit Bedingungen mithilfe der whereKlausel abgerufen und ausgewählte Datensätze gelöscht. Mit diesem Sequelize-Wissen erstellen Sie nun Assoziationen in Sequelize. Danach können Sie mithilfe von Sequelize-Modellen eine Vielzahl von Beziehungen definieren und damit arbeiten.

Schritt 4 – Erstellen von Assoziationen mit Sequelize

In diesem Schritt verwenden Sie die standardmäßigen Zuordnungstypen, die Sequelize unterstützt: Eins-zu- eins- , Eins-zu- viele- und Viele-zu-viele- Zuordnungen. Sie verwenden Beispieldaten zu Schülern, Kursen und Klassenstufen.

Sequelize verwendet Assoziationstypen basierend auf den folgenden Datenbankbeziehungen:

Eins-zu-eins- Beziehung : Eine Eins-zu-eins-Beziehung bedeutet, dass ein Datensatz in einer Tabelle genau einem Datensatz in einer anderen Tabelle zugeordnet ist. In Bezug auf Sequelize können SiebelongsTo()undhasOne()Assoziationen verwenden, um diese Art von Beziehung zu erstellen.

Eins-zu-viele- Beziehung : Eine Eins-zu-viele-Beziehung bedeutet, dass ein Datensatz in einer Tabelle mehreren Datensätzen in einer anderen Tabelle zugeordnet ist. Mit Sequelize können SiehasMany()Assoziationsmethoden verwenden, um diese Art von Beziehung zu erstellen.

Viele-zu-Viele- Beziehung : Eine Viele-zu-Viele-Beziehung bedeutet, dass mehrere Datensätze in einer Tabelle mehreren Datensätzen in einer anderen Tabelle zugeordnet sind. Mit Sequelize können SiebelongsToMany()Assoziationen verwenden, um diese Art von Beziehung zu erstellen.

Bevor Sie diese Zuordnungen erstellen, erstellen Sie zunächst eine neue Datenbank namens student_dbund fügen neue Modelle und einige Beispieldaten für Schüler, Kurse und Klassenstufen hinzu.

Um die Datenbank zu erstellen, folgen Sie demselben Prozess in Schritt 1 – Installieren und Konfigurieren von Sequelize, um sich bei MySQL anzumelden und eine Datenbank mit dem Namen zu erstellen student_db. Sobald die neue Datenbank erstellt wurde, melden Sie sich von MySQL ab. Als Nächstes beginnen Sie mit dem Erstellen von Datenbankzuordnungen.

Aufbau einer Eins-zu-Eins-Beziehung mitbelongsTo()

In diesem Abschnitt erstellen Sie mithilfe von Sequelize-Modellen eine Eins-zu-eins-Beziehung. Stellen Sie sich vor, Sie möchten die Daten eines Schülers zusammen mit seiner Klassenstufe abrufen. Da ein Schüler nur eine Klassenstufe haben kann, ist diese Art der Zuordnung eine Eins-zu-eins-Beziehung und Sie können die belongsTo()Methode verwenden.

Hinweis: Es gibt einen Unterschied zwischen belongsTo()und hasOne(). belongsTo()fügt das foreignKeyin der Quelltabelle hasOne()hinzu, während es in der Zieltabelle hinzugefügt wird. Wenn beide Beziehungen gleichzeitig verwendet werden, funktioniert dies in jedem Fall als bidirektionale Eins-zu-Eins-Beziehungen.

Mit der belongsTo()Methode können Sie eine Eins-zu-eins-Beziehung zwischen zwei Sequelize-Modellen erstellen. In diesem Beispiel verwenden Sie die Modelle Studentund .Grade

Erstellen Sie eine neue Datei namens one_to_one.js. Fügen Sie, wie im vorherigen Abschnitt Verbinden mit der MySQL-Datenbank , die Zeilen ein, um eine Verbindung zur Datenbank herzustellen und Ihren MySQL-Benutzer am Anfang der Datei zu authentifizieren. Stellen Sie sicher, dass Sie die MySQL-Anmeldeinformationen nach Bedarf aktualisieren:

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

In diesem Abschnitt erstellen Sie drei Modelle in der neuen student_dbDatenbank: Student, Grade, und Course. Sie beginnen mit der Erstellung der Modelle Studentund . GradeSpäter in diesem Schritt erstellen Sie das CoursesModell.

Fügen Sie für das StudentModell den folgenden Codeblock hinzu 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
   }
});

Dieses Schülermodell enthält zwei Spalten: student_idund name.

Fügen Sie als Nächstes einen Codeblock für das GradeModell hinzu:

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

Das GradeModell enthält die Spalte grade.

Um die Zuordnungen zu demonstrieren, müssen Sie der Datenbank Beispieldaten hinzufügen. Dazu verwenden Sie die bulk()Methode. Anstatt Daten einzeln in die Zeilen bulkCreate()einzufügen, können Sie mit der Methode mehrere Zeilen gleichzeitig in Ihre Datenbankmodelle einfügen.

Importieren Sie nun die Gradeund StudentDaten in ihre jeweiligen Modelle in der Datenbank wie gezeigt:

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

Hier stellen Sie Beispieldaten bereit und importieren die Daten in die Modelle Studentund . GradeWenn Ihre Datenbank, Modelle und Beispieldaten vorhanden sind, können Sie Zuordnungen erstellen.

Fügen Sie in one-to-one.jsdie folgende Zeile unter dem student_dataBlock hinzu:

...
Student.belongsTo(Grade);

Als nächstes müssen Sie überprüfen, ob die Zuordnung ordnungsgemäß funktioniert. Dazu können Sie alle Schülerdaten mit den zugehörigen Notenstufen abrufen, indem Sie den includeParameter innerhalb der findAll()Methode übergeben.

Da Sie die Studentennote erreichen müssen, bestehen Sie Gradeals Model. Fügen Sie in der sequelize.sync()Methode die hervorgehobenen Zeilen wie gezeigt hinzu:

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

Der vollständige Code sieht wie folgt aus:

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

Speichern und schließen Sie Ihre Datei.

Führen Sie die Datei mit dem folgenden Befehl aus:

node one_to_one.js

Die Ausgabe ist lang und Sie sehen alle Schülerdaten mit Notenstufen. Hier ist ein Ausschnitt der Ausgabe mit Schülerdaten:

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

Abhängig von den verwendeten Befehlszeilentools wird die Ausgabe möglicherweise als erweiterte Ansicht gedruckt oder nicht. Wenn es sich um eine erweiterte Ansicht handelt, wird das erweiterte gradeObjekt als Ausgabe gedruckt.

In diesem Abschnitt haben Sie mithilfe des Student.belongsTo(Grade);Methodenaufrufs eine 1:1-Beziehung erstellt und die Details gemäß der von Ihnen erstellten Zuordnung abgerufen.

Erstellen einer 1:n-Beziehung mithasMany()

In diesem Abschnitt erstellen Sie mithilfe von Sequelize-Modellen eine 1:n-Beziehung. Stellen Sie sich vor, Sie möchten alle Schüler einer ausgewählten Klassenstufe zuordnen. Da eine bestimmte Klassenstufe mehrere Schüler haben kann, handelt es sich um eine Eins-zu-Viele-Beziehung.

Kopieren Sie zunächst den Inhalt von one_to_one.jsin eine neue Datei namens one_to_many.js. one_to_many.jsEntfernen Sie in die Zeilen nach dem student_dataBlock. Ihre one_to_many.jsDatei wird wie folgt aussehen:

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

Verwenden Sie nach dem student_dataBlock die hasMany()Methode, um eine neue Beziehung zu erstellen:

...
Grade.hasMany(Student)

Mit der hasMany()Methode können Sie eine Eins-zu-Viele-Beziehung zwischen zwei Sequelize-Modellen erstellen. Hier verwenden Sie die Modelle Gradeund .Student

Fügen Sie als Nächstes die sequelize.sync()Methode mit der findAll()Methode unter der hasMany()Zeile hinzu:

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

Hier versuchen Sie, auf alle Schüler einer bestimmten Klassenstufe zuzugreifen – in diesem Fall auf alle Schüler der Klasse 9. Sie haben auch das StudentModell in der includeOption hinzugefügt.

Hier ist der vollständige Code:

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

Speichern und schließen Sie Ihre Datei.

Führen Sie die Datei mit dem folgenden Befehl aus:

node one_to_many.js

Die Ausgabe sieht ähnlich wie die folgende aus. Es wird ziemlich lange dauern, aber alle Schüler in der Klasse 9werden wie folgt zurückgegeben:

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);In diesem Abschnitt haben Sie mithilfe des Methodenaufrufs eine 1:n-Beziehung erstellt . In der Ausgabe haben Sie die Details gemäß der von Ihnen erstellten Zuordnung abgerufen.

Erstellen von Many-to-Many-Beziehungen mitbelongsToMany()

In diesem Abschnitt erstellen Sie viele-zu-viele-Beziehungen mithilfe von Sequelize-Modellen. Stellen Sie sich als Beispiel eine Situation vor, in der Studenten in Kurse eingeschrieben sind. Ein Student kann sich in viele Kurse einschreiben und ein Kurs kann viele Studenten haben. Dies ist eine Viele-zu-Viele-Beziehung. Um dies mit Sequelize zu implementieren, verwenden Sie die Modelle Student, Courseund StudentCoursemit der belongsToMany()Methode.

Erstellen Sie zunächst eine Datei mit dem Namen many_to_many.jsund fügen Sie die Datenbankinitiierungs- und Authentifizierungscodeblöcke wie folgt hinzu. (Sie können die Codeblöcke aus dem vorherigen one_to_many.jsBeispiel wiederverwenden.) Achten Sie darauf, die hervorgehobenen Datenbankverbindungswerte nach Bedarf zu aktualisieren.

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

Als Nächstes erstellen Sie die Datenbankmodelle für viele-zu-viele-Beziehungen: Studentund Course. Anschließend fügen Sie diesen Modellen einige Beispieldaten hinzu.

...

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

Hier erstellen Sie die Modelle Studentund Courseund geben einige Beispieldaten an. Sie legen auch eine fest courseID, die Sie zum Abrufen von Schülern gemäß diesem Beziehungstyp verwenden.

Schließlich haben Sie ein neues Modell namens definiert StudentCourse, das die Beziehungsdaten zwischen Studentund verwaltet Course. In diesem Beispiel studentId 1ist eingeschrieben in courseId 1und courseId 2.

Sie haben die Datenbankinitiierung abgeschlossen und Beispieldaten zur Datenbank hinzugefügt. Erstellen Sie als Nächstes viele-zu-viele-Beziehungen mit der belongsToMany()folgenden Methode:

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

Innerhalb der belongsToMany()Methode übergeben Sie die throughKonfiguration mit dem Namen des Modells als Konfigurationsoption. In diesem Fall ist es StudentCourse. Dies ist die Tabelle, die die Viele-zu-Viele-Beziehungen verwaltet.

Schließlich können Sie überprüfen, ob die Zuordnung ordnungsgemäß funktioniert, indem Sie alle Kursdaten mit zugeordneten Studenten abrufen. Dazu übergeben Sie den includeParameter innerhalb der findAll()Methode. Fügen Sie die folgenden Zeilen hinzu 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);
});

Der vollständige Code sieht wie folgt aus:

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

Speichern und schließen Sie die Datei.

Führen Sie die Datei mit dem folgenden Befehl aus:

node many_to_many.js

Die Ausgabe ist lang, sieht aber etwa so aus:

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

Wie Sie in dieser Ausgabe sehen können, wurden die Kurse mit zugehörigen Studenten abgerufen. Innerhalb des coursesBlocks sehen Sie separate idWerte, die jeden Kurs angeben. Zum Beispiel id: 1ist mit dem course_name: Sciencefür den naturwissenschaftlichen Unterricht verbunden, wohingegen id: 2der mathematische Unterricht und so weiter.

In der Datenbank sehen Sie die drei generierten Tabellen mit den von Ihnen eingefügten Beispieldaten.

In diesem Schritt haben Sie Sequelize verwendet, um Eins-zu-eins-, Eins-zu-viele- und Viele-zu-viele-Zuordnungen zu erstellen. Als Nächstes arbeiten Sie mit Rohabfragen.

Schritt 5 – Arbeiten mit Rohabfragen

In diesem Schritt arbeiten Sie mit Rohabfragen in Sequelize. In den vorherigen Schritten haben Sie integrierte Sequelize-Methoden wie insert()und verwendet findAll(), um das Einfügen und Auswählen von Daten aus der Datenbank zu handhaben. Sie haben vielleicht bemerkt, dass diese Methoden einem bestimmten Muster zum Schreiben einer Abfrage folgen. Durch die Verwendung von Rohabfragen müssen Sie sich jedoch keine Gedanken über die integrierten Methoden und Muster von Sequelize machen. Mit Ihrem Wissen über SQL-Abfragen können Sie eine Reihe von Abfragen in Sequelize durchführen, von einfachen bis zu fortgeschrittenen.

Hier ist ein Beispiel für Rohabfragen, die die Aktion ausführen, alle Werte aus einer bestimmten Tabelle auszuwählen, die ausgewählten Werte gemäß der Bedingung zu löschen und die Tabelle mit den angegebenen Werten zu aktualisieren.

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

In Sequelize können Rohabfragen hauptsächlich mit zwei Methoden verwendet werden: Array-Ersetzung und Objekt-Ersetzung. Wenn Sie Werte an die SQL-Abfrage übergeben, können Sie entweder ein Array oder ein Objekt verwenden, um diese Ersetzung vorzunehmen.

Bevor Sie eine Rohabfrage schreiben, müssen Sie zunächst Schülerdaten in einer Beispieldatenbank bereitstellen. Melden Sie sich nach dem vorherigen Abschnitt Erstellen einer Beispieldatenbank bei MySQL an, erstellen Sie eine Datenbank namens sample_student_dbund melden Sie sich von MySQL ab.

Als Nächstes fügen Sie einige Rohdaten hinzu, um mit der Arbeit mit Rohabfragen zu beginnen. Erstellen Sie eine neue Datei mit dem Namen add_student_records.jsund fügen Sie die folgenden Codeblöcke hinzu, die die zuvor besprochenen Sequelize-Methoden von authenticate(), sync()und enthalten 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);
});

Hier initiieren Sie die Datenbankverbindung, erstellen das Modell und fügen einige Schülerdatensätze in die neue Datenbank ein.

Speichern und schließen Sie die Datei.

Führen Sie als Nächstes dieses Skript mit dem folgenden Befehl aus:

node add_student_records.js

Die Ausgabe wird etwa wie folgt aussehen. Es wird ziemlich lange dauern, aber alle Studentendatensätze, die Sie eingefügt haben, werden wie folgt zurückgegeben. Da student_ides sich um einen automatisch generierten UUID-Wert ( Universally Unique Identifiers ) handelt, ist dieser je nach Benutzer unterschiedlich.

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

…

Im nächsten Abschnitt wenden Sie Rohabfragen an, indem Sie eine der student_idAusgaben im obigen Codeblock verwenden. Kopieren Sie es nach unten, damit Sie es für die nächsten Abschnitte haben, in denen Sie die query()Methode zum Ersetzen von Arrays und Objekten verwenden werden.

Array-Ersatz

In diesem Abschnitt verwenden Sie die query()Methode für eine Array-Ersetzung. Mit dieser Methode kann Sequelize rohe oder bereits vorbereitete SQL-Abfragen ausführen.

Kopieren Sie zunächst den Inhalt der server.jsDatei aus Schritt 1 , da dieser die Sequelize()Methode „initiate“ und die Datenbankinitiierung enthält. Fügen Sie den Inhalt in eine neue Datei namens array_raw_query.js. Aktualisieren Sie den Datenbanknamen auf 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);
});

Fügen Sie am Ende der Datei den folgenden Codeblock für eine Array-Ersetzung hinzu und stellen Sie sicher, dass Sie ihn durch REPLACE_STUDENT_IDden student_idWert ersetzen, den Sie im vorherigen Abschnitt kopiert haben.

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

Für die Array-Ersetzung übergeben Sie die query()Methode mit der SQL-Abfrage und dem Konfigurationsobjekt. Es enthält den replacementsWert und den Typ. An Ersetzungen übergeben Sie Daten als Array und fangen diese Werte mit dem Fragezeichensymbol ( ?) ab.

Da Sie Daten über einen bestimmten Schüler abrufen müssen, student_idwird das als zweiter Parameter übergeben. Danach übergeben Sie das type: sequelize.QueryTypes.SELECTSchlüssel-Wert-Paar, mit dem Sie Daten aus der Datenbank auswählen können.

Es gibt auch einige andere Typen, wie z. B. QueryTypes.UPDATEund QueryTypes.DELETE. Je nach Anforderung können Sie den für Ihren Zweck passenden Typ auswählen.

Das Folgende zeigt den vollständigen Codeblock. Hier verbinden Sie sich mit der Datenbank und rufen die ausgewählten Schülerdaten mit einer Rohabfrage ab.

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

Speichern und schließen Sie Ihre Datei.

Als nächstes können Sie dieses Skript mit dem folgenden Befehl ausführen:

node array_raw_query.js

Sie sehen eine Ausgabe ähnlich der folgenden:

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

Aufgrund der gewählten student_idkönnen Ihre Ausgabewerte abweichen.

Objektersetzung

Auf den ersten Blick ähnelt die Objektersetzung der Array-Ersetzung, aber das Muster der Datenübergabe an die Rohabfrage ist anders. Bei der Ersetzungsoption übergeben Sie Daten als Objekt, und bei der Abfrageoption verwenden Sie Werte wie :key.

Erstellen Sie zunächst eine neue Datei mit dem Namen object_raw_query.jsund fügen Sie die vollständigen Codeblöcke aus der server.jsDatei ein und aktualisieren Sie die Datenbank auf 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);
});

Fügen Sie dann den folgenden Codeblock am Ende der neuen object_raw_query.jsDatei hinzu:

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

Hier erhalten Sie ausgewählte Schülerdaten nach der Objektersetzungsmethode. Sie erstellen ein replacementObjekt, indem idSie als die Schülerinformationen festlegen, die Sie abrufen möchten: { id: 'REPLACE_STUDENT_ID' }.

In der query()geben Sie an: 'SELECT * FROM students WHERE student_id = :id'. Mit der query()Methode übergeben Sie den Ersatzwert als Objekt, weshalb diese Methode als Objektersetzung bezeichnet wird.

Hier ist der vollständige Code:

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

Speichern und schließen Sie die Datei.

Führen Sie als Nächstes dieses Skript mit dem folgenden Befehl aus:

node object_raw_query.js

Die Ausgabe sieht etwa so aus:

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

Aufgrund der gewählten student_idkönnen Ihre Ausgabewerte abweichen.

In diesem Schritt haben Sie mit Sequelize-Rohabfragen unter Verwendung von zwei verschiedenen Methoden gearbeitet: Array-Ersetzung und Objekt-Ersetzung.

Fazit

In diesem Lernprogramm haben Sie Sequelize installiert und konfiguriert. Sie haben auch Modelle erstellt und mit ihnen gearbeitet, was eine der obligatorischen Komponenten von Sequelize ist. Schließlich haben Sie verschiedene Arten von Assoziationen erstellt und anhand praktischer Beispiele mit Rohabfragen gearbeitet.

Als Nächstes können Sie verschiedene Datentypen verwenden, um Datenbankmodelle zu erstellen. Sie können Datensätze in Datenbanken auch mit integrierten Methoden und Rohabfragen aktualisieren und löschen.

Quelle des Originalartikels unter https://www.digitalocean.com

#sequelize #node #mysql #database 

What is GEEK

Buddha Community

So verwenden Sie Sequelize mit Node und 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

Zenon  Pruschke

Zenon Pruschke

1658742600

So verwenden Sie Sequelize mit Node und MySQL

Erfahren Sie, wie Sie Sequelize mit MySQL installieren und konfigurieren. Verwenden von Sequelize zum Erstellen von Datenbanken und Modellen sowie zum Ausführen von Einfüge-, Auswahl-, Löschvorgängen und mehr 

Sequelize ist ein Node.js -basierter Object Relational Mapper, der die Arbeit mit MySQL- , MariaDB- , SQLite- , PostgreSQL - Datenbanken und mehr vereinfacht. Ein objektrelationaler Mapper führt Funktionen wie die Handhabung von Datenbankdatensätzen aus, indem er die Daten als Objekte darstellt. Sequelize verfügt über einen leistungsstarken Migrationsmechanismus, der vorhandene Datenbankschemata in neue Versionen umwandeln kann. Insgesamt bietet Sequelize hervorragende Unterstützung für Datenbanksynchronisierung, Eager Loading, Zuordnungen, Transaktionen und Datenbankmigrationen, während gleichzeitig die Entwicklungszeit verkürzt und SQL-Injektionen verhindert werden.

In diesem Tutorial installieren und konfigurieren Sie Sequelize mit MySQL in Ihrer lokalen Entwicklungsumgebung. Als Nächstes verwenden Sie Sequelize, um Datenbanken und Modelle zu erstellen und die Operationen insert, select, und auszuführen delete. Anschließend erstellen Sie Sequelize-Zuordnungen für Eins-zu- eins- , Eins -zu-viele- und Viele-zu-viele- Beziehungen. Schließlich erstellen Sie Sequelize-Rohabfragen für Array- und Objektersetzungen.

Dieses Tutorial wurde auf Node.js Version 14.17.6 und npmVersion 6.14.15 auf macOS Catalina getestet.

Schritt 1 – Installieren und Konfigurieren von Sequelize

In diesem Schritt installieren Sie Sequelize und stellen die Verbindung zu Ihrer MySQL-Datenbank her. Dazu erstellen Sie zunächst eine Node.js-Anwendung. Anschließend installieren Sie Sequelize, konfigurieren die MySQL-Datenbank und entwickeln eine einfache Anwendung.

Sequelize installieren

Beginnen Sie mit dem Erstellen eines Projektordners. In diesem Beispiel können Sie hello-world. Sobald der Ordner erstellt ist, navigieren Sie mit dem Terminal zu dem Ordner:

mkdir hello-world
cd hello-world

Erstellen Sie dann mit dem folgenden Befehl eine Node.js-Beispielanwendung:

npm init

Als Nächstes werden Sie aufgefordert, einige Einrichtungsfragen zu beantworten. Verwenden Sie die folgende Ausgabe für Ihre Konfiguration. Drücken ENTERSie , um den angezeigten Standardwert zu verwenden, und achten Sie darauf, den Haupteinstiegspunkt auf einzustellen server.js. Dadurch entsteht eine einfach zu pflegende Projektstruktur.

Die Ausgabe sieht wie folgt aus, wodurch die package.jsonDatei gefüllt wird:

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

Erstellen Sie als Nächstes eine leere server.jsDatei im Projektordner:

touch server.js

Nachdem Sie die vorherigen Schritte ausgeführt haben, sieht Ihre endgültige Ordnerstruktur folgendermaßen aus:

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

Jetzt können Sie Sequelize mit dem folgenden Befehl installieren:

npm i sequelize@6.11.0

Hinweis: Dieser Befehl installiert Version 6.11.0. Wenn Sie die neueste Version installieren müssen, führen Sie npm i sequelize.

Nach diesen Updates package.jsonsieht die Datei nun so aus:

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

In dem dependenciesAbschnitt sehen Sie nun eine Sequelize-Abhängigkeit.

Sie haben das Projekt eingerichtet und Sequelize installiert. Als Nächstes erstellen Sie eine Beispieldatenbank, zu der Sie eine Verbindung herstellen möchten.

Erstellen einer Beispieldatenbank

Als Teil der Voraussetzungen haben Sie MySQL installiert und konfiguriert, einschließlich der Erstellung eines Benutzers. Jetzt erstellen Sie eine leere Datenbank.

Dazu müssen Sie sich zunächst bei Ihrer MySQL-Instanz anmelden. Wenn Sie remote arbeiten, können Sie Ihr bevorzugtes Tool verwenden. Wenn Sie eine lokal ausgeführte MySQL-Instanz verwenden, können Sie den folgenden Befehl verwenden und dabei your_username durch Ihren MySQL-Benutzernamen ersetzen:

mysql -u your_username -p

-uBenutzername ist und die -pOption übergeben wird, wenn das Konto mit einem Passwort gesichert ist.

Der MySQL-Server wird Sie nach Ihrem Datenbankpasswort fragen. Geben Sie Ihr Passwort ein und drücken Sie ENTER.

Sobald Sie angemeldet sind, erstellen Sie eine Datenbank, die hello_world_dbmit dem folgenden Befehl aufgerufen wird:

CREATE DATABASE hello_world_db;

Um zu überprüfen, ob Sie die Datenbank erfolgreich erstellt haben, können Sie diesen Befehl verwenden:

SHOW DATABASES;

Ihre Ausgabe wird ungefähr so ​​​​aussehen:

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

Trennen Sie nach dem Erstellen der Beispieldatenbank die Verbindung zum MySQL-Server:

mysql> QUIT

Jetzt müssen Sie einen manuellen Treiber für die Datenbank Ihrer Wahl installieren. Da Sequelize nur ORM-Funktionen bietet, enthält es keine integrierten Datenbanktreiber. Daher müssen Sie Treiber nach Ihren Wünschen installieren. Navigieren Sie dazu mit dem Terminal zum Projektverzeichnis und installieren Sie den MySQL-Treiber mit dem folgenden Befehl im Projekt:

npm install --save mysql2

In diesem Fall verwenden Sie den Treiber für MySQL.

Hinweis: Da dieses Tutorial MySQL als Datenbank verwendet, verwenden Sie dafür einen Treiber. Abhängig von Ihrer Datenbank können Sie den Treiber wie folgt manuell installieren:

  • 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

Nachdem Sie nun über eine Beispieldatenbank verfügen, können Sie Ihre erste Sequelize-Anwendung mit Datenbankkonnektivität erstellen.

Verbindung zur MySQL-Datenbank herstellen

In diesem Abschnitt verbinden Sie die Node.js-Anwendung mithilfe von Sequelize mit der MySQL-Datenbank.

Um eine Verbindung zur Datenbank herzustellen, öffnen Sie server.jssie zur Bearbeitung mit nanooder Ihrem bevorzugten Code-Editor:

nano server.js

Hier erstellen Sie mithilfe einer Sequelize-Instanz eine Datenbankverbindung in Ihrer Anwendung. Übergeben Sie in der new Sequelize()Methode die MySQL-Serverparameter und Datenbankanmeldeinformationen wie folgt und ersetzen Sie DATABASE_USERNAMEund DATABASE_PASSWORDdurch die Anmeldeinformationen Ihres MySQL-Benutzers:

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

hostHier wird der MySQL-Server gehostet, daher müssen Sie eine Server-URL oder eine IP-Adresse angeben. Wenn Sie einen lokal installierten MySQL-Server verwenden, können Sie den Wert DATABASE_HOSTdurch localhostoder ersetzen.127.0.0.1

Wenn Sie einen Remote-Server verwenden, stellen Sie in ähnlicher Weise sicher, dass Sie die Datenbankverbindungswerte entsprechend durch die entsprechenden Details des Remote-Servers ersetzen.

Hinweis: Wenn Sie eine andere Datenbankserversoftware verwenden, können Sie den Dialektparameter entsprechend ersetzen. `Dialekt: 'mysql', 'mariadb', 'postgres', 'mssql'.

Rufen Sie als Nächstes eine Promise-basierte authenticate() Methode auf, um eine Datenbankverbindung mit der Anwendung zu instanziieren. Fügen Sie dazu den folgenden Codeblock zu Ihrer server.jsDatei hinzu:

...

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

Die authenticate()Methode wird verwendet, um sich mit der Datenbank zu verbinden und testet, ob die angegebenen Anmeldeinformationen korrekt sind. Hier ist die Datenbankverbindung standardmäßig geöffnet und es kann für alle Abfragen dieselbe Verbindung verwendet werden. Wann immer Sie die Verbindung schließen müssen, rufen Sie die sequelize.close()Methode nach diesem authenticate()Aufruf auf. Um mehr über Sequelize zu erfahren, lesen Sie bitte den Leitfaden „Erste Schritte“ .

Die meisten der von Sequelize bereitgestellten Methoden sind asynchron. Das bedeutet, dass Sie Prozesse in Ihrer Anwendung ausführen können, während sich ein asynchroner Codeblock in seiner Ausführungszeit befindet. Außerdem wird nach der erfolgreichen Ausführung des asynchronen Codeblocks ein Promise zurückgegeben, bei dem es sich um den Wert handelt, der am Ende eines Prozesses zurückgegeben wird. Daher können Sie in asynchronen Codeblöcken , und verwenden then(), um die verarbeiteten Daten zurückzugeben.catch()finally()

Zu diesem Zeitpunkt sieht die server.jsDatei wie folgt aus:

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

Speichern und schließen Sie Ihre Datei.

Führen Sie im Projektverzeichnis die server.jsAnwendung aus, indem Sie den folgenden Befehl ausführen:

node server.js

Ihre Ausgabe sieht folgendermaßen aus:

Output
Connection has been established successfully!

Sie haben die Datenbankverbindung erfolgreich erstellt.

In diesem Schritt haben Sie Sequelize installiert, eine Beispieldatenbank erstellt und Sequelize verwendet, um eine Verbindung mit der Datenbank herzustellen. Als Nächstes arbeiten Sie mit Modellen in Sequelize.

Schritt 2 – Erstellen einer Datenbanktabelle mit Sequelize

Nachdem Sie nun eine MySQL-Beispieldatenbank erstellt haben, können Sie mit Sequelize eine Tabelle erstellen und diese mit Daten füllen. In Sequelize werden Datenbanktabellen als Modelle bezeichnet . Ein Modell ist eine Abstraktion, die eine Tabelle der Datenbank darstellt. Modelle definieren mehrere Dinge, die sequenziert werden sollen, wie z. B. den Namen der Tabelle, Spaltendetails und Datentypen. In diesem Schritt erstellen Sie ein Sequelize-Modell für Buchdaten.

Erstellen Sie zunächst eine neue Datei mit dem Namen book.model.jsim Projektverzeichnis:

nano book.model.js

Fügen Sie ähnlich wie im vorherigen Schritt einen Sequelize-Code für die Datenbankinitiierung mit einem neuen Import für DataTypesoben in der Datei hinzu:

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

Sequelize enthält viele eingebaute Datentypen. Um auf diese Datentypen zuzugreifen, fügen Sie einen Import für DataTypes. Dieses Tutorial bezieht sich auf einige häufig verwendete Datentypen wie STRING, INTEGERund DATEONLY. Weitere Informationen zu anderen unterstützten Datentypen finden Sie in der offiziellen Sequelize-Dokumentation .

Fügen Sie dann die Zeilen hinzu, die Sie zuvor verwendet haben, um eine Verbindung zu Ihrer MySQL-Datenbank herzustellen, und aktualisieren Sie Ihre MySQL-Anmeldeinformationen entsprechend:

...

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

Als Nächstes erstellen Sie ein Modell namens books, das title, author, release_dateund subjectID enthält. Verwenden Sie sequelize.define()dazu die gezeigte Methode:

...

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

Die sequelize.define()Methode definiert ein neues Modell, das eine Tabelle in der Datenbank repräsentiert. Dieser Codeblock erstellt eine Tabelle mit dem Namen booksund speichert die Buchdatensätze gemäß title, author, release_dateund subject.

In diesem Code allowNullzeigt, dass der Modellspaltenwert nicht sein kann null. Wenn Sie einen solchen Wert festlegen müssen, können Sie ebenfalls defaultValue: "value".

Als Nächstes fügen Sie das bookModell Ihrer Datenbank hinzu. Dazu verwenden Sie die sync()Methode wie folgt:

...

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

In der sync()Methode bitten Sie Sequelize, einige Dinge mit der Datenbank zu tun. Bei diesem Aufruf führt Sequelize automatisch eine SQL-Abfrage an die Datenbank durch, erstellt eine Tabelle und gibt die Nachricht aus Book table created successfully!.

Wie bereits erwähnt, ist die sync()-Methode eine Promise-basierte Methode, was bedeutet, dass sie auch eine Fehlerbehandlung durchführen kann. In diesem Codeblock überprüfen Sie, ob die Tabelle erfolgreich erstellt wurde. Wenn nicht, gibt es einen Fehler über die catch-Methode zurück und gibt ihn auf der Ausgabe aus.

Hinweis: Sie können die Modellsynchronisierung verwalten, indem Sie forceParameter übergeben, um die Erstellung einer neuen Tabelle zu erzwingen, falls diese nicht vorhanden ist, oder eine vorhandene verwenden. Hier sind einige Beispiele, die Ihnen bei der Arbeit mit Sequelize hilfreich sein können:

  • model.sync(): Dies erstellt die Tabelle, falls sie noch nicht existiert.
  • model.sync({ force: true }): Dadurch wird die Tabelle erstellt, indem sie gelöscht wird, wenn dieselbe Tabelle bereits vorhanden ist.

Der endgültige Code sieht folgendermaßen aus:

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

Speichern und schließen Sie Ihre Datei.

Führen Sie Ihre Anwendung mit dem folgenden Befehl aus:

node book.model.js

Sie erhalten die folgende Ausgabe in Ihrer Befehlszeile:

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!

In der Ausgabe sehen Sie, dass das Rückgabeprotokoll die Nachricht enthält Book table created successfully!. Sie können dies überprüfen, indem Sie Ihre Datenbank überprüfen, um die neue booksTabelle zu sehen, die in der hello_world_dbDatenbank erstellt wurde.

Um die Erstellung der neuen Tabelle zu überprüfen, melden Sie sich bei Ihrer MySQL-Instanz an:

mysql -u YOUR_USERNAME -p

Wechseln Sie nach Eingabe Ihres Passwortes in die Musterdatenbank:

USE hello_world_db;

Führen Sie dann den Befehl aus, um Tabellen anzuzeigen:

SHOW TABLES;

Ihre Ausgabe wird ungefähr so ​​​​aussehen:

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

Trennen Sie abschließend die Verbindung zum MySQL-Server:

mysql> QUIT

Sie haben überprüft, dass die bookModellerstellung erfolgreich war. Mit diesem Prozess können Sie eine beliebige Anzahl von Modellen erstellen, indem Sie demselben Verfahren folgen.

In diesem Schritt haben Sie ein Modell in einer Datenbank erstellt und die Arbeit mit einem Modell unter Verwendung integrierter Methoden begonnen. Sie haben auch von Sequelize unterstützte Datentypen verwendet, um Ihr Modell zu definieren. Als Nächstes arbeiten Sie mit grundlegenden Modellabfragen.

Schritt 3 – Verwenden von Sequelize für Datenbankabfragen

In diesem Schritt verwenden Sie die integrierten Sequelize-Abfragen zum Einfügen, Auswählen, Auswählen mit Bedingungsklauseln und Löschen.

Einfügen eines neuen Datensatzes

Im vorherigen Schritt haben Sie ein bookModell in der Datenbank erstellt. In diesem Abschnitt fügen Sie Daten in dieses Modell ein.

Kopieren Sie zunächst den Inhalt von book.model.jsaus dem vorherigen Schritt. Erstellen Sie eine neue Datei mit dem Namen book.controller.js, um die Abfragelogik zu verarbeiten. Fügen Sie den Code von book.model.jsbis hinzu book.controller.js.

book.controller.jsSuchen Sie in die Methode sync(). Fügen Sie in der sync()Methode die folgenden hervorgehobenen Zeilen hinzu:

...

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

Hier fügen Sie einen neuen Buchdatensatz in das booksModell ein, das Sie bereits erstellt haben, indem Sie die sync()Methode verwenden, die das Hinzufügen neuer Datensätze zu zuvor erstellten Modellen unterstützt. Sobald die sync()-Methode erfolgreich ausgeführt wird, führt sie die then()Methode aus. Innerhalb der then()Methode rufen Sie die create()Methode auf, um die neuen Datensätze in das Modell einzufügen.

Sie verwenden die create()Methode, um die Daten, die Sie der Datenbank hinzufügen müssen, als Objekt zu übergeben. Der hervorgehobene Codeabschnitt fügt einen neuen Eintrag in Ihre vorhandene booksTabelle ein. In diesem Beispiel fügen Sie Clean Codeby hinzu Robert Cecil Martin, das mit der subjectID von kategorisiert wurde 3. Sie können denselben Code, aktualisiert mit Informationen für andere Bücher, verwenden, um Ihrer Datenbank neue Datensätze hinzuzufügen.

Speichern und schließen Sie die Datei.

Führen Sie die Anwendung mit dem folgenden Befehl aus:

node book.controller.js

Ihre Ausgabe sieht in etwa so aus:

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

Sie haben einen neuen Datensatz in das Modell eingefügt, das Sie in der Datenbank erstellt haben. Sie können weiterhin mehrere Datensätze mit demselben Verfahren hinzufügen.

Auswahl aller Datensätze

findAll()In diesem Abschnitt werden Sie mithilfe der Methode alle Buchdatensätze aus der Datenbank auswählen und abrufen . Öffnen book.controller.jsund entfernen Sie dazu zuerst die vorherige Book.create()Methode. Fügen Sie in der Methode sync()die Book.findAll()Methode wie gezeigt hinzu:

...

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

...

Speichern und schließen Sie die Datei.

Führen Sie als Nächstes die Anwendung mit dem folgenden Befehl erneut aus:

node book.controller.js

Ihre Ausgabe sieht in etwa so aus:

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

Die Ausgabe enthält alle Buchdaten als Array-Objekt. Sie haben die Sequelize- findAll()Methode erfolgreich verwendet, um alle Buchdaten aus der Datenbank zurückzugeben.

Auswählen mit der whereKlausel

In diesem Abschnitt wählen Sie Werte mit Bedingungen unter Verwendung der whereKlausel aus. Die whereKlausel wird verwendet, um eine Bedingung beim Abrufen von Daten anzugeben. findOne()Für dieses Lernprogramm erhalten Sie mithilfe der Methode ein Buch anhand einer bestimmten Datensatz-ID aus der Datenbank .

Öffnen Sie dazu book.controller.jszum Bearbeiten, löschen Sie die findAll()Methode und fügen Sie die folgenden Zeilen hinzu:

...

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

Hier wählen Sie mit der findOne()Methode mit der whereOption einen bestimmten Bucheintrag aus der Datenbank aus. In diesem Beispiel rufen Sie die Buchdaten ab, deren idWert gleich ist 1.

Speichern und schließen Sie die Datei.

Führen Sie als Nächstes die Anwendung aus:

node book.controller.js

Ihre Ausgabe sieht in etwa so aus:

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

Sie haben erfolgreich whereKlauseln verwendet, um Daten aus Sequelize-Modellen abzurufen. Sie können die whereKlausel in der Datenbankanwendung verwenden, um bedingte Daten zu erfassen.

Löschen eines Datensatzes

Um einen bestimmten Datensatz aus dem Datenbankmodell zu löschen, verwenden Sie die destroy()Methode mit der whereOption. Öffnen Sie dazu book.controller.js, entfernen Sie die findOne()Methode und fügen Sie die folgenden hervorgehobenen Zeilen hinzu:

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

Hier entfernen Sie einen Bucheintrag aus der Datenbank, indem Sie die destroy()Methode mit der whereOption verwenden und die iddes zu entfernenden Buchs übergeben. Sie werden den Bucheintrag entfernen, dessen idGleichheit 2.

Speichern und schließen Sie die Datei.

Führen Sie als Nächstes die Anwendung aus:

node book.controller.js

Ihre Ausgabe sieht wie folgt aus:

Output
Successfully deleted record.

Der Datensatz wurde gelöscht.

In diesem Schritt haben Sie mit Ihrem Datenbankmodell und Modellabfragen experimentiert. Sie haben die Datenbank initiiert, Modelle erstellt, Datensätze eingefügt, Datensätze abgerufen, Datensätze mit Bedingungen mithilfe der whereKlausel abgerufen und ausgewählte Datensätze gelöscht. Mit diesem Sequelize-Wissen erstellen Sie nun Assoziationen in Sequelize. Danach können Sie mithilfe von Sequelize-Modellen eine Vielzahl von Beziehungen definieren und damit arbeiten.

Schritt 4 – Erstellen von Assoziationen mit Sequelize

In diesem Schritt verwenden Sie die standardmäßigen Zuordnungstypen, die Sequelize unterstützt: Eins-zu- eins- , Eins-zu- viele- und Viele-zu-viele- Zuordnungen. Sie verwenden Beispieldaten zu Schülern, Kursen und Klassenstufen.

Sequelize verwendet Assoziationstypen basierend auf den folgenden Datenbankbeziehungen:

Eins-zu-eins- Beziehung : Eine Eins-zu-eins-Beziehung bedeutet, dass ein Datensatz in einer Tabelle genau einem Datensatz in einer anderen Tabelle zugeordnet ist. In Bezug auf Sequelize können SiebelongsTo()undhasOne()Assoziationen verwenden, um diese Art von Beziehung zu erstellen.

Eins-zu-viele- Beziehung : Eine Eins-zu-viele-Beziehung bedeutet, dass ein Datensatz in einer Tabelle mehreren Datensätzen in einer anderen Tabelle zugeordnet ist. Mit Sequelize können SiehasMany()Assoziationsmethoden verwenden, um diese Art von Beziehung zu erstellen.

Viele-zu-Viele- Beziehung : Eine Viele-zu-Viele-Beziehung bedeutet, dass mehrere Datensätze in einer Tabelle mehreren Datensätzen in einer anderen Tabelle zugeordnet sind. Mit Sequelize können SiebelongsToMany()Assoziationen verwenden, um diese Art von Beziehung zu erstellen.

Bevor Sie diese Zuordnungen erstellen, erstellen Sie zunächst eine neue Datenbank namens student_dbund fügen neue Modelle und einige Beispieldaten für Schüler, Kurse und Klassenstufen hinzu.

Um die Datenbank zu erstellen, folgen Sie demselben Prozess in Schritt 1 – Installieren und Konfigurieren von Sequelize, um sich bei MySQL anzumelden und eine Datenbank mit dem Namen zu erstellen student_db. Sobald die neue Datenbank erstellt wurde, melden Sie sich von MySQL ab. Als Nächstes beginnen Sie mit dem Erstellen von Datenbankzuordnungen.

Aufbau einer Eins-zu-Eins-Beziehung mitbelongsTo()

In diesem Abschnitt erstellen Sie mithilfe von Sequelize-Modellen eine Eins-zu-eins-Beziehung. Stellen Sie sich vor, Sie möchten die Daten eines Schülers zusammen mit seiner Klassenstufe abrufen. Da ein Schüler nur eine Klassenstufe haben kann, ist diese Art der Zuordnung eine Eins-zu-eins-Beziehung und Sie können die belongsTo()Methode verwenden.

Hinweis: Es gibt einen Unterschied zwischen belongsTo()und hasOne(). belongsTo()fügt das foreignKeyin der Quelltabelle hasOne()hinzu, während es in der Zieltabelle hinzugefügt wird. Wenn beide Beziehungen gleichzeitig verwendet werden, funktioniert dies in jedem Fall als bidirektionale Eins-zu-Eins-Beziehungen.

Mit der belongsTo()Methode können Sie eine Eins-zu-eins-Beziehung zwischen zwei Sequelize-Modellen erstellen. In diesem Beispiel verwenden Sie die Modelle Studentund .Grade

Erstellen Sie eine neue Datei namens one_to_one.js. Fügen Sie, wie im vorherigen Abschnitt Verbinden mit der MySQL-Datenbank , die Zeilen ein, um eine Verbindung zur Datenbank herzustellen und Ihren MySQL-Benutzer am Anfang der Datei zu authentifizieren. Stellen Sie sicher, dass Sie die MySQL-Anmeldeinformationen nach Bedarf aktualisieren:

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

In diesem Abschnitt erstellen Sie drei Modelle in der neuen student_dbDatenbank: Student, Grade, und Course. Sie beginnen mit der Erstellung der Modelle Studentund . GradeSpäter in diesem Schritt erstellen Sie das CoursesModell.

Fügen Sie für das StudentModell den folgenden Codeblock hinzu 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
   }
});

Dieses Schülermodell enthält zwei Spalten: student_idund name.

Fügen Sie als Nächstes einen Codeblock für das GradeModell hinzu:

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

Das GradeModell enthält die Spalte grade.

Um die Zuordnungen zu demonstrieren, müssen Sie der Datenbank Beispieldaten hinzufügen. Dazu verwenden Sie die bulk()Methode. Anstatt Daten einzeln in die Zeilen bulkCreate()einzufügen, können Sie mit der Methode mehrere Zeilen gleichzeitig in Ihre Datenbankmodelle einfügen.

Importieren Sie nun die Gradeund StudentDaten in ihre jeweiligen Modelle in der Datenbank wie gezeigt:

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

Hier stellen Sie Beispieldaten bereit und importieren die Daten in die Modelle Studentund . GradeWenn Ihre Datenbank, Modelle und Beispieldaten vorhanden sind, können Sie Zuordnungen erstellen.

Fügen Sie in one-to-one.jsdie folgende Zeile unter dem student_dataBlock hinzu:

...
Student.belongsTo(Grade);

Als nächstes müssen Sie überprüfen, ob die Zuordnung ordnungsgemäß funktioniert. Dazu können Sie alle Schülerdaten mit den zugehörigen Notenstufen abrufen, indem Sie den includeParameter innerhalb der findAll()Methode übergeben.

Da Sie die Studentennote erreichen müssen, bestehen Sie Gradeals Model. Fügen Sie in der sequelize.sync()Methode die hervorgehobenen Zeilen wie gezeigt hinzu:

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

Der vollständige Code sieht wie folgt aus:

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

Speichern und schließen Sie Ihre Datei.

Führen Sie die Datei mit dem folgenden Befehl aus:

node one_to_one.js

Die Ausgabe ist lang und Sie sehen alle Schülerdaten mit Notenstufen. Hier ist ein Ausschnitt der Ausgabe mit Schülerdaten:

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

Abhängig von den verwendeten Befehlszeilentools wird die Ausgabe möglicherweise als erweiterte Ansicht gedruckt oder nicht. Wenn es sich um eine erweiterte Ansicht handelt, wird das erweiterte gradeObjekt als Ausgabe gedruckt.

In diesem Abschnitt haben Sie mithilfe des Student.belongsTo(Grade);Methodenaufrufs eine 1:1-Beziehung erstellt und die Details gemäß der von Ihnen erstellten Zuordnung abgerufen.

Erstellen einer 1:n-Beziehung mithasMany()

In diesem Abschnitt erstellen Sie mithilfe von Sequelize-Modellen eine 1:n-Beziehung. Stellen Sie sich vor, Sie möchten alle Schüler einer ausgewählten Klassenstufe zuordnen. Da eine bestimmte Klassenstufe mehrere Schüler haben kann, handelt es sich um eine Eins-zu-Viele-Beziehung.

Kopieren Sie zunächst den Inhalt von one_to_one.jsin eine neue Datei namens one_to_many.js. one_to_many.jsEntfernen Sie in die Zeilen nach dem student_dataBlock. Ihre one_to_many.jsDatei wird wie folgt aussehen:

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

Verwenden Sie nach dem student_dataBlock die hasMany()Methode, um eine neue Beziehung zu erstellen:

...
Grade.hasMany(Student)

Mit der hasMany()Methode können Sie eine Eins-zu-Viele-Beziehung zwischen zwei Sequelize-Modellen erstellen. Hier verwenden Sie die Modelle Gradeund .Student

Fügen Sie als Nächstes die sequelize.sync()Methode mit der findAll()Methode unter der hasMany()Zeile hinzu:

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

Hier versuchen Sie, auf alle Schüler einer bestimmten Klassenstufe zuzugreifen – in diesem Fall auf alle Schüler der Klasse 9. Sie haben auch das StudentModell in der includeOption hinzugefügt.

Hier ist der vollständige Code:

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

Speichern und schließen Sie Ihre Datei.

Führen Sie die Datei mit dem folgenden Befehl aus:

node one_to_many.js

Die Ausgabe sieht ähnlich wie die folgende aus. Es wird ziemlich lange dauern, aber alle Schüler in der Klasse 9werden wie folgt zurückgegeben:

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);In diesem Abschnitt haben Sie mithilfe des Methodenaufrufs eine 1:n-Beziehung erstellt . In der Ausgabe haben Sie die Details gemäß der von Ihnen erstellten Zuordnung abgerufen.

Erstellen von Many-to-Many-Beziehungen mitbelongsToMany()

In diesem Abschnitt erstellen Sie viele-zu-viele-Beziehungen mithilfe von Sequelize-Modellen. Stellen Sie sich als Beispiel eine Situation vor, in der Studenten in Kurse eingeschrieben sind. Ein Student kann sich in viele Kurse einschreiben und ein Kurs kann viele Studenten haben. Dies ist eine Viele-zu-Viele-Beziehung. Um dies mit Sequelize zu implementieren, verwenden Sie die Modelle Student, Courseund StudentCoursemit der belongsToMany()Methode.

Erstellen Sie zunächst eine Datei mit dem Namen many_to_many.jsund fügen Sie die Datenbankinitiierungs- und Authentifizierungscodeblöcke wie folgt hinzu. (Sie können die Codeblöcke aus dem vorherigen one_to_many.jsBeispiel wiederverwenden.) Achten Sie darauf, die hervorgehobenen Datenbankverbindungswerte nach Bedarf zu aktualisieren.

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

Als Nächstes erstellen Sie die Datenbankmodelle für viele-zu-viele-Beziehungen: Studentund Course. Anschließend fügen Sie diesen Modellen einige Beispieldaten hinzu.

...

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

Hier erstellen Sie die Modelle Studentund Courseund geben einige Beispieldaten an. Sie legen auch eine fest courseID, die Sie zum Abrufen von Schülern gemäß diesem Beziehungstyp verwenden.

Schließlich haben Sie ein neues Modell namens definiert StudentCourse, das die Beziehungsdaten zwischen Studentund verwaltet Course. In diesem Beispiel studentId 1ist eingeschrieben in courseId 1und courseId 2.

Sie haben die Datenbankinitiierung abgeschlossen und Beispieldaten zur Datenbank hinzugefügt. Erstellen Sie als Nächstes viele-zu-viele-Beziehungen mit der belongsToMany()folgenden Methode:

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

Innerhalb der belongsToMany()Methode übergeben Sie die throughKonfiguration mit dem Namen des Modells als Konfigurationsoption. In diesem Fall ist es StudentCourse. Dies ist die Tabelle, die die Viele-zu-Viele-Beziehungen verwaltet.

Schließlich können Sie überprüfen, ob die Zuordnung ordnungsgemäß funktioniert, indem Sie alle Kursdaten mit zugeordneten Studenten abrufen. Dazu übergeben Sie den includeParameter innerhalb der findAll()Methode. Fügen Sie die folgenden Zeilen hinzu 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);
});

Der vollständige Code sieht wie folgt aus:

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

Speichern und schließen Sie die Datei.

Führen Sie die Datei mit dem folgenden Befehl aus:

node many_to_many.js

Die Ausgabe ist lang, sieht aber etwa so aus:

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

Wie Sie in dieser Ausgabe sehen können, wurden die Kurse mit zugehörigen Studenten abgerufen. Innerhalb des coursesBlocks sehen Sie separate idWerte, die jeden Kurs angeben. Zum Beispiel id: 1ist mit dem course_name: Sciencefür den naturwissenschaftlichen Unterricht verbunden, wohingegen id: 2der mathematische Unterricht und so weiter.

In der Datenbank sehen Sie die drei generierten Tabellen mit den von Ihnen eingefügten Beispieldaten.

In diesem Schritt haben Sie Sequelize verwendet, um Eins-zu-eins-, Eins-zu-viele- und Viele-zu-viele-Zuordnungen zu erstellen. Als Nächstes arbeiten Sie mit Rohabfragen.

Schritt 5 – Arbeiten mit Rohabfragen

In diesem Schritt arbeiten Sie mit Rohabfragen in Sequelize. In den vorherigen Schritten haben Sie integrierte Sequelize-Methoden wie insert()und verwendet findAll(), um das Einfügen und Auswählen von Daten aus der Datenbank zu handhaben. Sie haben vielleicht bemerkt, dass diese Methoden einem bestimmten Muster zum Schreiben einer Abfrage folgen. Durch die Verwendung von Rohabfragen müssen Sie sich jedoch keine Gedanken über die integrierten Methoden und Muster von Sequelize machen. Mit Ihrem Wissen über SQL-Abfragen können Sie eine Reihe von Abfragen in Sequelize durchführen, von einfachen bis zu fortgeschrittenen.

Hier ist ein Beispiel für Rohabfragen, die die Aktion ausführen, alle Werte aus einer bestimmten Tabelle auszuwählen, die ausgewählten Werte gemäß der Bedingung zu löschen und die Tabelle mit den angegebenen Werten zu aktualisieren.

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

In Sequelize können Rohabfragen hauptsächlich mit zwei Methoden verwendet werden: Array-Ersetzung und Objekt-Ersetzung. Wenn Sie Werte an die SQL-Abfrage übergeben, können Sie entweder ein Array oder ein Objekt verwenden, um diese Ersetzung vorzunehmen.

Bevor Sie eine Rohabfrage schreiben, müssen Sie zunächst Schülerdaten in einer Beispieldatenbank bereitstellen. Melden Sie sich nach dem vorherigen Abschnitt Erstellen einer Beispieldatenbank bei MySQL an, erstellen Sie eine Datenbank namens sample_student_dbund melden Sie sich von MySQL ab.

Als Nächstes fügen Sie einige Rohdaten hinzu, um mit der Arbeit mit Rohabfragen zu beginnen. Erstellen Sie eine neue Datei mit dem Namen add_student_records.jsund fügen Sie die folgenden Codeblöcke hinzu, die die zuvor besprochenen Sequelize-Methoden von authenticate(), sync()und enthalten 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);
});

Hier initiieren Sie die Datenbankverbindung, erstellen das Modell und fügen einige Schülerdatensätze in die neue Datenbank ein.

Speichern und schließen Sie die Datei.

Führen Sie als Nächstes dieses Skript mit dem folgenden Befehl aus:

node add_student_records.js

Die Ausgabe wird etwa wie folgt aussehen. Es wird ziemlich lange dauern, aber alle Studentendatensätze, die Sie eingefügt haben, werden wie folgt zurückgegeben. Da student_ides sich um einen automatisch generierten UUID-Wert ( Universally Unique Identifiers ) handelt, ist dieser je nach Benutzer unterschiedlich.

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

…

Im nächsten Abschnitt wenden Sie Rohabfragen an, indem Sie eine der student_idAusgaben im obigen Codeblock verwenden. Kopieren Sie es nach unten, damit Sie es für die nächsten Abschnitte haben, in denen Sie die query()Methode zum Ersetzen von Arrays und Objekten verwenden werden.

Array-Ersatz

In diesem Abschnitt verwenden Sie die query()Methode für eine Array-Ersetzung. Mit dieser Methode kann Sequelize rohe oder bereits vorbereitete SQL-Abfragen ausführen.

Kopieren Sie zunächst den Inhalt der server.jsDatei aus Schritt 1 , da dieser die Sequelize()Methode „initiate“ und die Datenbankinitiierung enthält. Fügen Sie den Inhalt in eine neue Datei namens array_raw_query.js. Aktualisieren Sie den Datenbanknamen auf 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);
});

Fügen Sie am Ende der Datei den folgenden Codeblock für eine Array-Ersetzung hinzu und stellen Sie sicher, dass Sie ihn durch REPLACE_STUDENT_IDden student_idWert ersetzen, den Sie im vorherigen Abschnitt kopiert haben.

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

Für die Array-Ersetzung übergeben Sie die query()Methode mit der SQL-Abfrage und dem Konfigurationsobjekt. Es enthält den replacementsWert und den Typ. An Ersetzungen übergeben Sie Daten als Array und fangen diese Werte mit dem Fragezeichensymbol ( ?) ab.

Da Sie Daten über einen bestimmten Schüler abrufen müssen, student_idwird das als zweiter Parameter übergeben. Danach übergeben Sie das type: sequelize.QueryTypes.SELECTSchlüssel-Wert-Paar, mit dem Sie Daten aus der Datenbank auswählen können.

Es gibt auch einige andere Typen, wie z. B. QueryTypes.UPDATEund QueryTypes.DELETE. Je nach Anforderung können Sie den für Ihren Zweck passenden Typ auswählen.

Das Folgende zeigt den vollständigen Codeblock. Hier verbinden Sie sich mit der Datenbank und rufen die ausgewählten Schülerdaten mit einer Rohabfrage ab.

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

Speichern und schließen Sie Ihre Datei.

Als nächstes können Sie dieses Skript mit dem folgenden Befehl ausführen:

node array_raw_query.js

Sie sehen eine Ausgabe ähnlich der folgenden:

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

Aufgrund der gewählten student_idkönnen Ihre Ausgabewerte abweichen.

Objektersetzung

Auf den ersten Blick ähnelt die Objektersetzung der Array-Ersetzung, aber das Muster der Datenübergabe an die Rohabfrage ist anders. Bei der Ersetzungsoption übergeben Sie Daten als Objekt, und bei der Abfrageoption verwenden Sie Werte wie :key.

Erstellen Sie zunächst eine neue Datei mit dem Namen object_raw_query.jsund fügen Sie die vollständigen Codeblöcke aus der server.jsDatei ein und aktualisieren Sie die Datenbank auf 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);
});

Fügen Sie dann den folgenden Codeblock am Ende der neuen object_raw_query.jsDatei hinzu:

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

Hier erhalten Sie ausgewählte Schülerdaten nach der Objektersetzungsmethode. Sie erstellen ein replacementObjekt, indem idSie als die Schülerinformationen festlegen, die Sie abrufen möchten: { id: 'REPLACE_STUDENT_ID' }.

In der query()geben Sie an: 'SELECT * FROM students WHERE student_id = :id'. Mit der query()Methode übergeben Sie den Ersatzwert als Objekt, weshalb diese Methode als Objektersetzung bezeichnet wird.

Hier ist der vollständige Code:

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

Speichern und schließen Sie die Datei.

Führen Sie als Nächstes dieses Skript mit dem folgenden Befehl aus:

node object_raw_query.js

Die Ausgabe sieht etwa so aus:

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

Aufgrund der gewählten student_idkönnen Ihre Ausgabewerte abweichen.

In diesem Schritt haben Sie mit Sequelize-Rohabfragen unter Verwendung von zwei verschiedenen Methoden gearbeitet: Array-Ersetzung und Objekt-Ersetzung.

Fazit

In diesem Lernprogramm haben Sie Sequelize installiert und konfiguriert. Sie haben auch Modelle erstellt und mit ihnen gearbeitet, was eine der obligatorischen Komponenten von Sequelize ist. Schließlich haben Sie verschiedene Arten von Assoziationen erstellt und anhand praktischer Beispiele mit Rohabfragen gearbeitet.

Als Nächstes können Sie verschiedene Datentypen verwenden, um Datenbankmodelle zu erstellen. Sie können Datensätze in Datenbanken auch mit integrierten Methoden und Rohabfragen aktualisieren und löschen.

Quelle des Originalartikels unter 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