用flask开发个人博客（23）—— flask中的数据模型关系

一、一对一关系

        一个人和身份证之间的关系，一个人只有一个身份证，一个身份证也只有被一个人拥有。

class Identification(db.Model):
    """
    身份证
    """
    __tablename__='idents'
    id=db.Column(db.Integer,primary_key=True)
    address=db.Column(db.String(64),unique=True)
    user=db.relationship('User',backref='ident',uselist=False)

    def __repr__(self):
        return '<Identification %s>'%self.id

class User(db.Model):
    """
    用户
    """
    __tablename__='users'
    id = db.Column(db.Integer,primary_key=True)
    name = db.Column(db.String(64),unique=True)
    ident_id=db.Column(db.Integer,db.ForeignKey('idents.id'))

    def __repr__(self):
        return '<User %s>'%self.name

        我们创建了两个类：一个用户类User和一个身份类Identification,User和Identification之间是一对一的关系，所以我们在Identification的user字段，db.relationship中设置其uselist属性为false，表示该类和反向引用的User类是一对一的关系，user不是一个列表。

       我们可以在终端中进行验证：

>>> i=Identification(id=123)
>>> u=User(name='Hyman')
>>> i.user=u
>>> u.ident
<Identification 123>

二、一对多关系

       就是我们在《 用flask开发个人博客（19）—— 数据模型的外键关系》一文中列举的角色Role和用户User之间的关系：

1. class Role(db.Model):    
2.       __tablename__='roles'    
3.       id = db.Column(db.Integer,primary_key=True)    
4.       name = db.Column(db.String(64),unique=True)    
5.       users = db.relationship('User',backref='role')  
6.       
7.       def __repr__(self):    
8.           return '<Role %s>'%self.name    
9.  class User(db.Model):    
10.       __tablename__='users'    
11.       id=db.Column(db.Integer,primary_key=True)    
12.       name=db.Column(db.String(64),unique=True)    
13.       role_id = db.Column(db.Integer,db.ForeignKey('roles.id'))  
14.       def __repr__(self):    
15.           return '<User %s>'%self.name   

      

         这里面，我们在第5行使用relationship时，没有显示的使用uselist，但是它默认是True，也就是多对一关系的。我们当时这样验证这种一对多的关系：

1. >>>from test.py import Role,User  
2. >>>r=Role(id=1,name='admin')  
3. >>>u=User(id=10,name='Hyman',role_id=1)  
4. >>>r.users.append(u)  
5. >>>print u.role  
6.    <Role admin>  

三、多对一的关系

        多对一的关系把一对多关系的外键和relationship对调即可。

四、多对多关系

    多对多关系，需要借助第三个表来实现。通过第三个表，将多对多关系分解成两个一对多关系。以我们常见的Student类和Class类为例，一个Student可以选择多个Class，而一门Class也可以被多个Student选择，我们创建一个Relation表来关联Student和Class。

relation=db.Table('relations',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=relation,backref=db.backref('students',lazy='dynamic'),lazy='dynamic')
    
    def __repr__(self):
        return '<Student %s>'%self.name

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

    def __repr__(self):
        return '<CLass %s>'%self.name

        第一行，我们创建了一个Table叫做relation。之所以在这里创建，是因为我不想创建数据库，而是利用db.Table，将这个表创建到内存中。relation表中含有两个字段分别作为外键关联到Student类和Class类的主键id中。紧接着创建两个表Student和Class，在Student表中我们创建了一个db.relationship，用backref在Class类中添加反向引用students。并用secondary指定作为中间表的relation。

      我们可以按照下面的方式验证多对多的关系：

>> c1=Class(name='match')
>>> s1=Student(name='hyman')
>>> c2=Class(name='english')
>>> s2=Student(name='tom')
>>> s1.classes.append(c1)
>>> s1.classes.append(c2)
>>> s2.classes.append(c1)

        我们创建了两个Student类的对象s1和s2,两个Class类的对象c1和c2。然后s1选择c1和c2，s2选择c1。完成了上述的关联，我们从c1和c2的角度去查看选择其的Student对象。

        查看c1的：

>>> for stu in c1.students:
...     print stu
... 
<Student hyman>
<Student tom>

        查看c2的：

>> for stu in c2.students:
...     print stu
... 
<Student hyman>

        我们发现c1和c2都正确显示选择其的Student类对象的信息，我们的多对多关系成功通过第三个表得到了关联。

Github位置：
https://github.com/HymanLiuTS/flaskTs

克隆本项目：
git clone git@github.com:HymanLiuTS/flaskTs.git
获取本文源代码：
git checkout FL23