Sequelize中按多对多关联值筛选条目并保留全关联值的实现方法

我刚好在项目里处理过几乎一模一样的场景，用sequelize-typescript完全可以实现，下面分模型定义和查询逻辑两部分给你拆解：

一、先确认模型与关联定义 #

首先得把多态多对多的关联关系用sequelize-typescript的装饰器正确配置好，重点是中间表EntityTag的多态字段和额外的value属性：

1. Tag 模型 #

import { Table, Column, Model, HasMany, PrimaryKey, AutoIncrement } from 'sequelize-typescript';
import { EntityTag } from './EntityTag';

@Table
export class Tag extends Model {
  @PrimaryKey
  @AutoIncrement
  @Column
  id: number;

  @Column({ unique: true })
  name: string; // 标签关键字，比如"priority"、"category"

  @HasMany(() => EntityTag)
  entityTags: EntityTag[];
}

2. EntityTag 中间表（带多态和value字段） #

import { Table, Column, Model, ForeignKey, BelongsTo, PrimaryKey, AutoIncrement } from 'sequelize-typescript';
import { Tag } from './Tag';
import { Item } from './Item';

@Table
export class EntityTag extends Model {
  @PrimaryKey
  @AutoIncrement
  @Column
  id: number;

  @ForeignKey(() => Tag)
  @Column
  tagId: number;

  @Column
  entityId: number; // 关联的实体ID（比如Item的id）

  @Column
  entityType: string; // 多态标识，比如"Item"、"Post"

  @Column
  value: string; // 标签的具体值，比如"high"、"tech"

  @BelongsTo(() => Tag)
  tag: Tag;

  @BelongsTo(() => Item, 'entityId') // 指定外键对应Item的id
  item: Item;
}

3. Item 模型 #

import { Table, Column, Model, HasMany, PrimaryKey, AutoIncrement } from 'sequelize-typescript';
import { EntityTag } from './EntityTag';

@Table
export class Item extends Model {
  @PrimaryKey
  @AutoIncrement
  @Column
  id: number;

  @Column
  name: string;

  // 多态关联到EntityTag，通过entityId和entityType匹配
  @HasMany(() => EntityTag, {
    foreignKey: 'entityId',
    scope: {
      entityType: 'Item' // 指定当前实体的多态标识
    }
  })
  entityTags: EntityTag[];
}

二、核心查询逻辑：筛选Item但保留全部关联标签 #

这里的关键是不要在include的关联里加where条件（那样会过滤掉Item的其他关联标签），而是通过子查询或者JOIN来筛选符合条件的Item，然后再完整加载它的所有关联标签。

方法1：使用EXISTS子查询（推荐，性能更优） #

比如我们要筛选出「关联了名称为priority且value为high的Tag」的Item，同时返回每个Item的所有标签：

import { Item } from './models/Item';
import { EntityTag } from './models/EntityTag';
import { Tag } from './models/Tag';
import { Op } from 'sequelize';

const filteredItems = await Item.findAll({
  include: [
    {
      model: EntityTag,
      include: [Tag],
      // 这里不要加where！确保加载所有关联的EntityTag和Tag
    }
  ],
  where: {
    [Op.exists]: EntityTag.findOne({
      attributes: [],
      where: {
        entityId: { [Op.col]: 'Item.id' },
        entityType: 'Item',
        value: 'high',
        '$tag.name$': 'priority' // 关联Tag的name条件
      },
      include: [
        {
          model: Tag,
          attributes: []
        }
      ]
    })
  },
  distinct: true // 避免重复的Item（如果同一个Item匹配多次子查询）
});

方法2：使用JOIN + 去重 #

如果更习惯JOIN写法，也可以这么做，但要注意去重：

const filteredItems = await Item.findAll({
  include: [
    {
      model: EntityTag,
      include: [Tag]
    }
  ],
  where: {
    '$entityTags.tag.name$': 'priority',
    '$entityTags.value$': 'high'
  },
  includeIgnoreAttributes: false,
  distinct: true
});

注意：这种写法虽然简洁，但如果Item有多个符合条件的EntityTag记录，会导致Item被重复查询，所以必须加distinct: true来去重。

三、关键注意点 #

• 多态标识的一致性：确保Item模型里的scope.entityType和查询时EntityTag的entityType条件完全一致，比如都用'Item'（大小写敏感）。
• 避免过滤关联数据：如果直接在include的EntityTag里加where，会导致返回的Item只包含符合条件的Tag，而不是全部关联Tag，这和需求相悖，一定要避免。
• 性能优化：如果数据量较大，建议给EntityTag的entityType、entityId、tagId、value字段建立联合索引，提升查询速度。

内容的提问来源于stack exchange，提问作者Emanuele Casadio