Sequelize值关联查询

一、介绍

很多博客都有关于这方面的介绍，对于初学者来说是比较看起来比较困难， 所以本文直接使用demo的方式进行演示

比较全面的介绍可看这边博客：https://blog.csdn.net/awhlmcyn/article/details/79816478

二、演示的场景

在RBAC权限管理模型中，需要三张表，role(角色表)、access（权限表）、role_access(角色权限关联表)

1、建立角色模型

module.exports = app => {
    const { STRING, INTEGER, DATE } = app.Sequelize;
  
    const Role = app.model.define('role', {
      id: { type: INTEGER, primaryKey: true},
      title: STRING,
      description: STRING,
      status:{
        type:INTEGER,
        defaultValue:0
      },
      created_at: DATE,
      updated_at: DATE,
      is_del:{
        type:INTEGER,
        defaultValue:0
      }
    });
  
    return Role;
  };

数据库表结构 

2、建立权限模型

 

module.exports = app=>{
    const { STRING, INTEGER, DATE } = app.Sequelize;
  
    const Access = app.model.define('access', {
      id: { type: INTEGER, primaryKey: true},
      moduleName: STRING,
      actionName:STRING,
      type: {
          type:INTEGER,
          defaultValue:0
      },
      url:STRING,
      modelId:STRING,
      sort:STRING,
      description:STRING,
      status:{
        type:INTEGER,
        defaultValue:0
      },
      created_at: DATE,
      updated_at: DATE,
      is_del:{
        type:INTEGER,
        defaultValue:0
      }
    },{
        freezeTableName: true  //直接查找设置的表名，默认是表名加s或者es
    });
  
    return Access;
}

数据库表结构

三、角色权限关联表

module.exports = app => {
  const { STRING, INTEGER, DATE } = app.Sequelize;

  const RoleAccess = app.model.define('role_access', {
    id: { type: INTEGER, primaryKey: true},
    // title: STRING,
    role_id: STRING,
    access_id:STRING,
    // description: STRING,
    status:{
      type:INTEGER,
      defaultValue:0
    },
    created_at: DATE,
    updated_at: DATE,
    is_del:{
      type:INTEGER,
      defaultValue:0
    }
  },{
    freezeTableName: true  //直接查找设置的表名，默认是表名加s或者es
  });

  return RoleAccess;
};

三、进行关联查询

（1） hasOne，用法A.hasOne(B,{})  一对一

例如、一个管理员需要确定他含有哪些权限，目前只限于查询权限的ID，由于角色权限关联表中含有角色ID

  Role.hasOne(RoleAccess,{
                // as: 'roleAccess',      //将关联的数据显示到该字段上
                foreginkey:"role_id",  //关联的外键
            })
        let result = await Role.findAll({
            // include:[{model:RoleAccess,as: 'roleAccess',}]
            include:[RoleAccess]
        })

查询结果是

（2）belongsTo ，用法是B.belongsTo(A,{})   一对一

例如：通过角色权限表反查角色，由于角色权限表中含有角色表的主键，所以角色权限属于角色

  RoleAccess.belongsTo(Role,{
                // as: 'roleAccess',      //将关联的数据显示到该字段上
                foreginkey:"role_id",  //关联的外键
            })
        let result = await RoleAccess.findAll({
            // include:[{model:RoleAccess,as: 'roleAccess',}]
            include:[Role]
        })

查询结果是

（3）hasMany,用法A.hasMany(b) 一对多

权限角色表数据

例如：一个角色有多种权限，如增加用户，删除用户等多种权限

 Role.hasMany(RoleAccess,{
            as: 'roleAccess',
            foreginkey:"role_id",
        })
        let result = await Role.findAll({
            include:[{model:RoleAccess,as: 'roleAccess',}]
        })

结果是

与hasOne的区别

 Role.hasOne(RoleAccess,{
                // as: 'roleAccess',      //将关联的数据显示到该字段上
                foreginkey:"role_id",  //关联的外键
            })
        let result = await Role.findAll({
            // include:[{model:RoleAccess,as: 'roleAccess',}]
            include:[RoleAccess]
        })

结果是

以上两种对比可以理解一对一，与一对多的含义，并不是指表的的一对一和一对多，而是每一条记录就一个模型，一对一、一对多是指模型 

（4） belongsToMany 多对多，用法

A.belongsToMany (C,{

foreginkey:"A_id",

through: B

})

C.belongsToMany (A,{

foreginkey:"C_id",

through: B

})

如、一个角色有很多权限，一种权限可能属于多个角色

 Access.belongsToMany(Role,{
            foreginkey:"role_id",
            through: RoleAccess
        })
        Role.belongsToMany(Access,{
            foreginkey:"access_id",
            through: RoleAccess
        })
        let result = await Role.findAll({
            include:[Access]
        })

结果是