Model usage - 模型使用

    在本文中，我们将探讨 finder 方法可以做什么:

    findOrCreate - 搜索特定元素或创建它（如果不可用）

    方法 findOrCreate 可用于检查数据库中是否已存在某个元素。 如果是这种情况，则该方法将生成相应的实例。 如果元素不存在，将会被创建。

    如果是这种情况，则该方法将导致相应的实例。 如果元素不存在，将会被创建。

    假设我们有一个空的数据库，一个 User 模型有一个 username 和 job。

    1. User
    2.   .findOrCreate({where: {username: 'sdepold'}, defaults: {job: 'Technical Lead JavaScript'}})
    3.   .spread((user, created) => {
    4.     console.log(user.get({
    5.       plain: true
    6.     }))
    7.     console.log(created)
    9.     /*
    10.     findOrCreate 返回一个包含已找到或创建的对象的数组，找到或创建的对象和一个布尔值，如果创建一个新对象将为true，否则为false，像这样:
    12.     [ {
    13.         username: 'sdepold',
    14.         job: 'Technical Lead JavaScript',
    15.         id: 1,
    16.         createdAt: Fri Mar 22 2013 21: 28: 34 GMT + 0100(CET),
    17.         updatedAt: Fri Mar 22 2013 21: 28: 34 GMT + 0100(CET)
    18.       },
    19.       true ]
    21. 在上面的例子中，".spread" 将数组分成2部分，并将它们作为参数传递给回调函数，在这种情况下将它们视为 "user" 和 "created" 。（所以“user”将是返回数组的索引0的对象，并且 "created" 将等于 "true"。）
    22.     */
    23.   })

    代码创建了一个新的实例。 所以当我们已经有一个实例了 …

    1. User.create({ username: 'fnord', job: 'omnomnom' })
    2.   .then(() => User.findOrCreate({where: {username: 'fnord'}, defaults: {job: 'something else'}}))
    3.   .spread((user, created) => {
    4.     console.log(user.get({
    5.       plain: true
    6.     }))
    7.     console.log(created)
    9.     /*
    10.     在这个例子中，findOrCreate 返回一个如下的数组：
    11.     [ {
    12.         username: 'fnord',
    13.         job: 'omnomnom',
    14.         id: 2,
    15.         createdAt: Fri Mar 22 2013 21: 28: 34 GMT + 0100(CET),
    16.         updatedAt: Fri Mar 22 2013 21: 28: 34 GMT + 0100(CET)
    17.       },
    18.       false
    19.     ]
    20.     由findOrCreate返回的数组通过 ".spread" 扩展为两部分，并且这些部分将作为2个参数传递给回调函数，在这种情况下将其视为 "user" 和 "created" 。（所以“user”将是返回数组的索引0的对象，并且 "created" 将等于 "false"。）
    21.     */
    22.   })

    …现有条目将不会更改。 看到第二个用户的 “job”，并且实际上创建操作是假的。

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

    这是一个方便的方法，它结合了 findAll 和 count（见下文），当处理与分页相关的查询时，这是有用的，你想用 limit 和 offset 检索数据，但也需要知道总数与查询匹配的记录数：

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

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

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

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

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

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

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

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

    传递给 findAndCountAll 的 options 对象与 findAll 相同（如下所述）。

    findAll - 搜索数据库中的多个元素

    1. // 找到多个条目
    2. Project.findAll().then(projects => {
    3.   // projects 将是所有 Project 实例的数组
    4. })
    6. // 也可以：
    7. Project.all().then(projects => {
    8.   // projects 将是所有 Project 实例的数组
    9. })
    11. // 搜索特定属性 - 使用哈希
    12. Project.findAll({ where: { name: 'A Project' } }).then(projects => {
    13.   // projects将是一个具有指定 name 的 Project 实例数组
    14. })
    16. // 在特定范围内进行搜索
    17. Project.findAll({ where: { id: [1,2,3] } }).then(projects => {
    18.   // projects将是一系列具有 id 1,2 或 3 的项目
    19.   // 这实际上是在做一个 IN 查询
    20. })
    22. Project.findAll({
    23.   where: {
    24.     id: {
    25.       [Op.and]: {a: 5},           // 且 (a = 5)
    26.       [Op.or]: [{a: 5}, {a: 6}],  // (a = 5 或 a = 6)
    27.       [Op.gt]: 6,                // id > 6
    28.       [Op.gte]: 6,               // id >= 6
    29.       [Op.lt]: 10,               // id < 10
    30.       [Op.lte]: 10,              // id <= 10
    31.       [Op.ne]: 20,               // id != 20
    32.       [Op.between]: [6, 10],     // 在 6 和 10 之间
    33.       [Op.notBetween]: [11, 15], // 不在 11 和 15 之间
    34.       [Op.in]: [1, 2],           // 在 [1, 2] 之中
    35.       [Op.notIn]: [1, 2],        // 不在 [1, 2] 之中
    36.       [Op.like]: '%hat',         // 包含 '%hat'
    37.       [Op.notLike]: '%hat',       // 不包含 '%hat'
    38.       [Op.iLike]: '%hat',         // 包含 '%hat' (不区分大小写)  (仅限 PG)
    39.       [Op.notILike]: '%hat',      // 不包含 '%hat'  (仅限 PG)
    40.       [Op.overlap]: [1, 2],       // && [1, 2] (PG数组重叠运算符)
    41.       [Op.contains]: [1, 2],      // @> [1, 2] (PG数组包含运算符)
    42.       [Op.contained]: [1, 2],     // <@ [1, 2] (PG数组包含于运算符)
    43.       [Op.any]: [2,3],            // 任何数组[2, 3]::INTEGER (仅限 PG)
    44.     },
    45.     status: {
    46.       [Op.not]: false,           // status 不为 FALSE
    47.     }
    48.   }
    49. })

    复合过滤 / OR / NOT 查询

    你可以使用多层嵌套的 AND，OR 和 NOT 条件进行一个复合的 where 查询。 为了做到这一点，你可以使用 or ， and 或 not 运算符:

    1. Project.findOne({
    2.   where: {
    3.     name: 'a project',
    4.     [Op.or]: [
    5.       { id: [1,2,3] },
    6.       { id: { [Op.gt]: 10 } }
    7.     ]
    8.   }
    9. })
    11. Project.findOne({
    12.   where: {
    13.     name: 'a project',
    14.     id: {
    15.       [Op.or]: [
    16.         [1,2,3],
    17.         { [Op.gt]: 10 }
    18.       ]
    19.     }
    20.   }
    21. })
    1. SELECT *
    2. FROM `Projects`
    3. WHERE (
    5. )
    6. LIMIT 1;

    not 示例:

    1. Project.findOne({
    2.   where: {
    3.     name: 'a project',
    4.     [Op.not]: [
    5.       { id: [1,2,3] },
    6.       { array: { [Op.contains]: [3,4,5] } }
    7.     ]
    8.   }
    9. });

    将生成:

    1. SELECT *
    2. FROM `Projects`
    3. WHERE (
    4.   `Projects`.`name` = 'a project'
    5.    AND NOT (`Projects`.`id` IN (1,2,3) OR `Projects`.`array` @> ARRAY[3,4,5]::INTEGER[])
    6. )
    7. LIMIT 1;

    要获取更多相关数据，可以使用限制，偏移，顺序和分组：

    分组和排序的语法是相同的，所以下面只用一个单独的例子来解释分组，而其余的则是排序。 您下面看到的所有内容也可以对分组进行

    1. Project.findAll({order: 'title DESC'})
    2. // 生成 ORDER BY title DESC
    4. Project.findAll({group: 'name'})
    5. // 生成 GROUP BY name

    请注意，在上述两个示例中，提供的字符串逐字插入到查询中，所以不会转义列名称。 当你向 order / group 提供字符串时，将始终如此。 如果要转义列名，您应该提供一个参数数组，即使您只想通过单个列进行 order / group

    1. something.findOne({
    2.   order: [
    3.     // 将返回 `name`
    4.     ['name'],
    5.     // 将返回 `username` DESC
    6.     ['username', 'DESC'],
    7.     // 将返回 max(`age`)
    8.     sequelize.fn('max', sequelize.col('age')),
    9.     // 将返回 max(`age`) DESC
    10.     [sequelize.fn('max', sequelize.col('age')), 'DESC'],
    11.     // 将返回 otherfunction(`col1`, 12, 'lalala') DESC
    12.     [sequelize.fn('otherfunction', sequelize.col('col1'), 12, 'lalala'), 'DESC'],
    13.     // 将返回 otherfunction(awesomefunction(`col`)) DESC，这个嵌套是可以无限的！
    14.     [sequelize.fn('otherfunction', sequelize.fn('awesomefunction', sequelize.col('col'))), 'DESC']
    15.   ]
    16. })

    回顾一下，order / group数组的元素可以是以下内容：

    • String - 将被引用
    • Array - 第一个元素将被引用，第二个将被逐字地追加
    • Object -
      • raw 将被添加逐字引用
      • 如果未设置 raw，一切都被忽略，查询将失败
    • Sequelize.fn 和 Sequelize.col 返回函数和引用的列名

    原始查询

    有时候，你可能会期待一个你想要显示的大量数据集，而无需操作。 对于你选择的每一行，Sequelize 创建一个具有更新，删除和获取关联等功能的实例。如果您有数千行，则可能需要一些时间。 如果您只需要原始数据，并且不想更新任何内容，您可以这样做来获取原始数据。

    1. // 你期望从数据库的一个巨大的数据集,
    2. // 并且不想花时间为每个条目构建DAO？
    3. // 您可以传递一个额外的查询参数来取代原始数据：
    4. Project.findAll({ where: { ... }, raw: true })

    count - 计算数据库中元素的出现次数

    还有一种数据库对象计数的方法：

    1. Project.count().then(c => {
    2.   console.log("There are " + c + " projects!")
    3. })
    5. Project.count({ where: {'id': {[Op.gt]: 25}} }).then(c => {
    6.   console.log("There are " + c + " projects with an id greater than 25.")
    7. })

    max - 获取特定表中特定属性的最大值

    这里是获取属性的最大值的方法：

    1. /*
    2.    我们假设3个具有属性年龄的对象。
    3.    第一个是10岁，
    4.    第二个是5岁，
    5.    第三个是40岁。
    6. */
    7. Project.max('age').then(max => {
    8.   // 将返回 40
    9. })
    11. Project.max('age', { where: { age: { [Op.lt]: 20 } } }).then(max => {
    12.   // 将会是 10
    13. })

    min - 获取特定表中特定属性的最小值

    这里是获取属性的最小值的方法：

    1. /*
    2.    我们假设3个具有属性年龄的对象。
    3.    第一个是10岁，
    4.    第二个是5岁，
    5.    第三个是40岁。
    6. */
    7. Project.min('age').then(min => {
    8.   // 将返回 5
    9. })
    11. Project.min('age', { where: { age: { [Op.gt]: 5 } } }).then(min => {
    12.   // 将会是 10
    13. })

    为了计算表的特定列的总和，可以使用“sum”方法。

    1. /*
    2.    我们假设3个具有属性年龄的对象。
    3.    第一个是10岁，
    4.    第二个是5岁，
    5.    第三个是40岁。
    6. */
    7. Project.sum('age').then(sum => {
    8.   // 将返回 55
    9. })
    11. Project.sum('age', { where: { age: { [Op.gt]: 5 } } }).then(sum => {
    12.   // 将会是 50
    13. })

    预加载

    当你从数据库检索数据时，也想同时获得与之相关联的查询，这被称为预加载。这个基本思路就是当你调用 find 或 findAll 时使用 include 属性。让我们假设以下设置：

    1. const User = sequelize.define('user', { name: Sequelize.STRING })
    2. const Task = sequelize.define('task', { name: Sequelize.STRING })
    3. const Tool = sequelize.define('tool', { name: Sequelize.STRING })
    5. Task.belongsTo(User)
    6. User.hasMany(Task)
    7. User.hasMany(Tool, { as: 'Instruments' })
    9. sequelize.sync().then(() => {
    10.   // 这是我们继续的地方 ...
    11. })

    首先，让我们用它们的关联 user 加载所有的 task。

    1. Task.findAll({ include: [ User ] }).then(tasks => {
    2.   console.log(JSON.stringify(tasks))
    4.   /*
    5.     [{
    6.       "name": "A Task",
    7.       "id": 1,
    8.       "createdAt": "2013-03-20T20:31:40.000Z",
    9.       "updatedAt": "2013-03-20T20:31:40.000Z",
    10.       "userId": 1,
    11.       "user": {
    12.         "name": "John Doe",
    13.         "id": 1,
    14.         "createdAt": "2013-03-20T20:31:45.000Z",
    15.         "updatedAt": "2013-03-20T20:31:45.000Z"
    16.       }
    17.     }]
    18.   */
    19. })

    请注意，访问者（结果实例中的 User 属性）是单数形式，因为关联是一对一的。

    1. User.findAll({ include: [ Task ] }).then(users => {
    2.   console.log(JSON.stringify(users))
    4.   /*
    5.     [{
    6.       "name": "John Doe",
    7.       "id": 1,
    8.       "createdAt": "2013-03-20T20:31:45.000Z",
    9.       "updatedAt": "2013-03-20T20:31:45.000Z",
    10.       "tasks": [{
    11.         "name": "A Task",
    12.         "id": 1,
    13.         "createdAt": "2013-03-20T20:31:40.000Z",
    14.         "updatedAt": "2013-03-20T20:31:40.000Z",
    15.         "userId": 1
    16.       }]
    17.     }]
    18.   */
    19. })

    请注意，访问者（结果实例中的 Tasks 属性）是复数形式，因为关联是多对一的。

    如果关联是别名的（使用 as 参数），则在包含模型时必须指定此别名。 注意用户的 Tool 如何被别名为 Instruments。 为了获得正确的权限，您必须指定要加载的模型以及别名：

    您还可以通过指定与关联别名匹配的字符串来包含别名：

    1. User.findAll({ include: ['Instruments'] }).then(users => {
    2.   console.log(JSON.stringify(users))
    4.   /*
    5.     [{
    6.       "name": "John Doe",
    7.       "id": 1,
    8.       "createdAt": "2013-03-20T20:31:45.000Z",
    9.       "updatedAt": "2013-03-20T20:31:45.000Z",
    10.       "Instruments": [{
    11.         "name": "Toothpick",
    12.         "id": 1,
    13.         "createdAt": null,
    14.         "updatedAt": null,
    15.         "userId": 1
    16.       }]
    17.     }]
    18.   */
    19. })
    21. User.findAll({ include: [{ association: 'Instruments' }] }).then(users => {
    23.   /*
    24.     [{
    26.       "id": 1,
    27.       "createdAt": "2013-03-20T20:31:45.000Z",
    28.       "updatedAt": "2013-03-20T20:31:45.000Z",
    29.       "Instruments": [{
    30.         "name": "Toothpick",
    31.         "id": 1,
    32.         "createdAt": null,
    33.         "updatedAt": null,
    34.         "userId": 1
    35.       }]
    36.     }]
    37.   */
    38. })

    当预加载时，我们也可以使用 where 过滤关联的模型。 这将返回 Tool 模型中所有与 where 语句匹配的行的User。

    1. User.findAll({
    2.     include: [{
    3.         model: Tool,
    4.         as: 'Instruments',
    5.         where: { name: { [Op.like]: '%ooth%' } }
    6.     }]
    7. }).then(users => {
    8.     console.log(JSON.stringify(users))
    10.     /*
    11.       [{
    12.         "name": "John Doe",
    13.         "id": 1,
    14.         "createdAt": "2013-03-20T20:31:45.000Z",
    15.         "updatedAt": "2013-03-20T20:31:45.000Z",
    16.         "Instruments": [{
    17.           "name": "Toothpick",
    18.           "id": 1,
    19.           "createdAt": null,
    20.           "updatedAt": null,
    21.           "userId": 1
    22.         }]
    23.       }],
    25.       [{
    26.         "name": "John Smith",
    27.         "id": 2,
    28.         "createdAt": "2013-03-20T20:31:45.000Z",
    29.         "updatedAt": "2013-03-20T20:31:45.000Z",
    30.         "Instruments": [{
    31.           "name": "Toothpick",
    32.           "id": 1,
    33.           "createdAt": null,
    34.           "updatedAt": null,
    35.           "userId": 1
    36.         }]
    37.       }],
    38.     */
    39.   })

    当使用 include.where 过滤一个预加载的模型时，include.required 被隐式设置为 true。 这意味着内部联接完成返回具有任何匹配子项的父模型。

    使用预加载模型的顶层 WHERE

    将模型的 WHERE 条件从 ON 条件的 include 模式移动到顶层，你可以使用 '$nested.column$' 语法：

    1. User.findAll({
    2.     where: {
    3.         '$Instruments.name$': { [Op.iLike]: '%ooth%' }
    4.     },
    5.     include: [{
    6.         model: Tool,
    7.         as: 'Instruments'
    8.     }]
    9. }).then(users => {
    10.     console.log(JSON.stringify(users));
    12.     /*
    13.       [{
    14.         "name": "John Doe",
    15.         "id": 1,
    16.         "createdAt": "2013-03-20T20:31:45.000Z",
    17.         "updatedAt": "2013-03-20T20:31:45.000Z",
    18.         "Instruments": [{
    19.           "name": "Toothpick",
    20.           "id": 1,
    21.           "createdAt": null,
    22.           "updatedAt": null,
    23.           "userId": 1
    24.         }]
    25.       }],
    27.       [{
    28.         "name": "John Smith",
    29.         "id": 2,
    30.         "createdAt": "2013-03-20T20:31:45.000Z",
    31.         "updatedAt": "2013-03-20T20:31:45.000Z",
    32.         "Instruments": [{
    33.           "name": "Toothpick",
    34.           "id": 1,
    35.           "createdAt": null,
    36.           "updatedAt": null,
    37.           "userId": 1
    38.         }]
    39.       }],
    40.     */

    包括所有

    要包含所有属性，您可以使用 all：true 传递单个对象：

    1. User.findAll({ include: [{ all: true }]});

    包括软删除的记录

    如果想要加载软删除的记录，可以通过将 include.paranoid 设置为 false 来实现

    1. User.findAll({
    2.     include: [{
    3.         model: Tool,
    4.         where: { name: { [Op.like]: '%ooth%' } },
    5.         paranoid: false // query and loads the soft deleted records
    6.     }]
    7. });

    排序预加载关联

    在一对多关系的情况下。

    1. Company.findAll({ include: [ Division ], order: [ [ Division, 'name' ] ] });
    2. Company.findAll({ include: [ Division ], order: [ [ Division, 'name', 'DESC' ] ] });
    3. Company.findAll({
    4.   include: [ { model: Division, as: 'Div' } ],
    5.   order: [ [ { model: Division, as: 'Div' }, 'name' ] ]
    6. });
    7. Company.findAll({
    8.   include: [ { model: Division, as: 'Div' } ],
    9.   order: [ [ { model: Division, as: 'Div' }, 'name', 'DESC' ] ]
    10. });
    11. Company.findAll({
    12.   include: [ { model: Division, include: [ Department ] } ],
    13.   order: [ [ Division, Department, 'name' ] ]
    14. });

    在多对多关系的情况下，您还可以通过表中的属性进行排序。

    1. Company.findAll({
    2.   include: [ { model: Division, include: [ Department ] } ],
    3.   order: [ [ Division, DepartmentDivision, 'name' ] ]
    4. });

    您可以使用嵌套的预加载来加载相关模型的所有相关模型：

    1. User.findAll({
    2.   include: [
    3.     {model: Tool, as: 'Instruments', include: [
    4.       {model: Teacher, include: [ /* etc */]}
    5.     ]}
    6.   ]
    7. }).then(users => {
    8.   console.log(JSON.stringify(users))
    10.   /*
    11.     [{
    12.       "name": "John Doe",
    13.       "id": 1,
    14.       "createdAt": "2013-03-20T20:31:45.000Z",
    15.       "updatedAt": "2013-03-20T20:31:45.000Z",
    16.       "Instruments": [{ // 1:M and N:M association
    17.         "name": "Toothpick",
    18.         "id": 1,
    19.         "createdAt": null,
    20.         "updatedAt": null,
    21.         "userId": 1,
    22.         "Teacher": { // 1:1 association
    23.           "name": "Jimi Hendrix"
    24.         }
    25.       }]
    26.     }]
    27.   */
    28. })

    这将产生一个外连接。 但是，相关模型上的 where 语句将创建一个内部连接，并仅返回具有匹配子模型的实例。 要返回所有父实例，您应该添加 required: false。

    1. User.findAll({
    2.   include: [{
    3.     model: Tool,
    4.     as: 'Instruments',
    5.     include: [{
    6.       model: Teacher,
    7.       where: {
    8.         school: "Woodstock Music School"
    9.       },
    10.       required: false
    11.     }]
    12.   }]
    13. }).then(users => {
    14.   /* ... */
    15. })

    以上查询将返回所有用户及其所有乐器，但只会返回与 Woodstock Music School 相关的老师。

    包括所有也支持嵌套加载：