在 Sequelize 中优化对相关表的查询

Question

我想知道是否有更好的方法来获得以下结果：从通过多对多关系连接的表中过滤具有值的行列表。 在我的示例中，是具有某些乐器的歌曲。

这是我的歌曲模型：

module.exports = function(sequelize, DataTypes) {
    var Song = sequelize.define('songs', {
        id: {
            type: DataTypes.INTEGER(10).UNSIGNED,
            allowNull: false,
            primaryKey: true,
            autoIncrement: true
        },
        title: {
            type: DataTypes.STRING(50),
            allowNull: false
        },
    }, {
        tableName: 'songs',
        timestamps: false
    });

    Song.associate = function (models) {
        Song.belongsToMany(models.instruments, {through: 'songs_instruments', foreignKey: 'song_id'})
    };

    return Song
};

这是我的乐器模型：

module.exports = function(sequelize, DataTypes) {
    var Instrument = sequelize.define('instruments', {
        id: {
            type: DataTypes.INTEGER(10).UNSIGNED,
            allowNull: false,
            primaryKey: true,
            autoIncrement: true
        },
        name: {
            type: DataTypes.STRING(50),
            allowNull: false
        }
    }, {
        tableName: 'instruments',
        timestamps: false,
    });

    Instrument.associate = function (models) {
        Instrument.belongsToMany(models.songs, {through: 'songs_instruments', foreignKey: 'instrument_id'})
    };

    return Instrument
};

这是连接表的模型：

module.exports = function(sequelize, DataTypes) {
    return sequelize.define('songs_instruments', {
        id: {
            type: DataTypes.INTEGER(10).UNSIGNED,
            allowNull: false,
            primaryKey: true,
            autoIncrement: true
        },
        song_id: {
            type: DataTypes.INTEGER(10).UNSIGNED,
            allowNull: false,
            references: {
                model: 'songs',
                key: 'id'
            }
        },
        instrument_id: {
            type: DataTypes.INTEGER(10).UNSIGNED,
            allowNull: false,
            references: {
                model: 'instruments',
                key: 'id'
            }
        }
    }, {
        tableName: 'songs_instruments',
        timestamps: false
    });
};

这是我目前进行提取的方式（args['instruments'] 包含我要过滤歌曲的乐器列表）：

const instruments = await db.instruments.findAll({
    where: {name: args['instruments']}
})

const songs_instruments = await db.songs_instruments.findAll({
    where: {instrument_id: instruments.map(instrument => instrument.id)}
})

const songs = await db.songs.findAll({
    where: {id: songs_instruments.map(song => song.song_id)}
})
return songs

虽然这可以正常工作，并且最终我得到了我期望的结果，但我不禁想知道是否有更有效的方式来查询数据库，因为这样做会导致总共三个查询待执行：

Executing (default): SELECT `id`, `name` FROM `instruments` AS `instruments` WHERE `instruments`.`name` IN ('Vocals', 'Trumpet', 'Guitar');
Executing (default): SELECT `id`, `song_id`, `instrument_id` FROM `songs_instruments` AS `songs_instruments` WHERE `songs_instruments`.`instrument_id` IN (1, 3, 7);
Executing (default): SELECT `id`, `title` FROM `songs` AS `songs` WHERE `songs`.`id` IN (1, 1, 2, 2, 3, 3);

我对 Sequelize 很陌生，因此我实现目标的方法可能不正确/次优。

Answer 1

哦，我完全错过了.. 已经很晚了.. 是的，你可以这样做.. 添加下面的 as 来别名这个连接，并在歌曲中做同样的事情：'instruments'......你没有'不需要获取连接记录..

Instrument.associate = function (models) {
        Instrument.belongsToMany(models.songs, {through: 'songs_instruments', as: 'songs', foreignKey: 'instrument_id', otherKey: 'song_id'})
    };

const instruments = await db.instruments.findAll({
    where: {name: args['instruments']},
    {
     include: [{
        model: db.songs,
        as: 'songs', 
        through: db.songs_instruments,
      }]
   }
});

或者类似于下面的内容...

const songs = await db.songs.findAll({
          include: [{
            model: db.instruments,
            as: 'instruments', 
            through: db.songs_instruments,
            where: {name: args['instruments']}
          }],
        });

Answer 2

看起来您正在使用数据加载器，并且您的三个查询是批处理的..我认为你们都很好...您显然正在利用模型设置与 sequelize 所以它必须是通用的，我不明白这里有问题