如果你覺得Sequelize的文檔有點多、雜,不方便看,可以看看這篇。
在使用NodeJS
來關係型操作數據庫時,爲了方便,通常都會選擇一個合適的ORM
(Object
Relationship Model)框架。畢竟直接操作SQL
比較繁瑣,通過ORM
框架,我們可以使用面向對象的方式來操作表。NodeJS
社區有很多的ORM
框架,我比較喜歡Sequelize
,它功能豐富,可以非常方便的進行連表查詢。
這篇文章我們就來看看,Sequelize
是如何在SQL
之上進行抽象、封裝,從而提高開發效率的。
安裝
這篇文章主要使用MySQL
、Sequelize
、co
來進行介紹。安裝非常簡單:
$ npm install --save co
$ npm install --save sequelize
$ npm install --save mysql
代碼模板如下:
var Sequelize = require('sequelize');
var co = require('co');
co(function* () {
// code here
}).catch(function(e) {
console.log(e);
});
基本上,Sequelize
的操作都會返回一個Promise
,在co
的框架裏面可以直接進行yield
,非常方便。
建立數據庫連接
var sequelize = new Sequelize(
'sample', // 數據庫名
'root', // 用戶名
'zuki', // 用戶密碼
{
'dialect': 'mysql', // 數據庫使用mysql
'host': 'localhost', // 數據庫服務器ip
'port': 3306, // 數據庫服務器端口
'define': {
// 字段以下劃線(_)來分割(默認是駝峯命名風格)
'underscored': true
}
}
);
定義單張表
Sequelize
:
var User = sequelize.define(
// 默認表名(一般這裏寫單數),生成時會自動轉換成複數形式
// 這個值還會作爲訪問模型相關的模型時的屬性名,所以建議用小寫形式
'user',
// 字段定義(主鍵、created_at、updated_at默認包含,不用特殊定義)
{
'emp_id': {
'type': Sequelize.CHAR(10), // 字段類型
'allowNull': false, // 是否允許爲NULL
'unique': true // 字段是否UNIQUE
},
'nick': {
'type': Sequelize.CHAR(10),
'allowNull': false
},
'department': {
'type': Sequelize.STRING(64),
'allowNull': true
}
}
);
SQL
:
CREATE TABLE IF NOT EXISTS `users` (
`id` INTEGER NOT NULL auto_increment ,
`emp_id` CHAR(10) NOT NULL UNIQUE,
`nick` CHAR(10) NOT NULL,
`department` VARCHAR(64),
`created_at` DATETIME NOT NULL,
`updated_at` DATETIME NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB;
幾點說明:
-
建表
SQL
會自動執行的意思是你主動調用sync
的時候。類似這樣:User.sync({force: true});
(加force:true
,會先刪掉表後再建表)。我們也可以先定義好表結構,再來定義Sequelize
模型,這時可以不用sync
。兩者在定義階段沒有什麼關係,直到我們真正開始操作模型時,纔會觸及到表的操作,但是我們當然還是要儘量保證模型和表的同步(可以藉助一些migration
工具)。自動建表功能有風險,使用需謹慎。 -
所有數據類型,請參考文檔數據類型。
-
模型還可以定義虛擬屬性、類方法、實例方法,請參考文檔:模型定義
-
其他一些特殊定義如下所示:
var User = sequelize.define(
'user',
{
'emp_id': {
'type': Sequelize.CHAR(10), // 字段類型
'allowNull': false, // 是否允許爲NULL
'unique': true // 字段是否UNIQUE
},
'nick': {
'type': Sequelize.CHAR(10),
'allowNull': false
},
'department': {
'type': Sequelize.STRING(64),
'allowNull': true
}
},
{
// 自定義表名
'freezeTableName': true,
'tableName': 'xyz_users',
// 是否需要增加createdAt、updatedAt、deletedAt字段
'timestamps': true,
// 不需要createdAt字段
'createdAt': false,
// 將updatedAt字段改個名
'updatedAt': 'utime'
// 將deletedAt字段改名
// 同時需要設置paranoid爲true(此種模式下,刪除數據時不會進行物理刪除,而是設置deletedAt爲當前時間
'deletedAt': 'dtime',
'paranoid': true
}
);
單表增刪改查
通過Sequelize
獲取的模型對象都是一個DAO
(Data
Access Object)對象,這些對象會擁有許多操作數據庫表的實例對象方法(比如:save
、update
、destroy
等),需要獲取“乾淨”的JSON
對象可以調用get({'plain':
true})
。
通過模型的類方法可以獲取模型對象(比如:findById
、findAll
等)。
增
Sequelize
:
// 方法1:build後對象只存在於內存中,調用save後才操作db
var user = User.build({
'emp_id': '1',
'nick': '小紅',
'department': '技術部'
});
user = yield user.save();
console.log(user.get({'plain': true}));
// 方法2:直接操作db
var user = yield User.create({
'emp_id': '2',
'nick': '小明',
'department': '技術部'
});
console.log(user.get({'plain': true}));
SQL
:
INSERT INTO `users`
(`id`, `emp_id`, `nick`, `department`, `updated_at`, `created_at`)
VALUES
(DEFAULT, '1', '小紅', '技術部', '2015-11-02 14:49:54', '2015-11-02 14:49:54');
Sequelize
會爲主鍵id
設置DEFAULT
值來讓數據庫產生自增值,還將當前時間設置成了created_at
和updated_at
字段,非常方便。
改
Sequelize
:
// 方法1:操作對象屬性(不會操作db),調用save後操作db
user.nick = '小白';
user = yield user.save();
console.log(user.get({'plain': true}));
// 方法2:直接update操作db
user = yield user.update({
'nick': '小白白'
});
console.log(user.get({'plain': true}));
SQL
:
UPDATE `users`
SET `nick` = '小白白', `updated_at` = '2015-11-02 15:00:04'
WHERE `id` = 1;
更新操作時,Sequelize
將將當前時間設置成了updated_at
,非常方便。
如果想限制更新屬性的白名單,可以這樣寫:
// 方法1
user.emp_id = '33';
user.nick = '小白';
user = yield user.save({'fields': ['nick']});
// 方法2
user = yield user.update(
{'emp_id': '33', 'nick': '小白'},
{'fields': ['nick']}
});
這樣就只會更新nick
字段,而emp_id
會被忽略。這種方法在對錶單提交過來的一大推數據中只更新某些屬性的時候比較有用。
刪
Sequelize
:
yield user.destroy();
SQL
:
DELETE FROM `users` WHERE `id` = 1;
這裏有個特殊的地方是,如果我們開啓了paranoid
(偏執)模式,destroy
的時候不會執行DELETE
語句,而是執行一個UPDATE
語句將deleted_at
字段設置爲當前時間(一開始此字段值爲NULL
)。我們可以使用user.destroy({force:
true})
來強制刪除,從而執行DELETE
語句進行物理刪除。
查
查全部
Sequelize
:
var users = yield User.findAll();
console.log(users);
SQL
:
SELECT `id`, `emp_id`, `nick`, `department`, `created_at`, `updated_at` FROM `users`;
限制字段
Sequelize
:
var users = yield User.findAll({
'attributes': ['emp_id', 'nick']
});
console.log(users);
SQL
:
SELECT `emp_id`, `nick` FROM `users`;
字段重命名
Sequelize
:
var users = yield User.findAll({
'attributes': [
'emp_id', ['nick', 'user_nick']
]
});
console.log(users);
SQL
:
SELECT `emp_id`, `nick` AS `user_nick` FROM `users`;
where子句
Sequelize
的where
配置項基本上完全支持了SQL
的where
子句的功能,非常強大。我們一步步來進行介紹。
基本條件
Sequelize
:
var users = yield User.findAll({
'where': {
'id': [1, 2, 3],
'nick': 'a',
'department': null
}
});
console.log(users);
SQL
:
SELECT `id`, `emp_id`, `nick`, `department`, `created_at`, `updated_at`
FROM `users` AS `user`
WHERE
`user`.`id` IN (1, 2, 3) AND
`user`.`nick`='a' AND
`user`.`department` IS NULL;
可以看到,k: v
被轉換成了k
= v
,同時一個對象的多個k: v
對被轉換成了AND
條件,即:k1:
v1, k2: v2
轉換爲k1 = v1 AND k2 = v2
。
這裏有2個要點:
-
如果v是
null
,會轉換爲IS NULL
(因爲SQL
沒有= NULL
這種語法) -
如果v是數組,會轉換爲
IN
條件(因爲SQL
沒有=[1,2,3]
這種語法,況且也沒數組這種類型)
操作符
操作符是對某個字段的進一步約束,可以有多個(對同一個字段的多個操作符會被轉化爲AND
)。
Sequelize
:
var users = yield User.findAll({
'where': {
'id': {
'$eq': 1, // id = 1
'$ne': 2, // id != 2
'$gt': 6, // id > 6
'$gte': 6, // id >= 6
'$lt': 10, // id < 10
'$lte': 10, // id <= 10
'$between': [6, 10], // id BETWEEN 6 AND 10
'$notBetween': [11, 15], // id NOT BETWEEN 11 AND 15
'$in': [1, 2], // id IN (1, 2)
'$notIn': [3, 4] // id NOT IN (3, 4)
},
'nick': {
'$like': '%a%', // nick LIKE '%a%'
'$notLike': '%a' // nick NOT LIKE '%a'
},
'updated_at': {
'$eq': null, // updated_at IS NULL
'$ne': null // created_at IS NOT NULL
}
}
});
SQL
:
SELECT `id`, `emp_id`, `nick`, `department`, `created_at`, `updated_at`
FROM `users` AS `user`
WHERE
(
`user`.`id` = 1 AND
`user`.`id` != 2 AND
`user`.`id` > 6 AND
`user`.`id` >= 6 AND
`user`.`id` < 10 AND
`user`.`id` <= 10 AND
`user`.`id` BETWEEN 6 AND 10 AND
`user`.`id` NOT BETWEEN 11 AND 15 AND
`user`.`id` IN (1, 2) AND
`user`.`id` NOT IN (3, 4)
)
AND
(
`user`.`nick` LIKE '%a%' AND
`user`.`nick` NOT LIKE '%a'
)
AND
(
`user`.`updated_at` IS NULL AND
`user`.`updated_at` IS NOT NULL
);
這裏我們發現,其實相等條件k: v
這種寫法是操作符寫法k:
{$eq: v}
的簡寫。而要實現不等條件就必須使用操作符寫法k: {$ne: v}
。
條件
上面我們說的條件查詢,都是AND
查詢,Sequelize
同時也支持OR
、NOT
、甚至多種條件的聯合查詢。
AND條件
Sequelize
:
var users = yield User.findAll({
'where': {
'$and': [
{'id': [1, 2]},
{'nick': null}
]
}
});
SQL
:
SELECT `id`, `emp_id`, `nick`, `department`, `created_at`, `updated_at`
FROM `users` AS `user`
WHERE
(
`user`.`id` IN (1, 2) AND
`user`.`nick` IS NULL
);
OR條件
Sequelize
:
var users = yield User.findAll({
'where': {
'$or': [
{'id': [1, 2]},
{'nick': null}
]
}
});
SQL
:
SELECT `id`, `emp_id`, `nick`, `department`, `created_at`, `updated_at`
FROM `users` AS `user`
WHERE
(
`user`.`id` IN (1, 2) OR
`user`.`nick` IS NULL
);
NOT條件
Sequelize
:
var users = yield User.findAll({
'where': {
'$not': [
{'id': [1, 2]},
{'nick': null}
]
}
});
SQL
:
SELECT `id`, `emp_id`, `nick`, `department`, `created_at`, `updated_at`
FROM `users` AS `user`
WHERE
NOT (
`user`.`id` IN (1, 2) AND
`user`.`nick` IS NULL
);
轉換規則
我們這裏做個總結。Sequelize
對where
配置的轉換規則的僞代碼大概如下:
function translate(where) {
for (k, v of where) {
if (k == 表字段) {
// 先統一轉爲操作符形式
if (v == 基本值) { // k: 'xxx'
v = {'$eq': v};
}
if (v == 數組) { // k: [1, 2, 3]
v = {'$in': v};
}
// 操作符轉換
for (opk, opv of v) {
// op將opk轉換對應的SQL表示
=> k + op(opk, opv) + AND;
}
}
// 邏輯操作符處理
if (k == '$and') {
for (item in v) {
=> translate(item) + AND;
}
}
if (k == '$or') {
for (item in v) {
=> translate(item) + OR;
}
}
if (k == '$not') {
NOT +
for (item in v) {
=> translate(item) + AND;
}
}
}
function op(opk, opv) {
switch (opk) {
case $eq => ('=' + opv) || 'IS NULL';
case $ne => ('!=' + opv) || 'IS NOT NULL';
case $gt => '>' + opv;
case $lt => '<' + opv;
case $gte => '>=' + opv;
case $lte => '<=' + opv;
case $between => 'BETWEEN ' + opv[0] + ' AND ' + opv[1];
case $notBetween => 'NOT BETWEEN ' + opv[0] + ' AND ' + opv[1];
case $in => 'IN (' + opv.join(',') + ')';
case $notIn => 'NOT IN (' + opv.join(',') + ')';
case $like => 'LIKE ' + opv;
case $notLike => 'NOT LIKE ' + opv;
}
}
}
我們看一個複雜例子,基本上就是按上述流程來進行轉換。
Sequelize
:
var users = yield User.findAll({
'where': {
'id': [3, 4],
'$not': [
{
'id': {
'$in': [1, 2]
}
},
{
'$or': [
{'id': [1, 2]},
{'nick': null}
]
}
],
'$and': [
{'id': [1, 2]},
{'nick': null}
],
'$or': [
{'id': [1, 2]},
{'nick': null}
]
}
});
SQL
:
SELECT `id`, `emp_id`, `nick`, `department`, `created_at`, `updated_at`
FROM `users` AS `user`
WHERE
`user`.`id` IN (3, 4)
AND
NOT
(
`user`.`id` IN (1, 2)
AND
(`user`.`id` IN (1, 2) OR `user`.`nick` IS NULL)
)
AND
(
`user`.`id` IN (1, 2) AND `user`.`nick` IS NULL
)
AND
(
`user`.`id` IN (1, 2) OR `user`.`nick` IS NULL
);
排序
Sequelize
:
var users = yield User.findAll({
'order': [
['id', 'DESC'],
['nick']
]
});
SQL
:
SELECT `id`, `emp_id`, `nick`, `department`, `created_at`, `updated_at`
FROM `users` AS `user`
ORDER BY `user`.`id` DESC, `user`.`nick`;
分頁
Sequelize
:
var countPerPage = 20, currentPage = 5;
var users = yield User.findAll({
'limit': countPerPage, // 每頁多少條
'offset': countPerPage * (currentPage - 1) // 跳過多少條
});
SQL
:
SELECT `id`, `emp_id`, `nick`, `department`, `created_at`, `updated_at`
FROM `users` AS `user`
LIMIT 80, 20;
其他查詢方法
查詢一條數據
Sequelize
:
user = yield User.findById(1);
user = yield User.findOne({
'where': {'nick': 'a'}
});
SQL
:
SELECT `id`, `emp_id`, `nick`, `department`, `created_at`, `updated_at`
FROM `users` AS `user`
WHERE `user`.`id` = 1 LIMIT 1;
SELECT `id`, `emp_id`, `nick`, `department`, `created_at`, `updated_at`
FROM `users` AS `user`
WHERE `user`.`nick` = 'a' LIMIT 1;
查詢並獲取數量
Sequelize
:
var result = yield User.findAndCountAll({
'limit': 20,
'offset': 0
});
console.log(result);
SQL
:
SELECT count(*) AS `count` FROM `users` AS `user`;
SELECT `id`, `emp_id`, `nick`, `department`, `created_at`, `updated_at`
FROM `users` AS `user`
LIMIT 20;
這個方法會執行2個SQL
,返回的result
對象將包含2個字段:result.count
是數據總數,result.rows
是符合查詢條件的所有數據。
批量操作
插入
Sequelize
:
var users = yield User.bulkCreate(
[
{'emp_id': 'a', 'nick': 'a'},
{'emp_id': 'b', 'nick': 'b'},
{'emp_id': 'c', 'nick': 'c'}
]
);
SQL
:
INSERT INTO `users`
(`id`,`emp_id`,`nick`,`created_at`,`updated_at`)
VALUES
(NULL,'a','a','2015-11-03 02:43:30','2015-11-03 02:43:30'),
(NULL,'b','b','2015-11-03 02:43:30','2015-11-03 02:43:30'),
(NULL,'c','c','2015-11-03 02:43:30','2015-11-03 02:43:30');
這裏需要注意,返回的users
數組裏面每個對象的id
值會是null
。如果需要id
值,可以重新取下數據。
更新
Sequelize
:
var affectedRows = yield User.update(
{'nick': 'hhhh'},
{
'where': {
'id': [2, 3, 4]
}
}
);
SQL
:
UPDATE `users`
SET `nick`='hhhh',`updated_at`='2015-11-03 02:51:05'
WHERE `id` IN (2, 3, 4);
這裏返回的affectedRows
其實是一個數組,裏面只有一個元素,表示更新的數據條數(看起來像是Sequelize
的一個bug
)。
刪除
Sequelize
:
var affectedRows = yield User.destroy({
'where': {'id': [2, 3, 4]}
});
SQL
:
DELETE FROM `users` WHERE `id` IN (2, 3, 4);
這裏返回的affectedRows
是一個數字,表示刪除的數據條數。
關係
關係一般有三種:一對一、一對多、多對多。Sequelize
提供了清晰易用的接口來定義關係、進行表間的操作。
當說到關係查詢時,一般會需要獲取多張表的數據。有建議用連表查詢join
的,有不建議的。我的看法是,join
查詢這種黑科技在數據量小的情況下可以使用,基本沒有什麼影響,數據量大的時候,join
的性能可能會是硬傷,應該儘量避免,可以分別根據索引取單表數據然後在應用層對數據進行join
、merge
。當然,查詢時一定要分頁,不要findAll
。
一對一
模型定義
Sequelize
:
var User = sequelize.define('user',
{
'emp_id': {
'type': Sequelize.CHAR(10),
'allowNull': false,
'unique': true
}
}
);
var Account = sequelize.define('account',
{
'email': {
'type': Sequelize.CHAR(20),
'allowNull': false
}
}
);
/*
* User的實例對象將擁有getAccount、setAccount、addAccount方法
*/
User.hasOne(Account);
/*
* Account的實例對象將擁有getUser、setUser、addUser方法
*/
Account.belongsTo(User);
SQL
:
CREATE TABLE IF NOT EXISTS `users` (
`id` INTEGER NOT NULL auto_increment ,
`emp_id` CHAR(10) NOT NULL UNIQUE,
`created_at` DATETIME NOT NULL,
`updated_at` DATETIME NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB;
CREATE TABLE IF NOT EXISTS `accounts` (
`id` INTEGER NOT NULL auto_increment ,
`email` CHAR(20) NOT NULL,
`created_at` DATETIME NOT NULL,
`updated_at` DATETIME NOT NULL,
`user_id` INTEGER,
PRIMARY KEY (`id`),
FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE SET NULL ON UPDATE CASCADE
) ENGINE=InnoDB;
可以看到,這種關係中外鍵user_id
加在了Account
上。另外,Sequelize
還給我們生成了外鍵約束。
一般來說,外鍵約束在有些自己定製的數據庫系統裏面是禁止的,因爲會帶來一些性能問題。所以,建表的SQL
一般就去掉約束,同時給外鍵加一個索引(加速查詢),數據的一致性就靠應用層來保證了。
關係操作
增
Sequelize
:
var user = yield User.create({'emp_id': '1'});
var account = user.createAccount({'email': 'a'});
console.log(account.get({'plain': true}));
SQL
:
INSERT INTO `users`
(`id`,`emp_id`,`updated_at`,`created_at`)
VALUES
(DEFAULT,'1','2015-11-03 06:24:53','2015-11-03 06:24:53');
INSERT INTO `accounts`
(`id`,`email`,`user_id`,`updated_at`,`created_at`)
VALUES
(DEFAULT,'a',1,'2015-11-03 06:24:53','2015-11-03 06:24:53');
SQL
執行邏輯是:
-
使用對應的的
user_id
作爲外鍵在accounts
表裏插入一條數據。
改
Sequelize
:
var anotherAccount = yield Account.create({'email': 'b'});
console.log(anotherAccount);
anotherAccount = yield user.setAccount(anotherAccount);
console.log(anotherAccount);
SQL
:
INSERT INTO `accounts`
(`id`,`email`,`updated_at`,`created_at`)
VALUES
(DEFAULT,'b','2015-11-03 06:37:14','2015-11-03 06:37:14');
SELECT `id`, `email`, `created_at`, `updated_at`, `user_id`
FROM `accounts` AS `account` WHERE (`account`.`user_id` = 1);
UPDATE `accounts` SET `user_id`=NULL,`updated_at`='2015-11-03 06:37:14' WHERE `id` = 1;
UPDATE `accounts` SET `user_id`=1,`updated_at`='2015-11-03 06:37:14' WHERE `id` = 2;
SQL
執行邏輯是:
-
插入一條
account
數據,此時外鍵user_id
是空的,還沒有關聯user -
找出當前
user
所關聯的account
並將其user_id
置爲`NUL(爲了保證一對一關係) -
設置新的
acount
的外鍵user_id
爲user
的屬性id
,生成關係
刪
Sequelize
:
yield user.setAccount(null);
SQL
:
SELECT `id`, `email`, `created_at`, `updated_at`, `user_id`
FROM `accounts` AS `account`
WHERE (`account`.`user_id` = 1);
UPDATE `accounts`
SET `user_id`=NULL,`updated_at`='2015-11-04 00:11:35'
WHERE `id` = 1;
這裏的刪除實際上只是“切斷”關係,並不會真正的物理刪除記錄。
SQL
執行邏輯是:
-
找出
user
所關聯的account
數據 -
將其外鍵
user_id
設置爲NULL
,完成關係的“切斷”
查
Sequelize
:
var account = yield user.getAccount();
console.log(account);
SQL
:
SELECT `id`, `email`, `created_at`, `updated_at`, `user_id`
FROM `accounts` AS `account`
WHERE (`account`.`user_id` = 1);
這裏就是調用user
的getAccount
方法,根據外鍵來獲取對應的account
。
但是其實我們用面向對象的思維來思考應該是獲取user
的時候就能通過user.account
的方式來訪問account
對象。這可以通過Sequelize
的eager
loading
(急加載,和懶加載相反)來實現。
eager loading
的含義是說,取一個模型的時候,同時也把相關的模型數據也給我取過來(我很着急,不能按默認那種取一個模型就取一個模型的方式,我還要更多)。方法如下:
Sequelize
:
var user = yield User.findById(1, {
'include': [Account]
});
console.log(user.get({'plain': true}));
/*
* 輸出類似:
{ id: 1,
emp_id: '1',
created_at: Tue Nov 03 2015 15:25:27 GMT+0800 (CST),
updated_at: Tue Nov 03 2015 15:25:27 GMT+0800 (CST),
account:
{ id: 2,
email: 'b',
created_at: Tue Nov 03 2015 15:25:27 GMT+0800 (CST),
updated_at: Tue Nov 03 2015 15:25:27 GMT+0800 (CST),
user_id: 1 } }
*/
SQL
:
SELECT `user`.`id`, `user`.`emp_id`, `user`.`created_at`, `user`.`updated_at`, `account`.`id` AS `account.id`, `account`.`email` AS `account.email`, `account`.`created_at` AS `account.created_at`, `account`.`updated_at` AS `account.updated_at`, `account`.`user_id` AS `account.user_id`
FROM `users` AS `user` LEFT OUTER JOIN `accounts` AS `account`
ON `user`.`id` = `account`.`user_id`
WHERE `user`.`id` = 1 LIMIT 1;
可以看到,我們對2個表進行了一個外聯接,從而在取user
的同時也獲取到了account
。
其他補充說明
如果我們重複調用user.createAccount
方法,實際上會在數據庫裏面生成多條user_id
一樣的數據,並不是真正的一對一。
所以,在應用層保證一致性時,就需要我們遵循良好的編碼約定。新增就用user.createAccount
,更改就用user.setAccount
。
也可以給user_id
加一個UNIQUE
約束,在數據庫層面保證一致性,這時就需要做好try/catch
,發生插入異常的時候能夠知道是因爲插入了多個account
。
另外,我們上面都是使用user
來對account
進行操作。實際上反向操作也是可以的,這是因爲我們定義了Account.belongsTo(User)
。在Sequelize
裏面定義關係時,關係的調用方會獲得相關的“關係”方法,一般爲了兩邊都能操作,會同時定義雙向關係(這裏雙向關係指的是模型層面,並不會在數據庫表中出現兩個表都加上外鍵的情況,請放心)。
一對多
模型定義
Sequelize
:
var User = sequelize.define('user',
{
'emp_id': {
'type': Sequelize.CHAR(10),
'allowNull': false,
'unique': true
}
}
);
var Note = sequelize.define('note',
{
'title': {
'type': Sequelize.CHAR(64),
'allowNull': false
}
}
);
/*
* User的實例對象將擁有getNotes、setNotes、addNote、createNote、removeNote、hasNote方法
*/
User.hasMany(Note);
/*
* Note的實例對象將擁有getUser、setUser、createUser方法
*/
Note.belongsTo(User);
SQL
:
CREATE TABLE IF NOT EXISTS `users` (
`id` INTEGER NOT NULL auto_increment ,
`emp_id` CHAR(10) NOT NULL UNIQUE,
`created_at` DATETIME NOT NULL,
`updated_at` DATETIME NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB;
CREATE TABLE IF NOT EXISTS `notes` (
`id` INTEGER NOT NULL auto_increment ,
`title` CHAR(64) NOT NULL,
`created_at` DATETIME NOT NULL,
`updated_at` DATETIME NOT NULL,
`user_id` INTEGER,
PRIMARY KEY (`id`),
FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE SET NULL ON UPDATE CASCADE
) ENGINE=InnoDB;
可以看到這種關係中,外鍵user_id
加在了多的一端(notes
表)。同時相關的模型也自動獲得了一些方法。
關係操作
增
方法1
Sequelize
:
var user = yield User.create({'emp_id': '1'});
var note = yield user.createNote({'title': 'a'});
console.log(note);
SQL
:
NSERT INTO `users`
(`id`,`emp_id`,`updated_at`,`created_at`)
VALUES
(DEFAULT,'1','2015-11-03 23:52:05','2015-11-03 23:52:05');
INSERT INTO `notes`
(`id`,`title`,`user_id`,`updated_at`,`created_at`)
VALUES
(DEFAULT,'a',1,'2015-11-03 23:52:05','2015-11-03 23:52:05');
SQL
執行邏輯:
-
使用
user
的主鍵id
值作爲外鍵直接在notes
表裏插入一條數據。
方法2
Sequelize
:
var user = yield User.create({'emp_id': '1'});
var note = yield Note.create({'title': 'b'});
yield user.addNote(note);
SQL
:
INSERT INTO `users`
(`id`,`emp_id`,`updated_at`,`created_at`)
VALUES
(DEFAULT,'1','2015-11-04 00:02:56','2015-11-04 00:02:56');
INSERT INTO `notes`
(`id`,`title`,`updated_at`,`created_at`)
VALUES
(DEFAULT,'b','2015-11-04 00:02:56','2015-11-04 00:02:56');
UPDATE `notes`
SET `user_id`=1,`updated_at`='2015-11-04 00:02:56'
WHERE `id` IN (1);
SQL
執行邏輯:
-
插入一條
note
數據,此時該條數據的外鍵user_id
爲空 -
使用
user
的屬性id
值再更新該條note
數據,設置好外鍵,完成關係建立
改
Sequelize
:
// 爲user增加note1、note2
var user = yield User.create({'emp_id': '1'});
var note1 = yield user.createNote({'title': 'a'});
var note2 = yield user.createNote({'title': 'b'});
// 先創建note3、note4
var note3 = yield Note.create({'title': 'c'});
var note4 = yield Note.create({'title': 'd'});
// user擁有的note更改爲note3、note4
yield user.setNotes([note3, note4]);
SQL
:
/* 省去了創建語句 */
SELECT `id`, `title`, `created_at`, `updated_at`, `user_id`
FROM `notes` AS `note` WHERE `note`.`user_id` = 1;
UPDATE `notes`
SET `user_id`=NULL,`updated_at`='2015-11-04 12:45:12'
WHERE `id` IN (1, 2);
UPDATE `notes`
SET `user_id`=1,`updated_at`='2015-11-04 12:45:12'
WHERE `id` IN (3, 4);
SQL
執行邏輯:
-
根據
user
的屬性id
查詢所有相關的note
數據 -
將
note1
、note2
的外鍵user_id
置爲NULL
,切斷關係 -
將
note3
、note4
的外鍵user_id
置爲user
的屬性id
,完成關係建立
這裏爲啥還要查出所有的note
數據呢?因爲我們需要根據傳人setNotes
的數組來計算出哪些note
要切斷關係、哪些要新增關係,所以就需要查出來進行一個計算集合的“交集”運算。
刪
Sequelize
:
var user = yield User.create({'emp_id': '1'});
var note1 = yield user.createNote({'title': 'a'});
var note2 = yield user.createNote({'title': 'b'});
yield user.setNotes([]);
SQL
:
SELECT `id`, `title`, `created_at`, `updated_at`, `user_id`
FROM `notes` AS `note` WHERE `note`.`user_id` = 1;
UPDATE `notes`
SET `user_id`=NULL,`updated_at`='2015-11-04 12:50:08'
WHERE `id` IN (1, 2);
實際上,上面說到的“改”已經有“刪”的操作了(去掉note1
、note2
的關係)。這裏的操作是刪掉用戶的所有note
數據,直接執行user.setNotes([])
即可。
SQL
執行邏輯:
-
根據
user
的屬性id
查出所有相關的note
數據 -
將其外鍵
user_id
置爲NULL
,切斷關係
還有一個真正的刪除方法,就是removeNote
。如下所示:
Sequelize
:
yield user.removeNote(note);
SQL
:
UPDATE `notes`
SET `user_id`=NULL,`updated_at`='2015-11-06 01:40:12'
WHERE `user_id` = 1 AND `id` IN (1);
查
情況1
查詢user
的所有滿足條件的note
數據。
Sequelize
:
var notes = yield user.getNotes({
'where': {
'title': {
'$like': '%css%'
}
}
});
notes.forEach(function(note) {
console.log(note);
});
SQL
:
SELECT `id`, `title`, `created_at`, `updated_at`, `user_id`
FROM `notes` AS `note`
WHERE (`note`.`user_id` = 1 AND `note`.`title` LIKE '%a%');
這種方法的SQL
很簡單,直接根據user
的id
值來查詢滿足條件的note
即可。
情況2
查詢所有滿足條件的note
,同時獲取note
屬於哪個user
。
Sequelize
:
var notes = yield Note.findAll({
'include': [User],
'where': {
'title': {
'$like': '%css%'
}
}
});
notes.forEach(function(note) {
// note屬於哪個user可以通過note.user訪問
console.log(note);
});
SQL
:
SELECT `note`.`id`, `note`.`title`, `note`.`created_at`, `note`.`updated_at`, `note`.`user_id`,
`user`.`id` AS `user.id`, `user`.`emp_id` AS `user.emp_id`, `user`.`created_at` AS `user.created_at`, `user`.`updated_at` AS `user.updated_at`
FROM `notes` AS `note` LEFT OUTER JOIN `users` AS `user`
ON `note`.`user_id` = `user`.`id`
WHERE `note`.`title` LIKE '%css%';
這種方法,因爲獲取的主體是note
,所以將notes
去left
join
了users
。
情況3
查詢所有滿足條件的user
,同時獲取該user
所有滿足條件的note
。
Sequelize
:
var users = yield User.findAll({
'include': [Note],
'where': {
'created_at': {
'$lt': new Date()
}
}
});
users.forEach(function(user) {
// user的notes可以通過user.notes訪問
console.log(user);
});
SQL
:
SELECT `user`.`id`, `user`.`emp_id`, `user`.`created_at`, `user`.`updated_at`,
`notes`.`id` AS `notes.id`, `notes`.`title` AS `notes.title`, `notes`.`created_at` AS `notes.created_at`, `notes`.`updated_at` AS `notes.updated_at`, `notes`.`user_id` AS `notes.user_id`
FROM `users` AS `user` LEFT OUTER JOIN `notes` AS `notes`
ON `user`.`id` = `notes`.`user_id`
WHERE `user`.`created_at` < '2015-11-05 01:51:35';
這種方法獲取的主體是user
,所以將users
去left
join
了notes
。
一點補充
關於各種join的區別,可以參考:http://blog.codinghorror.com/a-visual-explanation-of-sql-joins/。
關於eager loading
我想再囉嗦幾句。include
裏面傳遞的是去取相關模型,默認是取全部,我們也可以再對這個模型進行一層過濾。像下面這樣:
Sequelize
:
// 查詢創建時間在今天之前的所有user,同時獲取他們note的標題中含有關鍵字css的所有note
var users = yield User.findAll({
'include': [
{
'model': Note,
'where': {
'title': {
'$like': '%css%'
}
}
}
],
'where': {
'created_at': {
'$lt': new Date()
}
}
});
SQL
:
SELECT `user`.`id`, `user`.`emp_id`, `user`.`created_at`, `user`.`updated_at`,
`notes`.`id` AS `notes.id`, `notes`.`title` AS `notes.title`, `notes`.`created_at` AS `notes.created_at`, `notes`.`updated_at` AS `notes.updated_at`, `notes`.`user_id` AS `notes.user_id`
FROM `users` AS `user` INNER JOIN `notes` AS `notes`
ON `user`.`id` = `notes`.`user_id` AND `notes`.`title` LIKE '%css%'
WHERE `user`.`created_at` < '2015-11-05 01:58:31';
注意:當我們對include
的模型加了where
過濾時,會使用inner
join
來進行查詢,這樣保證只有那些擁有標題含有css
關鍵詞note
的用戶纔會返回。
多對多關係
在多對多關係中,必須要額外一張關係表來將2個表進行關聯,這張表可以是單純的一個關係表,也可以是一個實際的模型(含有自己的額外屬性來描述關係)。我比較喜歡用一個模型的方式,這樣方便以後做擴展。
模型定義
Sequelize
:
var Note = sequelize.define('note',
{
'title': {
'type': Sequelize.CHAR(64),
'allowNull': false
}
}
);
var Tag = sequelize.define('tag',
{
'name': {
'type': Sequelize.CHAR(64),
'allowNull': false,
'unique': true
}
}
);
var Tagging = sequelize.define('tagging',
{
'type': {
'type': Sequelize.INTEGER(),
'allowNull': false
}
}
);
// Note的實例擁有getTags、setTags、addTag、addTags、createTag、removeTag、hasTag方法
Note.belongsToMany(Tag, {'through': Tagging});
// Tag的實例擁有getNotes、setNotes、addNote、addNotes、createNote、removeNote、hasNote方法
Tag.belongsToMany(Note, {'through': Tagging});
SQL
:
CREATE TABLE IF NOT EXISTS `notes` (
`id` INTEGER NOT NULL auto_increment ,
`title` CHAR(64) NOT NULL,
`created_at` DATETIME NOT NULL,
`updated_at` DATETIME NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB;
CREATE TABLE IF NOT EXISTS `tags` (
`id` INTEGER NOT NULL auto_increment ,
`name` CHAR(64) NOT NULL UNIQUE,
`created_at` DATETIME NOT NULL,
`updated_at` DATETIME NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB;
CREATE TABLE IF NOT EXISTS `taggings` (
`type` INTEGER NOT NULL,
`created_at` DATETIME NOT NULL,
`updated_at` DATETIME NOT NULL,
`tag_id` INTEGER ,
`note_id` INTEGER ,
PRIMARY KEY (`tag_id`, `note_id`),
FOREIGN KEY (`tag_id`) REFERENCES `tags` (`id`) ON DELETE CASCADE ON UPDATE CASCADE,
FOREIGN KEY (`note_id`) REFERENCES `notes` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB;
可以看到,多對多關係中單獨生成了一張關係表,並設置了2個外鍵tag_id
和note_id
來和tags
和notes
進行關聯。關於關係表的命名,我比較喜歡使用動詞,因爲這張表是用來表示兩張表的一種聯繫,而且這種聯繫多數時候伴隨着一種動作。比如:用戶收藏商品(collecting
)、用戶購買商品(buying
)、用戶加入項目(joining
)等等。
增
方法1
Sequelize
:
var note = yield Note.create({'title': 'note'});
yield note.createTag({'name': 'tag'}, {'type': 0});
SQL
:
INSERT INTO `notes`
(`id`,`title`,`updated_at`,`created_at`)
VALUES
(DEFAULT,'note','2015-11-06 02:14:38','2015-11-06 02:14:38');
INSERT INTO `tags`
(`id`,`name`,`updated_at`,`created_at`)
VALUES
(DEFAULT,'tag','2015-11-06 02:14:38','2015-11-06 02:14:38');
INSERT INTO `taggings`
(`tag_id`,`note_id`,`type`,`created_at`,`updated_at`)
VALUES
(1,1,0,'2015-11-06 02:14:38','2015-11-06 02:14:38');
SQL
執行邏輯:
-
在
notes
表插入記錄 -
在
tags
表中插入記錄 -
使用對應的值設置外鍵
tag_id
和note_id
以及關係模型本身需要的屬性(type: 0
)在關係表tagging
中插入記錄
關係表本身需要的屬性,通過傳遞一個額外的對象給設置方法來實現。
方法2
Sequelize
:
var note = yield Note.create({'title': 'note'});
var tag = yield Tag.create({'name': 'tag'});
yield note.addTag(tag, {'type': 1});
SQL
:
INSERT INTO `notes`
(`id`,`title`,`updated_at`,`created_at`)
VALUES
(DEFAULT,'note','2015-11-06 02:20:52','2015-11-06 02:20:52');
INSERT INTO `tags`
(`id`,`name`,`updated_at`,`created_at`)
VALUES
(DEFAULT,'tag','2015-11-06 02:20:52','2015-11-06 02:20:52');
INSERT INTO `taggings`
(`tag_id`,`note_id`,`type`,`created_at`,`updated_at`)
VALUES
(1,1,1,'2015-11-06 02:20:52','2015-11-06 02:20:52');
這種方法和上面的方法實際上是一樣的。只是我們先手動create
了一個Tag
模型。
方法3
Sequelize
:
var note = yield Note.create({'title': 'note'});
var tag1 = yield Tag.create({'name': 'tag1'});
var tag2 = yield Tag.create({'name': 'tag2'});
yield note.addTags([tag1, tag2], {'type': 2});
SQL
:
INSERT INTO `notes`
(`id`,`title`,`updated_at`,`created_at`)
VALUES
(DEFAULT,'note','2015-11-06 02:25:18','2015-11-06 02:25:18');
INSERT INTO `tags`
(`id`,`name`,`updated_at`,`created_at`)
VALUES
(DEFAULT,'tag1','2015-11-06 02:25:18','2015-11-06 02:25:18');
INSERT INTO `tags`
(`id`,`name`,`updated_at`,`created_at`)
VALUES
(DEFAULT,'tag2','2015-11-06 02:25:18','2015-11-06 02:25:18');
INSERT INTO `taggings` (`tag_id`,`note_id`,`type`,`created_at`,`updated_at`)
VALUES
(1,1,2,'2015-11-06 02:25:18','2015-11-06 02:25:18'),
(2,1,2,'2015-11-06 02:25:18','2015-11-06 02:25:18');
這種方法可以進行批量添加。當執行addTags
時,實際上就是設置好對應的外鍵及關係模型本身的屬性,然後在關係表中批量的插入數據。
改
Sequelize
:
// 先添加幾個tag
var note = yield Note.create({'title': 'note'});
var tag1 = yield Tag.create({'name': 'tag1'});
var tag2 = yield Tag.create({'name': 'tag2'});
yield note.addTags([tag1, tag2], {'type': 2});
// 將tag改掉
var tag3 = yield Tag.create({'name': 'tag3'});
var tag4 = yield Tag.create({'name': 'tag4'});
yield note.setTags([tag3, tag4], {'type': 3});
SQL
:
/* 前面添加部分的sql,和上面一樣*/
INSERT INTO `notes`
(`id`,`title`,`updated_at`,`created_at`)
VALUES
(DEFAULT,'note','2015-11-06 02:25:18','2015-11-06 02:25:18');
INSERT INTO `tags`
(`id`,`name`,`updated_at`,`created_at`)
VALUES
(DEFAULT,'tag1','2015-11-06 02:25:18','2015-11-06 02:25:18');
INSERT INTO `tags`
(`id`,`name`,`updated_at`,`created_at`)
VALUES
(DEFAULT,'tag2','2015-11-06 02:25:18','2015-11-06 02:25:18');
INSERT INTO `taggings`
(`tag_id`,`note_id`,`type`,`created_at`,`updated_at`)
VALUES
(1,1,2,'2015-11-06 02:25:18','2015-11-06 02:25:18'),
(2,1,2,'2015-11-06 02:25:18','2015-11-06 02:25:18');
/* 更改部分的sql */
INSERT INTO `tags`
(`id`,`name`,`updated_at`,`created_at`)
VALUES
(DEFAULT,'tag3','2015-11-06 02:29:55','2015-11-06 02:29:55');
INSERT INTO `tags`
(`id`,`name`,`updated_at`,`created_at`)
VALUES
(DEFAULT,'tag4','2015-11-06 02:29:55','2015-11-06 02:29:55');
/* 先刪除關係 */
DELETE FROM `taggings`
WHERE `note_id` = 1 AND `tag_id` IN (1, 2);
/* 插入新關係 */
INSERT INTO `taggings`
(`tag_id`,`note_id`,`type`,`created_at`,`updated_at`)
VALUES
(3,1,3,'2015-11-06 02:29:55','2015-11-06 02:29:55'),
(4,1,3,'2015-11-06 02:29:55','2015-11-06 02:29:55');
執行邏輯是,先將tag1
、tag2
在關係表中的關係刪除,然後再將tag3
、tag4
對應的關係插入關係表。
刪
Sequelize
:
// 先添加幾個tag
var note = yield Note.create({'title': 'note'});
var tag1 = yield Tag.create({'name': 'tag1'});
var tag2 = yield Tag.create({'name': 'tag2'});
var tag3 = yield Tag.create({'name': 'tag2'});
yield note.addTags([tag1, tag2, tag3], {'type': 2});
// 刪除一個
yield note.removeTag(tag1);
// 全部刪除
yield note.setTags([]);
SQL
:
/* 刪除一個 */
DELETE FROM `taggings` WHERE `note_id` = 1 AND `tag_id` IN (1);
/* 刪除全部 */
SELECT `type`, `created_at`, `updated_at`, `tag_id`, `note_id`
FROM `taggings` AS `tagging`
WHERE `tagging`.`note_id` = 1;
DELETE FROM `taggings` WHERE `note_id` = 1 AND `tag_id` IN (2, 3);
刪除一個很簡單,直接將關係表中的數據刪除。
全部刪除時,首先需要查出關係表中note_id
對應的所有數據,然後一次刪掉。
查
情況1
查詢note
所有滿足條件的tag
。
Sequelize
:
var tags = yield note.getTags({
//這裏可以對tags進行where
});
tags.forEach(function(tag) {
// 關係模型可以通過tag.tagging來訪問
console.log(tag);
});
SQL
:
SELECT `tag`.`id`, `tag`.`name`, `tag`.`created_at`, `tag`.`updated_at`,
`tagging`.`type` AS `tagging.type`, `tagging`.`created_at` AS `tagging.created_at`, `tagging`.`updated_at` AS `tagging.updated_at`, `tagging`.`tag_id` AS `tagging.tag_id`, `tagging`.`note_id` AS `tagging.note_id`
FROM `tags` AS `tag`
INNER JOIN `taggings` AS `tagging`
ON
`tag`.`id` = `tagging`.`tag_id` AND `tagging`.`note_id` = 1;
可以看到這種查詢,就是執行一個inner join
。
情況2
查詢所有滿足條件的tag
,同時獲取每個tag
所在的note
。
Sequelize
:
var tags = yield Tag.findAll({
'include': [
{
'model': Note
// 這裏可以對notes進行where
}
]
// 這裏可以對tags進行where
});
tags.forEach(function(tag) {
// tag的notes可以通過tag.notes訪問,關係模型可以通過tag.notes[0].tagging訪問
console.log(tag);
});
SQL
:
SELECT `tag`.`id`, `tag`.`name`, `tag`.`created_at`, `tag`.`updated_at`,
`notes`.`id` AS `notes.id`, `notes`.`title` AS `notes.title`, `notes`.`created_at` AS `notes.created_at`, `notes`.`updated_at` AS `notes.updated_at`,
`notes.tagging`.`type` AS `notes.tagging.type`, `notes.tagging`.`created_at` AS `notes.tagging.created_at`, `notes.tagging`.`updated_at` AS `notes.tagging.updated_at`, `notes.tagging`.`tag_id` AS `notes.tagging.tag_id`, `notes.tagging`.`note_id` AS `notes.tagging.note_id`
FROM `tags` AS `tag`
LEFT OUTER JOIN
(
`taggings` AS `notes.tagging` INNER JOIN `notes` AS `notes`
ON
`notes`.`id` = `notes.tagging`.`note_id`
)
ON `tag`.`id` = `notes.tagging`.`tag_id`;
這個查詢就稍微有點複雜。首先是notes
和taggings
進行了一個inner
join
,選出notes
;然後tags
和剛join
出的集合再做一次left
join
,得到結果。
情況3
查詢所有滿足條件的note
,同時獲取每個note
所有滿足條件的tag
。
Sequelize
:
var notes = yield Note.findAll({
'include': [
{
'model': Tag
// 這裏可以對tags進行where
}
]
// 這裏可以對notes進行where
});
notes.forEach(function(note) {
// note的tags可以通過note.tags訪問,關係模型通過note.tags[0].tagging訪問
console.log(note);
});
SQL
:
SELECT
`note`.`id`, `note`.`title`, `note`.`created_at`, `note`.`updated_at`,
`tags`.`id` AS `tags.id`, `tags`.`name` AS `tags.name`, `tags`.`created_at` AS `tags.created_at`, `tags`.`updated_at` AS `tags.updated_at`,
`tags.tagging`.`type` AS `tags.tagging.type`, `tags.tagging`.`created_at` AS `tags.tagging.created_at`, `tags.tagging`.`updated_at` AS `tags.tagging.updated_at`, `tags.tagging`.`tag_id` AS `tags.tagging.tag_id`, `tags.tagging`.`note_id` AS `tags.tagging.note_id`
FROM `notes` AS `note`
LEFT OUTER JOIN
(
`taggings` AS `tags.tagging` INNER JOIN `tags` AS `tags`
ON
`tags`.`id` = `tags.tagging`.`tag_id`
)
ON
`note`.`id` = `tags.tagging`.`note_id`;
這個查詢和上面的查詢類似。首先是tags
和taggins
進行了一個inner
join
,選出tags
;然後notes
和剛join
出的集合再做一次left
join
,得到結果。
其他沒有涉及東西
這篇文章已經夠長了,但是其實我們還有很多沒有涉及的東西,比如:聚合函數及查詢(having
、group
by
)、模型的驗證(validate
)、定義鉤子(hooks
)、索引等等。
這些主題下次再來寫寫。