1、简单 INSERT 查询

首先，创建一个简单例子：

// 创建一个新用户
const user = await User.create({ firstName: 'zhangsan', age: 25 })

Model.create() 方法是使用 Model.build() 构建为保存实例并使用 instance.save() 保存实例的简写。

2、简单 SELECT 查询

可以使用 findAll 方法从数据库中读取整个表：

// 查询所有用户
const users = await User.findAll()

// 相当于 SQL
SELECT * FROM ...

3、SELECT 查询特定属性

使用 attributes 查询特定字段：

Model.findAll({
  attributes: ['name', 'age']
})

// 相当于 SQL
SELECT name, age FROM ...

同时可以对字段重命名：

Model.findAll({
  attributes: ['name', ['bar', 'baz'], 'age']
})

// 相当于 SQL
SELECT name, bar AS baz, age FROM ...

也可以使用 sequelize.fn 进行聚合：

Model.findAll({
  attributes: [
    'name',
    [sequelize.fn('COUNT', sequelize.col('bar')), 'baz'],
    'age'
  ]
})

// 相当于 SQL
SELECT name, COUNT(bar) AS baz, age FROM ...

使用聚合函数时，必须为它提供一个别名。

如果只想添加聚合，那么列出模型的所有属性会很麻烦：

// 列举所有属性：
Model.findAll({
  attributes: [
    'id', 'name', 'sex',
    [sequelize.fn('COUNT', sequelize.col('bar')), 'baz'],
    'age'
  ]
})

// 使用 include 属性，如果以后再模型中添加、删除属性，它任然可以工作
Model.findAll({
  attributes: {
    include: [
      [sequelize.fn('COUNT', sequelize.col('bar')), 'baz']
    ]
  }
})

// 相当于
SELECT id, name, sex, COUNT(bar) AS baz, age FROM ...

同样，也可以排除某些属性：

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

// 相当于
SELECT id, name, sex, age FROM ...

4、应用 WHERE 子句

where 参数用于过滤查询，where 子句有很多运算符，可以从 Op 中以 Symbol 的形式使用。

• 基础

User.findAll({
  where: {
    id: 2
  }
})

// 相当于
SELECT * FROM tb_user WHERE id = 2

上面代码等效于：

const { Op } = require('sequelize')

User.findAll({
  where: {
    id: {
      [Op.eq]: 2
    }
  }
})

// 相当于
SELECT * FROM tb_user WHERE id = 2

可以传递多个校验：

User.findAll({
  where: {
    sex: 1,
    age: 25
  }
})

// 相当于
SELECT * FROM tb_user WHERE sex = 1 AND age = 25

上面的代码等效于：

const { Op } = require('sequelize')

User.findAll({
  where: {
    [Op.and]: [
      { sex: 1 },
      { age: 25 }
    ]
  }
})

// 相当于
SELECT * FROM tb_user WHERE sex = 1 AND age = 25

OR 可以通过类似的方式执行：

const { Op } = require('sequelize')

User.findAll({
  where: {
    [Op.or]: [
      { id: 20 },
      { id: 25 }
    ]
  }
})

// 相当于
SELECT * FROM tb_user WHERE id = 1 OR id = 25

由于以上的 OR 涉及相同字段，因此 Sequelize 允许使用稍有不同的结构，该结构更易读且作用相同：

const { Op } = require('sequelize')

User.destroy({
  where: {
    id: {
      [Op.or]: [20, 25]
    }
  }
})

// 相当于
DELETE FROM tb_user WHERE id = 20 OR id = 25

• 操作符

Sequelize 提供的多种运算符：

const { Op } = require('sequelize')

User.findAll({
  where: {
    [Op.and]: [{ a: 5 }, { b: 6 }],            // (a = 5) AND (b = 6)
    [Op.or]: [{ a: 5 }, { b: 6 }],             // (a = 5) OR (b = 6)
    someAttribute: {
      // 基本
      [Op.eq]: 3,                              // = 3
      [Op.ne]: 20,                             // != 20
      [Op.is]: null,                           // IS NULL
      [Op.not]: true,                          // IS NOT TRUE
      [Op.or]: [5, 6],                         // (someAttribute = 5) OR (someAttribute = 6)

      // 使用方言特定的列标识符 (以下示例中使用 PG):
      [Op.col]: 'user.organization_id',        // = "user"."organization_id"

      // 数字比较
      [Op.gt]: 6,                              // > 6
      [Op.gte]: 6,                             // >= 6
      [Op.lt]: 10,                             // < 10
      [Op.lte]: 10,                            // <= 10
      [Op.between]: [6, 10],                   // BETWEEN 6 AND 10
      [Op.notBetween]: [11, 15],               // NOT BETWEEN 11 AND 15

      // 其它操作符

      [Op.all]: sequelize.literal('SELECT 1'), // > ALL (SELECT 1)

      [Op.in]: [1, 2],                         // IN [1, 2]
      [Op.notIn]: [1, 2],                      // NOT IN [1, 2]

      [Op.like]: '%hat',                       // LIKE '%hat'
      [Op.notLike]: '%hat',                    // NOT LIKE '%hat'
      [Op.startsWith]: 'hat',                  // LIKE 'hat%'
      [Op.endsWith]: 'hat',                    // LIKE '%hat'
      [Op.substring]: 'hat',                   // LIKE '%hat%'
      [Op.regexp]: '^[h|a|t]',                 // REGEXP/~ '^[h|a|t]' (仅 MySQL/PG)
      [Op.notRegexp]: '^[h|a|t]',              // NOT REGEXP/!~ '^[h|a|t]' (仅 MySQL/PG)

      [Op.any]: [2, 3],                        // ANY ARRAY[2, 3]::INTEGER (仅 PG)
  }
})

Op.in 的简写语法

直接将数组参数传递给 where 将隐式使用 IN 运算符：

User.findAll({
  where: {
    id: [1, 2, 3] // 等同使用 `id: { [Op.in]: [1, 2, 3] }`
  }
})

// 相当于
SELECT * FROM tb_user WHERE id IN (1, 2, 3)

运算符的组合

运算符 Op.and， Op.or 和 Op.not 可用于创建任意复杂的嵌套逻辑比较。

使用 Op.and 和 Op.or 示例

const { Op } = require('sequelize')

User.findAll({
  where: {
    rank: {
      [Op.or]: {
        [Op.lt]: 1000,
        [Op.eq]: null
      }
    }
    //  rank < 1000 OR rank IS null

    {
      createdAt: {
        [Op.lt]: new Date(),
        [Op.gt]: new Date(new Date() - 24 * 60 * 60 * 1000)
      }
    }
    // createdAt < [timestamp] AND createdAt > [timestamp]
    
    {
      [Op.or]: [
        { title: { [Op.like]: 'Boat%' } },
        { description: { [Op.like]: '%boat%' } }
      ]
    }
    // title LIKE 'Boat%' OR description LIKE '%boat%'
  }
})

使用 Op.not 示例

User.findAll({
  where: {
    name: 'zhangsan',
    [Op.not]: [
      { id: [1, 2, 3] },
      { description: { [Op.like]: 'Hello%' } }
    ]
  }
})

上面代码将生成：

SELECT * FROM tb_user WHERE (name = 'zhangsan' AND NOT id IN (1, 2, 3) OR description LIKE 'Hello%'))

• 高级查询

如果你想得到类似 WHERE char_length('content') = 7 的结果怎么办？

User.findAll({
  where: sequelize.where(sequelize.fn('char_length', sequelize.col('content')), 7)
})

// 相当于
SELECT * FROM tb_user WHERE char_length('content') = 7

sequelize.fn 和 sequelize.col 分别指定 SQL 函数调用和列，应用这些方法，文不是传递纯字符串（如：char_length(content)），因为 Sequelize 需要以不同的方式对待这种情况（如：使用其他转移字符）。

如果需要更复杂：

Post.findAll({
  where: {
    [Op.or]: [
      sequelize.where(sequelize.fn('char_length', sequelize.col('content')), 7),
      {
        content: {
          [Op.like]: 'Hello%'
        }
      },
      {
        [Op.and]: [
          { status: 'draft' },
          sequelize.where(sequelize.fn('char_length', sequelize.col('content')), { [Op.gt]: 10 })
        ]
      }
    ]
  }
})

上面生成一下 SQL

SELECT * FROM WHERE (
  char_length('content') = 7
  OR
  content LIKE 'Hello%'
  OR (
    status = 'draft'
    AND
    char_length('content') > 10
  )
)

5、简单 UPDATE 查询

Update 查询也接受 where 参数，就像上面的读取查询一样。

// 将所有没有姓氏的人改为‘jeff’
await User.update({ lastName: 'jeff' }, {
  where: {
    lastName: null
  }
})

6、简单 DELETE 查询

Delete 查询也接受 where 参数，就像上面的读取查询一样。

// 删除所有名为‘jeff’的人
await User.destroy({
  where: {
    firstName: 'jeff'
  }
})

要销毁所有内容，可以使用 TRUNCATE SQL：

// 截断表格
await User.destory({
  truncate: true
})

7、批量创建

Sequelize 提供了 Model.builCreate 方法，以允许仅一个查询即可一次创建多个记录。通过接受数组对象文不是单个对象，Model.bulkCreate 的用法与 Model.create 非常相似。

const users = await User.bulkCreate([
  { name: 'zhangsan' },
  { name: 'lisi' }
])

但是，默认情况下，bulkCreate 不会在要创建的每个对象上运行验证（create 可以做到）。为了使 bulkCreate 也运行这些验证，必须通过 validate: true 参数。但这会降低性能，实例：

const Foo = sequelize.define('foo', {
  bar: DataTypes.TEXT,
  validate: {
    len: [4, 6]
  }
})

// 这个不会引发错误，两个实例都将被创建
await Foo.bulkCreate([
  { name: 'abc123' },
  { name: 'naem too long'}
])

// 这将引发错误，不会创建任何内容
await Foo.bulkCreate([
  { name: 'abc123' },
  { name: 'name too long'}
], { validate: true })

如果你直接从用户获取值,那么限制实际插入的列可能会有所帮助。 为了做到这一点，bulkCreate() 接受一个 fields 参数,该参数须为你要定义字段的数组(其余字段将被忽略).

await User.bulkCreate([
  { username: 'foo' },
  { username: 'bar', admin: true }
], { fields: ['username'] });
// foo 和 bar 都不会是管理员.

8、排序和分组

Sequelize 提供了 order and group 参数，来与 ORDER BY 和 GROUP BY 一起使用。

排序

order 参数采用一系列项来让 sequelize 方法对查询进行排序。这些 项 本身是 [column, direction] 形式的数组，该列将被正确转义，并且将在有效方向列表中进行验证（例如ASC，DESC，NULLS FIRST等）

Subtask.findAll({
  order: [
    // 将转义 title 并针对有效方向列表进行降序排列
    ['title', 'DESC'],

    // 将按最大年龄进行升序排序
    sequelize.fn('max', sequelize.col('age')),

    // 将按最大年龄进行降序排序
    [sequelize.fn('max', sequelize.col('age')), 'DESC'],

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

    // 将使用模型名称作为关联名称按关联模型的 createdAt 排序.
    [Task, 'createdAt', 'DESC'],

    // 将使用模型名称作为关联名称通过关联模型的 createdAt 排序.
    [Task, Project, 'createdAt', 'DESC'],

    // 将使用关联名称按关联模型的 createdAt 排序.
    ['Task', 'createdAt', 'DESC'],

    // 将使用关联的名称按嵌套的关联模型的 createdAt 排序.
    ['Task', 'Project', 'createdAt', 'DESC'],

    // 将使用关联对象按关联模型的 createdAt 排序. (首选方法)
    [Subtask.associations.Task, 'createdAt', 'DESC'],

    // 将使用关联对象按嵌套关联模型的 createdAt 排序. (首选方法)
    [Subtask.associations.Task, Task.associations.Project, 'createdAt', 'DESC'],

    // 将使用简单的关联对象按关联模型的 createdAt 排序.
    [{model: Task, as: 'Task'}, 'createdAt', 'DESC'],

    // 将由嵌套关联模型的 createdAt 简单关联对象排序.
    [{model: Task, as: 'Task'}, {model: Project, as: 'Project'}, 'createdAt', 'DESC']
  ],

  // 将按最大年龄降序排列
  order: sequelize.literal('max(age) DESC'),

  // 如果忽略方向,则默认升序,将按最大年龄升序排序
  order: sequelize.fn('max', sequelize.col('age')),

  // 如果省略方向,则默认升序, 将按年龄升序排列
  order: sequelize.col('age'),

  // 将根据方言随机排序(但不是 fn('RAND') 或 fn('RANDOM'))
  order: sequelize.random()
});

Foo.findOne({
  order: [
    // 将返回 `name`
    ['name'],
    // 将返回 `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'],
    // 将返回 otherfunction(awesomefunction(`col`)) DESC, 这种嵌套可能是无限的!
    [sequelize.fn('otherfunction', sequelize.fn('awesomefunction', sequelize.col('col'))), 'DESC']
  ]
});

回顾一下,order 数组的元素可以如下：

• 一个字符串 (它将被自动引用)
• 一个数组, 其第一个元素将被引用,第二个将被逐字追加
• 一个具有 raw 字段的对象:
  • raw 内容将不加引用地逐字添加
  • 其他所有内容都将被忽略,如果未设置 raw,查询将失败
• 调用 Sequelize.fn (这将在 SQL 中生成一个函数调用)
• 调用 Sequelize.col (这将引用列名)

分组

分组和排序的语法相同,只是分组不接受方向作为数组的最后一个参数(不存在 ASC, DESC, NULLS FIRST 等).

你还可以将字符串直接传递给 group,该字符串将直接(普通)包含在生成的 SQL 中. 请谨慎使用,请勿与用户生成的内容一起使用.

Project.findAll({ group: 'name' });
// 生成 'GROUP BY name'

9、限制和分页

使用 limit 和 offset 参数可以进行 限制/分页：

// 提取10个实例/行
Project.findAll({ limit: 10 })

// 跳过8个实例/行
Project.findAll({ offset: 8 })

// 跳过5个实例,然后获取5个实例
Project.findAll({ offset: 5, limit: 5 })

通常这些与 order 参数一起使用。

10、使用方法

count

count 方法仅计算数据库中元素出现的次数。

// 计算 age 大于 25 的人数
const amount = await User.count({
  where: {
    age: {
      [Op.gt]: 25
    }
  }
})

max，min 和 sum

Sequelize 还提供了 max,min 和 sum 便捷方法.

await User.max('age') // 40
await User.max('age', { where: { age: { [Op.lt]: 20 } } }) // 10
await User.min('age') // 5
await User.min('age', { where: { age: { [Op.gt]: 5 } } }) // 10
await User.sum('age') // 55
await User.sum('age', { where: { age: { [Op.gt]: 5 } } }) // 50