Node.js 的ORM(Sequelize) 的使用

爱枫林 發表於 2023-10-25 21:35:00

Sequelize是一个Node.js 的ORM。ORM是对象关系映射(Object Relational Mapping)，编程语言的中对象与关系型数据库中的关系(表)进行映射，对象的属性和值映射成表中的列和值。有了ORM，就可以使用面向对象的方式(调用对象的方法)来操作数据库，不用再写SQL语句。登录MySQL，CREATE DATABASE airline; 创建 airline 数据库。mkdir airline && cd airline && npm init -y，npm install sequelize mysql2，就可以使用Sequelize来操作数据库了。touch server.mjs，先连接数据库，就是创建Sequelize的实例
<div class="cnblogs_code">
<pre>import { Sequelize } from 'sequelize';
// new Sequelize(数据库名, 登录数据库的用户名, 登录数据库的密码, {host: 哪台主机上的数据库， dialect: 使用什么数据库})
const sequelize = new Sequelize('airline', 'root', '123', {
host: 'localhost',
dialect: 'mysql'
});

try {
await sequelize.authenticate();
console.log('连接成功');
} catch (error) {
console.error('连接失败', error);
}</pre>
</div>
　　node server.js，连接成功，开始操作数据库。Sequelize有一个Model的概念，它代表数据库中的一张表，所以操作数据库，就要先创建Model，提供表的名称，表的列及其数据类型，从而和数据库表进行关联，这样操作Model就相当于操作表。两种方式创建Model，sequelize.define()和继承Model并调用 init()方法。
<div class="cnblogs_code">
<pre>import { Sequelize, DataTypes } from 'sequelize';</pre>
<pre>// 参数: model名, 表中的字段及其数据类型, 可选配置项
sequelize.define('FlightSchedule', {
originAirport: DataTypes.STRING,
destinationAirport: DataTypes.STRING,
departureTime: DataTypes.DATE
});

// 或者类名就是model名
class FlightSchedule extends Model { }

// int参数：属性(对应表中的字段), 配置项
FlightSchedule.init({
originAirport: DataTypes.STRING,
destinationAirport: DataTypes.STRING,
departureTime: DataTypes.DATE
}, {
sequelize,
});</pre>
</div>
　　创建Model并没有提供表名，默认情况下，Sequelize会把Model名进行复数化，当作表名。FlightSchedule就代表flightschedules表。当然，表名可以在可选配置项中进行配置，也可以禁止复数化，数据库的字段名也可以不用驼峰命名，而是使用 _连接，
<div class="cnblogs_code">
<pre>{
freezeTableName: true, // 表名是flightschedule
tableName: 'a', // 直接定义表名为a
underscored: true // 数据库中的对应的字段是origin_airport
}</pre>
</div>
　　这里就不配置了，使用默认值就好。但此时数据库中并没有flightschedules表，怎么操作它？Sequelize提供了一个sync()方法，如果数据库中没有对应的表，它就会创建表，如果有，什么都不做。在define调用的后面
<div class="cnblogs_code">
<pre>await sequelize.sync(); </pre>
</div>
　　node server.js ，airline有了flightschedules表，但多了3个字段，id，createdAt和updatedAt。默认情况下，Sequelize会为Model增加三个属性(id, createdAt和updatedAt)。创建model时写了三个属性，实际上model有六个属性。当然createdAt和updatedAt 是可以配置的(在可选配置项里面)，timestamps为false，就不会给model上添加createdAt 和updatedAt属性。也可以添加某一个字段，比如timestamps为true, createdAt 为true，就只为model 增加createdAt属性。
 　　作为演示代码，以上使用没有问题。但真正的应用开发，就有很多问题，首先，数据库的配置信息写到主文件中，不利于配置不同的环境，需要配置文件。其次，项目中有多个model，不可能都写到主文件，需要一个目录来维护model。再就是sync()方法，修改表就无能为力了，需要migiration。Sequlize 提供了sequelize-cli 来初始化项目结构。npm install sequelize-cli -D，再npx sequelize init ，项目多了4个目录。config保存数据库配置信息，models包含项目中的所有Model。它默认包含index.js文件，从models目录下读取文件(fs.readdirSync(__dirname))，然后循环创建model(require(path.join(__dirname, file))(sequelize, Sequelize.DataTypes);)，赋值给db对象(db = model;)，最后把db对象暴露出去。暂时不用它的，删除它。在models下创建flightSchedule.mjs，
<div class="cnblogs_code">
<pre>export default (sequelize, DataTypes) => {
return sequelize.define('FlightSchedule', {
originAirport: DataTypes.STRING,
destinationAirport: DataTypes.STRING,
departureTime: DataTypes.DATE
});
};</pre>
</div>
　　然后在index.mjs
<div class="cnblogs_code">
<pre>import { Sequelize, DataTypes } from 'sequelize';
import { createRequire } from 'module'; // 在esm中使用require，处理JSON

import createFlightSchedule from './flightSchedule.mjs' // 引入model

const env = process.env.NODE_ENV || 'development';
const require = createRequire(import.meta.url);
const config = require('../config/config.json')

const sequelize = new Sequelize(config.database, config.username, config.password, config);

const FlightSchedule = createFlightSchedule(sequelize, DataTypes) // 创建Model

export {
FlightSchedule,
sequelize
}</pre>
</div>
　　可以看到，默认情况下，连接的是development数据库，在config.json中配置development
<div class="cnblogs_code">
<pre>"development": {
"username": "root",
"password": "123",
"database": "airline",
"host": "127.0.0.1",
"dialect": "mysql"
}</pre>
</div>
　　migrations目录包含对表Schema的定义和修改。创建了FlightSchedule Model，就要创建flightschedules表。新建一个建表migration，npx sequelize migration:generate --name create-flight-schedule，name参数表明这是什么migration。migrations目录下生成了一个文件，名字带有时间戳。它有两个方法，up(…) 用来定义migration要做的事情，down(…) 回滚这个migration做的事情，所以要在up中创建table，在down中删除table。需要注意的是，Sequelize默认会为Model增加id，createdAt和updatedAt属性，所以创建表时，表也要有对应的列
<div class="cnblogs_code">
<pre>/** @type {import('sequelize-cli').Migration} */
module.exports = {
async up(queryInterface, Sequelize) {
await queryInterface.createTable('flightSchedules', {
 id: {
 allowNull: false,
 autoIncrement: true,
 primaryKey: true,
 type: Sequelize.INTEGER
 },
 originAirport: {
 type: Sequelize.STRING
 },
 destinationAirport: {
 type: Sequelize.STRING
 },
 departureTime: {
 type: Sequelize.DATE
 },
 createdAt: {
 allowNull: false,
 type: Sequelize.DATE
 },
 updatedAt: {
 allowNull: false,
 type: Sequelize.DATE
 }
});
},
async down(queryInterface, Sequelize) {
await queryInterface.dropTable('flightSchedules');
}
};</pre>
</div>
　　在MySQL中删除flightschedules表。再npx sequelize db:migrate 执行migrations目录下的迁移操作，查看数据库，有了flightschedules表，但也多了SequelizeMeta表(记录执行过的迁移脚本)。执行migrate的时候，Sequelize会按时间戳的顺序遍历整个migrations目录， 然后跳过SequelizeMeta 表中包含的文件，也就是以前执行过的migration文件，不用再重复执行了。
　　seeders目录快速向数据库中填充数据，方便测试程序。npx sequelize seed:generate --name initial-flight-schedules. seeders目录创建了一个js文件，up(…) 填充数据，down(…) 回滚数据。
<div class="cnblogs_code">
<pre>/** @type {import('sequelize-cli').Migration} */
module.exports = {
async up(queryInterface, Sequelize) {
await queryInterface.bulkInsert('flightSchedules', [{
 originAirport: "济南",
 destinationAirport: "武汉",
 departureTime: "2022-01-01 08:00:00",
 createdAt: new Date(),
 updatedAt: new Date(),
}], {});
},

async down(queryInterface, Sequelize) {
await queryInterface.bulkDelete('flightSchedules', null, {});
}
};</pre>
</div>
　　npx sequelize db:seed:all，执行seeders目录下的所有文件。npx sequelize db:seed --seed=fileName，指定执行seeders目录下哪个文件。无论执行哪一个命令，flightschedules表中都有一条记录。需要注意的是， db:migrate and db:seed 命令使用 NODE_ENV 环境变量来决定执行到哪个数据库，默认是development 配置下的数据库
　　再创建一个Airplane Model，在models下新建airplane.mjs
<div class="cnblogs_code">
<pre>export default (sequelize, DataTypes) => {
return sequelize.define('Airplane', {
 planeModel: DataTypes.STRING,
 totalSeats: DataTypes.STRING,
});
};</pre>
</div>
　　再在index.mjs 引入并创建Airplane Model
<div class="cnblogs_code">
<pre>import createAirplane from './airplane.mjs';

const Airplane = createAirplane(sequelize, DataTypes)

export {
Airplane,
FlightSchedule,
sequelize
}</pre>
</div>
　　创建migration，npx sequelize migration:generate --name create-airplane, 
<div class="cnblogs_code">
<pre>module.exports = {
async up(queryInterface, Sequelize) {
await queryInterface.createTable('airplanes', {
 // id, createdAt和updatedAt都一样，这里就省略，没有写了
 planeModel: {
 type: Sequelize.STRING
 },
 totalSeats: {
 type: Sequelize.INTEGER
 },
});
},
async down(queryInterface, Sequelize) {
await queryInterface.dropTable('airplanes');
}
};</pre>
</div>
　　npx sequelize db:migrate 执行migration，再npx sequelize seed:generate --name initial-airplanes 建一个seeder文件，填充数据
<div class="cnblogs_code">
<pre>module.exports = {
async up(queryInterface, Sequelize) {
await queryInterface.bulkInsert('airplanes', [{
 planeModel: 'Airbus A220-100',
 totalSeats: 110,
 createdAt: new Date(),
 updatedAt: new Date()
}, {
 planeModel: 'Airbus A220-300',
 totalSeats: 110,
 createdAt: new Date(),
 updatedAt: new Date()
}, {
 planeModel: 'Airbus A 318',
 totalSeats: 115,
 createdAt: new Date(),
 updatedAt: new Date()
}, {
 planeModel: 'Boeing 707-100',
 totalSeats: 100,
 createdAt: new Date(),
 updatedAt: new Date(),
}, {
 planeModel: 'Boeing 737-100',
 totalSeats: 85,
 createdAt: new Date(),
 updatedAt: new Date()
}], {});
},

async down(queryInterface, Sequelize) {
await queryInterface.bulkDelete('airplanes', null, {});
}
};</pre>
</div>
　　npx sequelize db:seed --seed=20231017074324-initial-airplanes.js(需要改成自己的文件名)。再创建一个customer Model，在models目录下，创建customer.mjs 
<div class="cnblogs_code">
<pre>export default (sequelize, DataTypes) => {
return sequelize.define('Customer', {
 name: DataTypes.STRING,
 email: DataTypes.STRING,
});
}</pre>
</div>
　　然后index.mjs中引入
<div class="cnblogs_code">
<pre>import createCustomer from './customer.mjs';
const Customer = createCustomer(sequelize, DataTypes);

export {
Airplane,
Customer,
FlightSchedule,
sequelize
}</pre>
</div>
　　最后生成一个migration文件，npx sequelize migration:generate --name create-customer
<div class="cnblogs_code">
<pre>module.exports = {
async up(queryInterface, Sequelize) {
await queryInterface.createTable('customers', {
 // 还是省略了id，createdAt和updateAt
 name: {
 type: Sequelize.STRING
 },
 email: {
 type: Sequelize.STRING
 },
});
},

async down(queryInterface, Sequelize) {
queryInterface.dropTable('customers');
}
};</pre>
</div>
　　npx sequelize db:migrate执行migration。现在server.mjs
<div class="cnblogs_code">
<pre>import { sequelize, Customer, Airplane, FlightSchedule } from "./models/index.mjs";
await sequelize.authenticate()</pre>
</div>
　　增删改查
　　新增一条记录：Model名.create()，参数是一个对象，对象的属性就是创建model时定义的属性，Sequelize自动添加的属性，它自己会处理好。返回值是一个model实例，就是插入的表的一行，它有toJSON() 方法
<div class="cnblogs_code">
<pre>const record = await Customer.create({name: 'Sam', email: '123@qq.com'});
console.log(record.toJSON())</pre>
</div>
　　node server.mjs, 数据库中成功插入一条数据。这时可以npm i nodemon -D, npx nodemon  server.mjs启动服务器。model名.bulkCreate()批量插入数据，它接受的是数组，数组的每一个元素是对象，对象和create()接受的对象一样
<div class="cnblogs_code">
<pre>const record = await Customer.bulkCreate([
{ name: '张三', email: '456@qq.com' },
{ name: '李四', email: '789@qq.com' }, { name: '王五', email: '1789@qq.com' } ])</pre>
<pre>console.log(record.map(r => r.toJSON()))</pre>
</div>
　　删除：删除一条记录，可以先model名.findOne() 查出这个实例， 然后再在实例上调用destroy()方法
<div class="cnblogs_code">
<pre>var record = await Customer.findOne({ where: { id: 3 } });
await record.destroy();</pre>
</div>
　　删除多条记录，那就要用model名.destroy()，destroy的参数就是筛选条件。 
<div class="cnblogs_code">
<pre>await Customer.destroy({ where: { id: 2 } }); </pre>
</div>
　　删除还有硬删除和软删除之分。创建model时配置了paranoid: true，就表示软删除，删除只是在model实例上添加deleteAt字段，不会真正的从数据库中删除数据，当然前提是timestamps 设为true，此时要硬删除，就要在调用destroy方法时，添加force: true。如果软删除，在migration的时候，要在表中创建deleteAt字段。
<div class="cnblogs_code">
<pre>await Customer.destroy({ where: { id: 4 }, force: true }); </pre>
</div>
　　更新：更新多条记录，使用model名.update()，第一个参数是要更新成什么， 第二个参数是查询条件
<div class="cnblogs_code">
<pre>await Customer.update(
{ name: '张三', email: '456@qq.com' },
{ where: { id: 1 } }
);</pre>
</div>
　　如果只想更新一条记录，先调用model名.findOne()获取到实例，然后修改实例的属性或调用increment 和decrement 方法修改属性，最后调用实例上的save()。
<div class="cnblogs_code">
<pre>var record = await Customer.findOne({ where: { id: 1 } });
record.name = 'Sam'
await record.save()</pre>
</div>
　　查询：modal名.方法名，比如findAll，findone。
<div class="cnblogs_code">
<pre>const airplances = await Airplane.findAll(); // findAll返回的是数组。
console.log(airplances.map(ap => ap.toJSON()));
const airplance = await Airplane.findOne();
console.log(airplance.toJSON())</pre>
</div>
　　查询方法中，带有attributes参数，列出需要的某个或某些字段
<div class="cnblogs_code">
<pre>const airplance = await Airplane.findOne({
attributes: ['planeModel', 'totalSeats']
});
console.log(airplance.toJSON())</pre>
</div>
　　如果要排除某个字段，用exclude
<div class="cnblogs_code">
<pre>const airplance = await Airplane.findOne({
attributes: {exclude: ['createdAt']}
});</pre>
</div>
　　如果对字段进行重命名，数组中的元素需要是一个数组，它的第一项是原字段名，第二项是新字段名。
<div class="cnblogs_code">
<pre>const airplance = await Airplane.findOne({
attributes: ['planeModel', ['totalSeats', 'seats']] // totalSeats 重命名为 seats
});</pre>
</div>
　　查询方法中，提供where进行条件查询，为此Sequelize还专门提供了Op。
<div class="cnblogs_code">
<pre>import { Op } from 'sequelize';

const airplance = await Airplane.findOne({
where: {
 id: {
 : [1, 2]
 /**
 * 或
 * : {
 * : 2,
 * : null
 * }
 */
 }
}
});</pre>
</div>
　　如果查询中调用函数，要用sequelize.fn，第一个参数是函数名，第二个参数用sequelize.col来指定对哪一个属性来进行函数操作。如果在where条件中使用函数，sequelize.where 来表示相等性。
<div class="cnblogs_code">
<pre>const airplances = await Airplane.findAll({
where: sequelize.where(
 // sequelize.where的第二个参数是基本类型，它就进行相等比较
 sequelize.fn('char_length', sequelize.col('planeModel')), 5)
 // 进行其他比较，第二个参数是个对象，定义比较
 // sequelize.fn('char_length', sequelize.col('planeModel')), {
 // : 12
 // })
});</pre>
</div>
　　如果在查询字段中调用函数，要定义别名
<div class="cnblogs_code">
<pre>const airplance = await Airplane.findOne({
 attributes: [

 ],
});</pre>
</div>
　　查询方法参数中带有order，就是排序，它是一个数组，数组的每一项也是一个数组，子数组的第一项指定按哪个字段进行排序，第二项指定按升序还是降序进行排序
<div class="cnblogs_code">
<pre>const airplances = await Airplane.findAll({
order: [
 ['totalSeats', 'DESC']
]
});</pre>
</div>
　　查询方法的参数中带有group，就是分组，指定按哪一个字段进行分组。分组之后，通常使用聚合函数，聚合函数的使用和普通函数的用法相同，
<div class="cnblogs_code">
<pre>const airplances = await Airplane.findAll({
attributes: ['planeModel', ],
group: 'planeModel'
});</pre>
</div>
　　查询方法中，带有offset和limit，就是用于分页
<div class="cnblogs_code">
<pre>const airplances = await Airplane.findAll({
offset: 1, limit: 2
});</pre>
</div>
　　sequlieze.query 可以执行原生sql。
<div class="cnblogs_code">
<pre>const airplances = await sequelize.query('SELECT * FROM airplanes', {
type: QueryTypes.SELECT,
});</pre>
</div>
　　在model的定义中，除了定义必要的属性，还可以对每一个属性定义setter，getter函数。getter函数对从数据库获取回来的数据进行转化，比如小写转化成大写。setter函数先对数据进行转化，再存储到数据库，比如对密码进行加密。甚至可以设置虚拟字段，该字段不存数据库，sequlize自己做的转化，主要作用是组合不同的属性，它的类型是DataType.VIRTUAL，然后设置get方法返回值。把Customer modal 修改如下
<div class="cnblogs_code">
<pre>function hash(value) {
return value + '@xdsd'
}
export default (sequelize, DataTypes) => {
return sequelize.define('Customer', {
 name: {
 type: DataTypes.STRING,
 get() {
 // getDataValue 返回存储在数据库中的原始值
 const rawValue = this.getDataValue('name');
 return rawValue.toUpperCase()
 }
 },
 email: {
 type: DataTypes.STRING,
 set(value) {
 // setDataValue对用户输入的值进行操作
 this.setDataValue('email', hash(value));
 },
 },
 fullName: {
 type: DataTypes.VIRTUAL,
 get() {
 return `${this.name} ${this.email}`;
 }
 }
});
}</pre>
</div>
　　新增一个user 并查询
<div class="cnblogs_code">
<pre>await Customer.create({name: 'Jason', email: '2345@qq.com'})
const user = await Customer.findAll()</pre>
</div>
　　可以看到
<div class="cnblogs_code">
<pre>{
"name": "JASON", // name 大写
"fullName": "JASON 2345@qq.com@xdsd", // 虚拟字段
"email": "2345@qq.com@xdsd" // email进行了hash
}</pre>
</div>
　　关系
　　关系型数据库中，表与表之间存在1对1，1对多，和多对多的关系，那在Sequelize中，怎么用model来表示这些关系？每一个model都有四个方法，hasOne, BelongsTo, hasMany, BelongsToMany。由于关系是相对的，所以每一种关系都用两个方法实现。　
　　实现1对1，用hasOne和BelongsTo。比如飞机(Airplanes)和飞机详情表(AirplaneDetails)， 由于表与表之间的关系是通过外键实现的，外键放到哪张表上？哪张表能单独存在，airplanes能单独存在，details则是依附airplane的，所以外键放到details上，airplanes有一个(hasOne)details， details属于(BelongsTo)airplane，
<div class="cnblogs_code">
<pre>Airplane.hasOne(AirplaneDetail)
AirplaneDetail.BelongsTo(Airplane)</pre>
</div>
　　hasOne把外键放到它的参数上，AirplaneDetail model中，多了一个AirplaneId属性，它所引用的model名+Id，相应的，airplaneDetail表多了AirplaneId列，除非AirplaneId列已存在。当有了关系后，调用hasOne和BelongsTo的model 实例多了几个辅助方法，来方便的设置关系。从数据库查到airplane后，airplane有getAirplaneDetail， setAirplaneDetail 和createAirplaneDetail 方法。AirplaneDetail实例setAirplane等方法。
　　实现1对多，用hasMany和belongsTo。比如 一架飞机可以执行多次航班(hasMany)，但一个航班只能属于一架飞机(BelongsTo)。models下的index.mjs
<div class="cnblogs_code">
<pre>Airplane.hasMany(FlightSchedule)
FlightSchedule.belongsTo(Airplane)</pre>
</div>
　　1对多的关系，外键放到多的那一边，所以FlightSchedule多了AirplaneId属性，对应的，flightschedules表多airplaneId列。为了满足关系，需要做migration。给flightschedules表添加外键，npx sequelize migration:generate --name add-flightschedules-references
<div class="cnblogs_code">
<pre>module.exports = {
async up (queryInterface, Sequelize) {
await queryInterface.addColumn('FlightSchedules', 'AirplaneId', {
 type: Sequelize.INTEGER,
});

await queryInterface.addConstraint('FlightSchedules', {
 type: 'foreign key',
 fields: ['AirplaneId'],
 references: {
 table: 'Airplanes',
 field: 'id'
 },
 name: 'fkey_flight_schedules_airplane',
 onDelete: 'set null',
 onUpdate: 'cascade'
});
},

async down (queryInterface, Sequelize) {
await queryInterface.removeConstraint(
 'FlightSchedules', 'fkey_flight_schedules_airplane'
);

await queryInterface.removeColumn('FlightSchedules', 'AirplaneId');
}
};</pre>
</div>
　　npx sequelize db:migrate 执行迁移。airplane实例有getFlightSchedules和addFlightSchedule(或addflightSchedules)，createFlightSchedule， countFlightSchedules 等方法
<div class="cnblogs_code">
<pre>const airplance = await Airplane.findOne({ where: { id: 1 } });
const flightSchedule = await FlightSchedule.findOne({ where: { id: 1 } })

await airplance.addFlightSchedule(flightSchedule) // flightSchedules表中，id=1的 AirplaneId 变成了 '1'
await airplance.createFlightSchedule({ //创建了一条flightSchedule记录，并且它的AirplaneId也是1
originAirport: "深圳",
destinationAirport: "武汉",
departureTime: "2023-10-01 20:00:00"
})

const flightSchedules = await airplance.getFlightSchedules();
const count = await airplance.countFlightSchedules()
console.log(flightSchedules.map(r => r.toJSON()))</pre>
</div>
　　实现多对多要用BelongsToMany，因为多对多的关系，需要中间表，所以它还要一个through参数来指定使用哪张表，如果参数是字符串，Sequelize默认表中字段名是两个关联model的名字+id。比如Customer 和FlightSchedule，一个乘客可以乘多趟航班，一趟航班有多个客人，它们之间的关联是购买的飞机票。models下的index.mjs
<div class="cnblogs_code">
<pre>Customer.belongsToMany(FlightSchedule, { through: 'BoardingTickets' });
FlightSchedule.belongsToMany(Customer, { through: 'BoardingTickets' });</pre>
</div>
　　为了满足关系，需要做migration，创建BoardingTickets表,  npx sequelize migration:generate --name create-board-ticket
<div class="cnblogs_code">
<pre>module.exports = {
async up(queryInterface, Sequelize) {
await queryInterface.createTable('BoardingTickets', {
 id: {
 allowNull: false,
 autoIncrement: true,
 primaryKey: true,
 type: Sequelize.INTEGER
 },
 createdAt: {
 allowNull: false,
 type: Sequelize.DATE
 },
 updatedAt: {
 allowNull: false,
 type: Sequelize.DATE
 },
 CustomerId: {
 type: Sequelize.INTEGER,
 references: {
 model: 'Customers',
 key: 'id'
 },
 onUpdate: 'set null',
 onDelete: 'cascade'
 },
 FlightScheduleId: {
 type: Sequelize.INTEGER,
 references: {
 model: 'FlightSchedules',
 field: 'id'
 },
 onDelete: 'set null',
 onUpdate: 'cascade'
 }
});
},

async down(queryInterface, Sequelize) {
await queryInterface.dropTable('BoardingTickets');
}
};</pre>
</div>
　　npx sequelize db:migrate 执行迁移。model 实例上多了很多方法来建立联系，比如addFlightSchedule
<div class="cnblogs_code">
<pre>const customer = await Customer.findOne({ where: { id: 1 } });
const flightSchedule = await FlightSchedule.findOne({ where: { id: 1 } })

customer.addFlightSchedule(flightSchedule)</pre>
</div>
　　addFlightSchedule执行的Sql语句是INSERT INTO `BoardingTickets` (`createdAt`,`updatedAt`,`CustomerId`,`FlightScheduleId`) VALUES ('2024-08-15 08:52:37','2024-08-15 08:52:37',1,1); boardingtickets表多了一条记录。getFlightSchedules会把中间表查出来，
<div class="cnblogs_code">
<pre>const customer = await Customer.findOne({ where: { id: 1 } });
const flightSchedules = await customer.getFlightSchedules();
console.log(JSON.stringify(flightSchedules, undefined, 4))</pre>
</div>
　　查询结果如下：
<div class="cnblogs_code">
<pre>[
{
 "id": 1,
 "originAirport": "济南",
 "destinationAirport": "武汉",
 "departureTime": "2022-01-01T08:00:00.000Z",
 "createdAt": "2023-10-21T15:05:37.000Z",
 "updatedAt": "2023-10-23T14:44:16.000Z",
 "AirplaneId": 1,
 "BoardingTickets": {
 "createdAt": "2023-10-23T15:00:55.000Z",
 "updatedAt": "2023-10-23T15:00:55.000Z",
 "CustomerId": 1,
 "FlightScheduleId": 1
 }
}
]</pre>
</div>
　　如果不想返回中间表，或只想返回中间表的某些属性，给getFlightSchedules传递joinTableAttributes参数，
<div class="cnblogs_code">
<pre> const flightSchedules = await customer.getFlightSchedules({
 joinTableAttributes: []
});</pre>
</div>
　　以上的查询称为 Lazy load，先用model 查出一个实例，再用实例的方法，查询另外需要的数据，就是先查一张表，再查另外一张表中，执行了两次query请求，那能不能一次性地把所有数据都查询出来，那就是Eager load，查询的时候，使用include，包含关联的表，连表查询。
<div class="cnblogs_code">
<pre>const customer = await Customer.findOne({
where: { id: 1 },
include: [{
 model: FlightSchedule, //连接FlightSchedules 表
 through: { attributes: [] } // 不需要中间表的数据
 }]
});</pre>
</div>
　　一次查出了customer和它关联的 FlightSchedules。
　　事务：分为 unmanaged 事务和managed事务。 unmanaged事务，手动创建事务，提交或回滚事物 
<div class="cnblogs_code">
<pre>const tx = await sequelize.transaction(); // 创建一个事务
try {
const plane = await Airplane.findByPk(2);

const schedule = await FlightSchedule.create({
 originAirport: '上海',
 destinationAirport: '北京',
 departureTime: '2023-10-24 10:10:00',
}, { transaction: tx });

await schedule.setAirplane(plane, { transaction: tx });

await tx.commit(); // 提交事务
} catch (error) {
await tx.rollback(); // 回滚事务
}</pre>
</div>
　　managed transactions 就是自动提交和回滚事务。把要做的事性作为回调函数，传递给sequelize.transaction 就是managed transactions
<div class="cnblogs_code">
<pre>try {
const plane = await Airplane.findByPk(3);

const flight = await sequelize.transaction(async (tx) => {
 const schedule = await FlightSchedule.create({
 originAirport: '上海',
 destinationAirport: '深圳',
 departureTime: '2023-10-24 10:10:00',
 }, { transaction: tx });

 await schedule.setAirplane(plane, { transaction: tx });

 return schedule
})

// 在这里自动提交事务
} catch (error) {
//在这里，事务已经回滚了
}</pre>
</div>
　　对已经存在的数据库使用Sequelize，由于数据库已经存在，我们需要创建model来适配它的Schema。比如数据库有一张表是foo_bars, 它的属性是
<div class="cnblogs_code">
<pre>id INTEGER AUTOINCREMENT
first_name VARCHAR(200)
last_name VARCHAR(200)
email VARCHAR(200)
date_created DATETIME
date_updated DATETIME</pre>
</div>
　　没有createdAt 和UpdatedAt, 并且表名和字段名都使用下划线，所以在定义model的时候，都需要自定义
<div class="cnblogs_code">
<pre>{
 // options
 sequelize,
 modelName: 'FooBar',
 tableName: 'foo_bars',
 createdAt: 'date_created',
 updatedAt: 'date_updated',
 underscore: true,
},</pre>
</div>
　　第二个要注意的是如果没有表中没有使用id作为主键，需要在创建的model中删除id，
<div class="cnblogs_code">
<pre>class FooBar extends Model {}
FooBar.removeAttribute('id');</pre>
</div>
  
来源：https://www.cnblogs.com/SamWeb/p/17750418.html

頁: [1]

琼殿技术论坛's Archiver

Node.js 的ORM(Sequelize) 的使用