Python 2.7 + SQLAlchemy 对称自引用多对多好友关系实现求助

嘿，我懂你要做的对称好友关系——A加B为好友，B自动就是A的好友，不需要存两条重复记录对吧？其实用secondary表是正确的思路，但关键要处理好关联条件和存储约束，避免冗余和单向查询的问题。下面给你一套可行的实现方案：

1. 定义基础模型与关联表 #

首先需要用户表，以及存储好友关系的中间表。核心是给中间表加约束，避免同时存储(A,B)和(B,A)，杜绝冗余数据：

from sqlalchemy import Table, Column, Integer, String, ForeignKey, CheckConstraint
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import relationship, backref, sessionmaker

Base = declarative_base()

# 好友关系中间表
friendship = Table(
    'friendship', Base.metadata,
    Column('user_id', Integer, ForeignKey('users.id'), primary_key=True),
    Column('friend_id', Integer, ForeignKey('users.id'), primary_key=True),
    # 关键约束：确保user_id始终小于friend_id，避免重复存储双向关系
    CheckConstraint('user_id < friend_id', name='chk_user_friend_order')
)

class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String(50), nullable=False)

    # 定义对称的好友关系
    friends = relationship(
        'User',
        secondary=friendship,
        # 匹配当前用户作为user_id的情况
        primaryjoin=(id == friendship.c.user_id),
        # 匹配当前用户作为friend_id的情况（实现对称查询的核心）
        secondaryjoin=(id == friendship.c.friend_id),
        # 双向引用，确保反向查询也能拿到好友列表
        backref=backref('friends', uselist=True),
        # 用dynamic加载方便后续链式查询
        lazy='dynamic'
    )

2. 自定义好友操作方法 #

因为加了user_id < friend_id的约束，直接用user.friends.append()可能会违反规则（比如当前用户ID比好友大时），所以给User模型加两个方法处理添加/删除逻辑：

class User(Base):
    # ... 上面的字段和关系定义 ...

    def add_friend(self, friend):
        """添加好友，自动处理存储顺序"""
        if friend not in self.friends:
            # 确保存储的记录符合约束
            if self.id < friend.id:
                self.friends.append(friend)
            else:
                friend.friends.append(self)

    def remove_friend(self, friend):
        """删除好友，对称移除关系"""
        if friend in self.friends:
            if self.id < friend.id:
                self.friends.remove(friend)
            else:
                friend.friends.remove(self)

3. 验证功能效果 #

用下面的代码测试是否符合预期：

# 创建会话（这里用SQLite举例，可替换为其他数据库）
engine = create_engine('sqlite:///friends.db')
Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)
session = Session()

# 创建测试用户
alice = User(name='Alice')
bob = User(name='Bob')
charlie = User(name='Charlie')
session.add_all([alice, bob, charlie])
session.commit()

# 添加好友
alice.add_friend(bob)
session.commit()

# 验证对称查询
print("Alice的好友:", [u.name for u in alice.friends.all()])  # 输出: ['Bob']
print("Bob的好友:", [u.name for u in bob.friends.all()])      # 输出: ['Alice']

# 再添加一个好友
bob.add_friend(charlie)
session.commit()
print("Bob的好友:", [u.name for u in bob.friends.all()])      # 输出: ['Alice', 'Charlie']
print("Charlie的好友:", [u.name for u in charlie.friends.all()])  # 输出: ['Bob']

# 删除好友
alice.remove_friend(bob)
session.commit()
print("Alice的好友:", [u.name for u in alice.friends.all()])  # 输出: []
print("Bob的好友:", [u.name for u in bob.friends.all()])      # 输出: ['Charlie']

为什么之前的思路可能出问题？ #

如果你的primaryjoin和secondaryjoin只设置了单向条件（比如只匹配user_id = 当前ID），查询时只能拿到单向好友列表，没法实现对称。另外如果没加约束或代码控制，容易出现重复存储(A,B)和(B,A)的情况，既浪费空间又可能导致查询结果重复。

如果你的数据库不支持CheckConstraint（比如旧版本SQLite），可以去掉这个约束，完全靠add_friend方法的逻辑保证只存一次关系，效果一致。

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