许 志强

许 志强

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 和 MySQL 中使用 Sequelize
Iara  Simões

Iara Simões

1658793420

Cómo usar Sequelize con Node y MySQL

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

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

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

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

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

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

Instalación de Sequelize

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

mkdir hello-world
cd hello-world

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

npm init

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

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

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

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

touch server.js

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

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

Ahora puedes instalar Sequelize con el siguiente comando:

npm i sequelize@6.11.0

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

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

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

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

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

Creación de una base de datos de muestra

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

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

mysql -u your_username -p

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

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

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

CREATE DATABASE hello_world_db;

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

SHOW DATABASES;

Tu salida será similar a esta:

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

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

mysql> QUIT

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

npm install --save mysql2

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

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

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

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

Conexión a la base de datos MySQL

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

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

nano server.js

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

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

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

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

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

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

...

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

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

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

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

const Sequelize = require("sequelize");

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

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

Guarde y cierre su archivo.

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

node server.js

Su salida se verá así:

Output
Connection has been established successfully!

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

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

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

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

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

nano book.model.js

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

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

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

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

...

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

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

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

...

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

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

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

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

...

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

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

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

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

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

El código final se verá así:

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

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

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

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

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

Guarde y cierre su archivo.

Ejecute su aplicación usando el siguiente comando:

node book.model.js

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

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

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

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

mysql -u YOUR_USERNAME -p

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

USE hello_world_db;

Y luego ejecute el comando para mostrar las tablas:

SHOW TABLES;

Tu salida será similar a esta:

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

Finalmente, desconéctese del servidor MySQL:

mysql> QUIT

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

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

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

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

Insertar un nuevo registro

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

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

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

...

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

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

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

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

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

Guarde y cierre el archivo.

Ejecute la aplicación usando el siguiente comando:

node book.controller.js

Su salida será similar a la siguiente:

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

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

Selección de todos los registros

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

...

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

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

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

...

Guarde y cierre el archivo.

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

node book.controller.js

Su salida será similar a la siguiente:

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

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

Seleccionar con la wherecláusula

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

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

...

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

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

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

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

Guarde y cierre el archivo.

A continuación, ejecute la aplicación:

node book.controller.js

Su salida será similar a la siguiente:

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

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

Eliminación de un registro

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

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

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

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

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

Guarde y cierre el archivo.

A continuación, ejecute la aplicación:

node book.controller.js

Su salida se verá como la siguiente:

Output
Successfully deleted record.

El registro ha sido eliminado.

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

Paso 4: crear asociaciones usando Sequelize

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

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

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

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

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

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

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

Crear una relación uno a uno conbelongsTo()

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

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

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

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

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

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

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

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

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

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

Este modelo de estudiante contiene dos columnas: student_idy name.

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

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

El Grademodelo contiene la columna grade.

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

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

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

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

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

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

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

...
Student.belongsTo(Grade);

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

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

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

El código completo se parece a lo siguiente:

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

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

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

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

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

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

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

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

Guarde y cierre su archivo.

Ejecute el archivo usando el siguiente comando:

node one_to_one.js

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

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

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

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

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

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

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

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

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

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

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

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

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

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

...
Grade.hasMany(Student)

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

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

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

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

Aquí está el código completo:

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

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

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

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

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

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

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

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

Guarde y cierre su archivo.

Ejecute el archivo con el siguiente comando:

node one_to_many.js

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

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

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

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

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

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

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

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

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

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

...

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

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

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

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

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

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

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

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

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

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

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

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

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

El código completo se parece a lo siguiente:

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

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

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

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

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

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

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

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

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

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

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

Guarde y cierre el archivo.

Ejecute el archivo usando el siguiente comando:

node many_to_many.js

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

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

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

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

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

Paso 5: trabajar con consultas sin formato

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Guarde y cierre el archivo.

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

node add_student_records.js

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

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

…

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

Reemplazo de matriz

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Guarde y cierre su archivo.

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

node array_raw_query.js

Verá un resultado similar al siguiente:

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

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

Reemplazo de objetos

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

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

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

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

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

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

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

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

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

Aquí está el código completo:

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

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

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

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

Guarde y cierre el archivo.

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

node object_raw_query.js

La salida será similar a la siguiente:

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

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

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

Conclusión

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

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

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

#sequelize #nodo #mysql 

Cómo usar Sequelize con Node y MySQL
Poppy Cooke

Poppy Cooke

1658786100

Comment utiliser Sequelize avec Node et MySQL

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

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

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

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

Étape 1 - Installation et configuration de Sequelize

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

Installation de Sequelize

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

mkdir hello-world
cd hello-world

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

npm init

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

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

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

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

touch server.js

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

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

Vous pouvez maintenant installer Sequelize avec la commande suivante :

npm i sequelize@6.11.0

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

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

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

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

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

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

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

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

mysql -u your_username -p

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

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

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

CREATE DATABASE hello_world_db;

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

SHOW DATABASES;

Votre sortie ressemblera à ceci :

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

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

mysql> QUIT

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

npm install --save mysql2

Dans ce cas, vous utilisez le pilote pour MySQL.

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

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

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

Connexion à la base de données MySQL

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

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

nano server.js

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

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

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

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

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

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

...

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

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

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

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

const Sequelize = require("sequelize");

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

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

Enregistrez et fermez votre fichier.

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

node server.js

Votre sortie ressemblera à ceci :

Output
Connection has been established successfully!

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

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

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

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

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

nano book.model.js

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

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

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

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

...

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

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

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

...

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

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

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

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

...

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

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

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

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

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

Le code final ressemblera à ceci :

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

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

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

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

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

Enregistrez et fermez votre fichier.

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

node book.model.js

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

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

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

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

mysql -u YOUR_USERNAME -p

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

USE hello_world_db;

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

SHOW TABLES;

Votre sortie ressemblera à ceci :

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

Enfin, déconnectez-vous du serveur MySQL :

mysql> QUIT

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

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

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

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

Insertion d'un nouvel enregistrement

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

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

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

...

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

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

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

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

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

Enregistrez et fermez le fichier.

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

node book.controller.js

Votre sortie ressemblera à ce qui suit :

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

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

Sélection de tous les enregistrements

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

...

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

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

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

...

Enregistrez et fermez le fichier.

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

node book.controller.js

Votre sortie ressemblera à ce qui suit :

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

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

Sélection avec la whereclause

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

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

...

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

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

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

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

Enregistrez et fermez le fichier.

Ensuite, lancez l'application :

node book.controller.js

Votre sortie ressemblera à ce qui suit :

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

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

Suppression d'un enregistrement

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

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

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

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

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

Enregistrez et fermez le fichier.

Ensuite, lancez l'application :

node book.controller.js

Votre sortie ressemblera à ceci :

Output
Successfully deleted record.

L'enregistrement a été supprimé.

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

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

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

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

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

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

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

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

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

Créer une relation individuelle avecbelongsTo()

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

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

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

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

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

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

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

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

Pour le Studentmodèle, ajoutez le bloc de code suivant àone_to_one.js :

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

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

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

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

Le Grademodèle contient la colonne grade.

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

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

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

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

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

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

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

...
Student.belongsTo(Grade);

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

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

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

Le code complet ressemble à ceci :

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

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

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

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

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

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

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

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

Enregistrez et fermez votre fichier.

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

node one_to_one.js

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

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

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

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

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

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

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

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

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

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

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

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

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

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

...
Grade.hasMany(Student)

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

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

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

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

Voici le code complet :

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

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

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

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

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

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

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

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

Enregistrez et fermez votre fichier.

Exécutez le fichier avec la commande suivante :

node one_to_many.js

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

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

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

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

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

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

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

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

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

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

...

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

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

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

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

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

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

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

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

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

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

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

Enfin, vous pouvez vérifier le bon fonctionnement de l'association en récupérant toutes les données des cours avec les étudiants associés. Vous ferez cela en passant le includeparamètre à l'intérieur de la findAll()méthode. Ajoutez les lignes suivantes à many_to_many.js:

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

Le code complet ressemble à ceci :

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

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

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

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

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

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

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

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

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

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

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

Enregistrez et fermez le fichier.

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

node many_to_many.js

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

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

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

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

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

Étape 5 - Travailler avec des requêtes brutes

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Enregistrez et fermez le fichier.

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

node add_student_records.js

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

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

…

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

Remplacement de baie

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

Pour commencer, copiez le contenu du server.jsfichier de l' étape 1 , car cela inclut la Sequelize()méthode d'initialisation et l'initialisation de la base de données. Collez le contenu dans un nouveau fichier nommé array_raw_query.js. Mettez à jour le nom de la base de donnéessample_student_db :

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

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

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

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

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

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

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

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

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

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

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

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

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

Enregistrez et fermez votre fichier.

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

node array_raw_query.js

Vous verrez une sortie semblable à la suivante :

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

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

Remplacement d'objet

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

Pour commencer, créez un nouveau fichier appelé object_raw_query.jset collez les blocs de code complets du server.jsfichier, en mettant à jour la base de données vers sample_student_db.

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

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

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

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

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

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

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

Voici le code complet :

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

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

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

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

Enregistrez et fermez le fichier.

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

node object_raw_query.js

La sortie ressemblera à ce qui suit :

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

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

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

Conclusion

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

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

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

#sequelize #node #mysql #database 

Comment utiliser Sequelize avec Node et MySQL
田辺  明美

田辺 明美

1658778840

NodeとMySQLでSequelizeを使用する方法

MySQLでSequelizeをインストールして構成する方法を学びます。Sequelizeを使用してデータベースとモデルを作成し、挿入、選択、削除操作などを実行します 

Sequelizeは、Node.jsベースのオブジェクトリレーショナルマッパーであり、 MySQLMariaDBSQLitePostgreSQLデータベースなどを簡単に操作できます。オブジェクトリレーショナルマッパーは、データをオブジェクトとして表すことにより、データベースレコードの処理などの機能を実行します。Sequelizeには、既存のデータベーススキーマを新しいバージョンに変換できる強力な移行メカニズムがあります。全体として、Sequelizeは、データベースの同期、積極的な読み込み、関連付け、トランザクション、およびデータベースの移行に対して優れたサポートを提供すると同時に、開発時間を短縮し、SQLインジェクションを防止します。

このチュートリアルでは、ローカル開発環境にMySQLを使用してSequelizeをインストールして構成します。次に、Sequelizeを使用してデータベースとモデルを作成し、、、、および操作を実行insertselectますdelete。次に、1対1、1対多、および多対多の関係のSequelizeアソシエーションを作成します。最後に、配列とオブジェクトを置き換えるためのSequelizerawクエリを作成します。

このチュートリアルは、macOSCatalinaのNode.jsバージョン14.17.6およびnpmバージョン6.14.15でテストされました。

ステップ1—Sequelizeのインストールと構成

このステップでは、Sequelizeをインストールし、MySQLデータベースへの接続を作成します。これを行うには、最初にNode.jsアプリケーションを作成します。次に、Sequelizeをインストールし、MySQLデータベースを構成して、簡単なアプリケーションを開発します。

Sequelizeのインストール

プロジェクトフォルダを作成することから始めます。この例では、を使用できます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サーバーのパラメーターとデータベースのクレデンシャルを次のように渡し、MySQLユーザーのクレデンシャルに置き換えDATABASE_USERNAMEますDATABASE_PASSWORD

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

hostMySQLサーバーがホストされている場所であるため、サーバーのURLまたはIPアドレスを指定する必要があります。ローカルにインストールされたMySQLサーバーを使用している場合は、値として、または値として置き換えることがDATABASE_HOSTできlocalhostます127.0.0.1

同様に、リモートサーバーを使用している場合は、それに応じてデータベース接続値を適切なリモートサーバーの詳細に置き換えてください。

注:他のデータベースサーバーソフトウェアを使用している場合は、それに応じて方言パラメータを置き換えることができます。`方言:'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

DataTypes前の手順と同様に、ファイルの先頭に新しいインポートを使用して、データベースを開始するためのSequelizeコードを追加します。

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

Sequelizeには、多くの組み込みデータ型が含まれています。これらのデータ型にアクセスするには、のインポートを追加しますDataTypesSTRINGこのチュートリアルでは、、、、などの頻繁に使用されるデータ型について説明INTEGERDATEONLYます。サポートされている他のデータ型の詳細については、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);
});

次に、、、、およびIDを含むと呼ばれるモデルを作成しbooksますtitle。これを行うには、次のような方法を使用します。authorrelease_datesubjectsequelize.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_datesubject

このコードで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.jsからにコードを追加しますbook.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コードの強調表示されたセクションは、既存のテーブルに新しいエントリを挿入します。この例では、 IDで分類さClean Codeれたbyを追加します。他の本の情報で更新された同じコードを使用して、データベースに新しいレコードを追加できます。Robert Cecil Martinsubject3

ファイルを保存して閉じます。

次のコマンドを使用してアプリケーションを実行します。

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

whereSequelizeモデルからデータを取得するために句を正常に使用しました。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削除します。idに等しい本のレコードを削除し2ます。

ファイルを保存して閉じます。

次に、アプリケーションを実行します。

node book.controller.js

出力は次のようになります。

Output
Successfully deleted record.

レコードが削除されました。

このステップでは、データベースモデルとモデルクエリを試しました。データベースを開始し、モデルを作成し、レコードを挿入し、レコードを取得し、where句を使用して条件付きのレコードを取得し、選択したレコードを削除しました。Sequelizeに関するこの知識を使用して、Sequelizeで関連付けを作成します。その後、Sequelizeモデルを使用して、さまざまな関係を定義し、操作できるようになります。

ステップ4—Sequelizeを使用して関連付けを作成する

このステップでは、Sequelizeがサポートする標準の関連付けタイプ(1対1、1対多、および多対多の関連付け)を使用します。学生、コース、および成績レベルに関するサンプルデータを使用します。

Sequelizeは、次のデータベース関係に基づいて関連付けタイプを使用します。

1対1の関係:1対1の関係とは、あるテーブルのレコードが別のテーブルの1つのレコードに正確に関連付けられていることを意味します。Sequelizeに関しては、belongsTo()hasOne()関連付けを使用して、このタイプの関係を作成できます。

1対多の関係:1対多の関係とは、あるテーブルのレコードが別のテーブルの複数のレコードに関連付けられていることを意味します。Sequelizeを使用するhasMany()アソシエーションメソッドを使用してこのタイプの関係を作成できます。

多対多の関係:多対多の関係とは、あるテーブルの複数のレコードが別のテーブルの複数のレコードに関連付けられていることを意味します。Sequelizeを使用belongsToMany()してこのタイプの関係を作成できます。

これらの関連付けを作成する前に、まずと呼ばれる新しいデータベースを作成し、student_db学生、コース、および学年の新しいモデルといくつかのサンプルデータを追加します。

データベースを作成するには、ステップ1 — Sequelizeのインストールと構成と同じプロセスに従ってMySQLにログインし、というデータベースを作成しますstudent_db。新しいデータベースが作成されたら、MySQLからログアウトします。次に、データベースの関連付けの作成を開始します。

と1対1の関係を作成するbelongsTo()

このセクションでは、Sequelizeモデルを使用して1対1の関係を作成します。1人の生徒の詳細と学年を取得したいとします。1人の生徒は1つの学年レベルしか持てないため、このタイプの関連付けは1対1の関係であり、このbelongsTo()方法を使用できます。

注:との間には違いがbelongsTo()ありhasOne()ます。ソーステーブルにをbelongsTo()追加しますが、ターゲットテーブルに追加します。いずれの場合も、両方の関係が同時に使用されると、双方向の1対1の関係の続編として機能します。foreignKeyhasOne()

このbelongsTo()メソッドを使用すると、2つのSequelizeモデル間に1対1の関係を作成できます。この例では、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データベースStudentに、、、Gradeおよびの3つのモデルを作成しますCourseStudentまず、とモデルを作成しGradeます。このステップの後半で、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_idこの学生モデルには、との2つの列が含まれていますname

次に、Gradeモデルのコードブロックを追加します。

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

Gradeモデルには列が含まれていますgrade

関連付けを示すには、サンプルデータをデータベースに追加する必要があります。そのためには、bulk()メソッドを使用します。この方法では、データを1つずつ行に挿入するのではなく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オブジェクトを出力として出力します。

このセクションでは、メソッド呼び出しを使用して1対1の関係をStudent.belongsTo(Grade);作成し、作成した関連付けに従って詳細を取得しました。

との1対多の関係の作成hasMany()

このセクションでは、Sequelizeモデルを使用して1対多の関係を作成します。選択した学年レベルに関連付けられているすべての生徒を取得したいとします。1つの特定の学年に複数の生徒がいる可能性があるため、これは1対多の関係です。

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()方法では、2つのSequelizeモデル間に1対多の関係を作成できます。ここでは、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);メソッド呼び出しを使用して1対多の関係を作成しました。出力では、作成した関連付けに従って詳細を取得しました。

との多対多の関係の作成belongsToMany()

このセクションでは、Sequelizeモデルを使用して多対多の関係を作成します。例として、学生がコースに登録されている状況を想像してみてください。1人の学生が多くのコースに登録でき、1つのコースに多くの学生が参加できます。これは多対多の関係です。Sequelizeを使用してこれを実装するには、モデル、、、およびメソッドをStudent使用CourseStudentCourseますbelongsToMany()

開始するには、というファイルを作成し、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);
});

次に、多対多の関係のデータベースモデルを作成します。StudentおよびCourse。次に、これらのモデルにいくつかのサンプルデータを追加します。

...

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

ここでは、モデルとモデルを作成し、StudentいくつCourseかのサンプルデータを提供します。また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各コースを示す個別の値が表示されます。たとえば、はScienceクラスid: 1のに接続されていますが、はMathsクラスに接続されています。course_name: Scienceid: 2

データベースには、挿入したサンプルデータを含む3つの生成されたテーブルが表示されます。

このステップでは、Sequelizeを使用して、1対1、1対多、および多対多の関連付けを作成しました。次に、生のクエリを操作します。

ステップ5—生のクエリの操作

このステップでは、Sequelizeで生のクエリを操作します。insert()前の手順では、およびなどのSequelize組み込みメソッドを使用findAll()して、データベースからのデータの挿入と選択を処理しました。これらのメソッドがクエリを作成するための特定のパターンに従っていることに気付いたかもしれません。ただし、生のクエリを使用すると、Sequelizeの組み込みメソッドとパターンについて心配する必要はありません。SQLクエリの知識を使用して、Sequelizeで単純なものからより高度なものまでさまざまなクエリを実行できます。

これは、特定のテーブルからすべての値を選択し、条件に従って選択された値を削除し、指定された値でテーブルを更新するアクションを実行する生のクエリの例です。

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

Sequelizeでは、rawクエリは、主に2つの方法論(配列置換とオブジェクト置換)で使用できます。SQLクエリに値を渡す場合、配列またはオブジェクトのいずれかを使用してその置換を行うことができます。

生のクエリを作成する前に、まずサンプルデータベースに学生データを提供する必要があります。前のセクション「サンプルデータベースの作成」に続いて、 MySQLにログインし、というデータベースを作成して、sample_student_dbMySQLからログアウトします。

次に、生データを追加して、生クエリの操作を開始します。と呼ばれる新しいファイルを作成し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(Universally Unique Identifiers)値であるため、ユーザーによって異なることに注意してください。

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次のセクションでは、上記のコードブロックの出力の1つを使用して生のクエリを適用します。query()配列とオブジェクトの置換にメソッドを使用する次のセクションで使用できるように、コピーしてください。

アレイの交換

このセクションではquery()、配列置換の方法を使用します。このメソッドを使用すると、Sequelizeは未加工またはすでに準備されたSQLクエリを実行できます。

開始するには、ステップ1server.jsのファイルの内容をコピーします。これには、開始メソッドとデータベースの開始が含まれています。内容を。という名前の新しいファイルに貼り付けます。データベース名を次のように更新します。Sequelize()array_raw_query.jssample_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、2番目のパラメーターとしてが渡されます。その後、type: sequelize.QueryTypes.SELECTキーと値のペアを渡します。これを使用して、データベースからデータを選択できます。

やなど、他にもいくつかのタイプがありQueryTypes.UPDATEますQueryTypes.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、出力値が異なる場合があります。

このステップでは、配列置換とオブジェクト置換という2つの異なる方法を使用して、Sequelizerawクエリを操作しました。

結論

このチュートリアルでは、Sequelizeをインストールして構成しました。また、Sequelizeの必須コンポーネントの1つであるモデルを作成し、操作しました。最後に、さまざまなタイプの関連付けを作成し、実際の例を使用して生のクエリを処理しました。

次に、さまざまなデータ型を使用してデータベースモデルを作成できます。組み込みのメソッドと生のクエリの両方を使用して、データベースのレコードを更新および削除することもできます。

https://www.digitalocean.comの元の記事のソース

#sequelize #node #mysql #database 

NodeとMySQLでSequelizeを使用する方法

Как использовать Sequelize с Node и MySQL

Узнайте, как установить и настроить Sequelize с MySQL. Использование Sequelize для создания баз данных и моделей, а также выполнения операций вставки, выбора, удаления и т. д. 

Sequelize — это реляционное сопоставление объектов на основе Node.js , которое упрощает работу с базами данных MySQL , MariaDB , SQLite , PostgreSQL и т. д. Object Relational Mapper выполняет такие функции, как обработка записей базы данных, представляя данные в виде объектов. Sequelize имеет мощный механизм миграции, который может преобразовывать существующие схемы базы данных в новые версии. В целом, Sequelize обеспечивает отличную поддержку синхронизации баз данных, быстрой загрузки, ассоциаций, транзакций и миграции баз данных, сокращая время разработки и предотвращая SQL-инъекции.

В этом руководстве вы установите и настроите Sequelize с MySQL в вашей локальной среде разработки. Далее вы будете использовать Sequelize для создания баз данных и моделей, а также для выполнения операций insert, selectи . deleteЗатем вы создадите ассоциации Sequelize для отношений « один к одному », « один ко многим » и « многие ко многим » . Наконец, вы создадите необработанные запросы Sequelize для замены массивов и объектов.

Это руководство было протестировано на Node.js версии 14.17.6 и npmверсии 6.14.15 в macOS Catalina.

Шаг 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

В этом разделе вы подключите приложение Node.js к базе данных MySQL с помощью Sequelize.

Чтобы подключиться к базе данных, откройте 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_HOSTна localhostили 127.0.0.1в качестве значения.

Точно так же, если вы используете удаленный сервер, обязательно замените значения подключения к базе данных соответствующими данными удаленного сервера.

Примечание. Если вы используете любое другое программное обеспечение сервера базы данных, вы можете соответствующим образом заменить параметр диалекта. `диалект: 'mysql', 'mariadb', 'postgres', 'mssql'.

Затем вызовите метод на основе обещаний 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, являются асинхронными. Это означает, что вы можете запускать процессы в своем приложении, пока выполняется блок асинхронного кода. Кроме того, после успешного выполнения блока асинхронного кода он возвращает обещание , которое является значением, возвращаемым в конце процесса. Поэтому в блоках асинхронного кода можно использовать 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в верхней части файла:

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

Sequelize содержит множество встроенных типов данных. Чтобы получить доступ к этим типам данных, вы добавляете импорт для DataTypes. В этом руководстве рассматриваются некоторые часто используемые типы данных, такие как STRING, INTEGERи DATEONLY. Чтобы узнать больше о других поддерживаемых типах данных, вы можете обратиться к официальной документации 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, которая включает title, author, release_dateи subjectID. Для этого используйте 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и хранит записи книги в соответствии с title, author, release_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() основан на обещаниях, что означает, что он также может выполнять обработку ошибок. В этом блоке кода вы проверите, успешно ли создана таблица. Если нет, он вернет ошибку через метод 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.jsв book.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, который был отнесен к категории с subjectидентификатором 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
    },
...
]

Выходные данные содержат все данные книги в виде объекта массива. Вы успешно использовали метод Sequelize findAll()для возврата всех данных о книгах из базы данных.

Выбор с помощью whereпункта

В этом разделе вы будете выбирать значения с условиями, используя whereпредложение. Предложение whereиспользуется для указания условия при выборке данных. В этом руководстве вы получите книгу по определенному идентификатору записи из базы данных, используя findOne()метод.

Для этого откройте 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книги для удаления. Вы собираетесь удалить запись книги, которая idравна 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. В этом примере вы используете модели Studentи Grade.

Создайте новый файл с именем 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базе данных три модели: Student, Grade, и Course. Вы начнете с создания моделей Studentи . GradeПозже на этом шаге вы создадите 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_idи name.

Затем добавьте блок кода для Gradeмодели:

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

Модель Gradeсодержит столбец grade.

Чтобы продемонстрировать ассоциации, вам нужно добавить образцы данных в базу данных. Для этого вы будете использовать bulk()метод. Вместо того, чтобы вставлять данные в строки одну за другой, этот bulkCreate()метод позволяет вам вставлять сразу несколько строк в ваши модели базы данных.

Итак, теперь импортируйте данные Gradeи Studentв соответствующие модели в базе данных, как показано ниже:

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

Здесь вы предоставляете образцы данных и импортируете данные в модели Studentи Grade. Имея базу данных, модели и примеры данных, вы готовы создавать ассоциации.

В 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. Здесь вы используете модели Gradeи Student.

Затем добавьте 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, вы будете использовать модели Student, Courseи StudentCourseс belongsToMany()методом.

Для начала создайте файл с именем 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);
});

Далее вы создадите модели базы данных для отношений «многие ко многим»: Studentи Course. Затем вы добавите некоторые образцы данных в эти модели.

...

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

Здесь вы создаете модели Studentи Courseи предоставляете некоторые образцы данных. Вы также устанавливаете courseID, который вы будете использовать для получения студентов в соответствии с этим типом отношений.

Наконец, вы определили новую модель с именем StudentCourse, которая управляет данными отношений между Studentи Course. В этом примере studentId 1зарегистрирован в courseId 1и courseId 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()и 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

Вывод будет примерно таким. Это будет довольно долго, но все студенческие записи, которые вы вставили, будут возвращены следующим образом. Обратите внимание, что поскольку это значение UUID ( универсальные уникальные идентификаторыstudent_id ), сгенерированное автоматически , оно будет отличаться в зависимости от пользователя.

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вторым параметром передается the. После этого вы передаете type: sequelize.QueryTypes.SELECTпару ключ-значение, которую можно использовать для выбора данных из базы данных.

Есть и другие типы, такие как QueryTypes.UPDATEи QueryTypes.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 

Как использовать Sequelize с Node и MySQL
최 호민

최 호민

1658757087

Node 및 MySQL과 함께 Sequelize를 사용하는 방법

Sequelize with MySQL을 설치하고 구성하는 방법을 알아보세요. Sequelize를 사용하여 데이터베이스 및 모델을 생성하고 삽입, 선택, 삭제 작업 등을 수행합니다. 

SequelizeMySQL , MariaDB , SQLite , PostgreSQL 데이터베이스 등과 쉽게 작업할 수 있도록 하는 Node.js 기반 객체 관계형 매퍼입니다. 개체 관계형 매퍼 는 데이터를 개체로 표시하여 데이터베이스 레코드 처리와 같은 기능을 수행합니다. Sequelize에는 기존 데이터베이스 스키마를 새 버전으로 변환할 수 있는 강력한 마이그레이션 메커니즘이 있습니다. 전반적으로 Sequelize는 데이터베이스 동기화, 즉시 로드, 연결, 트랜잭션 및 데이터베이스 마이그레이션에 대한 탁월한 지원을 제공하는 동시에 개발 시간을 줄이고 SQL 주입을 방지합니다.

이 자습서에서는 로컬 개발 환경에 Sequelize with MySQL을 설치하고 구성합니다. 다음으로 Sequelize를 사용하여 데이터베이스와 모델을 만들고 , 및 작업을 insert수행 select합니다 delete. 그런 다음 일대일 , 일대다다대다 관계 에 대한 Sequelize 연결을 만듭니다 . 마지막으로 배열 및 개체 교체를 위한 Sequelize 원시 쿼리 를 만듭니다.

이 튜토리얼은 npmmacOS 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 인스턴스를 사용하여 애플리케이션에서 데이터베이스 연결을 생성합니다. 이 메서드에서 MySQL 사용자의 자격 증명으로 대체 하여 new Sequelize()다음과 같이 MySQL 서버 매개변수와 데이터베이스 자격 증명을 전달합니다 .DATABASE_USERNAMEDATABASE_PASSWORD

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

hostMySQL 서버가 호스팅되는 곳이므로 서버 URL 또는 IP 주소를 제공해야 합니다. 로컬로 설치된 MySQL 서버를 사용하는 경우 값 DATABASE_HOST으로 localhost또는 127.0.0.1로 바꿀 수 있습니다.

마찬가지로 원격 서버를 사용하는 경우 데이터베이스 연결 값을 적절한 원격 서버 세부 정보로 적절하게 교체해야 합니다.

참고: 다른 데이터베이스 서버 소프트웨어를 사용하는 경우 그에 따라 dialect 매개변수를 바꿀 수 있습니다. `방언: 'mysql', 'mariadb', 'postgres', 'mssql'.

다음으로 약속 기반 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

DataTypes이전 단계와 유사하게 파일 맨 위에 새 가져오기를 사용하여 데이터베이스 시작을 위한 Sequelize 코드를 추가 합니다.

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

Sequelize에는 많은 내장 데이터 유형이 포함되어 있습니다. 이러한 데이터 유형에 액세스하려면 에 대한 가져오기를 추가합니다 DataTypes. STRING이 자습서 에서는 INTEGER, 및 와 같이 자주 사용되는 일부 데이터 유형을 참조합니다 DATEONLY. 지원되는 다른 데이터 유형에 대해 자세히 알아보려면 공식 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);
});

다음으로 , , 및 ID books를 포함하는 이라는 모델을 만듭니다 . 그렇게 하려면 다음 과 같은 방법을 사용하십시오.titleauthorrelease_datesubjectsequelize.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_datesubject

이 코드 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() 메서드는 약속 기반 메서드이므로 오류 처리도 수행할 수 있습니다. 이 코드 블록에서는 테이블이 성공적으로 생성되었는지 확인합니다. 그렇지 않은 경우 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.js합니다 book.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강조 표시된 코드 섹션은 기존 테이블 에 새 항목을 삽입 합니다. 이 예에서는 의 ID 로 분류된 을( Clean Code를 ) 추가합니다 . 다른 책에 대한 정보로 업데이트된 동일한 코드를 사용하여 데이터베이스에 새 레코드를 추가할 수 있습니다.Robert Cecil Martinsubject3

파일을 저장하고 닫습니다.

다음 명령을 사용하여 애플리케이션을 실행합니다.

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

출력에는 모든 책 데이터가 배열 객체로 포함됩니다. Sequelize findAll()메서드를 성공적으로 사용하여 데이터베이스에서 모든 책 데이터를 반환했습니다.

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

whereSequelize 모델에서 데이터를 가져오기 위해 절을 성공적으로 사용 했습니다. 데이터베이스 응용 프로그램에서 절을 사용하여 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()메서드를 사용하고 제거할 책의 전달을 통해 데이터베이스에서 책 레코드 를 제거합니다. 가 동일한 도서 레코드를 제거하려고 합니다 .whereidid2

파일을 저장하고 닫습니다.

다음으로 애플리케이션을 실행합니다.

node book.controller.js

출력은 다음과 같습니다.

Output
Successfully deleted record.

기록이 삭제되었습니다.

이 단계에서는 데이터베이스 모델 및 모델 쿼리를 실험했습니다. 데이터베이스를 시작하고, 모델을 만들고, 레코드를 삽입하고, 레코드를 검색하고, where절을 사용하여 조건이 있는 레코드를 검색하고, 선택한 레코드를 삭제했습니다. Sequelize에 대한 이 지식을 바탕으로 이제 Sequelize에서 연결을 생성할 수 있습니다. 그런 다음 Sequelize 모델을 사용하여 다양한 관계를 정의하고 작업할 수 있습니다.

4단계 - Sequelize를 사용하여 연결 만들기

이 단계에서는 Sequelize가 지원하는 표준 연결 유형 인 일대일 , 일대다다대다 연결을 사용합니다. 학생, 코스 및 학년 수준에 대한 샘플 데이터를 사용합니다.

Sequelize는 다음 데이터베이스 관계를 기반으로 연결 유형을 사용합니다.

일대일 관계 : 일대일 관계는 한 테이블의 레코드가 다른 테이블의 정확히 하나의 레코드와 연관됨을 의미합니다. SequelizebelongsTo()hasOne()연결을 사용하여 이러한 유형의 관계를 만들 수 있습니다.

일대다 관계 : 일대다 관계는 한 테이블의 레코드가 다른 테이블의 여러 레코드와 연결됨을 의미합니다. Sequelize를 사용하면hasMany()연관 방법을 사용하여 이러한 유형의 관계를 생성할 수 있습니다.

다대다 관계 : 다대다 관계는 한 테이블의 여러 레코드가 다른 테이블의 여러 레코드와 연결됨을 의미합니다. Sequelize를 사용하면belongsToMany()연결을 사용하여 이러한 유형의 관계를 만들 수 있습니다.

이러한 연결을 만들기 전에 먼저 라는 새 데이터베이스를 만들고 student_db학생, 코스 및 학년 수준에 대한 새 모델과 몇 가지 샘플 데이터를 추가합니다.

데이터베이스를 생성하려면 1단계 - Sequelize 설치 및 구성과 동일한 프로세스를 따라 MySQL에 로그인하고 이라는 데이터베이스를 생성합니다 student_db. 새 데이터베이스가 생성되면 MySQL에서 로그아웃합니다. 다음으로 데이터베이스 연결 만들기를 시작합니다.

와 일대일 관계 만들기belongsTo()

이 섹션에서는 Sequelize 모델을 사용하여 일대일 관계를 생성합니다. 한 학생의 학년 수준과 함께 세부 정보를 얻고 싶다고 상상해 보십시오. 한 학생은 하나의 학년만 가질 수 있으므로 이러한 유형의 연결은 일대일 관계이며 belongsTo()방법을 사용할 수 있습니다.

참고:belongsTo() 및 사이에는 차이가 있습니다 hasOne(). 소스 테이블에 belongsTo()추가 하고 대상 테이블에 추가합니다. 어쨌든 두 관계를 동시에 사용하는 경우 양방향 일대일 관계 시퀀싱으로 작동합니다.foreignKeyhasOne()

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데이터베이스 에 세 가지 모델 Student( , GradeCourse. 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를 사용하여 이를 구현하려면 모델 Student, Course및 메서드 StudentCourse를 사용합니다 .belongsToMany()

시작하려면 이라는 파일을 만들고 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);
});

Student다음 으로 다대다 관계에 대한 데이터베이스 모델을 만듭니다 Course. 그런 다음 해당 모델에 몇 가지 샘플 데이터를 추가합니다.

...

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모델을 만들고 몇 가지 샘플 데이터를 제공합니다. 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: Scienceid: 2

데이터베이스에서 사용자가 삽입한 샘플 데이터로 생성된 세 개의 테이블을 볼 수 있습니다.

이 단계에서는 Sequelize를 사용하여 일대일, 일대다 및 다대다 연결을 생성했습니다. 다음으로 원시 쿼리로 작업합니다.

5단계 — 원시 쿼리 작업

이 단계에서는 Sequelize에서 원시 쿼리 로 작업합니다. insert()이전 단계에서는 및 와 같은 Sequelize 기본 제공 메서드를 사용 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에 로그인하고 라는 데이터베이스를 생성하고 MySQL에서 sample_student_db로그아웃합니다.

다음으로 원시 쿼리 작업을 시작하기 위해 원시 데이터를 추가합니다. 라는 새 파일 을 만들고 이전에 설명된 , 및 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( Universally Unique Identifiers ) 값 이므로 사용자에 따라 다릅니다.

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 쿼리를 실행할 수 있습니다.

시작하려면 1단계server.js 의 파일 내용을 복사하십시오. 여기에는 시작 방법과 데이터베이스 시작이 포함됩니다. 내용을 이라는 새 파일에 붙여넣습니다 . 데이터베이스 이름을 다음 으로 업데이트하십시오.Sequelize()array_raw_query.jssample_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.UPDATE및 와 같은 다른 유형도 있습니다 QueryTypes.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 

Node 및 MySQL과 함께 Sequelize를 사용하는 방법
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 

So verwenden Sie Sequelize mit Node und MySQL

How To Use Sequelize with Node and MySQL

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

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

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

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

Etapa 1 — Instalando e configurando o Sequelize

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

Instalando o Sequelize

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

mkdir hello-world
cd hello-world

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

npm init

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

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

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

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

touch server.js

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

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

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

npm i sequelize@6.11.0

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

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

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

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

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

Criando um banco de dados de exemplo

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

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

mysql -u your_username -p

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

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

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

CREATE DATABASE hello_world_db;

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

SHOW DATABASES;

Sua saída será semelhante a esta:

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

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

mysql> QUIT

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

npm install --save mysql2

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

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

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

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

Conectando-se ao banco de dados MySQL

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

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

nano server.js

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

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

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

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

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

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

...

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

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

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

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

const Sequelize = require("sequelize");

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

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

Salve e feche seu arquivo.

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

node server.js

Sua saída ficará assim:

Output
Connection has been established successfully!

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

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

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

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

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

nano book.model.js

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

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

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

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

...

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

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

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

...

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

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

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

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

...

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

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

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

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

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

O código final ficará assim:

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

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

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

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

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

Salve e feche seu arquivo.

Execute seu aplicativo usando o seguinte comando:

node book.model.js

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

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

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

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

mysql -u YOUR_USERNAME -p

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

USE hello_world_db;

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

SHOW TABLES;

Sua saída será semelhante a esta:

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

Finalmente, desconecte-se do servidor MySQL:

mysql> QUIT

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

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

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

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

Inserindo um novo registro

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

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

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

...

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

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

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

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

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

Salve e feche o arquivo.

Execute o aplicativo usando o seguinte comando:

node book.controller.js

Sua saída será semelhante à seguinte:

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

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

Selecionando todos os registros

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

...

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

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

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

...

Salve e feche o arquivo.

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

node book.controller.js

Sua saída será semelhante à seguinte:

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

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

Selecionando com a whereCláusula

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

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

...

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

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

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

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

Salve e feche o arquivo.

Em seguida, execute o aplicativo:

node book.controller.js

Sua saída será semelhante à seguinte:

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

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

Apagando um registro

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

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

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

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

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

Salve e feche o arquivo.

Em seguida, execute o aplicativo:

node book.controller.js

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

Output
Successfully deleted record.

O registro foi excluído.

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

Passo 4 — Criando Associações Usando Sequelize

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

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

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

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

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

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

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

Criando um relacionamento pessoal combelongsTo()

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

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

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

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

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

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

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

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

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

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

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

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

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

O Grademodelo contém a coluna grade.

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

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

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

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

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

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

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

...
Student.belongsTo(Grade);

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

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

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

O código completo se parece com o seguinte:

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

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

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

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

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

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

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

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

Salve e feche seu arquivo.

Execute o arquivo usando o seguinte comando:

node one_to_one.js

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

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

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

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

Criando um relacionamento de um para muitos comhasMany()

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

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

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

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

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

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

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

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

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

...
Grade.hasMany(Student)

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

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

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

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

Aqui está o código completo:

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

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

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

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

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

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

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

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

Salve e feche seu arquivo.

Execute o arquivo com o seguinte comando:

node one_to_many.js

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

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

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

Criando relacionamentos muitos-para-muitos combelongsToMany()

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

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

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

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

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

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

...

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

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

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

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

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

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

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

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

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

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

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

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

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

O código completo se parece com o seguinte:

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

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

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

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

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

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

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

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

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

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

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

Salve e feche o arquivo.

Execute o arquivo usando o seguinte comando:

node many_to_many.js

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

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

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

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

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

Etapa 5 — Trabalhando com consultas brutas

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Salve e feche o arquivo.

Em seguida, execute este script usando o seguinte comando:

node add_student_records.js

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

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

…

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

Substituição de matriz

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

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

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

const sequelize = new Sequelize(
   'sample_student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
   );

sequelize.authenticate().then(() => {
    console.log('Connection has been established successfully.');
}).catch((error) => {
    console.error('Unable to connect to the database: ', error);
});

No final do arquivo, adicione o seguinte bloco de código para uma substituição de matriz, certificando-se de substituir REPLACE_STUDENT_IDpelo student_idvalor que você copiou na seção anterior.

...
sequelize.query(
    'SELECT * FROM students WHERE student_id = ?',
    {
      replacements: ['REPLACE_STUDENT_ID'],
      type: sequelize.QueryTypes.SELECT
    }
).then(result => {
    console.log(result);
}).catch((error) => {
    console.error('Failed to insert data : ', error);
});

Para substituição de array, você passa o query()método com a consulta SQL e o objeto de configuração. Ele contém o replacementsvalor e o tipo. ?Para substituições, você passa os dados como uma matriz e captura esses valores usando o símbolo de ponto de interrogação ( ).

Em seguida, como você precisa obter dados sobre um aluno específico, o student_idé passado como o segundo parâmetro. Depois disso, você passa o type: sequelize.QueryTypes.SELECTpar chave-valor, que pode ser usado para selecionar dados do banco de dados.

Existem alguns outros tipos também, como QueryTypes.UPDATEe QueryTypes.DELETE. Dependendo do requisito, você pode selecionar o tipo que se adequa à sua finalidade.

O seguinte mostra o bloco de código completo. Aqui você se conecta ao banco de dados e recupera os dados do aluno selecionado usando uma consulta bruta.

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'sample_student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
   );

sequelize.authenticate().then(() => {
    console.log('Connection has been established successfully.');
}).catch((error) => {
    console.error('Unable to connect to the database: ', error);
});

sequelize.query(
    'SELECT * FROM students WHERE student_id = ?',
    {
      replacements: ['REPLACE_STUDENT_ID'],
      type: sequelize.QueryTypes.SELECT
    }
).then(result => {
    console.log(result);
}).catch((error) => {
    console.error('Failed to insert data : ', error);
});

Salve e feche seu arquivo.

Em seguida, você pode executar este script usando o seguinte comando:

node array_raw_query.js

Você verá uma saída semelhante à seguinte:

Output
Connection has been established successfully.
[ { student_id: 'STUDENT_ID_YOU_RETRIEVED',
    name: 'Robert Gray',
    createdAt: 2022-05-06T13:14:50.000Z,
    updatedAt: 2022-05-06T13:14:50.000Z } ]

Devido ao selecionado student_id, seus valores de saída podem diferir.

Substituição de objetos

Na superfície, a substituição de objetos é semelhante à substituição de matrizes, mas o padrão de passagem de dados para a consulta bruta é diferente. Na opção de substituição, você passa os dados como um objeto e, na opção de consulta, usa valores como :key.

Para começar, crie um novo arquivo chamado object_raw_query.jse cole os blocos de código completos do server.jsarquivo, atualizando o banco de dados para sample_student_db.

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'sample_student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
   );

sequelize.authenticate().then(() => {
    console.log('Connection has been established successfully.');
}).catch((error) => {
    console.error('Unable to connect to the database: ', error);
});

Em seguida, adicione o seguinte bloco de código ao final do novo object_raw_query.jsarquivo:

...
sequelize.query(
  'SELECT * FROM students WHERE student_id = :id',
  {
    replacements: { id: 'REPLACE_STUDENT_ID' },
    type: sequelize.QueryTypes.SELECT
  }
 ).then(result => {
    console.log(result);
}).catch((error) => {
    console.error('Failed to insert data : ', error);
});

Aqui, você obtém dados de alunos selecionados usando o método de substituição de objetos. Você cria um replacementobjeto, definindo idcomo as informações do aluno que deseja recuperar: { id: 'REPLACE_STUDENT_ID' }.

No query(), você indica: 'SELECT * FROM students WHERE student_id = :id'. Usando o query()método, você passa o valor de substituição como um objeto, razão pela qual esse método é conhecido como substituição de objeto.

Aqui está o código completo:

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'sample_student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
   );

sequelize.authenticate().then(() => {
    console.log('Connection has been established successfully.');
}).catch((error) => {
    console.error('Unable to connect to the database: ', error);
});

sequelize.query(
  'SELECT * FROM students WHERE student_id = :id',
  {
    replacements: { id: 'REPLACE_STUDENT_ID' },
    type: sequelize.QueryTypes.SELECT
  }
 ).then(result => {
    console.log(result);
}).catch((error) => {
    console.error('Failed to insert data : ', error);
});

Salve e feche o arquivo.

Em seguida, execute este script usando o seguinte comando:

node object_raw_query.js

A saída será semelhante à seguinte:

Output
Connection has been established successfully.
[ { student_id: 'STUDENT_ID_YOU_RETRIEVED',
    name: 'Robert Gray',
    createdAt: 2022-05-06T13:14:50.000Z,
    updatedAt: 2022-05-06T13:14:50.000Z } ]

Devido ao selecionado student_id, seus valores de saída podem diferir.

Nesta etapa, você trabalhou com Sequelize consultas brutas usando duas metodologias diferentes: substituição de matriz e substituição de objeto.

Conclusão

Neste tutorial, você instalou e configurou o Sequelize. Você também criou e trabalhou com modelos, que é um dos componentes obrigatórios do Sequelize. Por fim, você criou diferentes tipos de associações e trabalhou com consultas brutas usando exemplos práticos.

Em seguida, você pode usar diferentes tipos de dados para criar modelos de banco de dados. Você também pode atualizar e excluir registros em bancos de dados com métodos internos e consultas brutas.

Fonte do artigo original em https://www.digitalocean.com

#sequelize #node #mysql #database 

How To Use Sequelize with Node and MySQL

كيفية استخدام Sequelize مع Node.js و MySQL

تعرف على كيفية تثبيت وتهيئة Sequelize مع MySQL. استخدام Sequelize لإنشاء قواعد بيانات ونماذج ، بالإضافة إلى إجراء عمليات الإدراج والاختيار والحذف والمزيد 

Sequelize هو مخطط علاقات كائنات يستند إلى Node.js يجعل من السهل العمل مع قواعد بيانات MySQL و MariaDB و SQLite و PostgreSQL والمزيد. ينفذ مخطط علاقة الكائن وظائف مثل معالجة سجلات قاعدة البيانات من خلال تمثيل البيانات ككائنات. يحتوي Sequelize على آلية ترحيل قوية يمكنها تحويل مخططات قاعدة البيانات الحالية إلى إصدارات جديدة. بشكل عام ، يوفر Sequelize دعمًا ممتازًا لمزامنة قاعدة البيانات ، والتحميل الجاد ، والجمعيات ، والمعاملات ، وترحيل قواعد البيانات مع تقليل وقت التطوير ومنع حقن SQL.

في هذا البرنامج التعليمي ، ستقوم بتثبيت وتهيئة Sequelize مع MySQL في بيئة التطوير المحلية الخاصة بك. بعد ذلك ، ستستخدم Sequelize لإنشاء قواعد بيانات ونماذج ، بالإضافة إلى إجراء عمليات insertو selectو delete. بعد ذلك ، ستقوم بإنشاء ارتباطات Sequelize للعلاقات واحد لواحد ، واحد لكثير ، وعديد إلى متعدد . أخيرًا ، ستقوم بإنشاء استعلامات خام Sequelize لاستبدال المصفوفات والكائنات .

تم اختبار هذا البرنامج التعليمي على الإصدار 14.17.6 من Node.js والإصدار npm6.14.15 على نظام التشغيل macOS Catalina.

الخطوة 1 - تثبيت وتكوين التسلسل

في هذه الخطوة ، ستقوم بتثبيت Sequelize وإنشاء الاتصال بقاعدة بيانات MySQL. للقيام بذلك ، ستقوم أولاً بإنشاء تطبيق Node.js. بعد ذلك ، ستقوم بتثبيت Sequelize ، وتهيئة قاعدة بيانات MySQL ، وتطوير تطبيق بسيط.

تثبيت Sequelize

ابدأ بإنشاء مجلد المشروع. في هذا المثال ، يمكنك استخدام 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. بعد ذلك ، ستنشئ نموذج قاعدة بيانات للاتصال بها.

إنشاء نموذج قاعدة بيانات

كجزء من المتطلبات الأساسية ، قمت بتثبيت MySQL وضبطها ، والتي تضمنت إنشاء مستخدم. الآن سوف تقوم بإنشاء قاعدة بيانات فارغة.

للقيام بذلك ، أولاً ، تحتاج إلى تسجيل الدخول إلى مثيل MySQL الخاص بك. إذا كنت تعمل عن بعد ، يمكنك استخدام الأداة المفضلة لديك. إذا كنت تستخدم مثيل MySQL قيد التشغيل محليًا ، فيمكنك استخدام الأمر التالي ، مع استبدال اسم المستخدم الخاص بك باسم مستخدم 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

في هذا القسم ، ستقوم بتوصيل تطبيق Node.js بقاعدة بيانات MySQL باستخدام Sequelize.

للاتصال بقاعدة البيانات ، افتح 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_HOSTبالقيمة localhostأو 127.0.0.1كقيمة.

وبالمثل ، إذا كنت تستخدم خادمًا بعيدًا ، فتأكد من استبدال قيم اتصال قاعدة البيانات وفقًا لتفاصيل الخادم البعيد المناسبة.

ملاحظة: إذا كنت تستخدم أي برنامج خادم قاعدة بيانات آخر ، فيمكنك استبدال معلمة اللهجة وفقًا لذلك. اللهجة: 'mysql'، 'mariadb'، 'postgres'، 'mssql'.

بعد ذلك ، قم باستدعاء طريقة قائمة على الوعد 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 غير متزامنة. هذا يعني أنه يمكنك تشغيل العمليات في التطبيق الخاص بك بينما تكون كتلة التعليمات البرمجية غير المتزامنة في وقت التنفيذ. أيضًا ، بعد تنفيذ كتلة التعليمات البرمجية غير المتزامن الناجح ، فإنه يُرجع وعدًا ، وهو القيمة التي يتم إرجاعها في نهاية العملية. لذلك ، في كتل التعليمات البرمجية غير المتزامنة ، يمكنك استخدام 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 لبيانات الكتاب.

للبدء ، قم بإنشاء ملف جديد يسمى book.model.jsفي دليل المشروع:

nano book.model.js

على غرار الخطوة السابقة ، أضف رمز Sequelize لبدء قاعدة البيانات مع استيراد جديد DataTypesلأعلى الملف:

const { Sequelize, DataTypes } = require("sequelize");

يحتوي Sequelize على العديد من أنواع البيانات المضمنة. للوصول إلى أنواع البيانات هذه ، يمكنك إضافة استيراد لـ DataTypes. يشير هذا البرنامج التعليمي إلى بعض أنواع البيانات المستخدمة بشكل متكرر ، مثل STRINGو INTEGERو و DATEONLY. لمعرفة المزيد حول أنواع البيانات المدعومة الأخرى ، يمكنك الرجوع إلى وثائق 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، والذي يتضمن title، authorو release_date، و subjectID. للقيام بذلك ، استخدم 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وتخزين سجلات الكتاب وفقًا لـ title، authorو release_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 () طريقة قائمة على الوعد ، مما يعني أنه يمكنها أيضًا معالجة الأخطاء. في مقطع التعليمات البرمجية هذا ، ستتحقق مما إذا كان الجدول قد تم إنشاؤه بنجاح. إذا لم يكن كذلك ، فسيعيد خطأ عبر طريقة 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.jsإلى book.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 Codeبواسطة Robert Cecil Martin، والتي تم تصنيفها subjectبمعرف 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
    },
...
]

يحتوي الإخراج على جميع بيانات الكتاب ككائن مصفوفة. لقد استخدمت بنجاح findAll()طريقة Sequelize لإرجاع جميع بيانات الكتاب من قاعدة البيانات.

الاختيار مع whereالفقرة

في هذا القسم ، ستحدد القيم بشروط باستخدام whereالجملة. يتم whereاستخدام الجملة لتحديد شرط أثناء جلب البيانات. في هذا البرنامج التعليمي ، ستحصل على كتاب بمعرف سجل محدد من قاعدة البيانات باستخدام findOne()الطريقة.

للقيام بذلك ، افتح 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الكتاب للإزالة. ستقوم بإزالة سجل الكتاب الذي idيساوي 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()ستضيفه إلى الجدول الهدف. في أي حال ، إذا تم استخدام كلتا العلاقات في نفس الوقت ، فستعمل كعلاقات ثنائية الاتجاه ثنائية الاتجاه.

تسمح belongsTo()لك الطريقة بإنشاء علاقة رأس برأس بين نموذجين Sequelize. في هذا المثال ، أنت تستخدم نماذج Studentو .Grade

قم بإنشاء ملف جديد يسمى 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قاعدة البيانات الجديدة: Studentو Gradeو و Course. ستبدأ بإنشاء نماذج Studentو . Gradeلاحقًا في هذه الخطوة ، ستقوم بإنشاء 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_idو name.

بعد ذلك ، أضف كتلة التعليمات البرمجية Gradeللنموذج:

...
const Grade = sequelize.define("grades", {
   grade: {
       type: DataTypes.INTEGER,
       allowNull: false
   }
});

النموذج يحتوي Gradeعلى العمود grade.

لإثبات الارتباطات ، ستحتاج إلى إضافة بيانات نموذجية إلى قاعدة البيانات. لذلك ، ستستخدم bulk()الطريقة. بدلاً من إدراج البيانات في الصفوف واحدًا تلو الآخر ، bulkCreate()تسمح لك الطريقة بإدراج صفوف متعددة في نماذج قاعدة البيانات في وقت واحد.

حتى الآن ، قم باستيراد Gradeو Studentالبيانات إلى النماذج الخاصة بهم في قاعدة البيانات كما هو موضح:

...
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);
});

هنا ، تقوم بتوفير بيانات نموذجية واستيراد البيانات إلى النماذج Studentوالنماذج Grade. مع وجود قاعدة البيانات والنماذج وعينة البيانات الخاصة بك ، فأنت جاهز لإنشاء ارتباطات.

في 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. هنا ، أنت تستخدم نماذج Gradeو .Student

بعد ذلك ، أضف 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 ، ستستخدم النماذج Student، Courseومع StudentCourseالطريقة belongsToMany().

للبدء ، أنشئ ملفًا يسمى 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);
});

بعد ذلك ، ستنشئ نماذج قاعدة البيانات لعلاقات كثير إلى كثير: Studentو Course. ثم ستضيف بعض عينات البيانات إلى تلك النماذج.

...

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},
]

هنا ، يمكنك إنشاء نماذج Studentو Courseوتقديم بعض عينات البيانات. يمكنك أيضًا تعيين a courseID، والذي ستستخدمه لاسترداد الطلاب وفقًا لنوع العلاقة هذا.

أخيرًا ، قمت بتعريف نموذج جديد يسمى StudentCourse، والذي يدير بيانات العلاقة بين Studentو Course. في هذا المثال ، studentId 1تم تسجيله في courseId 1و courseId 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()و 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

سيكون الإخراج شيئًا مشابهًا لما يلي. ستكون طويلة جدًا ، ولكن سيتم إرجاع جميع سجلات الطلاب التي أدخلتها على النحو التالي. لاحظ أنه نظرًا لأن قيمة UUID ( المعرفات الفريدة عالميًاstudent_id ) يتم إنشاؤها تلقائيًا ، فستكون مختلفة اعتمادًا على المستخدم.

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.UPDATEو QueryTypes.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 

كيفية استخدام Sequelize مع Node.js و MySQL
Toby Rogers

Toby Rogers

1658723700

How to Use Sequelize with MySQL

Learn how to install and configure Sequelize with MySQL. Using Sequelize to create databases and models, as well as perform the insert, select, delete operations and more 

Sequelize is a Node.js-based Object Relational Mapper that makes it easy to work with MySQL, MariaDB, SQLite, PostgreSQL databases, and more. An Object Relational Mapper performs functions like handling database records by representing the data as objects. Sequelize has a powerful migration mechanism that can transform existing database schemas into new versions. Overall, Sequelize provides excellent support for database synchronization, eager loading, associations, transactions, and database migrations while reducing development time and preventing SQL injections.

In this tutorial, you will install and configure Sequelize with MySQL on your local development environment. Next, you will use Sequelize to create databases and models, as well as perform the insert, select, and delete operations. Then, you will create Sequelize associations for one-to-one, one-to-many, and many-to-many relationships. Finally, you will create Sequelize raw queries for array and object replacements.

Read more https://www.digitalocean.com

#sequelize #node #mysql #database 

How to Use Sequelize with MySQL
Hoang  Kim

Hoang Kim

1658720197

Cách sử dụng Sequelize với Node.js và MySQL

Tìm hiểu cách cài đặt và cấu hình Sequelize với MySQL. Sử dụng Sequelize để tạo cơ sở dữ liệu và mô hình, cũng như thực hiện các thao tác chèn, chọn, xóa và hơn thế nữa 

Sequelize là một Trình lập bản đồ quan hệ đối tượng dựa trên Node.js giúp bạn dễ dàng làm việc với cơ sở dữ liệu MySQL , MariaDB , SQLite , PostgreSQL và hơn thế nữa. Một Object Relational Mapper thực hiện các chức năng như xử lý các bản ghi cơ sở dữ liệu bằng cách biểu diễn dữ liệu dưới dạng các đối tượng. Sequelize có một cơ chế di chuyển mạnh mẽ có thể chuyển đổi các lược đồ cơ sở dữ liệu hiện có thành các phiên bản mới. Nhìn chung, Sequelize cung cấp hỗ trợ tuyệt vời cho đồng bộ hóa cơ sở dữ liệu, tải nhanh, liên kết, giao dịch và di chuyển cơ sở dữ liệu đồng thời giảm thời gian phát triển và ngăn chặn việc tiêm SQL.

Trong hướng dẫn này, bạn sẽ cài đặt và cấu hình Sequelize với MySQL trên môi trường phát triển cục bộ của bạn. insertTiếp theo, bạn sẽ sử dụng Sequelize để tạo cơ sở dữ liệu và mô hình , cũng như thực hiện selectdeletecác hoạt động. Sau đó, bạn sẽ tạo các liên kết theo trình tự cho các mối quan hệ một-một , một-nhiềunhiều-nhiều . Cuối cùng, bạn sẽ tạo các truy vấn thô Sequelize để thay thế mảng và đối tượng.

Hướng dẫn này đã được thử nghiệm trên Node.js phiên bản 14.17.6 và npmphiên bản 6.14.15 trên macOS Catalina.

Bước 1 - Cài đặt và cấu hình Sequelize

Trong bước này, bạn sẽ cài đặt Sequelize và tạo kết nối đến cơ sở dữ liệu MySQL của mình. Để làm điều đó, trước tiên bạn sẽ tạo một ứng dụng Node.js. Sau đó, bạn sẽ cài đặt Sequelize, cấu hình cơ sở dữ liệu MySQL và phát triển một ứng dụng đơn giản.

Cài đặt Sequelize

Bắt đầu bằng cách tạo một thư mục dự án. Trong ví dụ này, bạn có thể sử dụng hello-world. Sau khi thư mục được tạo, hãy điều hướng đến thư mục bằng terminal:

mkdir hello-world
cd hello-world

Sau đó, tạo một ứng dụng Node.js mẫu bằng lệnh sau:

npm init

Tiếp theo, bạn sẽ được nhắc trả lời một số câu hỏi thiết lập. Sử dụng đầu ra sau cho cấu hình của bạn. Nhấn ENTERđể sử dụng giá trị mặc định được hiển thị và đảm bảo đặt điểm nhập chính là server.js. Điều này tạo ra một cấu trúc dự án dễ bảo trì.

Đầu ra sẽ trông như sau, sẽ điền vào package.jsontệp:

{
  "name": "hello-world",
  "version": "1.0.0",
  "description": "",
  "main": "server.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "",
  "license": "ISC"
}

Tiếp theo, tạo một server.jstệp trống bên trong thư mục dự án:

touch server.js

Sau khi làm theo các bước trước đó, cấu trúc thư mục cuối cùng của bạn sẽ giống như sau:

hello-world/
├─ package.json
├─ server.js

Bây giờ bạn có thể cài đặt Sequelize bằng lệnh sau:

npm i sequelize@6.11.0

Lưu ý: Lệnh này cài đặt phiên bản 6.11.0. Nếu bạn cần cài đặt phiên bản mới nhất, hãy chạy npm i sequelize.

Sau những bản cập nhật này, package.jsontệp bây giờ trông giống như sau:

{
  "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"
  }
}

Trong dependenciesphần này, bây giờ bạn sẽ thấy một phụ thuộc Sequelize.

Bạn đã thiết lập dự án và cài đặt Sequelize. Tiếp theo, bạn sẽ tạo một cơ sở dữ liệu mẫu để kết nối.

Tạo cơ sở dữ liệu mẫu

Là một phần của điều kiện tiên quyết, bạn đã cài đặt và định cấu hình MySQL, bao gồm cả việc tạo người dùng. Bây giờ bạn sẽ tạo một cơ sở dữ liệu trống.

Để làm điều đó, trước tiên, bạn cần đăng nhập vào phiên bản MySQL của mình. Nếu bạn đang chạy từ xa, bạn có thể sử dụng công cụ ưa thích của mình. Nếu bạn đang sử dụng phiên bản MySQL chạy cục bộ, bạn có thể sử dụng lệnh sau, thay thế your_username bằng tên người dùng MySQL của bạn:

mysql -u your_username -p

-ulà tên người dùng và -ptùy chọn được chuyển nếu tài khoản được bảo mật bằng mật khẩu.

Máy chủ MySQL sẽ hỏi mật khẩu cơ sở dữ liệu của bạn. Nhập mật khẩu của bạn và nhấn ENTER.

Khi bạn đã đăng nhập, hãy tạo một cơ sở dữ liệu được gọi hello_world_dbbằng lệnh sau:

CREATE DATABASE hello_world_db;

Để xác minh xem bạn đã tạo cơ sở dữ liệu thành công hay chưa, bạn có thể sử dụng lệnh sau:

SHOW DATABASES;

Đầu ra của bạn sẽ tương tự như sau:

+--------------------+
|      Database      |
+--------------------+
| hello_world_db     |
| information_schema |
| mysql              |
| performance_schema |
| sys                |
+--------------------+

Sau khi tạo cơ sở dữ liệu mẫu, ngắt kết nối khỏi máy chủ MySQL:

mysql> QUIT

Bây giờ, bạn cần cài đặt một trình điều khiển thủ công cho cơ sở dữ liệu mà bạn lựa chọn. Vì Sequelize chỉ cung cấp các tính năng ORM, nó không bao gồm các trình điều khiển cơ sở dữ liệu tích hợp sẵn. Do đó, bạn sẽ cần cài đặt trình điều khiển theo sở thích của mình. Để làm điều đó, hãy điều hướng đến thư mục dự án bằng cách sử dụng thiết bị đầu cuối và cài đặt trình điều khiển MySQL cho dự án bằng lệnh sau:

npm install --save mysql2

Trong trường hợp này, bạn đang sử dụng trình điều khiển cho MySQL.

Lưu ý: Vì hướng dẫn này sử dụng MySQL làm cơ sở dữ liệu, bạn đang sử dụng trình điều khiển cho điều đó. Tùy thuộc vào cơ sở dữ liệu của bạn, bạn có thể cài đặt trình điều khiển theo cách thủ công như sau:

  • 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

Bây giờ bạn đã có một cơ sở dữ liệu mẫu, bạn có thể tạo ứng dụng Sequelize đầu tiên của mình với khả năng kết nối cơ sở dữ liệu.

Kết nối với Cơ sở dữ liệu MySQL

Trong phần này, bạn sẽ kết nối ứng dụng Node.js với cơ sở dữ liệu MySQL bằng cách sử dụng Sequelize.

Để kết nối với cơ sở dữ liệu, hãy mở server.jsđể chỉnh sửa bằng cách sử dụng nanohoặc trình soạn thảo mã ưa thích của bạn:

nano server.js

Tại đây, bạn sẽ tạo một kết nối cơ sở dữ liệu trong ứng dụng của mình bằng cách sử dụng phiên bản Sequelize. Trong new Sequelize()phương thức, hãy chuyển các tham số máy chủ MySQL và thông tin đăng nhập cơ sở dữ liệu như sau, thay thế DATABASE_USERNAMEDATABASE_PASSWORDbằng thông tin đăng nhập của người dùng MySQL của bạn:

const Sequelize = require("sequelize");
const sequelize = new Sequelize(
 'hello_world_db',
 'DATABASE_USERNAME',
 'DATABASE_PASSWORD',
  {
    host: 'DATABASE_HOST',
    dialect: 'mysql'
  }
);

hostlà nơi máy chủ MySQL được lưu trữ, vì vậy bạn sẽ cần cung cấp URL máy chủ hoặc địa chỉ IP. Nếu bạn đang sử dụng máy chủ MySQL được cài đặt cục bộ, bạn có thể thay thế DATABASE_HOSTbằng localhosthoặc 127.0.0.1dưới dạng giá trị.

Tương tự, nếu bạn đang sử dụng máy chủ từ xa, hãy đảm bảo thay thế các giá trị kết nối cơ sở dữ liệu tương ứng bằng các chi tiết máy chủ từ xa thích hợp.

Lưu ý: Nếu bạn đang sử dụng bất kỳ phần mềm máy chủ cơ sở dữ liệu nào khác, bạn có thể thay thế tham số phương ngữ cho phù hợp. `phương ngữ: 'mysql', 'mariadb', 'postgres', 'mssql'.

Tiếp theo, gọi một phương thức dựa trên lời hứa authenticate() để khởi tạo kết nối cơ sở dữ liệu với ứng dụng. Để làm điều đó, hãy thêm khối mã sau vào server.jstệp của bạn:

...

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

Phương authenticate()pháp này được sử dụng để kết nối với cơ sở dữ liệu và kiểm tra xem thông tin xác thực đã cho có chính xác hay không. Ở đây, kết nối cơ sở dữ liệu được mở theo mặc định và kết nối tương tự có thể được sử dụng cho tất cả các truy vấn. Bất cứ khi nào bạn cần đóng kết nối, hãy gọi sequelize.close()phương thức sau authenticate()cuộc gọi này. Để tìm hiểu thêm về Sequelize, vui lòng xem hướng dẫn bắt đầu của họ .

Hầu hết các phương thức được cung cấp bởi Sequelize là không đồng bộ. Điều đó có nghĩa là bạn có thể chạy các quy trình trong ứng dụng của mình trong khi khối mã không đồng bộ đang trong thời gian thực thi. Ngoài ra, sau khi thực thi khối mã không đồng bộ thành công, nó trả về một lời hứa , là giá trị được trả về khi kết thúc quá trình. Do đó, trong các khối mã không đồng bộ, bạn có thể sử dụng then()catch()trả finally()về dữ liệu đã xử lý.

Tại thời điểm này, server.jstệp sẽ giống như sau:

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);
});

Lưu và đóng tệp của bạn.

Trong thư mục dự án, chạy server.jsứng dụng bằng cách chạy lệnh sau:

node server.js

Đầu ra của bạn sẽ như thế này:

Output
Connection has been established successfully!

Bạn đã tạo kết nối cơ sở dữ liệu thành công.

Trong bước này, bạn đã cài đặt Sequelize, tạo cơ sở dữ liệu mẫu và sử dụng Sequelize để kết nối với cơ sở dữ liệu. Tiếp theo, bạn sẽ làm việc với các mô hình trong Sequelize.

Bước 2 - Tạo bảng cơ sở dữ liệu bằng cách sử dụng Sequelize

Bây giờ bạn đã tạo cơ sở dữ liệu MySQL mẫu, bạn có thể sử dụng Sequelize để tạo bảng và điền dữ liệu vào bảng đó. Trong Sequelize, các bảng cơ sở dữ liệu được gọi là mô hình . Mô hình là một trừu tượng đại diện cho một bảng của cơ sở dữ liệu. Mô hình xác định một số thứ để Sắp xếp theo thứ tự, chẳng hạn như tên của bảng, chi tiết cột và kiểu dữ liệu. Trong bước này, bạn sẽ tạo một mô hình Sequelize cho dữ liệu sách.

Để bắt đầu, hãy tạo một tệp mới có tên book.model.jstrong thư mục dự án:

nano book.model.js

Tương tự như bước trước, thêm mã Sequelize để khởi tạo cơ sở dữ liệu với một lần nhập mới DataTypesở đầu tệp:

const { Sequelize, DataTypes } = require("sequelize");

Sequelize chứa nhiều kiểu dữ liệu dựng sẵn. Để truy cập các loại dữ liệu đó, bạn thêm nhập cho DataTypes. Hướng dẫn này đề cập đến một số kiểu dữ liệu được sử dụng thường xuyên, chẳng hạn như STRING, INTEGERDATEONLY. Để tìm hiểu thêm về các kiểu dữ liệu được hỗ trợ khác, bạn có thể tham khảo tài liệu Sequelize chính thức .

Sau đó, bao gồm các dòng bạn đã sử dụng trước đây để tạo kết nối với cơ sở dữ liệu MySQL của bạn, cập nhật thông tin đăng nhập MySQL của bạn cho phù hợp:

...

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);
});

Tiếp theo, bạn sẽ tạo một mô hình có tên , booksbao gồm title, và ID. Để làm điều đó, hãy sử dụng phương pháp như được hiển thị:authorrelease_datesubjectsequelize.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,
   }
});

Phương sequelize.define()thức xác định một mô hình mới, mô hình này đại diện cho một bảng trong cơ sở dữ liệu. Khối mã này tạo một bảng được gọi và lưu trữ các bản booksghi sách theo dấu title, authorrelease_date.subject

Trong mã này, allowNullcho thấy rằng giá trị cột mô hình không được null. Tương tự như vậy, nếu bạn cần đặt một giá trị như vậy, bạn có thể sử dụng defaultValue: "value".

Tiếp theo, bạn sẽ thêm bookmô hình vào cơ sở dữ liệu của mình. Để làm điều đó, bạn sẽ sử dụng sync()phương pháp như sau:

...

sequelize.sync().then(() => {
   console.log('Book table created successfully!');
}).catch((error) => {
   console.error('Unable to create table : ', error);
});

Trong sync()phương thức này, bạn đang yêu cầu Sequelize thực hiện một vài thao tác với cơ sở dữ liệu. Với lệnh gọi này, Sequelize sẽ tự động thực hiện một truy vấn SQL đến cơ sở dữ liệu và tạo bảng, in thông báo Book table created successfully!.

Như đã đề cập, phương thức sync () là một phương thức dựa trên lời hứa, có nghĩa là nó cũng có thể thực hiện xử lý lỗi. Trong khối mã này, bạn sẽ kiểm tra xem bảng có được tạo thành công hay không. Nếu không, nó sẽ trả về một lỗi thông qua phương thức bắt và in nó trên đầu ra.

Lưu ý: Bạn có thể quản lý đồng bộ hóa mô hình bằng cách chuyển forcecác tham số để buộc tạo một bảng mới nếu nó không tồn tại hoặc sử dụng bảng hiện có. Dưới đây là một số ví dụ có thể hữu ích cho bạn khi làm việc với Sequelize:

  • model.sync(): Điều này tạo ra bảng nếu nó chưa tồn tại.
  • model.sync({ force: true }): Thao tác này tạo bảng bằng cách loại bỏ nó nếu đã tồn tại cùng một bảng.

Mã cuối cùng sẽ giống như sau:

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);
});

Lưu và đóng tệp của bạn.

Chạy ứng dụng của bạn bằng cách sử dụng lệnh sau:

node book.model.js

Bạn sẽ nhận được kết quả sau trong dòng lệnh của mình:

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!

Trong đầu ra, bạn sẽ thấy nhật ký trả về có chứa thông báo , Book table created successfully!. Bạn có thể xác minh điều này bằng cách kiểm tra cơ sở dữ liệu của mình để xem booksbảng mới được tạo trong hello_world_dbcơ sở dữ liệu.

Để xác minh việc tạo bảng mới, hãy đăng nhập vào phiên bản MySQL của bạn:

mysql -u YOUR_USERNAME -p

Sau khi nhập mật khẩu của bạn, hãy thay đổi vào cơ sở dữ liệu mẫu:

USE hello_world_db;

Và sau đó chạy lệnh để hiển thị các bảng:

SHOW TABLES;

Đầu ra của bạn sẽ tương tự như sau:

+---------------------------+
| Tables_in_hello_world_db |
+---------------------------+
| books                     |
+---------------------------+
1 row in set (0.00 sec)

Cuối cùng, ngắt kết nối khỏi máy chủ MySQL:

mysql> QUIT

Bạn đã xác minh rằng việc booktạo mô hình đã thành công. Sử dụng quy trình này, bạn có thể tạo bất kỳ số lượng mô hình nào bằng cách làm theo cùng một quy trình.

Trong bước này, bạn đã tạo một mô hình trong cơ sở dữ liệu và bắt đầu làm việc với một mô hình bằng các phương thức tích hợp sẵn. Bạn cũng đã sử dụng các kiểu dữ liệu hỗ trợ Sequelize để xác định mô hình của mình. Tiếp theo, bạn sẽ làm việc với các truy vấn mô hình cơ bản.

Bước 3 - Sử dụng Sequelize cho các truy vấn cơ sở dữ liệu

Trong bước này, bạn sẽ sử dụng các truy vấn tích hợp sẵn của Sequelize để chèn, chọn, chọn với các mệnh đề điều kiện và xóa.

Chèn bản ghi mới

Trong bước trước, bạn đã tạo một bookmô hình bên trong cơ sở dữ liệu. Trong phần này, bạn sẽ chèn dữ liệu vào mô hình này.

Để bắt đầu, hãy sao chép nội dung của book.model.jsbước trước. Tạo một tệp mới được gọi book.controller.jsđể xử lý logic truy vấn. Thêm mã từ book.model.jsđến book.controller.js.

Trong book.controller.js, xác định vị trí sync()phương thức. Trong sync()phương thức, hãy thêm các dòng được đánh dấu sau:

...

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);
});

Tại đây, bạn chèn một bản ghi sách mới vào booksmô hình bạn đã tạo bằng sync()phương pháp này, hỗ trợ thêm các bản ghi mới vào các mô hình đã tạo trước đó. Khi phương thức sync () thực thi thành công, nó sẽ chạy then()phương thức. Bên trong then()phương thức, bạn gọi create()phương thức để chèn các bản ghi mới vào mô hình.

Bạn sử dụng create()phương thức để chuyển dữ liệu bạn cần thêm vào cơ sở dữ liệu dưới dạng một đối tượng. Phần mã được đánh dấu sẽ chèn một mục mới vào booksbảng hiện có của bạn. Trong ví dụ này, bạn thêm Clean Codetheo Robert Cecil Martin, đã được phân loại với subjectID của 3. Bạn có thể sử dụng cùng một mã, được cập nhật thông tin cho các sách khác, để thêm các bản ghi mới vào cơ sở dữ liệu của bạn.

Lưu và đóng tập tin.

Chạy ứng dụng bằng lệnh sau:

node book.controller.js

Đầu ra của bạn sẽ giống như sau:

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,
   ...
}

Bạn đã chèn một bản ghi mới vào mô hình bạn đã tạo trong cơ sở dữ liệu. Bạn có thể tiếp tục thêm nhiều bản ghi bằng cách sử dụng cùng một quy trình.

Chọn tất cả các bản ghi

Trong phần này, bạn sẽ chọn và lấy tất cả các hồ sơ sổ sách từ cơ sở dữ liệu bằng findAll()phương pháp. Để làm điều đó, trước tiên hãy mở book.controller.jsvà xóa Book.create()phương thức trước đó. Trong sync()phương thức, thêm Book.findAll()phương thức như được hiển thị:

...

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);
});

...

Lưu và đóng tập tin.

Tiếp theo, chạy lại ứng dụng bằng lệnh sau:

node book.controller.js

Đầu ra của bạn sẽ giống như sau:

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
    },
...
]

Đầu ra chứa tất cả dữ liệu sách dưới dạng một đối tượng mảng. Bạn đã sử dụng thành công phương pháp Sequelize findAll()để trả về tất cả dữ liệu sách từ cơ sở dữ liệu.

Lựa chọn với wheremệnh đề

Trong phần này, bạn sẽ chọn các giá trị có điều kiện bằng wheremệnh đề. Mệnh wheređề được sử dụng để chỉ định một điều kiện trong khi tìm nạp dữ liệu. Đối với hướng dẫn này, bạn sẽ nhận được một cuốn sách theo ID bản ghi cụ thể từ cơ sở dữ liệu bằng cách sử dụng findOne()phương pháp này.

Để làm điều đó, hãy mở book.controller.jsđể chỉnh sửa, xóa findAll()phương thức và thêm các dòng sau:

...

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);
});

Tại đây, bạn chọn một bản ghi sổ cụ thể từ cơ sở dữ liệu bằng cách sử dụng findOne()phương pháp có wheretùy chọn. Trong ví dụ này, bạn đang truy xuất dữ liệu sách có idgiá trị bằng 1.

Lưu và đóng tập tin.

Tiếp theo, chạy ứng dụng:

node book.controller.js

Đầu ra của bạn sẽ giống như sau:

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
  },
  ...
}

Bạn đã sử dụng thành công wherecác mệnh đề để lấy dữ liệu từ các mô hình Sequelize. Bạn có thể sử dụng wheremệnh đề trong ứng dụng cơ sở dữ liệu để nắm bắt dữ liệu có điều kiện.

Xóa bản ghi

Để xóa một bản ghi cụ thể khỏi mô hình cơ sở dữ liệu, bạn sử dụng destroy()phương pháp với wheretùy chọn. Để làm điều đó, hãy mở book.controller.js, xóa findOne()phương thức và thêm các dòng được đánh dấu sau:

...
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);
});

Tại đây, bạn xóa một bản ghi sách khỏi cơ sở dữ liệu bằng cách sử dụng destroy()phương pháp có wheretùy chọn và chuyển vào bản idghi sách để xóa. Bạn sẽ xóa hồ sơ sổ sách có số idbằng 2.

Lưu và đóng tập tin.

Tiếp theo, chạy ứng dụng:

node book.controller.js

Đầu ra của bạn sẽ giống như sau:

Output
Successfully deleted record.

Bản ghi đã bị xóa.

Trong bước này, bạn đã thử nghiệm với mô hình cơ sở dữ liệu và truy vấn mô hình của mình. Bạn đã khởi tạo cơ sở dữ liệu, tạo mô hình, chèn bản ghi, bản ghi đã truy xuất, bản ghi được truy xuất với các điều kiện bằng cách sử dụng wheremệnh đề và xóa bản ghi đã chọn. Với kiến ​​thức này về Sequelize, bây giờ bạn sẽ tạo các liên kết trong Sequelize. Sau đó, bạn sẽ có thể xác định và làm việc với nhiều mối quan hệ khác nhau bằng cách sử dụng các mô hình Sequelize.

Bước 4 - Tạo liên kết bằng cách sử dụng Sequelize

Trong bước này, bạn sẽ sử dụng các kiểu liên kết tiêu chuẩn mà Sequelize hỗ trợ: liên kết một-một , một-nhiềunhiều-nhiều . Bạn sẽ sử dụng dữ liệu mẫu về sinh viên, khóa học và cấp lớp.

Sequelize sử dụng các kiểu kết hợp dựa trên các mối quan hệ cơ sở dữ liệu sau:

mối quan hệ một-một : Mối quan hệ một-một có nghĩa là một bản ghi trong một bảng được liên kết với chính xác một bản ghi trong một bảng khác. Về Sequelize, bạn có thể sử dụngbelongsTo()hasOne()các liên kết để tạo ra loại mối quan hệ này.

mối quan hệ một -nhiều : Mối quan hệ một-nhiều có nghĩa là một bản ghi trong một bảng được liên kết với nhiều bản ghi trong một bảng khác. Với Sequelize, bạn có thể sử dụnghasMany()các phương thức kết hợp để tạo kiểu quan hệ này.

Mối quan hệ nhiều-nhiều : Mối quan hệ nhiều-nhiều có nghĩa là nhiều bản ghi trong một bảng được liên kết với nhiều bản ghi trong bảng khác. Với Sequelize, bạn có thể sử dụngbelongsToMany()các liên kết để tạo loại mối quan hệ này.

Trước khi tạo các liên kết này, trước tiên bạn sẽ tạo một cơ sở dữ liệu mới được gọi là student_dbvà thêm các mô hình mới và một số dữ liệu mẫu cho sinh viên, khóa học và cấp lớp.

Để tạo cơ sở dữ liệu, hãy làm theo quy trình tương tự trong Bước 1 - Cài đặt và cấu hình Sequelize để đăng nhập vào MySQL và tạo cơ sở dữ liệu được gọi student_db. Khi cơ sở dữ liệu mới đã được tạo, hãy đăng xuất khỏi MySQL. Tiếp theo, bạn sẽ bắt đầu tạo các liên kết cơ sở dữ liệu.

Tạo mối quan hệ 1-1 vớibelongsTo()

Trong phần này, bạn sẽ tạo mối quan hệ 1-1 bằng cách sử dụng mô hình Sequelize. Hãy tưởng tượng bạn muốn nhận thông tin chi tiết của một học sinh cùng với cấp lớp của họ. Vì một học sinh chỉ có thể có một cấp lớp, nên kiểu liên kết này là mối quan hệ một-một và bạn có thể sử dụng belongsTo()phương pháp này.

Lưu ý: Có sự khác biệt giữa belongsTo()hasOne(). belongsTo()sẽ thêm foreignKeyvào bảng nguồn, trong khi hasOne()sẽ thêm nó vào bảng đích. Trong mọi trường hợp, nếu cả hai mối quan hệ được sử dụng cùng một lúc, nó sẽ hoạt động như Trình tự hóa các mối quan hệ một đối một hai chiều.

Phương belongsTo()pháp này cho phép bạn tạo mối quan hệ 1-1 giữa hai mô hình Sequelize. Trong ví dụ này, bạn đang sử dụng các mô hình StudentGrade.

Tạo một tệp mới có tên one_to_one.js. Như bạn đã làm trong phần trước, Kết nối với Cơ sở dữ liệu MySQL , bao gồm các dòng để tạo kết nối với cơ sở dữ liệu và xác thực người dùng MySQL của bạn ở đầu tệp. Đảm bảo cập nhật thông tin đăng nhập MySQL nếu cần:

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);
});

Trong phần này, bạn sẽ tạo ba mô hình trong student_dbcơ sở dữ liệu Studentmới :, GradeCourse. Bạn sẽ bắt đầu bằng cách tạo StudentGradecác mô hình. Sau đó trong bước này, bạn sẽ tạo Coursesmô hình.

Đối với Studentmô hình, hãy thêm khối mã sau vào 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
   }
});

Mô hình sinh viên này chứa hai cột: student_idname.

Tiếp theo, thêm một khối mã cho Grademô hình:

...
const Grade = sequelize.define("grades", {
   grade: {
       type: DataTypes.INTEGER,
       allowNull: false
   }
});

Gradehình chứa cột grade.

Để chứng minh các liên kết, bạn sẽ cần thêm dữ liệu mẫu vào cơ sở dữ liệu. Đối với điều đó, bạn sẽ sử dụng bulk()phương pháp này. Thay vì chèn dữ liệu vào từng hàng một, bulkCreate()phương pháp này cho phép bạn chèn nhiều hàng vào các mô hình cơ sở dữ liệu của mình cùng một lúc.

Vì vậy, bây giờ, hãy nhập GradeStudentdữ liệu vào các mô hình tương ứng của chúng trong cơ sở dữ liệu như được hiển thị:

...
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);
});

Tại đây, bạn cung cấp dữ liệu mẫu và nhập dữ liệu vào mô hình StudentGrade. Với cơ sở dữ liệu, mô hình và dữ liệu mẫu của bạn, bạn đã sẵn sàng tạo các liên kết.

Trong one-to-one.js, thêm dòng sau vào bên dưới student_datakhối:

...
Student.belongsTo(Grade);

Tiếp theo, bạn sẽ cần kiểm tra xem liên kết có hoạt động bình thường hay không. Để làm điều đó, bạn có thể truy xuất tất cả dữ liệu của học sinh với các cấp lớp liên quan bằng cách chuyển includetham số vào bên trong findAll()phương thức.

Vì bạn cần đạt được cấp độ học sinh nên bạn sẽ vượt qua Gradenhư người mẫu. Trong sequelize.sync()phương thức, hãy thêm các dòng được đánh dấu như được hiển thị:

...
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);
});

Mã hoàn chỉnh trông giống như sau:

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);
});

Lưu và đóng tệp của bạn.

Chạy tệp bằng cách sử dụng lệnh sau:

node one_to_one.js

Đầu ra sẽ dài và bạn sẽ thấy tất cả dữ liệu của học sinh với các cấp lớp. Đây là một đoạn mã của kết quả hiển thị dữ liệu sinh viên:

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:
...

Tùy thuộc vào công cụ dòng lệnh bạn đang sử dụng, đầu ra có thể in ra dưới dạng dạng xem mở rộng hoặc không. Nếu nó là một dạng xem được mở rộng, nó sẽ in gradeđối tượng được mở rộng làm đầu ra.

Trong phần này, bạn đã tạo mối quan hệ một đối một bằng cách sử dụng lệnh Student.belongsTo(Grade);gọi phương thức và nhận thông tin chi tiết theo liên kết bạn đã tạo.

Tạo mối quan hệ một-nhiều vớihasMany()

Trong phần này, bạn sẽ tạo mối quan hệ một-nhiều bằng cách sử dụng mô hình Sequelize. Hãy tưởng tượng bạn muốn có tất cả học sinh được liên kết với một cấp lớp đã chọn. Vì một cấp lớp cụ thể có thể có nhiều học sinh, đây là mối quan hệ một-nhiều.

Để bắt đầu, hãy sao chép nội dung của one_to_one.jsvào một tệp mới có tên one_to_many.js. Trong one_to_many.js, loại bỏ các dòng sau student_datakhối. Tệp của bạn one_to_many.jssẽ trông như thế này:

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}
]

Sau student_datakhối, hãy sử dụng hasMany()phương thức để tạo mối quan hệ mới:

...
Grade.hasMany(Student)

Phương hasMany()pháp này cho phép bạn tạo mối quan hệ một-nhiều giữa hai mô hình Sequelize. Ở đây, bạn đang sử dụng GradeStudentcác mô hình.

Tiếp theo, thêm sequelize.sync()phương thức với findAll()phương thức bên dưới hasMany()dòng:

...
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);
});

Ở đây, bạn đang cố gắng truy cập vào tất cả học sinh trong một cấp lớp cụ thể — trong trường hợp này là tất cả học sinh trong lớp 9. Bạn cũng đã thêm Studentmô hình trong includetùy chọn.

Đây là mã hoàn chỉnh:

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);
});

Lưu và đóng tệp của bạn.

Chạy tệp bằng lệnh sau:

node one_to_many.js

Đầu ra sẽ tương tự như sau. Sẽ khá lâu nhưng tất cả học sinh trong lớp 9sẽ được trả về như sau:

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 },
...

Trong phần này, bạn đã tạo mối quan hệ một-nhiều bằng cách Grade.hasMany(Student);gọi phương thức. Trong đầu ra, bạn truy xuất các chi tiết theo liên kết mà bạn đã tạo.

Tạo ra nhiều mối quan hệ vớibelongsToMany()

Trong phần này, bạn sẽ tạo mối quan hệ nhiều-nhiều bằng cách sử dụng mô hình Sequelize. Ví dụ, hãy tưởng tượng một tình huống mà sinh viên đăng ký vào các khóa học. Một học viên có thể đăng ký nhiều khóa học và một khóa học có thể có nhiều học viên. Đây là một mối quan hệ nhiều-nhiều. Để thực hiện điều này bằng cách sử dụng Sequelize, bạn sẽ sử dụng các mô hình StudentCoursephương StudentCoursepháp belongsToMany().

Để bắt đầu, hãy tạo một tệp được gọi many_to_many.jsvà thêm các khối mã xác thực và khởi tạo cơ sở dữ liệu như sau. (Bạn có thể sử dụng lại các khối mã từ one_to_many.jsví dụ trước.) Đảm bảo cập nhật các giá trị kết nối cơ sở dữ liệu được đánh dấu nếu cần.

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);
});

Tiếp theo, bạn sẽ tạo các mô hình cơ sở dữ liệu cho các mối quan hệ nhiều-nhiều: StudentCourse. Sau đó, bạn sẽ thêm một số dữ liệu mẫu vào các mô hình đó.

...

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},
]

Tại đây, bạn tạo StudentCoursecác mô hình và cung cấp một số dữ liệu mẫu. Bạn cũng đặt a courseID, mà bạn sẽ sử dụng để truy xuất học sinh theo kiểu quan hệ này.

Cuối cùng, bạn đã xác định một mô hình mới được gọi là StudentCourse, mô hình này quản lý dữ liệu mối quan hệ giữa StudentCourse. Trong ví dụ này, studentId 1được đăng ký courseId 1courseId 2.

Bạn đã hoàn thành việc khởi tạo cơ sở dữ liệu và thêm dữ liệu mẫu vào cơ sở dữ liệu. Tiếp theo, tạo mối quan hệ nhiều-nhiều bằng belongsToMany()phương pháp như được hiển thị:

...
Course.belongsToMany(Student, { through: 'StudentCourse'})
Student.belongsToMany(Course, { through: 'StudentCourse'})

Trong belongsToMany()phương thức, bạn chuyển throughcấu hình với tên của mô hình làm tùy chọn cấu hình. Trong trường hợp này, nó là StudentCourse. Đây là bảng quản lý các mối quan hệ nhiều-nhiều.

Cuối cùng, bạn có thể kiểm tra xem liên kết có hoạt động bình thường hay không bằng cách truy xuất tất cả dữ liệu khóa học với các sinh viên được liên kết. Bạn sẽ làm điều đó bằng cách chuyển includetham số vào bên trong findAll()phương thức. Thêm các dòng sau vào 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);
});

Mã hoàn chỉnh trông giống như sau:

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);
});

Lưu và đóng tập tin.

Chạy tệp bằng lệnh sau:

node many_to_many.js

Đầu ra sẽ dài, nhưng sẽ trông giống như sau:

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:
...

Như bạn có thể thấy trong đầu ra này, các khóa học có sinh viên liên quan đã được truy xuất. Trong courseskhối, bạn sẽ thấy các idgiá trị riêng biệt cho biết từng khóa học. Ví dụ: id: 1được kết nối với lớp course_name: Sciencedành cho Khoa học, trong khi id: 2lớp Toán, v.v.

Trong cơ sở dữ liệu, bạn có thể thấy ba bảng được tạo với dữ liệu mẫu mà bạn đã chèn.

Trong bước này, bạn đã sử dụng Sequelize để tạo các liên kết một-một, một-nhiều và nhiều-nhiều. Tiếp theo, bạn sẽ làm việc với các truy vấn thô.

Bước 5 - Làm việc với các truy vấn thô

Trong bước này, bạn sẽ làm việc với các truy vấn thô trong Sequelize. Trong các bước trước, bạn đã sử dụng các phương thức tích hợp sẵn của Sequelize, chẳng hạn như insert()findAll(), để xử lý việc chèn và chọn dữ liệu từ cơ sở dữ liệu. Bạn có thể nhận thấy rằng các phương pháp đó tuân theo một mẫu cụ thể để viết một truy vấn. Tuy nhiên, với việc sử dụng các truy vấn thô, bạn không cần phải lo lắng về các phương thức và mẫu tích hợp sẵn của Sequelize. Sử dụng kiến ​​thức của bạn về các truy vấn SQL, bạn có thể thực hiện một loạt các truy vấn trong Sequelize từ đơn giản đến nâng cao hơn.

Dưới đây là một ví dụ về các truy vấn thô thực hiện hành động chọn tất cả các giá trị từ một bảng cụ thể, xóa các giá trị đã chọn theo điều kiện và cập nhật bảng với các giá trị đã cho.

SELECT * FROM table_name;
DELETE FROM table_name WHERE condition;
UPDATE table_name SET y = 42 WHERE x = 12;

Trong Sequelize, các truy vấn thô có thể được sử dụng với hai phương pháp chủ yếu: thay thế mảng và thay thế đối tượng. Khi bạn đang chuyển các giá trị cho truy vấn SQL, bạn có thể sử dụng một mảng hoặc một đối tượng để thực hiện việc thay thế đó.

Trước khi viết một truy vấn thô, trước tiên bạn cần cung cấp dữ liệu sinh viên trong cơ sở dữ liệu mẫu. Tiếp theo phần trước, Tạo cơ sở dữ liệu mẫu , đăng nhập vào MySQL, tạo cơ sở dữ liệu được gọi sample_student_dbvà đăng xuất khỏi MySQL.

Tiếp theo, bạn sẽ thêm một số dữ liệu thô để bắt đầu làm việc với các truy vấn thô. Tạo một tệp mới được gọi add_student_records.jsvà thêm các khối mã sau, chứa các phương thức Sequelize đã được thảo luận trước đây về 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);
});

Tại đây, bạn bắt đầu kết nối cơ sở dữ liệu, tạo mô hình và chèn một vài hồ sơ sinh viên vào bên trong cơ sở dữ liệu mới.

Lưu và đóng tập tin.

Tiếp theo, chạy tập lệnh này bằng lệnh sau:

node add_student_records.js

Đầu ra sẽ tương tự như sau. Nó sẽ khá dài, nhưng tất cả các hồ sơ học sinh mà bạn đã chèn sẽ được trả về như sau. Lưu ý rằng vì giá trị student_idUUID ( Số nhận dạng duy nhất phổ biến ) được tạo tự động nên giá trị này sẽ khác nhau tùy thuộc vào người dùng.

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
    },

…

Trong phần tiếp theo, bạn sẽ áp dụng các truy vấn thô bằng cách sử dụng một trong các student_idkết quả đầu ra trong khối mã ở trên. Sao chép nó xuống để bạn có nó cho các phần tiếp theo, nơi bạn sẽ sử dụng query()phương thức để thay thế mảng và đối tượng.

Thay thế mảng

Trong phần này, bạn sẽ sử dụng query()phương thức để thay thế mảng. Với phương pháp này, Sequelize có thể thực thi các truy vấn SQL thô hoặc đã được chuẩn bị sẵn.

Để bắt đầu, hãy sao chép nội dung của server.jstệp từ Bước 1 , vì nó bao gồm Sequelize()phương thức khởi tạo và khởi tạo cơ sở dữ liệu. Dán nội dung vào một tệp mới có tên array_raw_query.js. Cập nhật tên cơ sở dữ liệu thành 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);
});

Ở cuối tệp, hãy thêm khối mã sau để thay thế mảng, đảm bảo thay thế REPLACE_STUDENT_IDbằng student_idgiá trị mà bạn đã sao chép trong phần trước.

...
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);
});

Để thay thế mảng, bạn truyền query()phương thức với truy vấn SQL và đối tượng cấu hình. Nó chứa replacementsgiá trị và kiểu. Để thay thế, bạn chuyển dữ liệu dưới dạng một mảng và bắt các giá trị đó bằng ?biểu tượng dấu hỏi chấm ().

Tiếp theo, vì bạn cần lấy dữ liệu về một học sinh cụ thể, nên giá trị student_idsẽ được chuyển làm tham số thứ hai. Sau đó, bạn chuyển type: sequelize.QueryTypes.SELECTcặp khóa-giá trị mà bạn có thể sử dụng để chọn dữ liệu từ cơ sở dữ liệu.

Ngoài ra còn có một số loại khác, chẳng hạn như QueryTypes.UPDATEQueryTypes.DELETE. Tùy theo yêu cầu mà bạn có thể lựa chọn loại phù hợp với mục đích của mình.

Sau đây là toàn bộ khối mã. Tại đây bạn kết nối với cơ sở dữ liệu và truy xuất dữ liệu sinh viên đã chọn bằng truy vấn thô.

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);
});

Lưu và đóng tệp của bạn.

Tiếp theo, bạn có thể chạy tập lệnh này bằng lệnh sau:

node array_raw_query.js

Bạn sẽ thấy đầu ra tương tự như sau:

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 } ]

Do đã chọn student_id, giá trị đầu ra của bạn có thể khác nhau.

Thay thế đối tượng

Nhìn bề ngoài, thay thế đối tượng tương tự như thay thế mảng, nhưng mô hình truyền dữ liệu đến truy vấn thô là khác. Trong tùy chọn thay thế, bạn chuyển dữ liệu dưới dạng một đối tượng và trong tùy chọn truy vấn, bạn sử dụng các giá trị như :key.

Để bắt đầu, hãy tạo một tệp mới có tên object_raw_query.jsvà dán các khối mã hoàn chỉnh từ server.jstệp, cập nhật cơ sở dữ liệu lên 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);
});

Sau đó, thêm khối mã sau vào cuối object_raw_query.jstệp mới:

...
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);
});

Tại đây, bạn nhận được dữ liệu sinh viên đã chọn bằng cách sử dụng phương pháp thay thế đối tượng. Bạn tạo một replacementđối tượng, đặt làm thông tin sinh viên mà bạn idmuốn lấy:.{ id: 'REPLACE_STUDENT_ID' }

Trong , bạn chỉ ra query():. 'SELECT * FROM students WHERE student_id = :id'Sử dụng query()phương thức này, bạn chuyển giá trị thay thế dưới dạng một đối tượng, đó là lý do tại sao phương thức này được gọi là thay thế đối tượng.

Đây là mã hoàn chỉnh:

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);
});

Lưu và đóng tập tin.

Tiếp theo, chạy tập lệnh này bằng lệnh sau:

node object_raw_query.js

Đầu ra sẽ giống như sau:

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 } ]

Do đã chọn student_id, giá trị đầu ra của bạn có thể khác nhau.

Trong bước này, bạn đã làm việc với Chuỗi truy vấn thô bằng cách sử dụng hai phương pháp khác nhau: thay thế mảng và thay thế đối tượng.

Sự kết luận

Trong hướng dẫn này, bạn đã cài đặt và định cấu hình Sequelize. Bạn cũng đã tạo và làm việc với các mô hình, đây là một trong những thành phần bắt buộc của Sequelize. Cuối cùng, bạn đã tạo các kiểu liên kết khác nhau và làm việc với các truy vấn thô bằng cách sử dụng các ví dụ thực tế.

Tiếp theo, bạn có thể sử dụng các kiểu dữ liệu khác nhau để tạo các mô hình cơ sở dữ liệu. Bạn cũng có thể cập nhật và xóa bản ghi trong cơ sở dữ liệu bằng cả phương thức tích hợp sẵn và truy vấn thô.

Nguồn bài viết gốc tại https://www.digitalocean.com

#sequelize #node #mysql #database 

Cách sử dụng Sequelize với Node.js và MySQL
Hermann  Frami

Hermann Frami

1656755480

Serverless Sequelize Migrations

Serverless Sequelize Migrations

A plugin to manage sequelize migrations on serverless projects 

Features:

  • Create migration file
  • List pending and executed migrations
  • Apply pending migrations
  • Revert applied migrations
  • Reset all applied migrations

Documentation

Installation

  1. Add Serverless Sequelize Migrations to your project:
npm install --save serverless-sequelize-migrations
  1. Inside your serverless.yml file add the following entry to the plugins section (if there is no plugin section in the file you'll need to add it):
plugins:
    - serverless-sequelize-migrations

You can check whether the plugin is ready to be used through the terminal. To do so, type the following command on the CLI:

serverless

the console should display SequelizeMigrations as one of the available plugins in your Serverless project.

Setting up Sequelize

For the plugin to work correctly, you have to set the database information as environment variables on the service provider section as follows:

provider:
  environment:
    DB_DIALECT: 'database_dialect' /* one of 'mysql' | 'mariadb' | 'postgres' | 'mssql' */
    DB_NAME: 'database_name'
    DB_USERNAME: 'database_username'
    DB_PASSWORD: 'database_password'
    DB_HOST: 'database_host'
    DB_PORT: 'database_port'

or by using DB_CONNECTION_URL

provider:
  environment:
    DB_CONNECTION_URL: database_dialect://database_username:database_password@database_host:database_port/database_name`

Replace the variables with the information of your own database.

Obs: This plugin does not have support to create the database itself.

As per Sequelize docs, you'll have to manually install the driver for your database of choice:

# One of the following:
$ npm install --save pg pg-hstore # Postgres
$ npm install --save mysql2 # MySQL
$ npm install --save mariadb # MariaDB
$ npm install --save tedious # Microsoft SQL Server

Usage and command line options

To see the available commands of the plugin, run sls migrations on the terminal. The following should appear:

Plugin: SequelizeMigrations
migrations .................... Sequelize migrations management for Serverless
migrations create ............. Create a migration file
migrations up ................. Execute all pending migrations
migrations down ............... Rolls back one or more migrations
migrations reset .............. Rolls back all migrations
migrations list ............... Shows a list of migrations
    --path / -p ........................ Specify the migrations path (default is './migrations')
    --verbose / -v ..................... Shows sequelize logs

For any of these commands, you can specify two parameters:

  • --path to inform the path of migrations on your project.
  • --verbose to show sequelize execution logs during the operations.

In order to see the options of each command individually, you can run sls migrations <command> --help on the terminal.

The commands (those that have some option) and it's options are presented below:

  • migrations create
--name / -n (required) ... Specify the name of the migration to be created
  • migrations up
--rollback / -r .......... Rolls back applied migrations in case of error (default is false)
--dbDialect ........................ Specify the database dialect (one of: 'mysql', 'mariadb', 'postgres', 'mssql')
--dbHost ........................... Specify the database host
--dbPort ........................... Specify the database port
--dbName ........................... Specify the database name
--dbUsername ....................... Specify the database username
--dbPassword ....................... Specify the database password
  • migrations down
--times / -t ............. Specify how many times to roll back (default is 1)
--name / -n .............. Specify the name of the migration to be rolled back (e.g. "--name create-users.js")
--dbDialect ........................ Specify the database dialect (one of: 'mysql', 'mariadb', 'postgres', 'mssql')
--dbHost ........................... Specify the database host
--dbPort ........................... Specify the database port
--dbName ........................... Specify the database name
--dbUsername ....................... Specify the database username
--dbPassword ....................... Specify the database password
  • migrations list
--status / -s ............ Specify the status of migrations to be listed (--status pending [default] or --status executed)
--dbDialect ........................ Specify the database dialect (one of: 'mysql', 'mariadb', 'postgres', 'mssql')
--dbHost ........................... Specify the database host
--dbPort ........................... Specify the database port
--dbName ........................... Specify the database name
--dbUsername ....................... Specify the database username
--dbPassword ....................... Specify the database password

Custom migrations path

You can also define a migrations path variable on the custom section of your project service file.

custom:
  migrationsPath: './custom/migrations/path'

Important: if you inform the --path option through the CLI, this configuration will be ignored.

Credits and inspiration

This plugin was first based on Nevon's serverless-pg-migrations.

Author: Manelferreira
Source Code: https://github.com/manelferreira/serverless-sequelize-migrations 
License: MIT license

#serverless #sequelize 

Serverless Sequelize Migrations

Finale: RESTful Endpoint Generator for Your Sequelize Models

Looking for Maintainers

I no longer have time to keep up with this project. Please let me know if you're interested in becoming a maintainer. www. tomj. ninja

Finale

Create flexible REST endpoints and controllers from Sequelize models in your Express or Restify app.

This project aims to be a Sequelize 4.x and 5.x compatible version of Epilogue.

Installation

npm install finale-rest

Getting Started

var Sequelize = require('sequelize'),
    finale = require('finale-rest'),
    http = require('http');

// Define your models
var database = new Sequelize('database', 'root', 'password');
var User = database.define('User', {
  username: Sequelize.STRING,
  birthday: Sequelize.DATE
});

// Initialize server
var server, app;
if (process.env.USE_RESTIFY) {
  var restify = require('restify');
  var corsMiddleware = require('restify-cors-middleware');
  
  app = server = restify.createServer()
  var cors = corsMiddleware({
    preflightMaxAge: 5, // Optional
    origins: ['*'], // Should whitelist actual domains in production
    allowHeaders: ['Authorization', 'API-Token', 'Content-Range'], //Content-range has size info on lists
    exposeHeaders: ['Authorization', 'API-Token-Expiry', 'Content-Range']
  })

  server.pre(cors.preflight)
  server.use(cors.actual)

  server.use(restify.plugins.queryParser()); //{mapParams: true}
  server.use(restify.plugins.bodyParser());  //{mapParams: true, mapFiles: true}
  server.use(restify.plugins.acceptParser(server.acceptable));
} else {
  var express = require('express'),
      bodyParser = require('body-parser');

  var app = express();
  app.use(bodyParser.json());
  app.use(bodyParser.urlencoded({ extended: false }));
  server = http.createServer(app);
}

// Initialize finale
finale.initialize({
  app: app,
  sequelize: database
});

// Create REST resource
var userResource = finale.resource({
  model: User,
  endpoints: ['/users', '/users/:id']
});

// Create database and listen
database
  .sync({ force: true })
  .then(function() {
    server.listen(function() {
      var host = server.address().address,
          port = server.address().port;

      console.log('listening at http://%s:%s', host, port);
    });
  });

Migrate from Epilogue

Finale is built to be a drop-in replacement for Epilogue that supports Sequelize 4.x.x

const epilogue = require('epilogue')
epilogue.initialize(...)

// change to

const finale = require('finale-rest')
finale.initialize(...)

Controllers and endpoints

On the server we now have the following controllers and endpoints:

ControllerEndpointDescription
userResource.createPOST /usersCreate a user
userResource.listGET /usersGet a listing of users
userResource.readGET /users/:idGet details about a user
userResource.updatePUT /users/:idUpdate a user
userResource.deleteDELETE /users/:idDelete a user

Customize behavior

Of course it's likely that we'll want more flexibility. Our users resource has properties for each of the controller actions. Controller actions in turn have hooks for setting and overriding behavior at each step of the request. We have these milestones to work with: start, auth, fetch, data, write, send, and complete.

var ForbiddenError = require('finale-rest').Errors.ForbiddenError;

// disallow deletes on users
userResource.delete.auth(function(req, res, context) {
    throw new ForbiddenError("can't delete a user");
    // optionally:
    // return context.error(403, "can't delete a user");
})

We can set behavior for milestones directly as above, or we can add functionality before and after milestones too:

// check the cache first
userResource.list.fetch.before(function(req, res, context) {
    var instance = cache.get(context.criteria);

    if (instance) {
        // keep a reference to the instance and skip the fetch
        context.instance = instance;
        return context.skip;
    } else {
        // cache miss; we continue on
        return context.continue;
    }
})

Milestones can also be defined in a declarative fashion, and used as middleware with any resource. For example:

// my-middleware.js
module.exports = {
  create: {
    fetch: function(req, res, context) {
      // manipulate the fetch call
      return context.continue;
    }
  },
  list: {
    write: {
      before: function(req, res, context) {
        // modify data before writing list data
        return context.continue;
      },
      action: function(req, res, context) {
        // change behavior of actually writing the data
        return context.continue;
      },
      after: function(req, res, context) {
        // set some sort of flag after writing list data
        return context.continue;
      }
    }
  }
};

// my-app.js
var finale = require('finale-rest'),
    restMiddleware = require('my-middleware');

finale.initialize({
    app: app,
    sequelize: sequelize
});

var userResource = finale.resource({
    model: User,
    endpoints: ['/users', '/users/:id']
});

userResource.use(restMiddleware);

Finale middleware also supports bundling in extra resource configuration by specifying an "extraConfiguration" member of the middleware like so:

// my-middleware.js
module.exports = {
  extraConfiguration: function(resource) {
    // support delete for plural form of a resource
    var app = resource.app;
    app.del(resource.endpoints.plural, function(req, res) {
      resource.controllers.delete._control(req, res);
    });
  }
};

To show an error and halt execution of milestone functions you can throw an error:

var ForbiddenError = require('finale-rest').Errors.ForbiddenError;

before: function(req, res, context) {
    return authenticate.then(function(authed) {
        if(!authed) throw new ForbiddenError();

        return context.continue;
    });
}

REST API

Listing resources support filtering, searching, sorting, and pagination as described below.

Filtering

Add query parameters named after fields to limit results.

$ curl http://localhost/users?name=James+Conrad

HTTP/1.1 200 OK
Content-Type: application/json

[
  {
    "name": "James Conrad",
    "email": "jamesconrad@fastmail.fm"
  }
]

If your query specifies associations to be included – whether via a model scope (see below), manipulation of Finale's Context object in a custom Milestone handler, or simply by default in your Finale resource definition – your query parameters can reference fields on the joined models, e.g.

$ curl http://localhost/users?group.type=vip

Filtering using scope

Use scope to add additional filtering (More about scopes in sequelize - http://docs.sequelizejs.com/en/latest/docs/scopes/).

  // Define scope in model
  ...
  scope: {
    verified: {
      where : {
        email_verified: true
        phone_verified: true
      }  
    }
  }
$ curl http://localhost/users?scope=verified

HTTP/1.1 200 OK
Content-Type: application/json

[
  {
    "name": "James Conrad",
    "email": "jamesconrad@fastmail.fm"
    "email_verified": true,
    "phone_verified": true
  }
]

Search

Use the q parameter to perform a substring search across all fields.

$ curl http://localhost/users?q=james

HTTP/1.1 200 OK
Content-Type: application/json

[
  {
    "name": "James Conrad",
    "email": "jamesconrad@fastmail.fm"
  }, {
    "name": "Jim Huntington",
    "email": "jamesh@huntington.mx"
  }
]

Search behavior can be customized to change the parameter used for searching, as well as which attributes are included in the search, like so:

var userResource = finale.resource({
    model: User,
    endpoints: ['/users', '/users/:id'],
    search: {
      param: 'searchOnlyUsernames',
      attributes: [ 'username' ]
    }
});

This would restrict substring searches to the username attribute of the User model, and the search parameter would be 'searchOnlyUsernames':

$ curl http://localhost/users?searchOnlyUsernames=james

By default, the substring search is performed using a {field} LIKE '%{query}%' pattern. However, this behavior can be customized by specifying a search operator. Valid operators include: Op.like (default), Op.iLike, Op.notLike, Op.notILike, Op.ne, Op.eq, Op.not, Op.gte, Op.gt, Op.lte, Op.lt. All "*like" operators can only be used against Sequelize.STRING or Sequelize.TEXT fields. For instance:

var userResource = finale.resource({
    model: User,
    endpoints: ['/users', '/users/:id'],
    search: {
      operator: Sequelize.Op.gt,
      attributes: [ 'age' ]
    }
});

When querying against a Sequelize.BOOLEAN field, you'll need to use the Op.eq operator. You can also add multiple search parameters by passing the search key an array of objects:

var userResource = finale.resource({
    model: User,
    endpoints: ['/users', '/users/:id'],
    search: [
      {operator: Sequelize.Op.eq, param: 'emailVerified', attributes: [ 'email_verified' ]},
      {param: 'searchOnlyUsernames', attributes: [ 'username' ]}
    ] 
});

Sorting

Specify the sort parameter to sort results. Values are field names, optionally preceded by a - to indicate descending order. Multiple sort values may be separated by ,.

$ curl http://localhost/users?sort=-name

HTTP/1.1 200 OK
Content-Type: application/json

[
  {
    "name": "Jim Huntington",
    "email": "jamesh@huntington.mx"
  }, {
    "name": "James Conrad",
    "email": "jamesconrad@fastmail.fm"
  }
]

Sort behavior can be customized to change the parameter used for sorting, as well as which attributes are allowed to be used for sorting like so:

var userResource = finale.resource({
    model: User,
    endpoints: ['/users', '/users/:id'],
    sort: {
      param: 'orderby',
      attributes: [ 'username' ]
    }
});

This would restrict sorting to only the username attribute of the User model, and the sort parameter would be 'orderby':

$ curl http://localhost/users?orderby=username

Default sort criteria can be defined with the default attribute. The expected format for default sort criteria is exactly the same as if it was proceeding the sort parameter in the URL.

var userResource = finale.resource({
    model: User,
    endpoints: ['/users', '/users/:id'],
    sort: {
      default: '-email,username'
    }
});

With this configuration, these two calls would result in the same data:

$ curl http://localhost/users
$ curl http://localhost/users?sort=-email,username

Note that the sort parameter in the URL will override your default criteria.

By default all attributes defined on the model are allowed to be sorted on. Sorting on a attribute not allowed will cause a 400 error to be returned with errors in the format:

$ curl http://localhost/users?sortby=invalid,-otherinvalid,valid

HTTP/1.1 400 BAD REQUEST
Content-Type: application/json

{
  "message": "Sorting not allowed on given attributes",
  "errors": ["invalid", "otherinvalid"]
}

Pagination

List routes support pagination via offset or page and count query parameters. Find metadata about pagination and number of results in the Content-Range response header. Pagination defaults to a default of 100 results per page, and a maximum of 1000 results per page.

# get the third page of results
$ curl http://localhost/users?offset=200&count=100

HTTP/1.1 200 OK
Content-Type: application/json
Content-Range: items 200-299/3230

[
  { "name": "James Conrad", ... },
  ...
]

Alternatively, you can specify that pagination is disabled for a given resource by passing false to the pagination property like so:

var userResource = finale.resource({
    model: User,
    endpoints: ['/users', '/users/:id'],
    pagination: false
});

add_to_children on create and update action

For create and update actions, you can provide an add_to_children object to the context. The attributes of add_to_children will be added to all nested child objects sent in the request, overriding any values in the body. This is useful, for example, to inject common attributes from a session, like created_by_user_id or updated_by_user_id, to all children objects in the create body, without having to specify which ones they are specifically. Note: For doing this for top level writes and updates, you can simply specify context.attributes values. add_to_children is just for nested children objects.

finaleResource["create"].write.before(function(req:Request,res:Response,context:any) { 
    let loggedInUserId =  authManager.getLoggedInUserId(req);
    context.add_to_children = {
      updated_by_user_id :  loggedInUserId,
      created_by_user_id :  loggedInUserId
    }
    return context.continue;
  });
}

finaleResource["update"].write.before(function(req:Request,res:Response,context:any) { 
    let loggedInUserId =  authManager.getLoggedInUserId(req);
    context.add_to_children = {
      updated_by_user_id :  loggedInUserId
    }
    return context.continue;
  });
}

This currently is only supported for one level of nesting. It is not recursive.

Deep vs Shallow Payloads

By default, associations are included in read and list payloads. For list and read queries, you can set a shallow boolean on the context to indicate if you want it to include association child objects or not.

userResource["list"].fetch.before(function(req:Request,res:Response,context:any) { 
    context.shallow = true;
    return context.continue;
});

For finer-grain control over which children are included on a per-query basis, you can set context.shallow to true, and also leverage a children query parameter with a pipe-delimited list of associated children to include. children only works if shallow is set to true. The names used in the children query parameter are the as association names when setting up your sequelize models, or the default created by sequelize.

UserModel.belongsToMany(UserGroupModel), { through: UserGroupRelModel,foreignKey: "user_id" });
UserModel.belongsTo(OrganizationModel), { as: "PrimaryOrganization", foreignKey: "primary_organization_id" });
UserModel.belongsToMany(FooModel), { through: FooRelModel,foreignKey: "user_id" });
...
GET /user/?children=UserGroups|PrimaryOrganization

Finale API

initialize()

Set defaults and give finale a reference to your express app. Send the following parameters:

app

A reference to the Express application

base

Prefix to prepend to resource endpoints

updateMethod

HTTP method to use for update routes, one of POST, PUT, or PATCH

resource()

Create a resource and CRUD actions given a Sequelize model and endpoints. Accepts these parameters:

model

Reference to a Sequelize model

endpoints

Specify endpoints as an array with two sinatra-style URL paths in plural and singular form (e.g., ['/users', '/users/:id']).

actions

Create only the specified list of actions for the resource. Options include create, list, read, update, and delete. Defaults to all.

excludeAttributes

Explicitly remove the specified list of attributes from read and list operations

Milestones & Context

Check out the Milestone docs for information on lifecycle hooks that can be used with finale resources, and how to run custom code at various points during a request.

Protecting Finale REST Endpoints

To protect an endpoint, you must use milestones.

In order to protect and endpoint (for example, to require that only a logged in user or user with the appropriate security token can access a resource) you need to use the appropriate milestone hooks.

Below is an example of how to do this with standard Express middleware, which is commonly used to protect resources. Note that the callback functions required by Finale milestones look similar to express middleware, but the third argument (context) is different.

Suppose you have this resource:

var userResource = rest.resource({
    model: User
});

To protect all endpoints, we'll use userResource.all.auth, a hook used to authorize the endpoint before any operation (create, list, etc). Suppose also we have an express middlware function called authorize(req, res, done). This authorize function might for example be a passport strategy such as passport('local').

To authorize the endpoint, you would do this:

userResource.all.auth(function (req, res, context) {
  return new Promise(function(resolve, reject) {
    authorize(req, res, function (arg) {
      if (arg) {
        // Middleware function returned an error; this means the operation
        // should not be authorized.
        res.status(401).send({message: "Unauthorized"});
        resolve(context.stop);
      } else {
        resolve(context.continue);
      }
  });
})

In this code, note that userResource.all.auth is simply reusing the express middleware to do whatever authorization checking your code requires. We are passing a custom done function to the middleware, which resolves a promise as either context.stop or context.continue, indicating to finale whether or not to proceed. Note that in the case where the transaction isn't authorized, finale won't proceed, so it is your responsibility to send a response back to the client.

Protecting sub-resources

When models have assocations between them, to achieve the nested endpoints a la /user/1/UserGroups, finale creates sub-resources. Remember to set authorizations on those sub-resources as well. To get the sub-resources for a particular resource, you can use the string array subResourceNames attribute on the resource. Each name is also the name of an attribute on the resource.

userResource.all.auth(function (req, res, context) {
...
});

for(sub_resource_name in userResource.subResourceNames) {
    userResource[sub_resource_name].all.auth(function (req, res, context) {
      ...
    });
}

Further Information on Protecting Endpoints

The milestone documentation provides many other hooks for finer-grained operations, i.e. permitting all users to list but only some users to delete can be implemented by using the same approach described above, with different milestones.

Tests, Docker, OS X

The test suite requires use of Dtrace, which can be problematic on MacOS/OS X, which limits use of Dtrace. The base Dockerfile can be used to run tests.

docker build -t finale_test ./
docker run finale_test

Note: good errors happen, so stacktraces in the output are not necessarily indicative of a problem.

License

Copyright (C) 2012-2015 David Chester Copyright (C) 2014-2015 Matt Broadstone Copyright (C) 2017 Tom Juszczyk

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Author: Tommybananas
Source Code: https://github.com/tommybananas/finale 

#node #rest #sequelize #api 

Finale: RESTful Endpoint Generator for Your Sequelize Models
Ruth  Nabimanya

Ruth Nabimanya

1638601202

How to Connect Node.js Server with SQL Database using Sequelize ORM

In this tutorial, I’m going to guide you in creating a loose-coupled Node.js backend server dealing with an SQL database, using Sequelize to perform the Object Relational Mapping.

Here I’ll use Express which is a back-end web application framework for Node.js.

#node #nodejs #sql #database #sequelize 

How to Connect Node.js Server with SQL Database using Sequelize ORM
Camron  Shields

Camron Shields

1627226117

Database Migration with Sequelize in Node Js Express Application

Management of database changes in a production is a critical process for any application. And in this tutorial we are going to practice how we can use sequelize cli for handling database migrations. We will practice both doing the migration and undoing it. Other than migrations we are also going to pactice how we can add entries to tables via seed functionality of sequelize cli.
this tutorial is taken from my course, Test Driven Development with Node.js

The repo for this tutorial can be found here https://github.com/basarbk/tdd-nodejs/tree/L065

#sequelize #node #express

Database Migration with Sequelize in Node Js Express Application