How To Use Sequelize with Node and MySQL

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

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

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

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

Etapa 1 — Instalando e configurando o Sequelize

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

Instalando o Sequelize

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

mkdir hello-world
cd hello-world

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

npm init

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

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

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

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

touch server.js

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

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

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

npm i sequelize@6.11.0

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

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

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

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

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

Criando um banco de dados de exemplo

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

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

mysql -u your_username -p

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

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

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

CREATE DATABASE hello_world_db;

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

SHOW DATABASES;

Sua saída será semelhante a esta:

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

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

mysql> QUIT

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

npm install --save mysql2

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

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

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

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

Conectando-se ao banco de dados MySQL

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

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

nano server.js

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

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

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

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

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

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

...

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

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

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

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

const Sequelize = require("sequelize");

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

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

Salve e feche seu arquivo.

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

node server.js

Sua saída ficará assim:

Output
Connection has been established successfully!

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

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

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

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

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

nano book.model.js

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

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

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

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

...

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

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

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

...

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

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

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

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

...

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

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

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

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

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

O código final ficará assim:

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

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

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

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

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

Salve e feche seu arquivo.

Execute seu aplicativo usando o seguinte comando:

node book.model.js

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

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

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

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

mysql -u YOUR_USERNAME -p

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

USE hello_world_db;

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

SHOW TABLES;

Sua saída será semelhante a esta:

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

Finalmente, desconecte-se do servidor MySQL:

mysql> QUIT

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

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

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

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

Inserindo um novo registro

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

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

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

...

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

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

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

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

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

Salve e feche o arquivo.

Execute o aplicativo usando o seguinte comando:

node book.controller.js

Sua saída será semelhante à seguinte:

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

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

Selecionando todos os registros

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

...

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

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

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

...

Salve e feche o arquivo.

Em seguida, execute o aplicativo novamente usando o seguinte comando:

node book.controller.js

Sua saída será semelhante à seguinte:

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

A saída contém todos os dados do livro como um objeto de matriz. Você usou com êxito o método Sequelize findAll()para retornar todos os dados do livro do banco de dados.

Selecionando com a whereCláusula

Nesta seção, você selecionará valores com condições usando a wherecláusula. A wherecláusula é usada para especificar uma condição ao buscar dados. Para este tutorial, você obterá um livro por um ID de registro específico do banco de dados usando o findOne()método.

Para fazer isso, abra book.controller.jspara edição, exclua o findAll()método e adicione as seguintes linhas:

...

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

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

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

Aqui, você seleciona um registro contábil específico do banco de dados usando o findOne()método com a whereopção. Neste exemplo, você está recuperando os dados do livro cujo idvalor é igual a 1.

Salve e feche o arquivo.

Em seguida, execute o aplicativo:

node book.controller.js

Sua saída será semelhante à seguinte:

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

Você usou wherecláusulas com sucesso para obter dados de modelos do Sequelize. Você pode usar a wherecláusula no aplicativo de banco de dados para capturar dados condicionais.

Apagando um registro

Para excluir um registro específico do modelo de banco de dados, use o destroy()método com a whereopção. Para fazer isso, abra book.controller.js, remova o findOne()método e adicione as seguintes linhas destacadas:

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

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

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

Aqui, você remove um registro de livro do banco de dados usando o destroy()método com a whereopção e passando o iddo livro a ser removido. Você vai remover o registro do livro cujo idigual a 2.

Salve e feche o arquivo.

Em seguida, execute o aplicativo:

node book.controller.js

Sua saída terá a seguinte aparência:

Output
Successfully deleted record.

O registro foi excluído.

Nesta etapa, você experimentou seu modelo de banco de dados e consulta de modelo. Você iniciou o banco de dados, criou modelos, inseriu registros, recuperou registros, recuperou registros com condições usando a wherecláusula e excluiu registros selecionados. Com esse conhecimento do Sequelize, você agora criará associações no Sequelize. Depois disso, você poderá definir e trabalhar com uma variedade de relacionamentos usando os modelos do Sequelize.

Passo 4 — Criando Associações Usando Sequelize

Nesta etapa, você usará os tipos de associação padrão que o Sequelize suporta: associações um para um , um para muitos e muitos para muitos . Você usará dados de amostra sobre alunos, cursos e níveis de escolaridade.

O Sequelize usa tipos de associação com base nos seguintes relacionamentos de banco de dados:

relacionamento um-para-um : Um relacionamento um-para-um significa que um registro em uma tabela está associado exatamente a um registro em outra tabela. Em termos de Sequelize, você pode usarbelongsTo()ehasOne()associações para criar esse tipo de relacionamento.

relacionamento um-para-muitos : Um relacionamento um-para-muitos significa que um registro em uma tabela está associado a vários registros em outra tabela. Com o Sequelize, você pode usarhasMany()métodos de associação para criar esse tipo de relacionamento.

relacionamento muitos para muitos : um relacionamento muitos para muitos significa que vários registros em uma tabela estão associados a vários registros em outra tabela. Com o Sequelize, você pode usarbelongsToMany()associações para criar esse tipo de relacionamento.

Antes de criar essas associações, você primeiro criará um novo banco de dados chamado student_dbe adicionará novos modelos e alguns dados de amostra para alunos, cursos e séries.

Para criar o banco de dados, siga o mesmo processo da Etapa 1 — Instalando e configurando o Sequelize para fazer login no MySQL e criar um banco de dados chamado student_db. Depois que o novo banco de dados for criado, saia do MySQL. Em seguida, você começará a criar associações de banco de dados.

Criando um relacionamento pessoal combelongsTo()

Nesta seção, você criará um relacionamento um para um usando os modelos do Sequelize. Imagine que você deseja obter os detalhes de um aluno junto com sua série. Como um aluno pode ter apenas uma série, esse tipo de associação é um relacionamento de um para um e você pode usar o belongsTo()método.

Nota: Há uma diferença entre belongsTo()e hasOne(). belongsTo()adicionará o foreignKeyna tabela de origem, enquanto hasOne()o adicionará à tabela de destino. De qualquer forma, se ambos os relacionamentos forem usados ​​ao mesmo tempo, funcionará como Sequelizar relacionamentos bidirecional um para um.

O belongsTo()método permite que você crie um relacionamento um para um entre dois modelos do Sequelize. Neste exemplo, você está usando os modelos Studente .Grade

Crie um novo arquivo chamado one_to_one.js. Como você fez na seção anterior, Conectando-se ao banco de dados MySQL , inclua as linhas para criar uma conexão com o banco de dados e autenticar seu usuário MySQL na parte superior do arquivo. Certifique-se de atualizar as credenciais do MySQL conforme necessário:

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

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

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

Nesta seção, você criará três modelos no novo student_dbbanco de dados: Student, Grade, e Course. Você começará criando os modelos Studente . GradeMais adiante nesta etapa, você criará o Coursesmodelo.

Para o Studentmodelo, adicione o seguinte bloco de código a one_to_one.js:

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

Este modelo de aluno contém duas colunas: student_ide name.

Em seguida, adicione um bloco de código para o Grademodelo:

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

O Grademodelo contém a coluna grade.

Para demonstrar as associações, você precisará adicionar dados de amostra ao banco de dados. Para isso, você usará o bulk()método. Em vez de inserir dados nas linhas uma a uma, o bulkCreate()método permite inserir várias linhas em seus modelos de banco de dados de uma só vez.

Agora, importe os dados Gradee Studentpara seus respectivos modelos no banco de dados, conforme mostrado:

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

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

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

Aqui, você fornece dados de amostra e importa os dados para os modelos Studente . GradeCom seu banco de dados, modelos e dados de amostra prontos, você está pronto para criar associações.

Em one-to-one.js, adicione a seguinte linha abaixo do student_databloco:

...
Student.belongsTo(Grade);

Em seguida, você precisará verificar se a associação está funcionando corretamente. Para fazer isso, você pode recuperar os dados de todos os alunos com níveis de notas associados passando o includeparâmetro dentro do findAll()método.

Como você precisa obter a nota do aluno, você passará Gradecomo modelo. No sequelize.sync()método, adicione as linhas destacadas conforme mostrado:

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

O código completo se parece com o seguinte:

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

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

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

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

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

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

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

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

Salve e feche seu arquivo.

Execute o arquivo usando o seguinte comando:

node one_to_one.js

A saída será longa e você verá os dados de todos os alunos com níveis de notas. Aqui está um trecho da saída mostrando os dados do aluno:

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

Dependendo das ferramentas de linha de comando que você está usando, a saída pode ser impressa como uma exibição expandida ou não. Se for uma visualização expandida, imprime o gradeobjeto expandido como saída.

Nesta seção, você criou um relacionamento um para um usando a Student.belongsTo(Grade);chamada de método e obteve os detalhes de acordo com a associação criada.

Criando um relacionamento de um para muitos comhasMany()

Nesta seção, você criará um relacionamento um-para-muitos usando modelos do Sequelize. Imagine que você gostaria de associar todos os alunos a uma série selecionada. Como uma série específica pode ter vários alunos, essa é uma relação de um para muitos.

Para começar, copie o conteúdo de one_to_one.jsem um novo arquivo chamado one_to_many.js. Em one_to_many.js, remova as linhas após o student_databloco. Seu one_to_many.jsarquivo ficará assim:

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

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

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

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

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

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

Após o student_databloqueio, use o hasMany()método para criar um novo relacionamento:

...
Grade.hasMany(Student)

O hasMany()método permite que você crie um relacionamento um-para-muitos entre dois modelos do Sequelize. Aqui, você está usando os modelos Gradee .Student

Em seguida, adicione o sequelize.sync()método com o findAll()método abaixo da hasMany()linha:

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

Aqui você está tentando acessar todos os alunos em uma série específica—neste caso, todos os alunos na série 9. Você também adicionou o Studentmodelo na includeopção.

Aqui está o código completo:

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

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

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

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

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

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

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

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

Salve e feche seu arquivo.

Execute o arquivo com o seguinte comando:

node one_to_many.js

A saída será semelhante à seguinte. Será bastante longo, mas todos os alunos da série 9serão devolvidos da seguinte forma:

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

Nesta seção, você criou um relacionamento um para muitos usando a Grade.hasMany(Student);chamada de método. Na saída, você recuperou os detalhes de acordo com a associação criada.

Criando relacionamentos muitos-para-muitos combelongsToMany()

Nesta seção, você criará relacionamentos muitos-para-muitos usando modelos do Sequelize. Como exemplo, imagine uma situação em que os alunos estão matriculados em cursos. Um aluno pode se matricular em vários cursos e um curso pode ter muitos alunos. Esta é uma relação de muitos para muitos. Para implementar isso usando o Sequelize, você usará os modelos Student, Coursee StudentCoursecom o belongsToMany()método .

Para começar, crie um arquivo chamado many_to_many.jse adicione os blocos de código de inicialização e autenticação do banco de dados da seguinte maneira. (Você pode reutilizar os blocos de código do one_to_many.jsexemplo anterior.) Certifique-se de atualizar os valores de conexão de banco de dados destacados conforme necessário.

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

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

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

Em seguida, você criará os modelos de banco de dados para relacionamentos muitos para muitos: Studente Course. Em seguida, você adicionará alguns dados de amostra a esses modelos.

...

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

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

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

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

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

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

Aqui, você cria os modelos e e fornece alguns dados de exemplo Student. CourseVocê também define um courseID, que será usado para recuperar alunos de acordo com esse tipo de relacionamento.

Por fim, você definiu um novo modelo chamado StudentCourse, que gerencia os dados de relacionamento entre Studente Course. Neste exemplo, studentId 1está inscrito em courseId 1e courseId 2.

Você concluiu a inicialização do banco de dados e adicionou dados de amostra ao banco de dados. Em seguida, crie relacionamentos muitos para muitos usando o belongsToMany()método conforme mostrado:

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

Dentro do belongsToMany()método, você passa a throughconfiguração com o nome do modelo como opção de configuração. Neste caso, é StudentCourse. Esta é a tabela que gerencia os relacionamentos muitos-para-muitos.

Por fim, você pode verificar se a associação está funcionando corretamente, recuperando todos os dados do curso com os alunos associados. Você fará isso passando o includeparâmetro dentro do findAll()método. Adicione as seguintes linhas a many_to_many.js:

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

O código completo se parece com o seguinte:

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

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

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

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

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

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

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

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

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

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

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

Salve e feche o arquivo.

Execute o arquivo usando o seguinte comando:

node many_to_many.js

A saída será longa, mas será algo semelhante ao seguinte:

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

Como você pode ver nesta saída, os cursos com alunos associados foram recuperados. Dentro do coursesbloco, você verá idvalores separados que indicam cada curso. Por exemplo, id: 1está conectado ao course_name: Sciencepara a aula de Ciências, enquanto id: 2é a aula de Matemática e assim por diante.

No banco de dados, você pode ver as três tabelas geradas com os dados de amostra inseridos.

Nesta etapa, você usou o Sequelize para criar associações um para um, um para muitos e muitos para muitos. Em seguida, você trabalhará com consultas brutas.

Etapa 5 — Trabalhando com consultas brutas

Nesta etapa, você trabalhará com consultas brutas no Sequelize. Nas etapas anteriores, você usou métodos internos do Sequelize, como insert()e findAll(), para manipular a inserção e a seleção de dados do banco de dados. Você deve ter notado que esses métodos seguem um padrão específico para escrever uma consulta. No entanto, com o uso de consultas brutas, você não precisa se preocupar com os métodos e padrões internos do Sequelize. Usando seu conhecimento de consultas SQL, você pode realizar uma variedade de consultas no Sequelize, das mais simples às mais avançadas.

Aqui está um exemplo de consultas brutas que realizam a ação de selecionar todos os valores de uma determinada tabela, excluindo os valores selecionados de acordo com a condição e atualizando a tabela com os valores fornecidos.

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

No Sequelize, consultas brutas podem ser usadas principalmente com duas metodologias: substituição de array e substituição de objeto. Ao passar valores para a consulta SQL, você pode usar uma matriz ou um objeto para fazer essa substituição.

Antes de escrever uma consulta bruta, primeiro você precisará fornecer os dados do aluno em um banco de dados de exemplo. Seguindo a seção anterior, Criando um banco de dados de exemplo , faça login no MySQL, crie um banco de dados chamado sample_student_dbe saia do MySQL.

Em seguida, você adicionará alguns dados brutos para começar a trabalhar com consultas brutas. Crie um novo arquivo chamado add_student_records.jse adicione os seguintes blocos de código, que contêm os métodos Sequelize discutidos anteriormente de authenticate(), sync()e bulkCreate().

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

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

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

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

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

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

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

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

Aqui, você inicia a conexão com o banco de dados, cria o modelo e insere alguns registros de alunos dentro do novo banco de dados.

Salve e feche o arquivo.

Em seguida, execute este script usando o seguinte comando:

node add_student_records.js

A saída será algo semelhante ao seguinte. Será bastante longo, mas todos os registros de alunos inseridos serão devolvidos da seguinte forma. Observe que, como student_idé um valor UUID ( Identificadores Universais Universais ) gerado automaticamente, ele será diferente dependendo do usuário.

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

…

Na próxima seção, você aplicará consultas brutas usando uma das student_idsaídas no bloco de código acima. Copie-o para baixo para que você o tenha nas próximas seções, onde você usará o query()método para substituições de arrays e objetos.

Substituição de matriz

Nesta seção, você usará o query()método para substituição de matriz. Com este método, o Sequelize pode executar consultas SQL brutas ou já preparadas.

Para começar, copie o conteúdo do server.jsarquivo da Etapa 1 , pois isso inclui o Sequelize()método de inicialização e a inicialização do banco de dados. Cole o conteúdo em um novo arquivo chamado array_raw_query.js. Atualize o nome do banco de dados para sample_student_db:

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

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

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

No final do arquivo, adicione o seguinte bloco de código para uma substituição de matriz, certificando-se de substituir REPLACE_STUDENT_IDpelo student_idvalor que você copiou na seção anterior.

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

Para substituição de array, você passa o query()método com a consulta SQL e o objeto de configuração. Ele contém o replacementsvalor e o tipo. ?Para substituições, você passa os dados como uma matriz e captura esses valores usando o símbolo de ponto de interrogação ( ).

Em seguida, como você precisa obter dados sobre um aluno específico, o student_idé passado como o segundo parâmetro. Depois disso, você passa o type: sequelize.QueryTypes.SELECTpar chave-valor, que pode ser usado para selecionar dados do banco de dados.

Existem alguns outros tipos também, como QueryTypes.UPDATEe QueryTypes.DELETE. Dependendo do requisito, você pode selecionar o tipo que se adequa à sua finalidade.

O seguinte mostra o bloco de código completo. Aqui você se conecta ao banco de dados e recupera os dados do aluno selecionado usando uma consulta bruta.

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

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

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

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

Salve e feche seu arquivo.

Em seguida, você pode executar este script usando o seguinte comando:

node array_raw_query.js

Você verá uma saída semelhante à seguinte:

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

Devido ao selecionado student_id, seus valores de saída podem diferir.

Substituição de objetos

Na superfície, a substituição de objetos é semelhante à substituição de matrizes, mas o padrão de passagem de dados para a consulta bruta é diferente. Na opção de substituição, você passa os dados como um objeto e, na opção de consulta, usa valores como :key.

Para começar, crie um novo arquivo chamado object_raw_query.jse cole os blocos de código completos do server.jsarquivo, atualizando o banco de dados para sample_student_db.

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

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

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

Em seguida, adicione o seguinte bloco de código ao final do novo object_raw_query.jsarquivo:

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

Aqui, você obtém dados de alunos selecionados usando o método de substituição de objetos. Você cria um replacementobjeto, definindo idcomo as informações do aluno que deseja recuperar: { id: 'REPLACE_STUDENT_ID' }.

No query(), você indica: 'SELECT * FROM students WHERE student_id = :id'. Usando o query()método, você passa o valor de substituição como um objeto, razão pela qual esse método é conhecido como substituição de objeto.

Aqui está o código completo:

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

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

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

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

Salve e feche o arquivo.

Em seguida, execute este script usando o seguinte comando:

node object_raw_query.js

A saída será semelhante à seguinte:

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

Devido ao selecionado student_id, seus valores de saída podem diferir.

Nesta etapa, você trabalhou com Sequelize consultas brutas usando duas metodologias diferentes: substituição de matriz e substituição de objeto.

Conclusão

Neste tutorial, você instalou e configurou o Sequelize. Você também criou e trabalhou com modelos, que é um dos componentes obrigatórios do Sequelize. Por fim, você criou diferentes tipos de associações e trabalhou com consultas brutas usando exemplos práticos.

Em seguida, você pode usar diferentes tipos de dados para criar modelos de banco de dados. Você também pode atualizar e excluir registros em bancos de dados com métodos internos e consultas brutas.

Fonte do artigo original em https://www.digitalocean.com

#sequelize #node #mysql #database 

What is GEEK

Buddha Community

How To Use Sequelize with Node and MySQL
Joe  Hoppe

Joe Hoppe

1595905879

Best MySQL DigitalOcean Performance – ScaleGrid vs. DigitalOcean Managed Databases

HTML to Markdown

MySQL is the all-time number one open source database in the world, and a staple in RDBMS space. DigitalOcean is quickly building its reputation as the developers cloud by providing an affordable, flexible and easy to use cloud platform for developers to work with. MySQL on DigitalOcean is a natural fit, but what’s the best way to deploy your cloud database? In this post, we are going to compare the top two providers, DigitalOcean Managed Databases for MySQL vs. ScaleGrid MySQL hosting on DigitalOcean.

At a glance – TLDR
ScaleGrid Blog - At a glance overview - 1st pointCompare Throughput
ScaleGrid averages almost 40% higher throughput over DigitalOcean for MySQL, with up to 46% higher throughput in write-intensive workloads. Read now

ScaleGrid Blog - At a glance overview - 2nd pointCompare Latency
On average, ScaleGrid achieves almost 30% lower latency over DigitalOcean for the same deployment configurations. Read now

ScaleGrid Blog - At a glance overview - 3rd pointCompare Pricing
ScaleGrid provides 30% more storage on average vs. DigitalOcean for MySQL at the same affordable price. Read now

MySQL DigitalOcean Performance Benchmark
In this benchmark, we compare equivalent plan sizes between ScaleGrid MySQL on DigitalOcean and DigitalOcean Managed Databases for MySQL. We are going to use a common, popular plan size using the below configurations for this performance benchmark:

Comparison Overview
ScaleGridDigitalOceanInstance TypeMedium: 4 vCPUsMedium: 4 vCPUsMySQL Version8.0.208.0.20RAM8GB8GBSSD140GB115GBDeployment TypeStandaloneStandaloneRegionSF03SF03SupportIncludedBusiness-level support included with account sizes over $500/monthMonthly Price$120$120

As you can see above, ScaleGrid and DigitalOcean offer the same plan configurations across this plan size, apart from SSD where ScaleGrid provides over 20% more storage for the same price.

To ensure the most accurate results in our performance tests, we run the benchmark four times for each comparison to find the average performance across throughput and latency over read-intensive workloads, balanced workloads, and write-intensive workloads.

Throughput
In this benchmark, we measure MySQL throughput in terms of queries per second (QPS) to measure our query efficiency. To quickly summarize the results, we display read-intensive, write-intensive and balanced workload averages below for 150 threads for ScaleGrid vs. DigitalOcean MySQL:

ScaleGrid MySQL vs DigitalOcean Managed Databases - Throughput Performance Graph

For the common 150 thread comparison, ScaleGrid averages almost 40% higher throughput over DigitalOcean for MySQL, with up to 46% higher throughput in write-intensive workloads.

#cloud #database #developer #digital ocean #mysql #performance #scalegrid #95th percentile latency #balanced workloads #developers cloud #digitalocean droplet #digitalocean managed databases #digitalocean performance #digitalocean pricing #higher throughput #latency benchmark #lower latency #mysql benchmark setup #mysql client threads #mysql configuration #mysql digitalocean #mysql latency #mysql on digitalocean #mysql throughput #performance benchmark #queries per second #read-intensive #scalegrid mysql #scalegrid vs. digitalocean #throughput benchmark #write-intensive

How To Use Sequelize with Node and MySQL

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

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

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

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

Etapa 1 — Instalando e configurando o Sequelize

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

Instalando o Sequelize

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

mkdir hello-world
cd hello-world

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

npm init

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

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

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

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

touch server.js

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

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

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

npm i sequelize@6.11.0

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

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

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

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

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

Criando um banco de dados de exemplo

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

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

mysql -u your_username -p

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

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

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

CREATE DATABASE hello_world_db;

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

SHOW DATABASES;

Sua saída será semelhante a esta:

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

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

mysql> QUIT

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

npm install --save mysql2

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

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

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

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

Conectando-se ao banco de dados MySQL

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

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

nano server.js

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

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

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

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

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

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

...

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

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

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

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

const Sequelize = require("sequelize");

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

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

Salve e feche seu arquivo.

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

node server.js

Sua saída ficará assim:

Output
Connection has been established successfully!

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

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

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

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

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

nano book.model.js

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

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

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

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

...

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

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

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

...

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

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

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

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

...

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

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

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

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

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

O código final ficará assim:

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

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

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

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

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

Salve e feche seu arquivo.

Execute seu aplicativo usando o seguinte comando:

node book.model.js

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

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

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

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

mysql -u YOUR_USERNAME -p

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

USE hello_world_db;

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

SHOW TABLES;

Sua saída será semelhante a esta:

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

Finalmente, desconecte-se do servidor MySQL:

mysql> QUIT

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

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

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

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

Inserindo um novo registro

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

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

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

...

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

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

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

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

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

Salve e feche o arquivo.

Execute o aplicativo usando o seguinte comando:

node book.controller.js

Sua saída será semelhante à seguinte:

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

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

Selecionando todos os registros

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

...

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

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

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

...

Salve e feche o arquivo.

Em seguida, execute o aplicativo novamente usando o seguinte comando:

node book.controller.js

Sua saída será semelhante à seguinte:

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

A saída contém todos os dados do livro como um objeto de matriz. Você usou com êxito o método Sequelize findAll()para retornar todos os dados do livro do banco de dados.

Selecionando com a whereCláusula

Nesta seção, você selecionará valores com condições usando a wherecláusula. A wherecláusula é usada para especificar uma condição ao buscar dados. Para este tutorial, você obterá um livro por um ID de registro específico do banco de dados usando o findOne()método.

Para fazer isso, abra book.controller.jspara edição, exclua o findAll()método e adicione as seguintes linhas:

...

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

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

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

Aqui, você seleciona um registro contábil específico do banco de dados usando o findOne()método com a whereopção. Neste exemplo, você está recuperando os dados do livro cujo idvalor é igual a 1.

Salve e feche o arquivo.

Em seguida, execute o aplicativo:

node book.controller.js

Sua saída será semelhante à seguinte:

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

Você usou wherecláusulas com sucesso para obter dados de modelos do Sequelize. Você pode usar a wherecláusula no aplicativo de banco de dados para capturar dados condicionais.

Apagando um registro

Para excluir um registro específico do modelo de banco de dados, use o destroy()método com a whereopção. Para fazer isso, abra book.controller.js, remova o findOne()método e adicione as seguintes linhas destacadas:

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

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

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

Aqui, você remove um registro de livro do banco de dados usando o destroy()método com a whereopção e passando o iddo livro a ser removido. Você vai remover o registro do livro cujo idigual a 2.

Salve e feche o arquivo.

Em seguida, execute o aplicativo:

node book.controller.js

Sua saída terá a seguinte aparência:

Output
Successfully deleted record.

O registro foi excluído.

Nesta etapa, você experimentou seu modelo de banco de dados e consulta de modelo. Você iniciou o banco de dados, criou modelos, inseriu registros, recuperou registros, recuperou registros com condições usando a wherecláusula e excluiu registros selecionados. Com esse conhecimento do Sequelize, você agora criará associações no Sequelize. Depois disso, você poderá definir e trabalhar com uma variedade de relacionamentos usando os modelos do Sequelize.

Passo 4 — Criando Associações Usando Sequelize

Nesta etapa, você usará os tipos de associação padrão que o Sequelize suporta: associações um para um , um para muitos e muitos para muitos . Você usará dados de amostra sobre alunos, cursos e níveis de escolaridade.

O Sequelize usa tipos de associação com base nos seguintes relacionamentos de banco de dados:

relacionamento um-para-um : Um relacionamento um-para-um significa que um registro em uma tabela está associado exatamente a um registro em outra tabela. Em termos de Sequelize, você pode usarbelongsTo()ehasOne()associações para criar esse tipo de relacionamento.

relacionamento um-para-muitos : Um relacionamento um-para-muitos significa que um registro em uma tabela está associado a vários registros em outra tabela. Com o Sequelize, você pode usarhasMany()métodos de associação para criar esse tipo de relacionamento.

relacionamento muitos para muitos : um relacionamento muitos para muitos significa que vários registros em uma tabela estão associados a vários registros em outra tabela. Com o Sequelize, você pode usarbelongsToMany()associações para criar esse tipo de relacionamento.

Antes de criar essas associações, você primeiro criará um novo banco de dados chamado student_dbe adicionará novos modelos e alguns dados de amostra para alunos, cursos e séries.

Para criar o banco de dados, siga o mesmo processo da Etapa 1 — Instalando e configurando o Sequelize para fazer login no MySQL e criar um banco de dados chamado student_db. Depois que o novo banco de dados for criado, saia do MySQL. Em seguida, você começará a criar associações de banco de dados.

Criando um relacionamento pessoal combelongsTo()

Nesta seção, você criará um relacionamento um para um usando os modelos do Sequelize. Imagine que você deseja obter os detalhes de um aluno junto com sua série. Como um aluno pode ter apenas uma série, esse tipo de associação é um relacionamento de um para um e você pode usar o belongsTo()método.

Nota: Há uma diferença entre belongsTo()e hasOne(). belongsTo()adicionará o foreignKeyna tabela de origem, enquanto hasOne()o adicionará à tabela de destino. De qualquer forma, se ambos os relacionamentos forem usados ​​ao mesmo tempo, funcionará como Sequelizar relacionamentos bidirecional um para um.

O belongsTo()método permite que você crie um relacionamento um para um entre dois modelos do Sequelize. Neste exemplo, você está usando os modelos Studente .Grade

Crie um novo arquivo chamado one_to_one.js. Como você fez na seção anterior, Conectando-se ao banco de dados MySQL , inclua as linhas para criar uma conexão com o banco de dados e autenticar seu usuário MySQL na parte superior do arquivo. Certifique-se de atualizar as credenciais do MySQL conforme necessário:

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

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

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

Nesta seção, você criará três modelos no novo student_dbbanco de dados: Student, Grade, e Course. Você começará criando os modelos Studente . GradeMais adiante nesta etapa, você criará o Coursesmodelo.

Para o Studentmodelo, adicione o seguinte bloco de código a one_to_one.js:

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

Este modelo de aluno contém duas colunas: student_ide name.

Em seguida, adicione um bloco de código para o Grademodelo:

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

O Grademodelo contém a coluna grade.

Para demonstrar as associações, você precisará adicionar dados de amostra ao banco de dados. Para isso, você usará o bulk()método. Em vez de inserir dados nas linhas uma a uma, o bulkCreate()método permite inserir várias linhas em seus modelos de banco de dados de uma só vez.

Agora, importe os dados Gradee Studentpara seus respectivos modelos no banco de dados, conforme mostrado:

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

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

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

Aqui, você fornece dados de amostra e importa os dados para os modelos Studente . GradeCom seu banco de dados, modelos e dados de amostra prontos, você está pronto para criar associações.

Em one-to-one.js, adicione a seguinte linha abaixo do student_databloco:

...
Student.belongsTo(Grade);

Em seguida, você precisará verificar se a associação está funcionando corretamente. Para fazer isso, você pode recuperar os dados de todos os alunos com níveis de notas associados passando o includeparâmetro dentro do findAll()método.

Como você precisa obter a nota do aluno, você passará Gradecomo modelo. No sequelize.sync()método, adicione as linhas destacadas conforme mostrado:

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

O código completo se parece com o seguinte:

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

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

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

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

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

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

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

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

Salve e feche seu arquivo.

Execute o arquivo usando o seguinte comando:

node one_to_one.js

A saída será longa e você verá os dados de todos os alunos com níveis de notas. Aqui está um trecho da saída mostrando os dados do aluno:

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

Dependendo das ferramentas de linha de comando que você está usando, a saída pode ser impressa como uma exibição expandida ou não. Se for uma visualização expandida, imprime o gradeobjeto expandido como saída.

Nesta seção, você criou um relacionamento um para um usando a Student.belongsTo(Grade);chamada de método e obteve os detalhes de acordo com a associação criada.

Criando um relacionamento de um para muitos comhasMany()

Nesta seção, você criará um relacionamento um-para-muitos usando modelos do Sequelize. Imagine que você gostaria de associar todos os alunos a uma série selecionada. Como uma série específica pode ter vários alunos, essa é uma relação de um para muitos.

Para começar, copie o conteúdo de one_to_one.jsem um novo arquivo chamado one_to_many.js. Em one_to_many.js, remova as linhas após o student_databloco. Seu one_to_many.jsarquivo ficará assim:

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

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

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

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

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

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

Após o student_databloqueio, use o hasMany()método para criar um novo relacionamento:

...
Grade.hasMany(Student)

O hasMany()método permite que você crie um relacionamento um-para-muitos entre dois modelos do Sequelize. Aqui, você está usando os modelos Gradee .Student

Em seguida, adicione o sequelize.sync()método com o findAll()método abaixo da hasMany()linha:

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

Aqui você está tentando acessar todos os alunos em uma série específica—neste caso, todos os alunos na série 9. Você também adicionou o Studentmodelo na includeopção.

Aqui está o código completo:

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

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

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

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

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

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

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

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

Salve e feche seu arquivo.

Execute o arquivo com o seguinte comando:

node one_to_many.js

A saída será semelhante à seguinte. Será bastante longo, mas todos os alunos da série 9serão devolvidos da seguinte forma:

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

Nesta seção, você criou um relacionamento um para muitos usando a Grade.hasMany(Student);chamada de método. Na saída, você recuperou os detalhes de acordo com a associação criada.

Criando relacionamentos muitos-para-muitos combelongsToMany()

Nesta seção, você criará relacionamentos muitos-para-muitos usando modelos do Sequelize. Como exemplo, imagine uma situação em que os alunos estão matriculados em cursos. Um aluno pode se matricular em vários cursos e um curso pode ter muitos alunos. Esta é uma relação de muitos para muitos. Para implementar isso usando o Sequelize, você usará os modelos Student, Coursee StudentCoursecom o belongsToMany()método .

Para começar, crie um arquivo chamado many_to_many.jse adicione os blocos de código de inicialização e autenticação do banco de dados da seguinte maneira. (Você pode reutilizar os blocos de código do one_to_many.jsexemplo anterior.) Certifique-se de atualizar os valores de conexão de banco de dados destacados conforme necessário.

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

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

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

Em seguida, você criará os modelos de banco de dados para relacionamentos muitos para muitos: Studente Course. Em seguida, você adicionará alguns dados de amostra a esses modelos.

...

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

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

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

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

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

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

Aqui, você cria os modelos e e fornece alguns dados de exemplo Student. CourseVocê também define um courseID, que será usado para recuperar alunos de acordo com esse tipo de relacionamento.

Por fim, você definiu um novo modelo chamado StudentCourse, que gerencia os dados de relacionamento entre Studente Course. Neste exemplo, studentId 1está inscrito em courseId 1e courseId 2.

Você concluiu a inicialização do banco de dados e adicionou dados de amostra ao banco de dados. Em seguida, crie relacionamentos muitos para muitos usando o belongsToMany()método conforme mostrado:

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

Dentro do belongsToMany()método, você passa a throughconfiguração com o nome do modelo como opção de configuração. Neste caso, é StudentCourse. Esta é a tabela que gerencia os relacionamentos muitos-para-muitos.

Por fim, você pode verificar se a associação está funcionando corretamente, recuperando todos os dados do curso com os alunos associados. Você fará isso passando o includeparâmetro dentro do findAll()método. Adicione as seguintes linhas a many_to_many.js:

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

O código completo se parece com o seguinte:

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

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

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

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

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

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

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

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

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

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

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

Salve e feche o arquivo.

Execute o arquivo usando o seguinte comando:

node many_to_many.js

A saída será longa, mas será algo semelhante ao seguinte:

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

Como você pode ver nesta saída, os cursos com alunos associados foram recuperados. Dentro do coursesbloco, você verá idvalores separados que indicam cada curso. Por exemplo, id: 1está conectado ao course_name: Sciencepara a aula de Ciências, enquanto id: 2é a aula de Matemática e assim por diante.

No banco de dados, você pode ver as três tabelas geradas com os dados de amostra inseridos.

Nesta etapa, você usou o Sequelize para criar associações um para um, um para muitos e muitos para muitos. Em seguida, você trabalhará com consultas brutas.

Etapa 5 — Trabalhando com consultas brutas

Nesta etapa, você trabalhará com consultas brutas no Sequelize. Nas etapas anteriores, você usou métodos internos do Sequelize, como insert()e findAll(), para manipular a inserção e a seleção de dados do banco de dados. Você deve ter notado que esses métodos seguem um padrão específico para escrever uma consulta. No entanto, com o uso de consultas brutas, você não precisa se preocupar com os métodos e padrões internos do Sequelize. Usando seu conhecimento de consultas SQL, você pode realizar uma variedade de consultas no Sequelize, das mais simples às mais avançadas.

Aqui está um exemplo de consultas brutas que realizam a ação de selecionar todos os valores de uma determinada tabela, excluindo os valores selecionados de acordo com a condição e atualizando a tabela com os valores fornecidos.

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

No Sequelize, consultas brutas podem ser usadas principalmente com duas metodologias: substituição de array e substituição de objeto. Ao passar valores para a consulta SQL, você pode usar uma matriz ou um objeto para fazer essa substituição.

Antes de escrever uma consulta bruta, primeiro você precisará fornecer os dados do aluno em um banco de dados de exemplo. Seguindo a seção anterior, Criando um banco de dados de exemplo , faça login no MySQL, crie um banco de dados chamado sample_student_dbe saia do MySQL.

Em seguida, você adicionará alguns dados brutos para começar a trabalhar com consultas brutas. Crie um novo arquivo chamado add_student_records.jse adicione os seguintes blocos de código, que contêm os métodos Sequelize discutidos anteriormente de authenticate(), sync()e bulkCreate().

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

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

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

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

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

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

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

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

Aqui, você inicia a conexão com o banco de dados, cria o modelo e insere alguns registros de alunos dentro do novo banco de dados.

Salve e feche o arquivo.

Em seguida, execute este script usando o seguinte comando:

node add_student_records.js

A saída será algo semelhante ao seguinte. Será bastante longo, mas todos os registros de alunos inseridos serão devolvidos da seguinte forma. Observe que, como student_idé um valor UUID ( Identificadores Universais Universais ) gerado automaticamente, ele será diferente dependendo do usuário.

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

…

Na próxima seção, você aplicará consultas brutas usando uma das student_idsaídas no bloco de código acima. Copie-o para baixo para que você o tenha nas próximas seções, onde você usará o query()método para substituições de arrays e objetos.

Substituição de matriz

Nesta seção, você usará o query()método para substituição de matriz. Com este método, o Sequelize pode executar consultas SQL brutas ou já preparadas.

Para começar, copie o conteúdo do server.jsarquivo da Etapa 1 , pois isso inclui o Sequelize()método de inicialização e a inicialização do banco de dados. Cole o conteúdo em um novo arquivo chamado array_raw_query.js. Atualize o nome do banco de dados para sample_student_db:

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

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

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

No final do arquivo, adicione o seguinte bloco de código para uma substituição de matriz, certificando-se de substituir REPLACE_STUDENT_IDpelo student_idvalor que você copiou na seção anterior.

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

Para substituição de array, você passa o query()método com a consulta SQL e o objeto de configuração. Ele contém o replacementsvalor e o tipo. ?Para substituições, você passa os dados como uma matriz e captura esses valores usando o símbolo de ponto de interrogação ( ).

Em seguida, como você precisa obter dados sobre um aluno específico, o student_idé passado como o segundo parâmetro. Depois disso, você passa o type: sequelize.QueryTypes.SELECTpar chave-valor, que pode ser usado para selecionar dados do banco de dados.

Existem alguns outros tipos também, como QueryTypes.UPDATEe QueryTypes.DELETE. Dependendo do requisito, você pode selecionar o tipo que se adequa à sua finalidade.

O seguinte mostra o bloco de código completo. Aqui você se conecta ao banco de dados e recupera os dados do aluno selecionado usando uma consulta bruta.

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

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

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

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

Salve e feche seu arquivo.

Em seguida, você pode executar este script usando o seguinte comando:

node array_raw_query.js

Você verá uma saída semelhante à seguinte:

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

Devido ao selecionado student_id, seus valores de saída podem diferir.

Substituição de objetos

Na superfície, a substituição de objetos é semelhante à substituição de matrizes, mas o padrão de passagem de dados para a consulta bruta é diferente. Na opção de substituição, você passa os dados como um objeto e, na opção de consulta, usa valores como :key.

Para começar, crie um novo arquivo chamado object_raw_query.jse cole os blocos de código completos do server.jsarquivo, atualizando o banco de dados para sample_student_db.

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

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

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

Em seguida, adicione o seguinte bloco de código ao final do novo object_raw_query.jsarquivo:

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

Aqui, você obtém dados de alunos selecionados usando o método de substituição de objetos. Você cria um replacementobjeto, definindo idcomo as informações do aluno que deseja recuperar: { id: 'REPLACE_STUDENT_ID' }.

No query(), você indica: 'SELECT * FROM students WHERE student_id = :id'. Usando o query()método, você passa o valor de substituição como um objeto, razão pela qual esse método é conhecido como substituição de objeto.

Aqui está o código completo:

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

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

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

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

Salve e feche o arquivo.

Em seguida, execute este script usando o seguinte comando:

node object_raw_query.js

A saída será semelhante à seguinte:

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

Devido ao selecionado student_id, seus valores de saída podem diferir.

Nesta etapa, você trabalhou com Sequelize consultas brutas usando duas metodologias diferentes: substituição de matriz e substituição de objeto.

Conclusão

Neste tutorial, você instalou e configurou o Sequelize. Você também criou e trabalhou com modelos, que é um dos componentes obrigatórios do Sequelize. Por fim, você criou diferentes tipos de associações e trabalhou com consultas brutas usando exemplos práticos.

Em seguida, você pode usar diferentes tipos de dados para criar modelos de banco de dados. Você também pode atualizar e excluir registros em bancos de dados com métodos internos e consultas brutas.

Fonte do artigo original em https://www.digitalocean.com

#sequelize #node #mysql #database 

Node.js Tutorials #4 - Node & MySQL - How to use Mysql database with Node.js

Node.js Tutorials #4 - Node & MySQL - How to use Mysql database with Node.js
Sample code in Node with writing SELECT, INSERT, UPDATE query with parameters

Node tutorials playlist - https://www.youtube.com/playlist?list=PLC8jf7P7lriyXGwAdPsmyBsZenxh-gJzl

00:00 Node & MySQL - Install MySQL
01:37 Node & MySQL - SELECT query
11:06 Node & MySQL - INSERT query
11:06 Node & MySQL - Multiple INSERT queries
21:59 Node & MySQL - UPDATE query
26:35 Node & MySQL - DELETE query

Basics of Node.js Tutorials #1 - Starting with Node - https://youtu.be/qO8X0t6YePE
Basics of Node.js Tutorials #2 - Node & Express - GET request - https://youtu.be/7Ryp2YeM_W8
Basics of Node.js Tutorials #3 - Node & Express - POST, PUT, DELETE request - https://youtu.be/3ItPpS_r2a8
Basics of Node.js Tutorials #4 - Node & MySQL - How to use Mysql database with Node.js - https://youtu.be/8Xdz0RP-kD4
Basics of Node.js Tutorials #5 - Node with Express & MySQL - Using Express with MySQL DB in Node.js - https://youtu.be/4DMxw123kw4
Node.js Tutorials #6 - Node & Express Middleware - Using Middleware with Express in Node.js - https://youtu.be/qch1mJQeYvU
Node.js Tutorials #7 - Node & Cookies - Using Cookes with Express in Node.js - Cookie-parser - https://youtu.be/Gm2VNzP4yok
Node.js Tutorials #8 - Node & JSONWebToken (JWT) - Using JSONWebToken (JWT) with Express in Node.js - https://youtu.be/UT1k0DYBBPk

#node.js #mysql #database #node

Toby Rogers

Toby Rogers

1658723700

How to Use Sequelize with MySQL

Learn how to install and configure Sequelize with MySQL. Using Sequelize to create databases and models, as well as perform the insert, select, delete operations and more 

Sequelize is a Node.js-based Object Relational Mapper that makes it easy to work with MySQL, MariaDB, SQLite, PostgreSQL databases, and more. An Object Relational Mapper performs functions like handling database records by representing the data as objects. Sequelize has a powerful migration mechanism that can transform existing database schemas into new versions. Overall, Sequelize provides excellent support for database synchronization, eager loading, associations, transactions, and database migrations while reducing development time and preventing SQL injections.

In this tutorial, you will install and configure Sequelize with MySQL on your local development environment. Next, you will use Sequelize to create databases and models, as well as perform the insert, select, and delete operations. Then, you will create Sequelize associations for one-to-one, one-to-many, and many-to-many relationships. Finally, you will create Sequelize raw queries for array and object replacements.

Read more https://www.digitalocean.com

#sequelize #node #mysql #database 

How to use MySQL using Node.js and Express – CRUD | XAMPP / PhpMyAdmin

In this video, you are going to learn how to use MySQL using Node.js and Express. We are going to create a very basic Beer API and have a look at how we can Get Records, Post Records, Delete Records and Update Records.

Support the channel by Subscribing and Liking this video

Source Files / Article: https://raddy.co.uk/blog/using-node-js-with-mysql-crud-xampp-phpmyadmin/

Introduction: (0:00)
Project Setup: (1:04)
Database Setup: (8:56)
MySQL - SELECT ALL: (15:14)
MySQL - SELECT BY ID: (26:09)
MySQL - DELETE BY ID: (28:40)
MySQL - INSERT: (32:01)
MySQL - INSERT: (38:00)
MySQL - BYE: (47:57)

SOCIAL: @RaddyTheBrand
🌍 Website: www.raddy.co.uk
📂GitHub: www.github.com/RaddyTheBrand
☕ Donate: www.buymeacoffee.com/RaddyTheBrand
🎴 Instagram: www.instagram.com/RaddyTheBrand
🐤 Twitter: www.twitter.com/RaddyTheBrand
📰 Newsletter: www.raddy.co.uk/newsletter

#mysql #node #node.js #crud #xampp #hpmyadmin