Sequelize в Node.js: Руководство

Предварительные условия

• На локальной машине разработки должны быть установлены Nodejs и MySQL . - Базовые знания объектов JavaScript, обещаний и типов данных.
• Хорошее понимание основных запросов MySQL и реляционных баз данных.

Примечание: обязательно добавьте путь к переменной среды PATH для Nodejs и MySQL.

Введение

Реляционные базы данных ( MySQL, PostgreSQL, MariaDB, Microsoft SQL Server, SQLite и т. д. ) используют SQL-запросы для управления данными. Эти запросы могут увеличить сложность и занять много времени. Кроме того, мы склонны забывать эти SQL-запросы. Поэтому мы используем инструмент ORM ( Object-Relational Mapping ), который сопоставляет объект javascript с необработанными SQL-запросами реляционной базы данных. Sequelize в nodejs — это объектно-реляционный преобразователь. Sequelize использует объекты javascript и обещания для взаимодействия с базой данных. Следовательно, Sequelize менее сложен, менее затратен по времени, быстр и прост в изучении. Здесь мы обсудим управление реляционными базами данных с помощью Sequelize в nodejs.

Особенности Sequelize

• Sequelize — это ORM-инструмент на основе обещаний, созданный для nodejs.
• Нам не нужно запоминать синтаксис запросов, поскольку Sequelize использует объект JavaScript .
• Sequelize поддерживает различные базы данных, например MySQL , PostgreSQL , MariaDB , Microsoft SQL Server , SQLite и т. д.

Установка и настройка Sequelize

Установка Sequelize

• Создайте новую папку с именем node-with-sequelize и перейдите в текущую папку node-with-sequelize с помощью CLI (интерфейса командной строки), как показано ниже:

mkdir node-with-sequelize
cd node-with-sequelize

• Инициализируйте проект Node, который создаст файл package.json внутри папки node-with-sequelize .

npm init -y

• Создайте файл с именем server.js внутри папки node-with-sequelize . Теперь структура папок будет выглядеть так, как показано ниже:

node-with-sequelize/
├─ server.js
├─ package.json

• Установите и сохраните пакет npm sequelize для sequelize ORM и драйвер mysql2 для базы данных MySQL.

npm install --save sequelize
npm install --save mysql2

Примечание: Существуют различные базы данных. Для этой статьи мы используем только базу данных MySQL. Однако мы можем использовать любую другую базу данных, установив соответствующие драйверы, как показано ниже:

• Для PostgreSQL, npm install --save pg pg-hstore # Postgres
• Для MySQL npm install --save mysql2
• Для MariaDB, npm install --save mariadb
• Для SQLite, npm install --save sqlite3
• Для Microsoft SQL Server npm install --save утомительно # Microsoft SQL Server

Создание образца базы данных

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

• Мы запустим следующую команду в командной строке и заменим USERNAME на имя пользователя вашей базы данных.

mysql -u USERNAME -p

• После запуска указанной выше команды MySQL запросит пароль. Итак, вводим пароль и нажимаем клавишу Enter .
• Мы создадим новую базу данных с именем sequelize_db и проверим, была ли создана база данных или нет.

mysql> CREATE DATABASE sequelize_db;
mysql> SHOW DATABASES;

• При запуске команды SHOW DATABASES появится список баз данных:

+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
| sequelize_db       |
| student_database   |
| world              |
+--------------------+

Примечание: Каждая команда SQL должна заканчиваться точкой с запятой и использовать QUIT для закрытия соединения с базой данных MySQL.

Подключение к базе данных MySQL

• Мы создадим файл с именем config.js и добавим следующий код в файл config.js . Вы назначите свое имя пользователя базы данных и пароль базы данных DATABASE_USERNAME и DATABASE_PASSWORD соответственно.

const DATABASE_NAME = 'sequelize_db'
const DATABASE_USERNAME = 'your_database_username'
const DATABASE_PASSWORD = 'your_database_password'

module.exports = {
    DATABASE_NAME,
    DATABASE_USERNAME,
    DATABASE_PASSWORD
}

• Теперь мы установим соединение между приложением node и базой данных MySQL с помощью Sequelize. Мы добавим следующий код в файл server.js .

const { Sequelize, DataTypes } = require('sequelize')
const { DATABASE_NAME,
    DATABASE_USERNAME,
    DATABASE_PASSWORD } = require('./config')

// Create an instance of sequelize
const sequelize =
    new Sequelize(DATABASE_NAME,
        DATABASE_USERNAME,
        DATABASE_PASSWORD, {
        host: 'localhost',
        dialect: 'mysql'
    })

// Validate and connect to the database
sequelize
    .authenticate()
    .then(() => console.log('Successfully connected to the database!'))
    .catch((error) => console.log('Failed to connect the database:', error))

• В приведенном выше блоке кода мы создаем экземпляр Sequelize для подключения нашего приложения node к базе данных MySQL. Также мы используем метод authenticate() для проверки учетных данных базы данных и проверки того, подключена ли база данных или нет.

Примечание: диалект может быть разным для разных баз данных. Это может быть MySQL, MariaDB, Postgres, mssql в зависимости от используемой нами базы данных.

Использование Sequelize для запросов к базе данных

• Мы создадим новый файл с именем studentDB.js внутри папки node-with-sequelize и базу данных с именем student_database .

mysql> CREATE DATABASE student_database 
const { Sequelize, DataTypes } = require('sequelize')
const { DATABASE_NAME,
    DATABASE_USERNAME,
    DATABASE_PASSWORD } = require('./config')

// Create an instance of sequelize
const sequelize =
    new Sequelize('student_database',
        DATABASE_USERNAME,
        DATABASE_PASSWORD, {
        host: 'localhost',
        dialect: 'mysql'
    })

// Validate and connect to the database
sequelize.authenticate()
    .then(() => console.log('Successfully connected to `student_database`!'))
    .catch((error) => console.log('Failed to connect `student_database`:', error))

• Мы добавляем указанный выше код в файл studentDB.js и подключаем student_database к нашему приложению Node.
• Теперь мы определим модель с именем student, используя метод define() , который делает имя модели множественным числом, и создадим таблицу с именем students в student_database . Мы добавляем следующий код в файл studentDB.js :

// Define the student model that creates a table in the `student_database`
const Student = sequelize.define('student', {
    firstName: DataTypes.STRING,
    lastName: DataTypes.STRING
})

• В приведенном выше блоке кода мы используем метод sequelize.define() для создания модели, представляющей таблицу и описывающей столбцы.

1. Вставка новой строки

• Мы создаем новый файл с именем addStudent.js внутри папки node-with-sequelize и добавляем следующий код в файл addStudent.js .

// Copy the code from `studentDB.js` and paste it here

// Synchronize database or model using sequelize.sync() or Student.sync()
sequelize.sync()
    .then(async () => {
        // Insert new row using `create()` method
        await Student.create({
            firstName: 'Modi',
            lastName: 'Singh'
        })
        console.log('Successfully added a new student!')
    })
    .catch((error) => console.log('Failed to synchronize with the database:', error))

• В приведенном выше блоке кода мы используем метод create() для добавления нового студента в таблицу студентов . Метод create() позволяет нам передавать данные о новом студенте в формате объекта.

2. Выбор всех строк

• Мы создаем файл с именем getStudents.js внутри папки node-with-sequelize и добавляем следующий код в файл getStudents.js

// Copy the code of `studentDB.js` here

// Synchronize database or model using sequelize.sync() or Student.sync()
sequelize.sync()
    .then(async () => {
        let students;
        // Select all rows using `findAll()` method
        students = await Student.findAll({raw:true})
        console.log('List of students', students)
    })
    .catch((error) => console.log('Failed to synchronize with the database', error))

• В приведенном выше блоке кода мы используем findAll() для извлечения всех студентов из таблицы студентов . Метод findAll() принимает необязательный объект для предоставления дополнительной информации.
• В приведенном выше примере мы используем свойство raw , которое принимает логическое значение: true или false . Когда мы устанавливаем raw в true , findall() не возвращает метаданные при возврате обещаний.

3. Выбор строки с использованием предложения where

• Мы создаем файл с именем getStudent.js и добавляем в него следующий код .

// Copy the code of `studentDB.js` here

// Synchronize database or model using sequelize.sync() or Student.sync()
sequelize.sync()
    .then(async () => {
        let student;
        // Select a row using `findOne()` method and where clause
        student = await Student.findOne({
            raw: true,
            where: { id: 1 }
        })
        console.log('Fetched one student', student)
    })
    .catch((error) => console.log('Failed to synchronize with the database', error))

• В приведенном выше блоке кода мы используем findOne() для извлечения студента по id . Однако мы также можем использовать firstName и lastName для извлечения студента. findOne() возвращает только первую запись, если в таблице есть дублирующая запись.

4. Удаление строки с использованием предложения where

• Мы создаем файл с именем removeStudent.js и добавляем в него следующий код .

// Copy the code of `studentDB.js` here         

// Synchronize database or model using sequelize.sync() or Student.sync()
sequelize.sync()
    .then(async () => {

        // Delete all rows using `destroy()` method and `where` clause
        await Student.destroy({ where: { id: 1 } })
        console.log('Deleted One student!')
    })
    .catch((error) => console.log('Failed to synchronize with the database', error))

• В приведенном выше блоке кода мы используем метод destroy() для удаления конкретного студента из таблицы students . Метод destroy() принимает необязательный объект для предоставления дополнительной информации. В приведенном выше примере мы используем свойство where для получения идентификатора студента и удаления студента из таблицы students .

5. Удаление всех строк

• Мы создаем файл с именем removeStudents.js и добавляем в него следующий код .

// Copy the code of `studentDB.js` here         

// Synchronize database or model using sequelize.sync() or Student.sync()
sequelize.sync()
    .then(async () => {
        // Delete all rows using `destroy()` method and set `truncate` to true
        await Student.destroy({ truncate: true })
        console.log('Deleted all students!')
    })
    .catch((error) => console.log('Failed to synchronize with the database', error))

• В приведенном выше примере мы используем свойство truncate , устанавливаем его в значение true и удаляем всех студентов из таблицы students .

Создание ассоциаций с использованием Sequelize

Sequelize имеет четыре метода для создания ассоциации между моделями: belongsTo() , hasOne() , hasMany() , belongsToMany() .

1. Отношения один к одному

• Рассмотрим, у нас есть выборка данных студентов и три уровня оценок: A , B и C. Каждый студент может иметь только одну оценку. Следовательно, это отношение один к одному.

const { Sequelize, DataTypes } = require('sequelize')
const { DATABASE_NAME,
    DATABASE_USERNAME,
    DATABASE_PASSWORD } = require('./config')

// Create an instance of sequelize
const sequelize =
    new Sequelize('student_database',
        DATABASE_USERNAME,
        DATABASE_PASSWORD, {
        host: 'localhost',
        dialect: 'mysql'
    })

// Validate and connect to the database
sequelize.authenticate()
    .then(() => console.log('Successfully connected to `student_database`!'))
    .catch((error) => console.log('Failed to connect `student_database`:', error))

// Define Student Model
const Student = sequelize.define('student', {
    id: { type: DataTypes.INTEGER, primaryKey: true },
    firstName: DataTypes.STRING,
    lastName: DataTypes.STRING,
});

// Define Grade Model
const Grade = sequelize.define('grade', {
    grade: {
        type: DataTypes.STRING
    }
})

// Students List
const students =
    [{ id: 1, firstName: 'Modi', lastName: 'Singh', gradeId: '1' },
    { id: 2, firstName: 'Suhani', lastName: 'Shah', gradeId: '3' },
    { id: 3, firstName: 'Abdul', lastName: 'Kalam', gradeId: '2' },
    { id: 4, firstName: 'Shahrukh', lastName: 'Khan', gradeId: '1' },
    { id: 5, firstName: 'Akshay', lastName: 'Kumar', gradeId: '3' }]

// Grades List
const grades = [{ grade: 'A' }, { grade: 'B' }, { grade: 'C' }]

// One to One Relationship using `hasOne()` method
Student.hasOne(Grade);

sequelize.sync({ force: true }).then(() => {
    // Create grades in bulk
    Grade.bulkCreate(grades, { validate: true }).then(() => {
        // Create students in bulk
        Student.bulkCreate(students, { validate: true }).then(() => {
            Student.findAll({ // find all students including their grades
                raw: true,
                include: [{
                    model: Grade
                }]
            }).then(response => {
                console.log(response)
            }).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);
});

• В приведенном выше примере мы используем метод hasOne() , который добавляет внешний ключ studentId к целевой модели Grade :

+-----------+--------------+------+-----+---------+----------------+
| Field     | Type         | Null | Key | Default | Extra          |
+-----------+--------------+------+-----+---------+----------------+
| id        | int          | NO   | PRI | NULL    | auto_increment |
| grade     | varchar(255) | YES  |     | NULL    |                |
| createdAt | datetime     | NO   |     | NULL    |                |
| updatedAt | datetime     | NO   |     | NULL    |                |
| studentId | int          | YES  | MUL | NULL    |                |
+-----------+--------------+------+-----+---------+----------------+

• Мы также можем использовать метод belongsTo() , который добавит внешний ключ gradeId к исходной модели Student :

+-----------+--------------+------+-----+---------+-------+
| Field     | Type         | Null | Key | Default | Extra |
+-----------+--------------+------+-----+---------+-------+
| id        | int          | NO   | PRI | NULL    |       |
| firstName | varchar(255) | YES  |     | NULL    |       |
| lastName  | varchar(255) | YES  |     | NULL    |       |
| createdAt | datetime     | NO   |     | NULL    |       |
| updatedAt | datetime     | NO   |     | NULL    |       |
| gradeId   | int          | YES  | MUL | NULL    |       |
+-----------+--------------+------+-----+---------+-------+

2. Отношение «один ко многим»

• Опять же, рассмотрим ту же выборку студентов и три уровня оценок: A , B и C. Мы можем дать одну оценку нескольким студентам. Следовательно, это отношение «один ко многим».

const { Sequelize, DataTypes } = require('sequelize')
const { DATABASE_NAME,
    DATABASE_USERNAME,
    DATABASE_PASSWORD } = require('./config')

// Create an instance of sequelize
const sequelize =
    new Sequelize('student_database',
        DATABASE_USERNAME,
        DATABASE_PASSWORD, {
        host: 'localhost',
        dialect: 'mysql'
    })

// Validate and connect to the database
sequelize.authenticate()
    .then(() => console.log('Successfully connected to `student_database`!'))
    .catch((error) => console.log('Failed to connect `student_database`:', error))

// Define Student Model
const Student = sequelize.define('student', {
    id: { type: DataTypes.INTEGER, primaryKey: true },
    firstName: DataTypes.STRING,
    lastName: DataTypes.STRING,
});

// Define Grade Model
const Grade = sequelize.define('grade', {
    grade: {
        type: DataTypes.STRING
    }
})

// Students List
const students =
    [{ id: 1, firstName: 'Modi', lastName: 'Singh', gradeId: '1' },
    { id: 2, firstName: 'Suhani', lastName: 'Shah', gradeId: '3' },
    { id: 3, firstName: 'Abdul', lastName: 'Kalam', gradeId: '2' },
    { id: 4, firstName: 'Shahrukh', lastName: 'Khan', gradeId: '1' },
    { id: 5, firstName: 'Akshay', lastName: 'Kumar', gradeId: '3' }]

// Grades List
const grades = [{ grade: 'A' }, { grade: 'B' }, { grade: 'C' }]

// One-to-Many Relationship
Grade.hasMany(Student);

sequelize.sync({ force: true }).then(() => {
    // Create grades in bulk
    Grade.bulkCreate(grades, { validate: true }).then(() => {
        // Create students in bulk
        Student.bulkCreate(students, { validate: true }).then(() => {
            Grade.findAll({ // find all students by selecting a particular grade
                raw: true,
                where: { grade: 'A' },
                include: [{
                    model: Student
                }]
            }).then(response => {
                console.log(response)
            }).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);
});

• В приведенном выше примере мы используем метод hasMany() , который добавляет внешний ключ gradeId к целевой модели Student :

+-----------+--------------+------+-----+---------+-------+
| Field     | Type         | Null | Key | Default | Extra |
+-----------+--------------+------+-----+---------+-------+
| id        | int          | NO   | PRI | NULL    |       |
| firstName | varchar(255) | YES  |     | NULL    |       |
| lastName  | varchar(255) | YES  |     | NULL    |       |
| createdAt | datetime     | NO   |     | NULL    |       |
| updatedAt | datetime     | NO   |     | NULL    |       |
| gradeId   | int          | YES  | MUL | NULL    |       |
+-----------+--------------+------+-----+---------+-------+

Отношение «многие ко многим»

• Рассмотрим, у нас есть три модели: Student , Course и Enrollment . Любой студент может записаться на любой курс. Поэтому у нас есть отношения многие-ко-многим.

const { Sequelize, DataTypes } = require('sequelize')
const { DATABASE_NAME,
    DATABASE_USERNAME,
    DATABASE_PASSWORD } = require('./config')

// Create an instance of sequelize
const sequelize =
    new Sequelize('student_database',
        DATABASE_USERNAME,
        DATABASE_PASSWORD, {
        host: 'localhost',
        dialect: 'mysql'
    })

// Validate and connect to the database
sequelize.authenticate()
    .then(() => console.log('Successfully connected to `student_database`!'))
    .catch((error) => console.log('Failed to connect `student_database`:', error))

// Define Course Model
const Course = sequelize.define('course', {
    courseName: {
        type: DataTypes.STRING
    }
})

// Define Student Model
const Student = sequelize.define('student', {
    id: { type: DataTypes.INTEGER, primaryKey: true },
    firstName: DataTypes.STRING,
    lastName: DataTypes.STRING,
});

//Student's enrollment in the courses
const Enrollment = sequelize.define('enrollment', {
    id: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true
    }
})

// Students List
const students =
    [{ id: 1, firstName: 'Modi', lastName: 'Singh' },
    { id: 2, firstName: 'Suhani', lastName: 'Shah' },
    { id: 3, firstName: 'Abdul', lastName: 'Kalam' },
    { id: 4, firstName: 'Shahrukh', lastName: 'Khan' },
    { id: 5, firstName: 'Akshay', lastName: 'Kumar' }]

// Courses List
const courses =
    [{ courseName: 'NodeJS' },
    { courseName: 'MySQL Database' },
    { courseName: 'Sequelize ORM' }]

// Enrollments 
const enrollments = [
    { courseId: 1, studentId: 5 },
    { courseId: 3, studentId: 3 },
    { courseId: 3, studentId: 1 },
    { courseId: 1, studentId: 4 },
    { courseId: 2, studentId: 2 },
]
// Many-to-many Relationship
Course.belongsToMany(Student, { through: Enrollment });
Student.belongsToMany(Course, { through: Enrollment });

sequelize.sync({ force: true }).then(() => {
    Course.bulkCreate(courses, { validate: true }).then(() => {
        Student.bulkCreate(students, { validate: true }).then(() => {
            Enrollment.bulkCreate(enrollments, { validate: true }).then(() => {
                Course.findAll({
                    raw: true,
                    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 the table : ', error);
});

• В приведенном выше примере мы устанавливаем связь между моделью Student и моделью Course через модель Enrollment . Мы используем метод belongsToMany() , который добавляет внешний ключ courseId и studentId к модели Enrollment .

+-----------+----------+------+-----+---------+----------------+
| Field     | Type     | Null | Key | Default | Extra          |
+-----------+----------+------+-----+---------+----------------+
| id        | int      | NO   | PRI | NULL    | auto_increment |
| createdAt | datetime | NO   |     | NULL    |                |
| updatedAt | datetime | NO   |     | NULL    |                |
| courseId  | int      | YES  | MUL | NULL    |                |
| studentId | int      | YES  | MUL | NULL    |                |
+-----------+----------+------+-----+---------+----------------+

Работа с необработанными запросами

1. Заполнение таблицы с помощью bulkCreate()

const { Sequelize, DataTypes } = require('sequelize')

// Create Sequilize Instance
const sequelize = new Sequelize('student_database', 'DATABASE_USERNAME', 'DATABASE_PASSWORD', {
    host: 'localhost',
    dialect: 'mysql',
})

// Establish The Connection
sequelize.authenticate().then(() => {
    console.log('App is successfully connected to the database.');
}).catch((error) => {
    console.error('OOPS! Failed to connect', error);
});

// Define Student Model
const Student = sequelize.define('student', {
    id: { type: DataTypes.INTEGER, primaryKey: true },
    firstName: DataTypes.STRING,
    lastName: DataTypes.STRING,
});

// Student data
const students =
    [{ id: 1, firstName: 'Modi', lastName: 'Singh' },
    { id: 2, firstName: 'Suhani', lastName: 'Shah' },
    { id: 3, firstName: 'Abdul', lastName: 'Kalam' },
    { id: 4, firstName: 'Shahrukh', lastName: 'Khan' },
    { id: 5, firstName: 'Akshay', lastName: 'Kumar' }]

// Populate table with data
sequelize.sync().then(() => {
    // Add students in bulk
    Student.bulkCreate(students, { validate: true }).then(() => {
        console.log("Students are added to database");
    }).catch((error) => {
        console.log(error);
    });
});

В приведенном выше блоке кода мы используем метод bulkCreate() для добавления нескольких строк. bulkCreate() принимает два параметра: массив данных о студентах и ​​необязательный объект для передачи дополнительной информации.

2. Замена массива

const { Sequelize, DataTypes } = require('sequelize')
const { DATABASE_NAME,
    DATABASE_USERNAME,
    DATABASE_PASSWORD } = require('./config')

// Create an instance of sequelize
const sequelize =
    new Sequelize('student_database',
        DATABASE_USERNAME,
        DATABASE_PASSWORD, {
        host: 'localhost',
        dialect: 'mysql'
    })

// Validate and connect to the database
sequelize.authenticate()
    .then(() => console.log('Successfully connected to `student_database`!'))
    .catch((error) => console.log('Failed to connect `student_database`:', error))

// Use `SELECT` Query With un-named
sequelize.query('SELECT * FROM students WHERE firstName = ?', {
    replacements: ['Abdul'], type: sequelize.QueryTypes.SELECT
})
    .then((response) => {
        console.log(response)
    })
    .catch((err) => {
        console.log(err)
    })

В приведенном выше блоке кода мы используем сырой запрос MySQL с Sequelize. Символ ? используется для извлечения данных о студентах и ​​будет заменен массивом, переданным свойству replacements .

3. Замена объекта

const { Sequelize, DataTypes } = require('sequelize')
const { DATABASE_NAME,
    DATABASE_USERNAME,
    DATABASE_PASSWORD } = require('./config')

// Create an instance of sequelize
const sequelize =
    new Sequelize('student_database',
        DATABASE_USERNAME,
        DATABASE_PASSWORD, {
        host: 'localhost',
        dialect: 'mysql'
    })

// Validate and connect to the database
sequelize.authenticate()
    .then(() => console.log('Successfully connected to `student_database`!'))
    .catch((error) => console.log('Failed to connect `student_database`:', error))

// Use `SELECT` Query With named parameters
sequelize.query('SELECT * FROM students WHERE firstName = :name', {
    replacements: {name:'Abdul'}, type: sequelize.QueryTypes.SELECT
})
    .then((response) => {
        console.log(response)
    })
    .catch((err) => {
        console.log(err)
    })

В приведенном выше блоке кода мы используем ключ :name для извлечения данных о студентах. :name будет заменен ключом объекта, переданного свойству replacements .

Примеры

Определение модели Sequelize

• Модель в Sequelize создает таблицу в базе данных, которая содержит строки и столбцы. В приведенном выше блоке кода sequelize является экземпляром Sequelize ORM. .define() содержит три параметра:

Синтаксис

    sequelize.define('model_name',attributes_typeobject,others_typeObject)

• Имя модели: Создает новую таблицу в базе данных, содержащую строки и столбцы. Это должна быть строка.
• Атрибуты: создает поля в столбце со своими типами данных и другими параметрами. Это должен быть объект
• Другое: содержит любые другие необязательные параметры и является типом объекта.
• Рассмотрим, мы хотим создать таблицу студентов, которая содержит столбцы: id , firstName , и lastName . Итак, мы создаем файл с именем student.model.js и добавляем следующий код в файл student.model.js

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

// Create Sequelize Instance
const sequelize = new Sequelize(
    'student_database',
    'DATABASE_USERNAME',
    'DATABASE_PASSWORD',
    {
        host: 'localhost',
        dialect: 'mysql'
    }
);

// Establish The Connection
sequelize.authenticate().then(() => {
    console.log('App is successfully connected to the database.');
}).catch((error) => {
   console.error('OOPS! Failed to connect', error);
});

// Define Student Model
const Student = sequelize.define('student',{
    id: DataTypes.INTEGER,
    firstName: Datatypes.STRING,
    lastName:DataTypes.STRING
});

// Createa table in Database
sequeliz e.sync().then(() => {
    console.log('Created the student table successfully');
}).catch((error) => {
    console.error('Operatioununsuccessfull:', error);
});

Вывод При запуске команды node student.model имя модели будет преобразовано во множественное число, а в базе данных student_database будет создана таблица с именем students .

$ node student.model
Executing (default): SELECT 1+1 AS result
Executing (default): DROP TABLE IF EXISTS `students`;
The app is successfully connected to the database.
Executing (default): CREATE TABLE IF NOT EXISTS `students` (`id` INTEGER , `firstName` VARCHAR(255), `lastName` VA
RCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL, PRIMARY KEY (`id`)) ENGINE=InnoDB;      
Executing (default): SHOW INDEX FROM `students`
Created the student table successfully

В student_database будет создана таблица студентов , как показано ниже:

mysql> DESC students;
+-----------+-------------+------+-----+---------+-------+
| Field     | Type        | Null | Key | Default | Extra |
+-----------+-------------+------+-----+---------+-------+
| id        | int         | NO   | PRI | NULL    |       |
| firstName | varchar(255)| YES  |     | NULL    |       |
| lastName  | varchar(255)| YES  |     | NULL    |       |
| createdAt | datetime    | NO   |     | NULL    |       |
| updatedAt | datetime    | NO   |     | NULL    |       |
+-----------+-------------+------+-----+---------+-------+

Таблица сброса Sequelize

• Мы используем метод .drop() для удаления таблицы из базы данных.
• Мы создадим файл с именем student.drop.js и добавим следующий код в файл student.drop.js

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

// Create Sequelize Instance
const sequelize = new Sequelize(
    'student_database',
    'DATABASE_USERNAME',
    'DATABASE_PASSWORD',
    {
        host: 'localhost',
        dialect: 'mysql'
    }
);

// Establish The Connection
sequelize.authenticate().then(() => {
    console.log('App is successfully connected to the database.');
}).catch((error) => {
   console.error('OOPS! Failed to connect', error);
});

// Define Student Model
const Student = sequelize.define('student',{
    id: DataTypes.INTEGER,
    firstName:Datatypes.STRING,
    lastName:DataTypes.STRING
});

// Drop Model from Database
sequelize.drop().then(() => {
    console.log('Deleted the students table successfully);
}).catch((error) => {
    console.error('Operation unsuccesful:', error);
});

Вывод При запуске команды node student.drop она удалит таблицу students из student_databse .

$ node student.drop
Executing (default): SELECT 1+1 AS result
Executing (default): DROP TABLE IF EXISTS `students`;
App is successfully connected to the database.
Deleted thstudent'sts table successfully

Sequelize bulkСоздать

• Мы используем метод bulkCreate() для одновременного добавления нескольких строк.
• Мы создадим файл с именем student.bulkCreate.js и добавим в файл student.bulkCreate.js следующий код .

const { Sequelize, DataTypes } = require('sequelize')
const { DATABASE_NAME, DATABASE_PASSWORD } = require('./config')

// Create Sequilize Instance
const sequelize = new Sequelize('student_database', DATABASE_NAME, DATABASE_PASSWORD, {
    host: 'localhost',
    dialect: 'mysql',
})

// Establish The Connection
sequelize.authenticate().then(() => {
    console.log('App is successfully connected to the database.');
}).catch((error) => {
    console.error('OOPS! Failed to connect', error);
});

// Define Student Model
const Student = sequelize.define('student', {
    id: { type: DataTypes.INTEGER, primaryKey: true },
    firstName: DataTypes.STRING,
    lastName: DataTypes.STRING,
});

// Populate with data
const students =
    [{ id: 1, firstName: 'Modi', lastName: 'Singh' },
    { id: 2, firstName: 'Suhani', lastName: 'Shah' },
    { id: 3, firstName: 'Abdul', lastName: 'Kalam' },
    { id: 4, firstName: 'Shahrukh', lastName: 'Khan' },
    { id: 5, firstName: 'Akshay', lastName: 'Kumar' }]

// Sync, bulk create, validate and Close The Connection
sequelize.sync().then(() => {
    Student.bulkCreate(students, { validate: true }).then(() => {
        console.log("Students are added to database");
    }).catch((error) => {
        console.log(error);
    });
});

Вывод При запуске команды node student.bulkCreate данные о студентах будут добавлены в таблицу students базы данных student_database .

+----+-----------+----------+---------------------+---------------------+
| id | firstName | lastName | createdAt           | updatedAt           |
+----+-----------+----------+---------------------+---------------------+
|  1 | Modi      | Singh    | 2022-10-23 06:35:17 | 2022-10-23 06:35:17 |
|  2 | Suhani    | Shah     | 2022-10-23 06:35:17 | 2022-10-23 06:35:17 |
|  3 | Abdul     | Kalam    | 2022-10-23 06:35:17 | 2022-10-23 06:35:17 |
|  4 | Shahrukh  | Khan     | 2022-10-23 06:35:17 | 2022-10-23 06:35:17 |
|  5 | Akshay    | Kumar    | 2022-10-23 06:35:17 | 2022-10-23 06:35:17 |
+----+-----------+----------+---------------------+---------------------+

Sequelize findOne

• Мы используем метод findOne() для получения одной строки по id .
• Мы создадим файл с именем student.findOne.js и добавим в него следующий код .

const { Sequelize, DataTypes } = require('sequelize')
const { DATABASE_NAME, DATABASE_PASSWORD } = require('./config')

// Create Sequilize Instance
const sequelize = new Sequelize('student_database', DATABASE_NAME, DATABASE_PASSWORD, {
    host: 'localhost',
    dialect: 'mysql',
})

//Validate and Establish The Connection
sequelize.authenticate().then(() => {
    console.log('App is successfully connected to the database.');
}).catch((err) => {
    console.error('Oops! Failed to Connect', err);
})

// Define Student Model
const Student = sequelize.define('student', {
    id: { type: DataTypes.INTEGER, primaryKey: true },
    firstName: DataTypes.STRING,
    lastName: DataTypes.STRING,
});

// Find Student By Id
Student.findOne({ where: { id: 3 } }).then((student) => {
    console.log(student.get());
}).catch((err) => {
    console.error('Something went wrong:', err);
});

Выход

$ node student.findone
Executing (default): SELECT 1+1 AS result
Executing (default): SELECT `id`, `firstName`, `lastName
`, `createdAt`, `updatedAt` FROM `students` AS `student`
 WHERE `student`.`id` = 3;
App is successfully connected to the database.
{
  id: 3,
  firstName: 'Abdul',
  lastName: 'Kalam',
  createdAt: 2022-10-20T05:56:22.000Z,
  updatedAt: 2022-10-20T05:56:22.000Z
}

Sequelize с Async, Await

const { Sequelize, DataTypes } = require('sequelize')
const { DATABASE_NAME, DATABASE_PASSWORD } = require('./config')

// Create Sequilize Instance
const sequelize = new Sequelize('student_database', DATABASE_NAME, DATABASE_PASSWORD, {
    host: 'localhost',
    dialect: 'mysql',
})

//Validate and Establish The Connection
sequelize.authenticate().then(() => {
    console.log('App is successfully connected to the database.');
}).catch((err) => {
    console.error('Oops! Failed to Connect', err);
})

// Define Student Model
const Student = sequelize.define('student', {
    id: { type: DataTypes.INTEGER, primaryKey: true },
    firstName: DataTypes.STRING,
    lastName: DataTypes.STRING,
});

// Get Students By Id
async function getStudentById() {
    let student = await Student.findOne({where:{id:3}});
    console.log(student.get());
}

getStudentById();

Выход

$ node student.findoneasync
Executing (default): SELECT 1+1 AS result
Executing (default): SELECT `id`, `firstName`, `lastName`, `createdAt`, `updatedAt` FROM 
`students` AS `student` WHERE `student`.`id` = 3;
App is successfully connected to the database.
{
  id: 3,
  firstName: 'Abdul',
  lastName: 'Kalam',
  createdAt: 2022-10-20T05:56:22.000Z,
  updatedAt: 2022-10-20T05:56:22.000Z
}

Количество секвенций

• Мы используем метод count(), чтобы получить количество строк в таблице.
• Мы создадим файл с именем countRow.js и добавим в него следующий код .

const { Sequelize, DataTypes } = require('sequelize')
const { DATABASE_NAME, DATABASE_PASSWORD } = require('./config')

// Create Sequilize Instance
const sequelize = new Sequelize('student_database', DATABASE_NAME, DATABASE_PASSWORD, {
    host: 'localhost',
    dialect: 'mysql',
})

//Validate and Establish The Connection
sequelize.authenticate().then(() => {
    console.log('App is successfully connected to the database.');
}).catch((err) => {
    console.error('Oops! Failed to Connect', err);
})

// Define Student Model
const Student = sequelize.define('student', {
    id: { type: DataTypes.INTEGER, primaryKey: true },
    firstName: DataTypes.STRING,
    lastName: DataTypes.STRING,
});

// Count no. of rows
Student.count()
    .then((res) => console.log(`There are ${res} rows in students table.`))
    .catch((err) => console.error(err))

Выход

$ node Countrow
Executing (default): SELECT 1+1 AS result
Executing (default): SELECT count(*) AS `count` FROM `st
udents` AS `student`;
App is successfuly connected to the database.
There are 5 rostudents'udents table.

Sequelize Удалить строку

• Мы используем метод destroy() для удаления строки с использованием id .
• Мы создадим файл с именем student.delete.js и добавим в него следующий код .

const { Sequelize, DataTypes } = require('sequelize')
const { DATABASE_NAME, DATABASE_PASSWORD } = require('./config')

// Create Sequilize Instance
const sequelize = new Sequelize('student_database', DATABASE_NAME, DATABASE_PASSWORD, {
    host: 'localhost',
    dialect: 'mysql',
})

//Validate and Establish The Connection
sequelize.authenticate().then(() => {
    console.log('App is successfully connected to the database.');
}).catch((err) => {
    console.error('Oops! Failed to Connect', err);
})

// Define Student Model
const Student = sequelize.define('student', {
    id: { type: DataTypes.INTEGER, primaryKey: true },
    firstName: DataTypes.STRING,
    lastName: DataTypes.STRING,
});

// Delete Student Row By Id
Student.destroy({ where: { id: 5 } })
    .then(() => {
        console.log('Row with selected id is deleted successfully.');
    })
    .catch((err) => {
        console.log(err);
    })

Выход

$ node student.delete
Executing (default): SELECT 1+1 AS result
Executing (default): DELETE FROM `students` WHERE `id` = 5
App is successfuly connected to the database.
Row with selected id is deleted successfully.

Sequelize Обновление строки

• Мы используем метод update() для обновления строки с использованием id .
• Мы создадим файл с именем student.update.js и добавим в него следующий код .

const { Sequelize, DataTypes } = require('sequelize')
const { DATABASE_NAME, DATABASE_PASSWORD } = require('./config')

// Create Sequilize Instance
const sequelize = new Sequelize('student_database', DATABASE_NAME, DATABASE_PASSWORD, {
    host: 'localhost',
    dialect: 'mysql',
})

//Validate and Establish The Connection
sequelize.authenticate().then(() => {
    console.log('App is successfully connected to the database.');
}).catch((err) => {
    console.error('Oops! Failed to Connect', err);
})

// Define Student Model
const Student = sequelize.define('student', {
    id: { type: DataTypes.INTEGER, primaryKey: true },
    firstName: DataTypes.STRING,
    lastName: DataTypes.STRING,
});

// Delete Student Row By Id
Student.update({ firstName: 'Rampal', lastName: 'Yadav' },
    { where: { id: 5 } })
    .then((response) => {
        console.log(`Student with ${response.id} row is updated`);
    })
    .catch((error) => {
        console.log(err);
    })

Выход

$ node student.update
Executing (default): SELECT 1+1 AS result
Executing (default): UPDATE `students` SET `firstName`=?,`lastName`=?,`updatedAt`=? WHERE
 `id` = ?
App is successfully connected to the database.
1 row is affected

Sequelize findAll

• Мы используем findAll() для получения данных из всех строк.
• Мы создадим файл с именем student.findAll.js и добавим в него следующий код .

const { Sequelize, DataTypes } = require('sequelize')
const { DATABASE_NAME, DATABASE_PASSWORD } = require('./config')

// Create Sequilize Instance
const sequelize = new Sequelize('student_database', DATABASE_NAME, DATABASE_PASSWORD, {
    host: 'localhost',
    dialect: 'mysql',
})

//Validate and Establish The Connection
sequelize.authenticate().then(() => {
    console.log('App is successfully connected to the database.');
}).catch((err) => {
    console.error('Oops! Failed to Connect', err);
})

// Define Student Model
const Student = sequelize.define('student', {
    id: { type: DataTypes.INTEGER, primaryKey: true },
    firstName: DataTypes.STRING,
    lastName: DataTypes.STRING,
});

// Find All Students
Student.findAll({ raw: true })
    .then((rows) => {
        console.log('List of All Students:', rows)
    })
    .catch((err) => {
        console.log(err)
    })

Вывод:

$ node student.findall
Executing (default): SELECT 1+1 AS result
Executing (default): SELECT `id`, `firstName`, `lastName`, `createdAt`, `updatedAt` FROM 
`students` AS `student`;
App is successfully connected to the database.
List of All Students: [
  {
    id: 1,
    firstName: 'Modi',
    lastName: 'Singh',
    createdAt: 2022-10-20T05:56:22.000Z,
    updatedAt: 2022-10-20T05:56:22.000Z
  },
  {
    id: 2,
    firstName: 'Suhani',
    lastName: 'Shah',
    createdAt: 2022-10-20T05:56:22.000Z,
    updatedAt: 2022-10-20T05:56:22.000Z
  },
  {
    id: 3,
    firstName: 'Abdul',
    lastName: 'Kalam',
    createdAt: 2022-10-20T05:56:22.000Z,
    updatedAt: 2022-10-20T05:56:22.000Z
  },
  {
    id: 4,
    firstName: 'Shahrukh',
    lastName: 'Khan',
    createdAt: 2022-10-20T05:56:22.000Z,
    updatedAt: 2022-10-20T05:56:22.000Z
  },
  {
    id: 5,
    firstName: 'Akshay',
    lastName: 'Kumar',
    createdAt: 2022-10-20T05:56:22.000Z,
    updatedAt: 2022-10-20T05:56:22.000Z
  }
]

Sequelize Select Columns с атрибутами

• Мы передаем значение свойству attribute с помощью findAll() и находим строку с определенным полем столбца.
• Мы создадим файл с именем student.findAllColAttr.js и добавим следующий код в файл student.findAllColAttr.js .

const { Sequelize, DataTypes } = require('sequelize')
const { DATABASE_NAME, DATABASE_PASSWORD } = require('./config')

// Create Sequilize Instance
const sequelize = new Sequelize('student_database', DATABASE_NAME, DATABASE_PASSWORD, {
    host: 'localhost',
    dialect: 'mysql',
})

//Validate and Establish The Connection
sequelize.authenticate().then(() => {
    console.log('App is successfully connected to the database.');
}).catch((err) => {
    console.error('Oops! Failed to Connect', err);
})

// Define Student Model
const Student = sequelize.define('student', {
    id: { type: DataTypes.INTEGER, primaryKey: true },
    firstName: DataTypes.STRING,
    lastName: DataTypes.STRING,
});

// Find All Students
Student.findAll({ attributes: ['id', 'lastName'], raw: true })
    .then((rows) => {
        console.log('List of All Students:', rows)
    })
    .catch((err) => {
        console.log(err)
    })

Вывод:

$ node student.findAllColAttr
Executing (default): SELECT 1+1 AS result
Executing (default): SELECT `id`, `firstName` FROM `students` AS `student`;
App is successfully connected to the database.
List of All Students: [
  { id: 1, firstName: 'Modi' },
  { id: 2, firstName: 'Suhani' },
  { id: 3, firstName: 'Abdul' },
  { id: 4, firstName: 'Shahrukh' },
  { id: 5, firstName: 'Akshay' }
]

Sequelize Order By Clause

• Мы будем использовать свойство order с findAll() для получения всех строк в частичном использовании. Мы передаем значение свойству attribute с помощью findAll() rowsd для получения всех строк с определенным полем столбца.
• Мы создадим файл с именем student.orderByClause.js и добавим следующий код в файл student.orderByClause.js .

const { Sequelize, DataTypes } = require('sequelize')
const { DATABASE_NAME, DATABASE_PASSWORD } = require('./config')

// Create Sequilize Instance
const sequelize = new Sequelize('student_database', DATABASE_NAME, DATABASE_PASSWORD, {
    host: 'localhost',
    dialect: 'mysql',
})

//Validate and Establish The Connection
sequelize.authenticate().then(() => {
    console.log('App is successfully connected to the database.');
}).catch((err) => {
    console.error('Oops! Failed to Connect', err);
})

// Define Student Model
const Student = sequelize.define('student', {
    id: { type: DataTypes.INTEGER, primaryKey: true },
    firstName: DataTypes.STRING,
    lastName: DataTypes.STRING,
});

// Find All Students in Order By Clause
Student.findAll({ order: [['firstName', 'ASC']], raw: true })
    .then((rows) => {
        console.log('List of All Students:', rows)
    })
    .catch((err) => {
        console.log(err)
    })

Вывод

$ node student.orderByClause
Executing (default): SELECT 1+1 AS result
Executing (default): SELECT `id`, `firstName`, `lastName`, `createdAt`, `updatedAt` FROM 
`students` AS `student` ORDER BY `student`.`firstName` ASC;
App is successfully connected to the database.
List of All Students: [
  {
    id: 3,
    firstName: 'Abdul',
    lastName: 'Kalam',
    createdAt: 2022-10-20T05:56:22.000Z,
    updatedAt: 2022-10-20T05:56:22.000Z
  },
  {
    id: 5,
    firstName: 'Akshay',
    lastName: 'Kumar',
    createdAt: 2022-10-20T05:56:22.000Z,
    updatedAt: 2022-10-20T05:56:22.000Z
  },
  {
    id: 1,
    firstName: 'Modi',
    lastName: 'Singh',
    createdAt: 2022-10-20T05:56:22.000Z,
    updatedAt: 2022-10-20T05:56:22.000Z
  },
  {
    id: 4,
    firstName: 'Shahrukh',
    lastName: 'Khan',
    createdAt: 2022-10-20T05:56:22.000Z,
    updatedAt: 2022-10-20T05:56:22.000Z
  },
  {
    id: 2,
    firstName: 'Suhani',
    lastName: 'Shah',
    createdAt: 2022-10-20T05:56:22.000Z,
    updatedAt: 2022-10-20T05:56:22.000Z
  }
]
    id: 3,
    firstName: 'Abdul',
    lastName: 'Kalam',
    createdAt: 2022-10-20T05:56:22.000Z,
    updatedAt: 2022-10-20T05:56:22.000Z
  },
  {
    id: 5,
    firstName: 'Akshay',
    lastName: 'Kumar',
    createdAt: 2022-10-20T05:56:22.000Z,
    updatedAt: 2022-10-20T05:56:22.000Z
  },
  {
    id: 6,
    firstName: 'Lunar',
    lastName: 'Singh',
    createdAt: 2022-10-20T15:35:29.000Z,
    updatedAt: 2022-10-20T15:35:29.000Z
  },
  {
    id: 1,
    firstName: 'Modi',
    lastName: 'Singh',
    createdAt: 2022-10-20T05:56:22.000Z,
    updatedAt: 2022-10-20T05:56:22.000Z
  },
  {
    id: 14,
    firstName: 'Praiksha',
    firstName: 'Shahrukh',
    lastName: 'Khan',
    createdAt: 2022-10-20T05:56:22.000Z,
    updatedAt: 2022-10-20T05:56:22.000Z
  },
  {
    id: 2,
    firstName: 'Suhani',
    lastName: 'Shah',
    createdAt: 2022-10-20T05:56:22.000Z,
    updatedAt: 2022-10-20T05:56:22.000Z
  }
]

Заключение

• Sequelize — сторонний пакет, который использует объект для создания таблицы в базе данных.
• Мы можем подключить приложение Node к базе данных и управлять базой данных без каких-либо команд.
• Модель Sequelize определяет и описывает таблицу в базе данных.
• Модуль типов данных Sequelize помогает контролировать типы данных свойств модели.
• Методы, доступные в Sequelize, помогают управлять таблицами, строками и столбцами.
• Мы можем установить связь между моделями, используя методы: belongsTo() , hasOne() , hasMoney() и belongsToMany() .