高级概念

作用域

本节涉及关联作用域. 有关关联作用域与关联模型作用域的定义, 请参阅 作用域.

关联作用域允许你在关联上放置作用域(get 和 create的一组默认属性). 作用域可以放在关联模型(关联的目标)上,也可以放在n:m关系的中间表上.

1:n

假设我们有模型 Comment,Post 和 Image. Comment可以通过 commentableId 和 commentable 与Image或Post相关联 - 我们称 Post 和 Image 为 `Commentable’

  1. class Post extends Model {}
  2. Post.init({
  3.   title: Sequelize.STRING,
  4.   text: Sequelize.STRING
  5. }, { sequelize, modelName: 'post' });
  7. class Image extends Model {}
  8. Image.init({
  9.   title: Sequelize.STRING,
  10.   link: Sequelize.STRING
  11. }, { sequelize, modelName: 'image' });
  13. class Comment extends Model {
  14.   getItem(options) {
  15.     return this[
  16.       'get' +
  17.         this.get('commentable')
  18.           [0]
  19.           .toUpperCase() +
  20.         this.get('commentable').substr(1)
  21.     ](options);
  22.   }
  23. }
  25. Comment.init({
  26.   title: Sequelize.STRING,
  27.   commentable: Sequelize.STRING,
  28.   commentableId: Sequelize.INTEGER
  29. }, { sequelize, modelName: 'comment' });
  31. Post.hasMany(Comment, {
  32.   foreignKey: 'commentableId',
  33.   constraints: false,
  34.   scope: {
  35.     commentable: 'post'
  36.   }
  37. });
  39. Comment.belongsTo(Post, {
  40.   foreignKey: 'commentableId',
  41.   constraints: false,
  42.   as: 'post'
  43. });
  45. Image.hasMany(Comment, {
  46.   foreignKey: 'commentableId',
  47.   constraints: false,
  48.   scope: {
  49.     commentable: 'image'
  50.   }
  51. });
  53. Comment.belongsTo(Image, {
  54.   foreignKey: 'commentableId',
  55.   constraints: false,
  56.   as: 'image'
  57. });

constraints: false, 禁用引用约束 - 因为 commentableId 列引用了几个表,我们不能为它添加REFERENCES 约束. 请注意,Image -> Comment和Post -> Comment关系定义了一个作用域,分别是 commentable: 'image'和commentable: 'post'. 使用关联函数时,将自动应用此作用域:

  1. image.getComments()
  2. // SELECT "id", "title", "commentable", "commentableId", "createdAt", "updatedAt" FROM "comments" AS
  3. // "comment" WHERE "comment"."commentable" = 'image' AND "comment"."commentableId" = 1;
  5. image.createComment({
  6.   title: 'Awesome!'
  7. })
  8. // INSERT INTO "comments" ("id","title","commentable","commentableId","createdAt","updatedAt") VALUES
  9. // (DEFAULT,'Awesome!','image',1,'2018-04-17 05:36:40.454 +00:00','2018-04-17 05:36:40.454 +00:00')
  10. // RETURNING *;
  12. image.addComment(comment);
  13. // UPDATE "comments" SET "commentableId"=1,"commentable"='image',"updatedAt"='2018-04-17 05:38:43.948
  14. // +00:00' WHERE "id" IN (1)

Comment 上的 getItem 实用函数完成了图片 - 它只是将commentable字符串转换为对getImage或getPost的调用,提供了 comment 是属于post还是image的抽象. 你可以将普通选项对象作为参数传递给getItem(options) 以指定 where 条件或包含的任何位置.

n:m

继续使用多态模型的概念,考虑一个标签表 - 一个项目可以有多个标签,标签可以与多个项目相关联.

为简洁起见,该示例仅显示Post模型,但实际上Tag将与其他几个模型相关.

  1. class ItemTag extends Model {}
  2. ItemTag.init({
  3.   id: {
  4.     type: Sequelize.INTEGER,
  5.     primaryKey: true,
  6.     autoIncrement: true
  7.   },
  8.   tagId: {
  9.     type: Sequelize.INTEGER,
  10.     unique: 'item_tag_taggable'
  11.   },
  12.   taggable: {
  13.     type: Sequelize.STRING,
  14.     unique: 'item_tag_taggable'
  15.   },
  16.   taggableId: {
  17.     type: Sequelize.INTEGER,
  18.     unique: 'item_tag_taggable',
  19.     references: null
  20.   }
  21. }, { sequelize, modelName: 'item_tag' });
  23. class Tag extends Model {}
  24. Tag.init({
  25.   name: Sequelize.STRING,
  26.   status: Sequelize.STRING
  27. }, { sequelize, modelName: 'tag' });
  29. Post.belongsToMany(Tag, {
  30.   through: {
  31.     model: ItemTag,
  32.     unique: false,
  33.     scope: {
  34.       taggable: 'post'
  35.     }
  36.   },
  37.   foreignKey: 'taggableId',
  38.   constraints: false
  39. });
  41. Tag.belongsToMany(Post, {
  42.   through: {
  43.     model: ItemTag,
  44.     unique: false
  45.   },
  46.   foreignKey: 'tagId',
  47.   constraints: false
  48. });

请注意,作用域列(taggable)现在位于中间模型(ItemTag)上.

我们还可以定义一个更具限制性的关联,例如,通过应用中间模型(ItemTag)和目标模型(Tag)的作用域来获取post的所有待定tag:

  1. Post.belongsToMany(Tag, {
  2.   through: {
  3.     model: ItemTag,
  4.     unique: false,
  5.     scope: {
  6.       taggable: 'post'
  7.     }
  8.   },
  9.   scope: {
  10.     status: 'pending'
  11.   },
  12.   as: 'pendingTags',
  13.   foreignKey: 'taggableId',
  14.   constraints: false
  15. });
  17. post.getPendingTags();
  1. SELECT
  2.   "tag"."id",
  3.   "tag"."name",
  4.   "tag"."status",
  5.   "tag"."createdAt",
  6.   "tag"."updatedAt",
  7.   "item_tag"."id" AS "item_tag.id",
  8.   "item_tag"."tagId" AS "item_tag.tagId",
  9.   "item_tag"."taggable" AS "item_tag.taggable",
  10.   "item_tag"."taggableId" AS "item_tag.taggableId",
  11.   "item_tag"."createdAt" AS "item_tag.createdAt",
  12.   "item_tag"."updatedAt" AS "item_tag.updatedAt"
  13. FROM
  14.   "tags" AS "tag"
  15.   INNER JOIN "item_tags" AS "item_tag" ON "tag"."id" = "item_tag"."tagId"
  16.   AND "item_tag"."taggableId" = 1
  17.   AND "item_tag"."taggable" = 'post'
  18. WHERE
  19.   ("tag"."status" = 'pending');

constraints: false 禁用 taggableId 列的引用约束. 因为列是多态的,所以我们不能说它 REFERENCES 了一个特定的表.

用关联创建

如果所有元素都是新的,则可以在一个步骤中创建具有嵌套关联的实例.

BelongsTo / HasMany / HasOne 关联

考虑以下模型:

  1. class Product extends Model {}
  2. Product.init({
  3.   title: Sequelize.STRING
  4. }, { sequelize, modelName: 'product' });
  5. class User extends Model {}
  6. User.init({
  7.   firstName: Sequelize.STRING,
  8.   lastName: Sequelize.STRING
  9. }, { sequelize, modelName: 'user' });
  10. class Address extends Model {}
  11. Address.init({
  12.   type: Sequelize.STRING,
  13.   line1: Sequelize.STRING,
  14.   line2: Sequelize.STRING,
  15.   city: Sequelize.STRING,
  16.   state: Sequelize.STRING,
  17.   zip: Sequelize.STRING,
  18. }, { sequelize, modelName: 'address' });
  20. Product.User = Product.belongsTo(User);
  21. User.Addresses = User.hasMany(Address);
  22. // 也能用于 `hasOne`

可以通过以下方式在一个步骤中创建一个新的Product, User和一个或多个Address: 

  1. return Product.create({
  2.   title: 'Chair',
  3.   user: {
  4.     firstName: 'Mick',
  5.     lastName: 'Broadstone',
  6.     addresses: [{
  7.       type: 'home',
  8.       line1: '100 Main St.',
  9.       city: 'Austin',
  10.       state: 'TX',
  11.       zip: '78704'
  12.     }]
  13.   }
  14. }, {
  15.   include: [{
  16.     association: Product.User,
  17.     include: [ User.Addresses ]
  18.   }]
  19. });

这里,我们的用户模型称为user,带小写u - 这意味着对象中的属性也应该是user. 如果给sequelize.define指定的名称为User,对象中的键也应为User. 对于addresses也是同样的,除了它是一个 hasMany 关联的复数.

用别名创建 BelongsTo 关联

可以将前面的示例扩展为支持关联别名.

  1. const Creator = Product.belongsTo(User, { as: 'creator' });
  3. return Product.create({
  4.   title: 'Chair',
  5.   creator: {
  6.     firstName: 'Matt',
  7.     lastName: 'Hansen'
  8.   }
  9. }, {
  10.   include: [ Creator ]
  11. });

HasMany / BelongsToMany 关联

我们来介绍将产品与许多标签相关联的功能. 设置模型可能如下所示:

  1. class Tag extends Model {}
  2. Tag.init({
  3.   name: Sequelize.STRING
  4. }, { sequelize, modelName: 'tag' });
  6. Product.hasMany(Tag);
  7. // 也能用于 `belongsToMany`.

现在,我们可以通过以下方式创建具有多个标签的产品:

  1. Product.create({
  2.   id: 1,
  3.   title: 'Chair',
  4.   tags: [
  5.     { name: 'Alpha'},
  6.     { name: 'Beta'}
  7.   ]
  8. }, {
  9.   include: [ Tag ]
  10. })

然后,我们可以修改此示例以支持别名:

  1. const Categories = Product.hasMany(Tag, { as: 'categories' });
  3. Product.create({
  4.   id: 1,
  5.   title: 'Chair',
  6.   categories: [
  7.     { id: 1, name: 'Alpha' },
  8.     { id: 2, name: 'Beta' }
  9.   ]
  10. }, {
  11.   include: [{
  12.     association: Categories,
  13.     as: 'categories'
  14.   }]
  15. })