Constraints & Circularities - 约束 & 循环

在表之间添加约束意味着使用 sequelize.sync 时必须在数据库中以一定顺序创建表. 如果 Task 具有对 User 的引用,则必须先创建 User 表,然后才能创建 Task 表. 有时这可能会导致循环引用,而 Sequelize 无法找到同步的顺序. 想象一下文档和版本的情况. 一个文档可以有多个版本,为方便起见,文档引用了其当前版本.

  1. const { Sequelize, Model, DataTypes } = require("sequelize");
  3. class Document extends Model {}
  4. Document.init({
  5.     author: DataTypes.STRING
  6. }, { sequelize, modelName: 'document' });
  8. class Version extends Model {}
  9. Version.init({
  10.   timestamp: DataTypes.DATE
  11. }, { sequelize, modelName: 'version' });
  13. Document.hasMany(Version); // 这会将 documentId 属性添加到 version 中
  14. Document.belongsTo(Version, {
  15.   as: 'Current',
  16.   foreignKey: 'currentVersionId'
  17. }); // 这会将 currentVersionId 属性添加到 document 中

但是,不幸的是,上面的代码将导致以下错误:

  1. Cyclic dependency found. documents is dependent of itself. Dependency chain: documents -> versions => documents

为了减少这种情况,我们可以将 constraints: false 传递给关联之一:

  1. Document.hasMany(Version);
  2. Document.belongsTo(Version, {
  3.   as: 'Current',
  4.   foreignKey: 'currentVersionId',
  5.   constraints: false
  6. });

这将使我们能够正确同步表:

  1. CREATE TABLE IF NOT EXISTS "documents" (
  2.   "id" SERIAL,
  3.   "author" VARCHAR(255),
  4.   "createdAt" TIMESTAMP WITH TIME ZONE NOT NULL,
  5.   "updatedAt" TIMESTAMP WITH TIME ZONE NOT NULL,
  6.   "currentVersionId" INTEGER,
  7.   PRIMARY KEY ("id")
  8. );
  10. CREATE TABLE IF NOT EXISTS "versions" (
  11.   "id" SERIAL,
  12.   "timestamp" TIMESTAMP WITH TIME ZONE,
  13.   "createdAt" TIMESTAMP WITH TIME ZONE NOT NULL,
  14.   "updatedAt" TIMESTAMP WITH TIME ZONE NOT NULL,
  15.   "documentId" INTEGER REFERENCES "documents" ("id") ON DELETE
  16.   SET
  17.     NULL ON UPDATE CASCADE,
  18.     PRIMARY KEY ("id")
  19. );

不受限制地强制执行外键引用

有时,你可能希望引用另一个表,而不添加任何约束或关联. 在这种情况下,你可以将引用属性手动添加到架构定义中,并标记它们之间的关系.

  1. class Trainer extends Model {}
  2. Trainer.init({
  3.   firstName: Sequelize.STRING,
  4.   lastName: Sequelize.STRING
  5. }, { sequelize, modelName: 'trainer' });
  7. // 在我们调用 Trainer.hasMany(series) 之后,
  8. // Series 将会有一个 trainerId = Trainer.id 外参考键
  9. class Series extends Model {}
  10. Series.init({
  11.   title: Sequelize.STRING,
  12.   subTitle: Sequelize.STRING,
  13.   description: Sequelize.TEXT,
  14.   // 设置与 `Trainer` 的外键关系(hasMany)
  15.   trainerId: {
  16.     type: DataTypes.INTEGER,
  17.     references: {
  18.       model: Trainer,
  19.       key: 'id'
  20.     }
  21.   }
  22. }, { sequelize, modelName: 'series' });
  24. // 在我们调用 Series.hasOne(Video) 之后,
  25. // Video 将具有 seriesId = Series.id 外参考键
  26. class Video extends Model {}
  27. Video.init({
  28.   title: Sequelize.STRING,
  29.   sequence: Sequelize.INTEGER,
  30.   description: Sequelize.TEXT,
  31.   // 设置与 `Series` 的关系(hasOne)
  32.   seriesId: {
  33.     type: DataTypes.INTEGER,
  34.     references: {
  35.       model: Series, // 可以是代表表名的字符串,也可以是 Sequelize 模型
  36.       key: 'id'
  37.     }
  38.   }
  39. }, { sequelize, modelName: 'video' });
  41. Series.hasOne(Video);
  42. Trainer.hasMany(Series);