최  호민

최 호민

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 

What is GEEK

Buddha Community

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

최 호민

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 

Hire Dedicated Node.js Developers - Hire Node.js Developers

If you look at the backend technology used by today’s most popular apps there is one thing you would find common among them and that is the use of NodeJS Framework. Yes, the NodeJS framework is that effective and successful.

If you wish to have a strong backend for efficient app performance then have NodeJS at the backend.

WebClues Infotech offers different levels of experienced and expert professionals for your app development needs. So hire a dedicated NodeJS developer from WebClues Infotech with your experience requirement and expertise.

So what are you waiting for? Get your app developed with strong performance parameters from WebClues Infotech

For inquiry click here: https://www.webcluesinfotech.com/hire-nodejs-developer/

Book Free Interview: https://bit.ly/3dDShFg

#hire dedicated node.js developers #hire node.js developers #hire top dedicated node.js developers #hire node.js developers in usa & india #hire node js development company #hire the best node.js developers & programmers

Aria Barnes

Aria Barnes

1622719015

Why use Node.js for Web Development? Benefits and Examples of Apps

Front-end web development has been overwhelmed by JavaScript highlights for quite a long time. Google, Facebook, Wikipedia, and most of all online pages use JS for customer side activities. As of late, it additionally made a shift to cross-platform mobile development as a main technology in React Native, Nativescript, Apache Cordova, and other crossover devices. 

Throughout the most recent couple of years, Node.js moved to backend development as well. Designers need to utilize a similar tech stack for the whole web project without learning another language for server-side development. Node.js is a device that adjusts JS usefulness and syntax to the backend. 

What is Node.js? 

Node.js isn’t a language, or library, or system. It’s a runtime situation: commonly JavaScript needs a program to work, however Node.js makes appropriate settings for JS to run outside of the program. It’s based on a JavaScript V8 motor that can run in Chrome, different programs, or independently. 

The extent of V8 is to change JS program situated code into machine code — so JS turns into a broadly useful language and can be perceived by servers. This is one of the advantages of utilizing Node.js in web application development: it expands the usefulness of JavaScript, permitting designers to coordinate the language with APIs, different languages, and outside libraries.

What Are the Advantages of Node.js Web Application Development? 

Of late, organizations have been effectively changing from their backend tech stacks to Node.js. LinkedIn picked Node.js over Ruby on Rails since it took care of expanding responsibility better and decreased the quantity of servers by multiple times. PayPal and Netflix did something comparative, just they had a goal to change their design to microservices. We should investigate the motivations to pick Node.JS for web application development and when we are planning to hire node js developers. 

Amazing Tech Stack for Web Development 

The principal thing that makes Node.js a go-to environment for web development is its JavaScript legacy. It’s the most well known language right now with a great many free devices and a functioning local area. Node.js, because of its association with JS, immediately rose in ubiquity — presently it has in excess of 368 million downloads and a great many free tools in the bundle module. 

Alongside prevalence, Node.js additionally acquired the fundamental JS benefits: 

  • quick execution and information preparing; 
  • exceptionally reusable code; 
  • the code is not difficult to learn, compose, read, and keep up; 
  • tremendous asset library, a huge number of free aides, and a functioning local area. 

In addition, it’s a piece of a well known MEAN tech stack (the blend of MongoDB, Express.js, Angular, and Node.js — four tools that handle all vital parts of web application development). 

Designers Can Utilize JavaScript for the Whole Undertaking 

This is perhaps the most clear advantage of Node.js web application development. JavaScript is an unquestionable requirement for web development. Regardless of whether you construct a multi-page or single-page application, you need to know JS well. On the off chance that you are now OK with JavaScript, learning Node.js won’t be an issue. Grammar, fundamental usefulness, primary standards — every one of these things are comparable. 

In the event that you have JS designers in your group, it will be simpler for them to learn JS-based Node than a totally new dialect. What’s more, the front-end and back-end codebase will be basically the same, simple to peruse, and keep up — in light of the fact that they are both JS-based. 

A Quick Environment for Microservice Development 

There’s another motivation behind why Node.js got famous so rapidly. The environment suits well the idea of microservice development (spilling stone monument usefulness into handfuls or many more modest administrations). 

Microservices need to speak with one another rapidly — and Node.js is probably the quickest device in information handling. Among the fundamental Node.js benefits for programming development are its non-obstructing algorithms.

Node.js measures a few demands all at once without trusting that the first will be concluded. Many microservices can send messages to one another, and they will be gotten and addressed all the while. 

Versatile Web Application Development 

Node.js was worked in view of adaptability — its name really says it. The environment permits numerous hubs to run all the while and speak with one another. Here’s the reason Node.js adaptability is better than other web backend development arrangements. 

Node.js has a module that is liable for load adjusting for each running CPU center. This is one of numerous Node.js module benefits: you can run various hubs all at once, and the environment will naturally adjust the responsibility. 

Node.js permits even apportioning: you can part your application into various situations. You show various forms of the application to different clients, in light of their age, interests, area, language, and so on. This builds personalization and diminishes responsibility. Hub accomplishes this with kid measures — tasks that rapidly speak with one another and share a similar root. 

What’s more, Node’s non-hindering solicitation handling framework adds to fast, letting applications measure a great many solicitations. 

Control Stream Highlights

Numerous designers consider nonconcurrent to be one of the two impediments and benefits of Node.js web application development. In Node, at whatever point the capacity is executed, the code consequently sends a callback. As the quantity of capacities develops, so does the number of callbacks — and you end up in a circumstance known as the callback damnation. 

In any case, Node.js offers an exit plan. You can utilize systems that will plan capacities and sort through callbacks. Systems will associate comparable capacities consequently — so you can track down an essential component via search or in an envelope. At that point, there’s no compelling reason to look through callbacks.

 

Final Words

So, these are some of the top benefits of Nodejs in web application development. This is how Nodejs is contributing a lot to the field of web application development. 

I hope now you are totally aware of the whole process of how Nodejs is really important for your web project. If you are looking to hire a node js development company in India then I would suggest that you take a little consultancy too whenever you call. 

Good Luck!

Original Source

#node.js development company in india #node js development company #hire node js developers #hire node.js developers in india #node.js development services #node.js development

The  NineHertz

The NineHertz

1611828639

Node JS Development Company | Hire Node.js Developers

The NineHertz promises to develop a pro-active and easy solution for your enterprise. It has reached the heights in Node js web development and is considered as one of the top-notch Node js development company across the globe.

The NineHertz aims to design a best Node js development solution to improve their branding status and business profit.

Looking to hire the leading Node js development company?

#node js development company #nodejs development company #node.js development company #node.js development companies #node js web development #node development company

sophia tondon

sophia tondon

1620990044

Top Node js Development Company India | Node js Web Development Services

Looking to hire top dedicated Node.js developers in India at affordable prices? Get dedicated Node.js developers with 6+ years of average experience on an hourly or full-time (dedicated monthly) basis to build dynamic, feature-rich, and secure software applications.

Our offshore Node JS developers create simple as well as complex enterprise-grade Node.js applications for small, mid-large scale businesses & can save your development cost up to 60%.

Planning to outsource Nodejs web development services? Or would you like to hire a team of Nodejs developers? Get in touch for a free consultation!

#hire node.js developers #hire node developers #node.js developers for hire #node js developers #node.js development company india