查询与原始查询

Sequelize中有两种查询：使用Model（模型）中的方法查询和使用sequelize.query()进行基于SQL语句的原始查询。

Model查询

1.1 Attributes - 属性与查询字段
1.2 Where - 指定筛选条件
1.3 limit/offset - 分页与限制返回结果数
1.4 查询排序

原始查询

2.1 原始查询方法
2.2 查询参数替换
2.3 参数绑定

1. Model查询

Model是一种表示与数据库中表关系的描述对象，它通过sequlize.define方法定义或通过sequlize.import导入创建实例对象。通过Model进行进行数据查询时，我们可以实现类似在数据库中直接使用SQL语句的查询、排序、分组、别名、连接查询等。

1.1 Attributes - 属性与查询字段

查询时，如果只需要查询模型的部分属性，可以在通过在查询选项中指定attributes实现。该选项是一个数组参数，在数组中指定要查询的属性即可，这些要查询的属性就表示要在数据库查询的字段：

Model.findAll({ attributes: ['foo', 'bar'] });

SELECT foo, bar ...

查询属性（字段）可以通过传入一个嵌套数据进行重命名：

Model.findAll({ attributes: ['foo', ['bar', 'baz']] });

SELECT foo, bar AS baz ...

通过sequelize.fn方法可以进行聚合查询：

Model.findAll({ attributes: [[sequelize.fn('COUNT', sequelize.col('hats')), 'no_hats']] });

SELECT COUNT(hats) AS no_hats ...

在使用聚合函数时，要给聚合字段指定一个别名。如，在上例中我们为聚合函数指定了别名'no_hats'，这样我们就能在查询的回调函数实例中通过instance.get('no_hats')来访问聚合统计的结果。

当需要查询所有字段并对某一字段使用聚合查询时，而只需要以对象的形式传入attributes并添加include子属性即可。

// 拽定全查询字段比较麻烦 Model.findAll({ attributes: ['id', 'foo', 'bar', 'baz', 'quz', [sequelize.fn('COUNT', sequelize.col('hats')), 'no_hats']] });

// 这样会比较简短，且在你添加/删除属性后不会出错 Model.findAll({ attributes: { include: [[sequelize.fn('COUNT', sequelize.col('hats')), 'no_hats']] } });

SELECT id, foo, bar, baz, quz, COUNT(hats) AS no_hats ...

全部查询时，可以通过exclude子属性来排除不需要查询的字段：

Model.findAll({ attributes: { exclude: ['baz'] } });

SELECT id, foo, bar, quz ...

关于聚合查询，请参考：在Sequelize中使用group by分组聚合查询

1.2 Where - 指定筛选条件

在模型的 find/finAll 或 updates/destroys 操作中，可以指定一个where选项以指定筛选条件，

where是一个包含属性/值对对象，sequelize会根据此对象生产查询语句的筛选条件。

基本用法

Post.findAll({ where: { authorId: 2 } }); // SELECT * FROM post WHERE authorId = 2

Post.findAll({ where: { authorId: 12, status: 'active' } }); // SELECT * FROM post WHERE authorId = 12 AND status = 'active';

Post.destroy({ where: { status: 'inactive' } }); // DELETE FROM post WHERE status = 'inactive';

Post.update({ updatedAt: null, }, { where: { deletedAt: { $ne: null } } }); // UPDATE post SET updatedAt = null WHERE deletedAt NOT NULL;

Post.findAll({ where: sequelize.where(sequelize.fn('char_length', sequelize.col('status')), 6) }); // SELECT * FROM post WHERE char_length(status) = 6;

操作符

$and: {a: 5} // AND (a = 5) $or: [{a: 5}, {a: 6}] // (a = 5 OR a = 6) $gt: 6, // > 6 $gte: 6, // >= 6 $lt: 10, // < 10 $lte: 10, // <= 10 $ne: 20, // != 20 $not: true, // IS NOT TRUE $between: [6, 10], // BETWEEN 6 AND 10 $notBetween: [11, 15], // NOT BETWEEN 11 AND 15 $in: [1, 2], // IN [1, 2] $notIn: [1, 2], // NOT IN [1, 2] $like: '%hat', // LIKE '%hat' $notLike: '%hat' // NOT LIKE '%hat' $iLike: '%hat' // ILIKE '%hat' (case insensitive) (PG only) $notILike: '%hat' // NOT ILIKE '%hat' (PG only) $like: { $any: ['cat', 'hat']} // LIKE ANY ARRAY['cat', 'hat'] - also works for iLike and notLike $overlap: [1, 2] // && [1, 2] (PG array overlap operator) $contains: [1, 2] // @> [1, 2] (PG array contains operator) $contained: [1, 2] // <@ [1, 2] (PG array contained by operator) $any: [2,3] // ANY ARRAY[2, 3]::INTEGER (PG only)

$col: 'user.organization_id' // = "user"."organization_id", with dialect specific column identifiers, PG in this example

组合查询

{ rank: { $or: { $lt: 1000, $eq: null } } } // rank < 1000 OR rank IS NULL

{ createdAt: { $lt: new Date(), $gt: new Date(new Date() - 24 60 60 * 1000) } } // createdAt < [timestamp] AND createdAt > [timestamp]

{ $or: [ { title: { $like: 'Boat%' } }, { description: { $like: '%boat%' } } ] } // title LIKE 'Boat%' OR description LIKE '%boat%'

嵌套对象

{ meta: { video: { url: { $ne: null } } } }

嵌套键

{ "meta.audio.length": { $gt: 20 } }

包含

{ "meta": { $contains: { site: { url: 'http://itbilu.com' } } } }

关系/联合

// 查询所有至少有一个task的projects，task.state === project.task Project.findAll({ include: [{ model: Task, where: { state: Sequelize.col('project.state') } }] })

1.3 limit/offset - 分页与限制返回结果数

查询进，我们可以使用limit限制返回结果条数，并可以通过offset来设置查询偏移（跳过）量，通过这两个属性我们可以实现分页查询的功能：

// 获取 10 条数据（实例） Project.findAll({ limit: 10 })

// 跳过 8 条数据（实例） Project.findAll({ offset: 8 })

// 跳过 5 条数据并获取其后的 5 条数据（实例） Project.findAll({ offset: 5, limit: 5 })

1.4 查询排序

order选项用于查询结果的排序数据。排序时应该传入一个包含属性-排序方向的元组/数组，以保证正确的转义：

something.findOne({ order: [ // 转义 username 并对查询结果按 DESC 方向排序 ['username', 'DESC'],

// 按 max(age) 排序
sequelize.fn('max', sequelize.col('age')),

// 按 max(age) DESC 排序
[sequelize.fn('max', sequelize.col('age')), 'DESC'],

// 按 otherfunction(`col1`, 12, 'lalala') DESC 排序
[sequelize.fn('otherfunction', sequelize.col('col1'), 12, 'lalala'), 'DESC'],

// 按相关联的User 模型的 name 属性排序
[User, 'name', 'DESC'],

// 按相关联的User 模型的 name 属性排序并将模型起别名为 Friend
[{model: User, as: 'Friend'}, 'name', 'DESC'],

// 按相关联的User 模型的嵌套关联的 Company 模型的 name 属性排序
[User, Company, 'name', 'DESC'],

] // 以下所有声明方式都会视为字面量，应该小心使用 order: 'convert(user_name using gbk)' order: 'username DESC' order: sequelize.literal('convert(user_name using gbk)') })

原始查询

有时会使用原始查询或执行已准备好的SQL语句，这时可以用Sequlize提供的工具函数sequelize.query来实现。

2.1 原始查询方法

默认情况下，该函数会返回两个参数 - 一个包含结果的数组和一个包含原数据对象。请注意，由于是原始查询，所以返回的元数据与使用的数据库类型有关，其对元数据的处理并不一致。

sequelize.query("UPDATE users SET y = 42 WHERE x = 12").spread(function(results, metadata) { // Results 会是一个空数组和一个包含受影响行数的metadata 元数据对象 })

如果不想使用元数据，可以查询时指定表示查询类型的type参数，以告诉sequelize 应该怎样去格式化返回结果。

sequelize.query("SELECT * FROM users", { type: sequelize.QueryTypes.SELECT}) .then(function(users) { // 并不需要在这spread 展开结果，因为所返回的只有所查询的结果 })

在选项参数中，可以使用model参数指定一个模型，指定后会将查询结果会是传入模型的实例：

// 调用已定义的模型并对其创建实例 sequelize.query('SELECT * FROM projects', { model: Projects }).then(function(projects){ // 每条记录都是一个Project 实例 })

2.2 查询参数替换

原始查询中有两种替换查询参数的方法，以:开头的参数的形式替换或以不命名以?替换。在选项对象中传递参数：

如果传递一个数组，? 会按数组的顺序被依次替换
巢传递一个对象，:key将会用对象的键替换。如果对象中未找到指定键，则会引发异常（反之亦然）

sequelize.query('SELECT * FROM projects WHERE status = ?', { replacements: ['active'], type: sequelize.QueryTypes.SELECT } ).then(function(projects) { console.log(projects) })

sequelize.query('SELECT * FROM projects WHERE status = :status ', { replacements: { status: 'active' }, type: sequelize.QueryTypes.SELECT } ).then(function(projects) { console.log(projects) })

2.3 参数绑定

参数绑定类似于参数替换。尤其是参数替换会在发送到数据库前被sequelize转义和替换，而参数绑定会被发送到SQL 查询文本外。

只有SQLite 和 PostgreSQL支持参数绑定，其它类型数据库都会将其插入到SQL 查询，并以相同的方式进行参数替换。参数绑定可以使用$1、$2……或$key的形式：

如果传入的是数组，$1会绑定到数组听第1个参数 (bind[0])
如果传入一个对象，$key会绑定到object['key']。每个key 必须以非数字的字符开始。$1不是个有效的key，尽管object['1'] 是存在的。
在使用$$时，不会被转义而是将$做为一个字面量使用。

传入的数组或对象必须包含所有绑定值，否则Sequelize会抛出异常。这同样适用于数据库可能会忽略绑定参数的情况下。

数据库可能会做进一步限制，绑定参数不能使用数据库关键字，也不能是表或列名，它在引用文本或数据时也可能被忽略。在PostgreSQL中，如果不能从上下文$1::varchar中推断类型，那么也需要进行类型转换。

sequelize.query('SELECT *, "text with literal $$1 and literal $$status" as t FROM projects WHERE status = $1', { bind: ['active'], type: sequelize.QueryTypes.SELECT } ).then(function(projects) { console.log(projects) })

sequelize.query('SELECT *, "text with literal $$1 and literal $$status" as t FROM projects WHERE status = $status', { bind: { status: 'active' }, type: sequelize.QueryTypes.SELECT } ).then(function(projects) { console.log(projects) })