Question

我无法找到合适的文档，但我想要做的是根据顶级模型的ID限制包含。我无法用语言表达，但这正是我希望实现的目标。

db.A.findAll({
  as: 'A',
  where: {
    ...
  },
  include: [{
    model: B,
    include: [{
      model: C,
      where: {
        color_id: A.color_id
      }
    }]
  }]
}

A与B相关联，而B有很多C.我试图限制获取C的数量，因为它导致查询非常慢。

编辑，添加模型关联：

const A = sequelize.define('A', {
  id: {
    type: DataTypes.INTEGER,
    allowNull: false,
    primaryKey: true,
    autoIncrement: true,
    field: 'id'
  }, {
    tableName: 'a',
    underscored: true,
    indexes: [
      { fields: ['b'] }
    ]
  }
});

A.associate = function (models) {
  A.belongsTo(models.B);
  A.belongsTo(models.D);
}

const B = sequelize.define('B', {
  ...non-related-columns
});

B.associate = function (models) {
  B.hasMany(models.C);
  B.belongsTo(models.D);
  B.hasMany(models.E);
  B.hasMany(models.F);
}

const C = sequelize.define('C', {
  ...non-related-columns
});

C.associate = function (models) {
  C.belongsTo(models.B);
  C.belongsTo(models.D);
}

Answer 1

更新：这是您要找的吗？

B.findOne({
  where: {
    id: a.bId
  },
  include: [{ all: true, nested: true }]
})

我之前的回答：

我认为这应该有效。我已经简化了这个问题。

const A = db.define('a', {
  name: Sequelize.STRING
})

const B = db.define('b', {
  name: Sequelize.STRING
})

const C = db.define('c', {
  type: Sequelize.STRING
})

A.belongsTo(B);
B.hasOne(A);

B.hasMany(C);
C.hasOne(B);

// given an A, find all Cs of type 'foo'

B.findOne({
  where: {
    id: a.bId
  }
})
.then(b => {
  return C.findAll({
    where: {
      bId: b.id,
      type: 'foo'
    }
  })
})
.the(foosWhichBelongToAThrougB => {
  //do something with your array of foos
})

我没有尝试使用一个查询来抓取所有内容，而是将其拆分为两个查询。一个找到与A相关联的B，然后找到一个与B相关联的所有C，并匹配C模型中的某些内容。

在Sequelize中使用parent模型作为条件

1 个答案: