Flask中数据库的多对多关系

大多数的其他关系类型都可以从一对多类型中衍生。多对一关系从“多”的一次看，就是一对多关系。一对一关系是简化版的一对多关系。唯一不能从一对多关系中演化出来的类型就是多对多关系。

• 多对多关系

一对多，多对一，一对一关系至少都有一侧是单个实体，表之间的联系通过外键实现，让外键指向那个实体。解决多对多的关系，需要引入第三张表，称为关联表，由此可以分解成原表和关联表之间的两个一对多关系。 比如学生选课，一个学生可以选择多门课程，一门课程可以被多个学生选择，这是一个典型的多对多的关系。

多对多关系在查询时的流程：比如查找一个学生选了哪些课程，首先从学生和注册之间的一对多关系开始，获取学生student_id对应的所有class_id，然后在按照多对一的方向遍历课程和注册之间的一对多的关系，找到该学生选择的所有课程。

1. 两个实体多对多关系

　　Flask-SQLAlchemy实现多对多关系

registrations = db.Table('registrations', 
    db.Column('student_id', db.Integer, db.ForeignKey('students.id')),
    db.Column('class_id', db.Integer, db.ForeignKey('classes.id')))

class Student(db.Model):
    __tablename__ = 'students'
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String)
    classes = db.relationship('Class', secondary=registrations,
                              backref = db.backref('students', lazy='dynamic'),
                              lazy='dynamic')

class Class(db.Model):
    __tablename__ = 'classes'
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String)

在多对多关系中，依然使用db.relationship()方法定义，但在多对多关系中，必须把secondary参数设为关联表。多对多关系可以在任何类中定义，backref参数会处理好关系的另一侧。关联表就是一个简单的表，不是模型，Flask-SQLAlchemy会自动接管这个表。

学生注册课程：

stu.classes.append(c)
db.session.add(stu)

列出学生注册的所有课程：

stu.classes.all()

注册了课程c的所有学生：

c.students.all()

• 自引用关系

在用户关注功能中，多对多关系中并不存在两个实体，只有User一个实体模型。如果关系中的两侧都在同一个表中，这种关系称为自引用关系

关联表follows，其中每一行表示一个用户关注另一个用户。左侧表示follower，可理解为粉丝，右侧表示followed，可理解为关注别人。

使用多对多关系时，需要存储两个实体之间的额外信息，比如某个用户关注另一个用户的时间信息。为了能处理自定义的数据，可以将关联表设计成可访问的模型。

class Follow(db.Model):
    __tablename__ = 'follows'
    follower_id = db.Column(db.Integer, db.ForeignKey('users.id'), primary_key=True)
    followed_id = db.Column(db.Integer, db.ForeignKey('users.id'), primary_key=True)
    timestamp = db.Column(db.DateTime, default=datetime.utcnow)
    
class User(UserMixin, db.Model):
    __tablename__ = 'users'
    ...
    followers = db.relationship('Follow',
                               foreign_keys=[Follow.followed_id],
                               backref=db.backref('followed', lazy='joined'),
                               lazy='dynamic',
                               cascade='all, delete-orphan')
    followed = db.relationship('Follow',
                               foreign_keys=[Follow.follower_id],
                               backref=db.backref('follower', lazy='joined'),
                               lazy='dynamic',
                               cascade='all, delete-orphan')

参数介绍：

　　1. foreign_keys参数表示关联的外键

　　2. backref参数表示将followed/follower回引Follow模型， 可以通过Follow.follower访问粉丝，通过Follow.followed访问关注的人

　　3. 回引中的lazy参数指定为joined可以实现立即从联结查询中加载相关对象

　　4. cascade参数配置在父对象上执行的操作对相关对象的影响

• 关注关系的辅助方法

class User(UserMixin, db.Model):
    __tablename__ = 'users'
    ...
    
    # 关注某个用户
    def follow(self, user):
        # 判断是否已经关注了
        if not self.is_following(user):
            # 新建关联表对象实例，记录粉丝和被关注者的关系
            f = Follow(follower=self, followed=user)
            db.session.add(f)
    
    # 取消关注某个用户
    def unfollow(self, user):
        # 检查取消的关注的用户是否已经被关注了
        f = self.followed.filter_by(followed_id=user.id).first()
        if f:
            db.session.delete(f)
    
    # 判断是否已经关注
    def is_following(self, user):
        # 确认用户有没有id，以防创建了用户，但是未提交到数据库
        if user.id is None:
            return False
        return self.followed.filter_by(followed_id=user.id).first() is not None
    
    # 判断是否被关注
    def is_followed_by(self, user):
        if user.id is None:
            return False
        return self.followers.filter_by(follower_id=user.id).first() is not None

• END