sequelize基础知识学习整理

sequelize文档

安装

1
2
3
4
5
6
npm install --save sequelize
# And one of the following:
npm install --save pg pg-hstore
npm install --save mysql2
npm install --save sqlite3
npm install --save tedious // MSSQL

连接

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
const Sequelize = require('sequelize');
const sequelize = new Sequelize('database', 'username', 'password', {
host: 'localhost',
port: port,
dialect: 'mysql'|'sqlite'|'postgres'|'mssql',
operatorsAliases: false,

pool: {
max: 5,
min: 0,
acquire: 30000,
idle: 10000
},

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

model

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
const User = sequelize.define('user', {
firstName: {
type: Sequelize.STRING
},
lastName: {
type: Sequelize.STRING
}
}, {
freezeTableName: true // 模型名字与表名相同
});

// 创建表
// force: true 如果表已经存在,将会丢弃表
User.sync();
// User.sync({force: true})

mdoel 类型

以下是 Sequelize 支持的一些数据类型.有关完整和更新的列表, 参阅DataTypes

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
Sequelize.STRING                      // VARCHAR(255)
Sequelize.STRING(1234) // VARCHAR(1234)
Sequelize.STRING.BINARY // VARCHAR BINARY
Sequelize.TEXT // TEXT
Sequelize.TEXT('tiny') // TINYTEXT

Sequelize.INTEGER // INTEGER
Sequelize.BIGINT // BIGINT
Sequelize.BIGINT(11) // BIGINT(11)

Sequelize.FLOAT // FLOAT
Sequelize.FLOAT(11) // FLOAT(11)
Sequelize.FLOAT(11, 12) // FLOAT(11,12)

Sequelize.REAL // REAL 仅限于PostgreSQL.
Sequelize.REAL(11) // REAL(11) 仅限于PostgreSQL.
Sequelize.REAL(11, 12) // REAL(11,12) 仅限于PostgreSQL.

Sequelize.DOUBLE // DOUBLE
Sequelize.DOUBLE(11) // DOUBLE(11)
Sequelize.DOUBLE(11, 12) // DOUBLE(11,12)

Sequelize.DECIMAL // DECIMAL
Sequelize.DECIMAL(10, 2) // DECIMAL(10,2)

Sequelize.DATE // DATETIME 针对 mysql / sqlite, TIMESTAMP WITH TIME ZONE 针对 postgres
Sequelize.DATE(6) // DATETIME(6) 针对 mysql 5.6.4+. 小数秒支持多达6位精度
Sequelize.DATEONLY // DATE 不带时间.
Sequelize.BOOLEAN // TINYINT(1)

Sequelize.ENUM('value 1', 'value 2') // 一个允许具有 “value 1” 和 “value 2” 的 ENUM
Sequelize.ARRAY(Sequelize.TEXT) // 定义一个数组。 仅限于 PostgreSQL。
Sequelize.ARRAY(Sequelize.ENUM) // 定义一个 ENUM 数组. 仅限于 PostgreSQL。

Sequelize.JSON // JSON 列. 仅限于 PostgreSQL, SQLite and MySQL.
Sequelize.JSONB // JSONB 列. 仅限于 PostgreSQL .

Sequelize.BLOB // BLOB (PostgreSQL 二进制)
Sequelize.BLOB('tiny') // TINYBLOB (PostgreSQL 二进制. 其他参数是 medium 和 long)

Sequelize.UUID // PostgreSQL 和 SQLite 的 UUID 数据类型, CHAR(36) BINARY 针对于 MySQL (使用默认值: Sequelize.UUIDV1 或 Sequelize.UUIDV4 来让 sequelize 自动生成 ID)

Sequelize.CIDR // PostgreSQL 的 CIDR 数据类型
Sequelize.INET // PostgreSQL 的 INET 数据类型
Sequelize.MACADDR // PostgreSQL 的 MACADDR

Sequelize.RANGE(Sequelize.INTEGER) // 定义 int4range 范围. 仅限于 PostgreSQL.
Sequelize.RANGE(Sequelize.BIGINT) // 定义 int8range 范围. 仅限于 PostgreSQL.
Sequelize.RANGE(Sequelize.DATE) // 定义 tstzrange 范围. 仅限于 PostgreSQL.
Sequelize.RANGE(Sequelize.DATEONLY) // 定义 daterange 范围. 仅限于 PostgreSQL.
Sequelize.RANGE(Sequelize.DECIMAL) // 定义 numrange 范围. 仅限于 PostgreSQL.

Sequelize.ARRAY(Sequelize.RANGE(Sequelize.DATE)) // 定义 tstzrange 范围的数组. 仅限于 PostgreSQL.

Sequelize.GEOMETRY // 空间列. 仅限于 PostgreSQL (具有 PostGIS) 或 MySQL.
Sequelize.GEOMETRY('POINT') // 具有几何类型的空间列. 仅限于 PostgreSQL (具有 PostGIS) 或 MySQL.
Sequelize.GEOMETRY('POINT', 4326) // 具有几何类型和SRID的空间列. 仅限于 PostgreSQL (具有 PostGIS) 或 MySQL.

mdoel defaultValue

find 使用

find 搜索数据库中的一个特定元素
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// 搜索已知的ids
Project.findById(123).then(project => {
// project 将是 Project的一个实例,并具有在表中存为 id 123 条目的内容。
// 如果没有定义这样的条目,你将获得null
})

// 搜索属性
Project.findOne({
where: {
title: 'aProject'
}
}).then(project => {
// project 将是 Projects 表中 title 为 'aProject' 的第一个条目 || null
})


Project.findOne({
where: {title: 'aProject'},
attributes: ['id', ['name', 'title']]
}).then(project => {
// project 将是 Projects 表中 title 为 'aProject' 的第一个条目 || null
// project.title 将包含 project 的 name
})
findOrCreate 搜索特定元素或创建它(如果不可用)

我们有一个空的数据库,一个 User 模型有一个 username 和 job

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
User
.findOrCreate({
where: {username: 'sdepold'},
defaults: {job: 'Technical Lead JavaScript'}
})
.spread((user, created) => {
console.log(user.get({
plain: true
}))
console.log(created)
/*
findOrCreate 返回一个包含已找到或创建的对象的数组,找到或创建的对象和一个布尔值,如果创建一个新对象将为true,否则为false,像这样:

[ {
username: 'sdepold',
job: 'Technical Lead JavaScript',
id: 1
},
true ]

在上面的例子中,".spread" 将数组分成2部分,并将它们作为参数传递给回调函数,在这种情况下将它们视为 "user" 和 "created" 。(所以“user”将是返回数组的索引0的对象,并且 "created" 将等于 "true"。)
*/
})

创建了一个新的实例.所以当我们已经有一个实例了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
User.create({ username: 'fnord', job: 'omnomnom' })
.then(() => User.findOrCreate({
where: {username: 'fnord'},
defaults: {job: 'something else'}
}))
.spread((user, created) => {
console.log(user.get({
plain: true
}))
console.log(created)

/*
在这个例子中,findOrCreate 返回一个如下的数组:
[ {
username: 'fnord',
job: 'omnomnom',
id: 2
},
false
]
由findOrCreate返回的数组通过 ".spread" 扩展为两部分,并且这些部分将作为2个参数传递给回调函数,在这种情况下将其视为 "user" 和 "created".(所以“user”将是返回数组的索引0的对象,并且 "created" 将等于 "false"。)
*/
})

findAndCountAll - 在数据库中搜索多个元素,返回数据和总计数

处理程序成功将始终接收具有两个属性的对象:

  • count - 一个整数,总数记录匹配where语句和关联的其它过滤器
  • rows - 一个数组对象,记录在limit和offset范围内匹配where语句和关联的其它过滤器
1
2
3
4
5
6
7
8
9
10
11
12
13
14
Project
.findAndCountAll({
where: {
title: {
[Op.like]: 'foo%'
}
},
offset: 10,
limit: 2
})
.then(result => {
console.log(result.count)
console.log(result.rows);
})

它支持 include。 只有标记为 required 的 include 将被添加到计数部分:

假设您想查找附有个人资料的所有用户:

1
2
3
4
5
6
User.findAndCountAll({
include: [
{ model: Profile, required: true}
],
limit: 3
});

因为 Profile 的 include 有 required 设置,这将导致内部连接,并且只有具有 profile 的用户将被计数。 如果我们从 include 中删除required,那么有和没有 profile 的用户都将被计数。 在include中添加一个 where 语句会自动使它成为 required:

1
2
3
4
5
6
User.findAndCountAll({
include: [
{ model: Profile, where: { active: true }}
],
limit: 3
});

上面的查询只会对具有 active profile 的用户进行计数,因为在将 where 语句添加到 include 时,required 被隐式设置为 true

传递给 findAndCountAll 的 options 对象与 findAll 相同(如下所述)

findAll - 搜索数据库中的多个元素
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
// 找到多个条目
Project.findAll().then(projects => {
// projects 将是所有 Project 实例的数组
})

// 也可以:
Project.all().then(projects => {
// projects 将是所有 Project 实例的数组
})

// 搜索特定属性 - 使用哈希
Project.findAll({ where: { name: 'A Project' } }).then(projects => {
// projects将是一个具有指定 name 的 Project 实例数组
})

// 在特定范围内进行搜索
Project.findAll({ where: { id: [1,2,3] } }).then(projects => {
// projects将是一系列具有 id 1,2 或 3 的项目
// 这实际上是在做一个 IN 查询
})

Project.findAll({
where: {
id: {
[Op.and]: {a: 5}, // 且 (a = 5)
[Op.or]: [{a: 5}, {a: 6}], // (a = 5 或 a = 6)
[Op.gt]: 6, // id > 6
[Op.gte]: 6, // id >= 6
[Op.lt]: 10, // id < 10
[Op.lte]: 10, // id <= 10
[Op.ne]: 20, // id != 20
[Op.between]: [6, 10], // 在 6 和 10 之间
[Op.notBetween]: [11, 15], // 不在 11 和 15 之间
[Op.in]: [1, 2], // 在 [1, 2] 之中
[Op.notIn]: [1, 2], // 不在 [1, 2] 之中
[Op.like]: '%hat', // 包含 '%hat'
[Op.notLike]: '%hat', // 不包含 '%hat'
[Op.iLike]: '%hat', // 包含 '%hat' (不区分大小写) (仅限 PG)
[Op.notILike]: '%hat', // 不包含 '%hat' (仅限 PG)
[Op.overlap]: [1, 2], // && [1, 2] (PG数组重叠运算符)
[Op.contains]: [1, 2], // @> [1, 2] (PG数组包含运算符)
[Op.contained]: [1, 2], // <@ [1, 2] (PG数组包含于运算符)
[Op.any]: [2,3], // 任何数组[2, 3]::INTEGER (仅限 PG)
},
status: {
[Op.not]: false, // status 不为 FALSE
}
}
})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// 限制字段
var users = await User.findAll({
'attributes': ['emp_id', 'nick']
});
SELECT `emp_id`, `nick` FROM `users`;

// 字段重命名
var users = await User.findAll({
'attributes': [
'emp_id', ['nick', 'user_nick']
]
})
SELECT `emp_id`, `nick` AS `user_nick` FROM `users`;

// where子句
var users = await User.findAll({
'where': {
'id': [1, 2, 3],
'nick': 'a',
'department': null
}
})
SELECT `id`, `emp_id`, `nick`, `department`, `created_at`, `updated_at`
FROM `user`
WHERE
`user`.`id` IN (1, 2, 3) AND
`user`.`nick`='a' AND
`user`.`department` IS NULL;

操作符 where

1
2
3
4
5
6
7
8
9
10
11
12
13
14
'$eq': 1,                //  = 1
'$ne': 2, // != 2
'$gt': 6, // > 6
'$gte': 6, // >= 6
'$lt': 10, // < 10
'$lte': 10, // <= 10
'$between': [6, 10], // BETWEEN 6 AND 10
'$notBetween': [11, 15], // NOT BETWEEN 11 AND 15
'$in': [1, 2], // IN (1, 2)
'$notIn': [3, 4] // NOT IN (3, 4)
'$like': '%a%', // LIKE '%a%'
'$notLike': '%a' // NOT LIKE '%a'
'$eq': null, // IS NULL
'$ne': null // IS NOT NULL


  • $and
  • $or
  • $not
  • order 排序
  • 分页 User.findAll({
    ‘limit’: countPerPage, // 每页多少条
    ‘offset’: countPerPage * (currentPage - 1)// 跳过多少条
    })
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// OR条件
var users = await User.findAll({
'where': {
'$or': [
{'id': [1, 2]},
{'nick': null}
]
}
})
SELECT `id`, `emp_id`, `nick`, `department`, `created_at`, `updated_at`
FROM `user` WHERE
(
`user`.`id` IN (1, 2) OR
`user`.`nick` IS NULL
)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// AND条件
var users = await User.findAll({
'where': {
'$and': [
{'id': [1, 2]},
{'nick': null}
]
}
})
SELECT `id`, `emp_id`, `nick`, `department`, `created_at`, `updated_at`
FROM `user` WHERE
(
`user`.`id` IN (1, 2) AND
`user`.`nick` IS NULL
)
1
2
3
4
5
6
7
8
9
// NOT条件
var users = await User.findAll({
'where': {
'$not': [
{'id': [1, 2]},
{'nick': null}
]
}
})
1
2


1
2


1
2


1
2


改 update 使用

1
2
3
4
5
6
7
8
9
10
11
// 方法1:操作对象属性(不会操作db),调用save后操作db
user.nick = '小白';
user = yield user.save();
console.log(user.get({'plain': true}));

// 方法2:直接update操作db
user.update({
'nick': '小白白'
}).then(user => {
console.log(user.get({'plain': true}))
})

ffff

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
User.findAll().then((users) => {
console.log(users)
})
findAll
findOne
findById
findOrCreate
findAndCountAll

findAll({
where: {
title: 'afacode'
},
attributes: ['id', ['name', title]]
})

findOrCreate({
where: {
username: 'afacode'
},
defaults: {
job: 'FE'
}
}).spread(user, created) => {

}
  • new Sequelize
  • sequelize.models 返回通过sequelize.define定义的所有模型对象
  • sequelize.define
  • sequelize.Utils
  • sequelize.Promise
  • sequelize.QueryTypes 查询类型枚举
  • sequelize.Validator
  • sequelize.Transaction 事务对象

project.max(‘age’)

project.min(‘age’)

project.sum(‘age’)

欢迎访问我的博客  地址      
https://blog.afacode.top