sequelize模型增刪改查詢(基礎)Model Querying - Basics等基礎操作

一、簡單 INSERT 查詢

　　首先,一個簡單的例子：

// 創建一個新用戶
const jane = await User.create({ firstName: "Jane", lastName: "Doe" }); console.log("Jane's auto-generated ID:", jane.id);

　　Model.create() 方法是使用 Model.build() 構建未保存實例並使用 instance.save() 保存實例的簡寫形式.

　　也可以定義在 create 方法中的屬性. 如果你基於用戶填寫的表單創建數據庫條目,這將特別有用. 例如,使用它可以允許你將 User 模型限制為僅設置用戶名和地址,而不設置管理員標志：

const user = await User.create({ username: 'alice123', isAdmin: true }, { fields: ['username'] }); // 假設 isAdmin 的默認值為 false
console.log(user.username); // 'alice123'
console.log(user.isAdmin); // false

二、簡單 SELECT 查詢

1、你可以使用 findAll 方法從數據庫中讀取整個表：

// 查詢所有用戶
const users = await User.findAll(); console.log(users.every(user => user instanceof User)); // true
console.log("All users:", JSON.stringify(users, null, 2));

2、選擇某些特定屬性,可以使用 attributes 參數：

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

3、可以使用嵌套數組來重命名屬性：

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

4、可以使用 sequelize.fn 進行聚合：

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

SELECT foo, COUNT(hats) AS n_hats, bar FROM ...

　　使用聚合函數時,必須為它提供一個別名,以便能夠從模型中訪問它. 在上面的示例中,你可以通過 instance.n_hats 獲取帽子數量.

　　有時,如果只想添加聚合,那么列出模型的所有屬性可能會很麻煩：

// 這是獲取帽子數量的煩人方法(每列都有)
Model.findAll({ attributes: [ 'id', 'foo', 'bar', 'baz', 'qux', 'hats', // 我們必須列出所有屬性...
    [sequelize.fn('COUNT', sequelize.col('hats')), 'n_hats'] // 添加聚合...
 ] }); // 這個更短,並且更不易出錯. 如果以后在模型中添加/刪除屬性,它仍然可以正常工作
Model.findAll({ attributes: { include: [ [sequelize.fn('COUNT', sequelize.col('hats')), 'n_hats'] ] } });

SELECT id, foo, bar, baz, qux, hats, COUNT(hats) AS n_hats FROM ...

　　同樣,也可以排除某些屬性：

Model.findAll({ attributes: { exclude: ['baz'] } }); // Assuming all columns are 'id', 'foo', 'bar', 'baz' and 'qux'
SELECT id, foo, bar, qux FROM ...

三、應用 WHERE 子句

　　where 參數用於過濾查詢.where 子句有很多運算符,可以從 Op 中以 Symbols 的形式使用.

 1、基礎

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

　　可以看到沒有顯式傳遞任何運算符(來自Op),因為默認情況下 Sequelize 假定進行相等比較. 上面的代碼等效於：

const { Op } = require("sequelize"); Post.findAll({ where: { authorId: { [Op.eq]: 2 } } }); // SELECT * FROM post WHERE authorId = 2

　　可以傳遞多個校驗:

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

　　就像在第一個示例中 Sequelize 推斷出 Op.eq 運算符一樣,在這里 Sequelize 推斷出調用者希望對兩個檢查使用 AND. 上面的代碼等效於：

const { Op } = require("sequelize"); Post.findAll({ where: { [Op.and]: [ { authorId: 12 }, { status: 'active' } ] } }); // SELECT * FROM post WHERE authorId = 12 AND status = 'active';

　　OR 可以通過類似的方式輕松執行，由於以上的 OR 涉及相同字段 ,因此 Sequelize 允許你使用稍有不同的結構,該結構更易讀並且作用相同：

const { Op } = require("sequelize"); Post.destroy({ where: { authorId: { [Op.or]: [12, 13] } } }); // DELETE FROM post WHERE authorId = 12 OR authorId = 13;

2、操作符

　　Sequelize 提供了多種運算符.

const { Op } = require("sequelize"); Post.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.iLike]: '%hat',                      // ILIKE '%hat' (不區分大小寫) (僅 PG)
      [Op.notILike]: '%hat',                   // NOT ILIKE '%hat' (僅 PG)
      [Op.regexp]: '^[h|a|t]',                 // REGEXP/~ '^[h|a|t]' (僅 MySQL/PG)
      [Op.notRegexp]: '^[h|a|t]',              // NOT REGEXP/!~ '^[h|a|t]' (僅 MySQL/PG)
      [Op.iRegexp]: '^[h|a|t]',                // ~* '^[h|a|t]' (僅 PG)
      [Op.notIRegexp]: '^[h|a|t]',             // !~* '^[h|a|t]' (僅 PG)
 [Op.any]: [2, 3],                        // ANY ARRAY[2, 3]::INTEGER (僅 PG) // 在 Postgres 中, Op.like/Op.iLike/Op.notLike 可以結合 Op.any 使用:
      [Op.like]: { [Op.any]: ['cat', 'hat'] }  // LIKE ANY ARRAY['cat', 'hat'] // 還有更多的僅限 postgres 的范圍運算符,請參見下文
 } } });

　　Op.in 的簡寫語法：直接將數組參數傳遞給 where 將隱式使用 IN 運算符

Post.findAll({ where: { id: [1,2,3] // 等同使用 `id: { [Op.in]: [1,2,3] }`
 } }); // SELECT ... FROM "posts" AS "post" WHERE "post"."id" IN (1, 2, 3);

3、運算符的邏輯組合

　　運算符 Op.and, Op.or 和 Op.not 可用於創建任意復雜的嵌套邏輯比較.

const { Op } = require("sequelize"); Foo.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示例

Project.findAll({ where: { name: 'Some Project', [Op.not]: [ { id: [1,2,3] }, { description: { [Op.like]: 'Hello%' } } ] } }); SELECT * FROM `Projects` WHERE ( `Projects`.`name` = 'a project' AND NOT ( `Projects`.`id` IN (1,2,3) OR `Projects`.`description` LIKE 'Hello%' ) )

4、高級查詢(不僅限於列)

　　如果你想得到類似 WHERE char_length("content") = 7 的結果怎么辦？

Post.findAll({ where: sequelize.where(sequelize.fn('char_length', sequelize.col('content')), 7) }); // SELECT ... FROM "posts" AS "post" 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 "posts" AS "post" WHERE ( char_length("content") = 7 OR "post"."content" LIKE 'Hello%' OR ( "post"."status" = 'draft' AND char_length("content") > 10 ) )

四、簡單 UPDATE 查詢

　　Update 查詢也接受 where 參數,就像上面的讀取查詢一樣.

// 將所有沒有姓氏的人更改為 "Doe"
await User.update({ lastName: "Doe" }, { where: { lastName: null } });

五、簡單 DELETE 查詢

　　Delete 查詢也接受 where 參數,就像上面的讀取查詢一樣.

// 刪除所有名為 "Jane" 的人 
await User.destroy({ where: { firstName: "Jane" } });

　　要銷毀所有內容,可以使用 TRUNCATE SQL：

// 截斷表格
await User.destroy({ truncate: true });

六、批量創建

　　Sequelize 提供了 Model.bulkCreate 方法,以允許僅一次查詢即可一次創建多個記錄.

　　通過接收數組對象而不是單個對象,Model.bulkCreate 的用法與 Model.create 非常相似.

const captains = await Captain.bulkCreate([ { name: 'Jack Sparrow' }, { name: 'Davy Jones' } ]); console.log(captains.length); // 2
console.log(captains[0] instanceof Captain); // true
console.log(captains[0].name); // 'Jack Sparrow'
console.log(captains[0].id); // 1 // (或另一個自動生成的值)

　　但是,默認情況下,bulkCreate 不會在要創建的每個對象上運行驗證(而 create 可以做到). 為了使 bulkCreate 也運行這些驗證,必須通過validate: true 參數. 但這會降低性能. 用法示例：

const Foo = sequelize.define('foo', { bar: { type: DataTypes.TEXT, validate: { len: [4, 6] } } }); // 這不會引發錯誤,兩個實例都將被創建
await Foo.bulkCreate([ { name: 'abc123' }, { name: 'name 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 都不會是管理員.

七、排序和分組

　　Sequelize 提供了 order and group 參數,來與 ORDER BY 和 GROUP BY 一起使用.

 1、排序

　　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 字段的對象:調用 Sequelize.fn (這將在 SQL 中生成一個函數調用)
  • raw 內容將不加引用地逐字添加
  • 其他所有內容都將被忽略,如果未設置 raw,查詢將失敗
• 調用 Sequelize.col (這將引用列名)

2、分組

　　分組和排序的語法相同,只是分組不接受方向作為數組的最后一個參數(不存在 ASC, DESC, NULLS FIRST 等).

　　你還可以將字符串直接傳遞給 group,該字符串將直接(普通)包含在生成的 SQL 中. 請謹慎使用,請勿與用戶生成的內容一起使用.

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

八、限制和分頁

　　使用 limit 和 offset 參數可以進行 限制/分頁：

// 提取10個實例/行
Project.findAll({ limit: 10 }); // 跳過8個實例/行
Project.findAll({ offset: 8 }); // 跳過5個實例,然后獲取5個實例
Project.findAll({ offset: 5, limit: 5 });

九、實用方法

　　Sequelize 還提供了一些實用方法.

1、count 方法僅計算數據庫中元素出現的次數.

const amount = await Project.count({ where: { id: { [Op.gt]: 25 } } }); console.log(`這有 ${amount} 個項目 id 大於 25`);

2、max, min 和 sum

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

　　假設我們有三個用戶,分別是10、5和40歲.

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