mysql - 寻找具有 Sequelize 关联的 friend

Question

我对 mysql Sequelize 还是比较陌生，试图更好地了解关联是如何工作的。我创建了一个简单的应用程序，用户可以在其中将彼此添加为 friend ，如果我是对的，这将是多对多关系？

我有一个用户表和一个friend_binds 表。 users 表是一个典型的 users 表，并且friend_binds 表是这样创建的:

CREATE TABLE `friend_binds` (
  `id` char(36) CHARACTER SET latin1 COLLATE latin1_bin NOT NULL,
  `friend_id` char(36) CHARACTER SET latin1 COLLATE latin1_bin NOT NULL,
  `created_at` datetime NOT NULL,
  `updated_at` datetime NOT NULL,
  `parent_id` char(36) CHARACTER SET latin1 COLLATE latin1_bin NOT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `friendKey` (`parent_id`,`friend_id`),
  CONSTRAINT `friend_binds_ibfk_1` FOREIGN KEY (`parent_id`) REFERENCES `users` (`id`) ON DELETE CASCADE ON UPDATE CASCADE

我最初的工作方式是每次添加 friend 时，都会向friend_binds(A 到B 和B 到A)创建两个条目。这个方法对我来说效果很好，无论是A还是B我都可以拉 friend 。

原始用户模型关联:

User.associate = models => {
    User.hasMany(models.friendBind, {
      foreignKey: {
        name: 'parentId',
        allowNull: false
      },
      onDelete: 'cascade',
      hooks: true
    })
  }

原始 FriendBinds 模型关联:

FriendBind.associate = models => {
    FriendBind.belongsTo(models.user, {
      foreignKey: {
        name: 'parentId',
        type: DataTypes.UUID,
        allowNull: false
      },
      onDelete: 'cascade'
    })
  }

我想看看我是否可以做到，所以我只需要在我的friend_binds 表中输入一个条目(即仅从 A 到 B)。我最终想添加一个状态列(已发送、已查看、已拒绝等)，我觉得每次都必须更新两行只是做错了。

我现在遇到的问题是，当我执行 user.getFriends() 时，它只会获取用户是 friend A (parent_id) 的 friend 。如果用户是 A 或 B，我认为我应该能够找到记录是错误的吗？我是否只需要 .findAll() 两次，一次搜索 parentId，一次搜索friendId？

这是新用户协会

User.associate = models => {
    User.belongsToMany(models.user, {
      as: "friends",
      through: "friend_binds",
      foreignKey: "userId",
      otherKey: "friendId"
    })
  }

在这种情况下，我在某处读到我什至不需要定义我的friend_binds 表，因为 sequelize 为我创建了它，所以我就是这样做的

为friend_binds 创建表运行的新查询

CREATE TABLE `friend_binds` (
  `created_at` datetime NOT NULL,
  `updated_at` datetime NOT NULL,
  `user_id` char(36) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL,
  `friend_id` char(36) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL,
  PRIMARY KEY (`user_id`,`friend_id`),
  KEY `friend_id` (`friend_id`),
  CONSTRAINT `friend_binds_ibfk_1` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE CASCADE ON UPDATE CASCADE,
  CONSTRAINT `friend_binds_ibfk_2` FOREIGN KEY (`friend_id`) REFERENCES `users` (`id`) ON DELETE CASCADE ON UPDATE CASCADE

找 friend 的相关代码

module.exports.getFriendsNew = async (req, res) => {
  try {
    const user = await db.user
      .findByPk(req.user.id)
      .catch(error => { throw new Error(error) })

    const friends = await user
      .getFriends()
      .then(results => {
        if (results.length === 0) { throw new Error("You have no friends") }
        return results
      })
      .catch(error => { throw new Error(error) })

    res.send(friends)

  } catch (error) {
    res.send(error.message)
  }
}res.send(error)
  }

使用此代码，我可以找到 friend A 的记录，但是如果我搜索 friend B，它会返回 0 个 friend 。

Answer 1

一个 user 可以有很多 friend ，那个也是 user 的 friend 可以有很多 friend ，这也是 users 。
users 和 users 之间肯定是多对多的关系。

要保持这种关系，您需要定义一个数据透视表。我会称它为 UsersFriends 。

因此，您将拥有的关联将如下所示。

User.belongsToMany(models.User, { 
  as: 'friends',
  foreignKey: 'user_id',
  through: UsersFriends
});
User.belongsToMany(models.User, { 
  as: 'userFriends',
  foreignKey: 'friend_id',
  through: UsersFriends
});

// UsersFriends 
module.exports = (sequelize, DataTypes) => {
  const TaskSparePart = sequelize.define('UsersFriends', {
    user_id: DataTypes.BIGINT,
    friend_id: DataTypes.BIGINT,
    created_at: DataTypes.DATE,
    updated_at: DataTypes.DATE,
  }, {
    tableName: 'users_friends',
  });
  return UsersFriends;
};

// To get friends
module.exports.getFriends = async (req, res) => {
  try {
     const user = await db.User.findOne({
        where: {
        id: req.user.id,
        },
        include: 'friends'
    })
    if (!user) throw new Error('User not found!');
    res.send(user.friends);
  } catch (error) {
    res.send(error.message)
  }
}