田辺  明美

田辺 明美

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 

What is GEEK

Buddha Community

NodeとMySQLでSequelizeを使用する方法
田辺  明美

田辺 明美

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