Return 只有 Sequelize.js 中需要的列与连接

Question

我正在从使用 node-mssql 切换到 Sequelize，以便以更简单的方式访问我的数据库。作为 sequelize 的新手，我正在通过提取正确的数据跌跌撞撞地前进。

当我将使用 .net 身份验证的 .net 站点转换为节点站点时，我正在使用现有的身份验证数据库。目前我正在尝试为现有用户提取所有角色。

这是我目前的代码。它 returns userID 和 roleID 以及我想要的用户名和角色名称。如何从我的查询结果中删除这 2 个 ID 列？

 test.aspnet_Users.findAll({
                logging: console.log,
                where: { LoweredUserName: `mcad2\${user}` },
                attributes: ['LoweredUserName'],
                include: {
                    model: test.aspnet_Roles,
                    as: 'RoleId_aspnet_Roles',
                    attributes: ['LoweredRoleName']
                }
            }).then(user => {
                console.log('\n\n' + JSON.stringify(user))
            })

数据库的设置使得 userID 和 roleID 都包含在第三个 table、aspnet_UsersInRoles 中。这是一个相对简单的 2 连接查询，但我不确定如何使用 sequelize 使其工作。

这是创建的 sequelize-auto 代码：

const Sequelize = require('sequelize');
module.exports = function(sequelize, DataTypes) {
  return sequelize.define('aspnet_Roles', {
    ApplicationId: {
      type: DataTypes.UUID,
      allowNull: false,
      references: {
        model: 'aspnet_Applications',
        key: 'ApplicationId'
      }
    },
    RoleId: {
      type: DataTypes.UUID,
      allowNull: false,
      primaryKey: true
    },
    RoleName: {
      type: DataTypes.STRING(256),
      allowNull: false
    },
    LoweredRoleName: {
      type: DataTypes.STRING(256),
      allowNull: false
    },
    Description: {
      type: DataTypes.STRING(256),
      allowNull: true
    }
  }, {
    sequelize,
    tableName: 'aspnet_Roles',
    schema: 'dbo',
    timestamps: false,
    indexes: [
      {
        name: "aspnet_Roles_index1",
        unique: true,
        fields: [
          { name: "ApplicationId" },
          { name: "LoweredRoleName" },
        ]
      },
      {
        name: "PK__aspnet_Roles__31EC6D26",
        unique: true,
        fields: [
          { name: "RoleId" },
        ]
      },
    ]
  });
};

const Sequelize = require('sequelize');
module.exports = function(sequelize, DataTypes) {
  return sequelize.define('aspnet_Users', {
    ApplicationId: {
      type: DataTypes.UUID,
      allowNull: false,
      references: {
        model: 'aspnet_Applications',
        key: 'ApplicationId'
      }
    },
    UserId: {
      type: DataTypes.UUID,
      allowNull: false,
      primaryKey: true
    },
    UserName: {
      type: DataTypes.STRING(256),
      allowNull: false
    },
    LoweredUserName: {
      type: DataTypes.STRING(256),
      allowNull: false
    },
    MobileAlias: {
      type: DataTypes.STRING(16),
      allowNull: true
    },
    IsAnonymous: {
      type: DataTypes.BOOLEAN,
      allowNull: false,
      defaultValue: false
    },
    LastActivityDate: {
      type: DataTypes.DATE,
      allowNull: false
    }
  }, {
    sequelize,
    tableName: 'aspnet_Users',
    schema: 'dbo',
    timestamps: false,
    indexes: [
      {
        name: "aspnet_Users_Index",
        unique: true,
        fields: [
          { name: "ApplicationId" },
          { name: "LoweredUserName" },
        ]
      },
      {
        name: "aspnet_Users_Index2",
        fields: [
          { name: "ApplicationId" },
          { name: "LastActivityDate" },
        ]
      },
      {
        name: "PK__aspnet_Users__03317E3D",
        unique: true,
        fields: [
          { name: "UserId" },
        ]
      },
    ]
  });
};

const Sequelize = require('sequelize');
module.exports = function(sequelize, DataTypes) {
  return sequelize.define('aspnet_UsersInRoles', {
    UserId: {
      type: DataTypes.UUID,
      allowNull: false,
      primaryKey: true,
      references: {
        model: 'aspnet_Users',
        key: 'UserId'
      }
    },
    RoleId: {
      type: DataTypes.UUID,
      allowNull: false,
      primaryKey: true,
      references: {
        model: 'aspnet_Roles',
        key: 'RoleId'
      }
    }
  }, {
    sequelize,
    tableName: 'aspnet_UsersInRoles',
    schema: 'dbo',
    timestamps: false,
    indexes: [
      {
        name: "aspnet_UsersInRoles_index",
        fields: [
          { name: "RoleId" },
        ]
      },
      {
        name: "PK__aspnet_UsersInRo__35BCFE0A",
        unique: true,
        fields: [
          { name: "UserId" },
          { name: "RoleId" },
        ]
      },
    ]
  });
};

var DataTypes = require("sequelize").DataTypes;
var _aspnet_Applications = require("./aspnet_Applications");
var _aspnet_Membership = require("./aspnet_Membership");
var _aspnet_Paths = require("./aspnet_Paths");
var _aspnet_PersonalizationAllUsers = require("./aspnet_PersonalizationAllUsers");
var _aspnet_PersonalizationPerUser = require("./aspnet_PersonalizationPerUser");
var _aspnet_Profile = require("./aspnet_Profile");
var _aspnet_Roles = require("./aspnet_Roles");
var _aspnet_SchemaVersions = require("./aspnet_SchemaVersions");
var _aspnet_Users = require("./aspnet_Users");
var _aspnet_UsersInRoles = require("./aspnet_UsersInRoles");
var _aspnet_WebEvent_Events = require("./aspnet_WebEvent_Events");
var _aspnet_ZoneNumbers = require("./aspnet_ZoneNumbers");
var _aspnet_ZonePositions = require("./aspnet_ZonePositions");

function initModels(sequelize) {
  var aspnet_Applications = _aspnet_Applications(sequelize, DataTypes);
  var aspnet_Membership = _aspnet_Membership(sequelize, DataTypes);
  var aspnet_Paths = _aspnet_Paths(sequelize, DataTypes);
  var aspnet_PersonalizationAllUsers = _aspnet_PersonalizationAllUsers(sequelize, DataTypes);
  var aspnet_PersonalizationPerUser = _aspnet_PersonalizationPerUser(sequelize, DataTypes);
  var aspnet_Profile = _aspnet_Profile(sequelize, DataTypes);
  var aspnet_Roles = _aspnet_Roles(sequelize, DataTypes);
  var aspnet_SchemaVersions = _aspnet_SchemaVersions(sequelize, DataTypes);
  var aspnet_Users = _aspnet_Users(sequelize, DataTypes);
  var aspnet_UsersInRoles = _aspnet_UsersInRoles(sequelize, DataTypes);
  var aspnet_WebEvent_Events = _aspnet_WebEvent_Events(sequelize, DataTypes);
  var aspnet_ZoneNumbers = _aspnet_ZoneNumbers(sequelize, DataTypes);
  var aspnet_ZonePositions = _aspnet_ZonePositions(sequelize, DataTypes);

  aspnet_Roles.belongsToMany(aspnet_Users, { as: 'UserId_aspnet_Users', through: aspnet_UsersInRoles, foreignKey: "RoleId", otherKey: "UserId" });
  aspnet_Users.belongsToMany(aspnet_Roles, { as: 'RoleId_aspnet_Roles', through: aspnet_UsersInRoles, foreignKey: "UserId", otherKey: "RoleId" });
  aspnet_Membership.belongsTo(aspnet_Applications, { as: "Application", foreignKey: "ApplicationId"});
  aspnet_Applications.hasMany(aspnet_Membership, { as: "aspnet_Memberships", foreignKey: "ApplicationId"});
  aspnet_Paths.belongsTo(aspnet_Applications, { as: "Application", foreignKey: "ApplicationId"});
  aspnet_Applications.hasMany(aspnet_Paths, { as: "aspnet_Paths", foreignKey: "ApplicationId"});
  aspnet_Roles.belongsTo(aspnet_Applications, { as: "Application", foreignKey: "ApplicationId"});
  aspnet_Applications.hasMany(aspnet_Roles, { as: "aspnet_Roles", foreignKey: "ApplicationId"});
  aspnet_Users.belongsTo(aspnet_Applications, { as: "Application", foreignKey: "ApplicationId"});
  aspnet_Applications.hasMany(aspnet_Users, { as: "aspnet_Users", foreignKey: "ApplicationId"});
  aspnet_PersonalizationAllUsers.belongsTo(aspnet_Paths, { as: "Path", foreignKey: "PathId"});
  aspnet_Paths.hasOne(aspnet_PersonalizationAllUsers, { as: "aspnet_PersonalizationAllUser", foreignKey: "PathId"});
  aspnet_PersonalizationPerUser.belongsTo(aspnet_Paths, { as: "Path", foreignKey: "PathId"});
  aspnet_Paths.hasMany(aspnet_PersonalizationPerUser, { as: "aspnet_PersonalizationPerUsers", foreignKey: "PathId"});
  aspnet_UsersInRoles.belongsTo(aspnet_Roles, { as: "Role", foreignKey: "RoleId"});
  aspnet_Roles.hasMany(aspnet_UsersInRoles, { as: "aspnet_UsersInRoles", foreignKey: "RoleId"});
  aspnet_Membership.belongsTo(aspnet_Users, { as: "User", foreignKey: "UserId"});
  aspnet_Users.hasOne(aspnet_Membership, { as: "aspnet_Membership", foreignKey: "UserId"});
  aspnet_PersonalizationPerUser.belongsTo(aspnet_Users, { as: "User", foreignKey: "UserId"});
  aspnet_Users.hasMany(aspnet_PersonalizationPerUser, { as: "aspnet_PersonalizationPerUsers", foreignKey: "UserId"});
  aspnet_Profile.belongsTo(aspnet_Users, { as: "User", foreignKey: "UserId"});
  aspnet_Users.hasOne(aspnet_Profile, { as: "aspnet_Profile", foreignKey: "UserId"});
  aspnet_UsersInRoles.belongsTo(aspnet_Users, { as: "User", foreignKey: "UserId"});
  aspnet_Users.hasMany(aspnet_UsersInRoles, { as: "aspnet_UsersInRoles", foreignKey: "UserId"});

  return {
    aspnet_Applications,
    aspnet_Membership,
    aspnet_Paths,
    aspnet_PersonalizationAllUsers,
    aspnet_PersonalizationPerUser,
    aspnet_Profile,
    aspnet_Roles,
    aspnet_SchemaVersions,
    aspnet_Users,
    aspnet_UsersInRoles,
    aspnet_WebEvent_Events,
    aspnet_ZoneNumbers,
    aspnet_ZonePositions,
  };
}
module.exports = initModels;
module.exports.initModels = initModels;
module.exports.default = initModels;

Answer 1

您可以在查询的 attribute 选项中添加一个“排除”选项并排除给定的列：

 test.aspnet_Users.findAll({
     logging: console.log,
     where: { LoweredUserName: `mcad2\${user}` },
     attributes: { exclude: ['userID'], include: ['LoweredUserName'] },
     include: {
         model: test.aspnet_Roles,
         as: 'RoleId_aspnet_Roles',
         attributes: { exclude: ['roleID'], include: ['LoweredRoleName'] },
     }
     }).then(user => {
         console.log('\n\n' + JSON.stringify(user))
     })

如果我正确理解了您的结构，这应该会在获取的数据中排除 userID 和 roleID。

Return 只有 Sequelize.js 中需要的列与连接

Return only desired columns from Sequelize.js with join

node.js

sequelize.js

sequelize-auto