SQLAlchemy的ORM（4）

表关系：

表之间的关系存在三种：一对一、一对多、多对多。而SQLAlchemy中的ORM也可以模拟这三种关系。因为一对一其实在SQLAlchemy中底层是通过一对多的方式模拟的，所以先来看下一对多的关系：

外键：

在Mysql中，外键可以让表之间的关系更加紧密。而SQLAlchemy同样也支持外键。通过ForeignKey类来实现，并且可以指定表的外键约束。相关示例代码如下：

  1. class Article(Base):
  2.     __tablename__ = 'article'
  3.     id = Column(Integer,primary_key=True,autoincrement=True)
  4.     title = Column(String(50),nullable=False)
  5.     content = Column(Text,nullable=False)
  6.     uid = Column(Integer,ForeignKey('user.id'))
  7.     def __repr__(self):
  8.         return "<Article(title:%s)>" % self.title
  10. class User(Base):
  11.     __tablename__ = 'user'
  12.     id = Column(Integer,primary_key=True,autoincrement=True)
  13.     username = Column(String(50),nullable=False)

外键约束有以下几项：

  1. RESTRICT：父表数据被删除，会阻止删除。默认就是这一项。
  2. NO ACTION：在MySQL中，同RESTRICT。
  3. CASCADE：级联删除。
  4. SET NULL：父表数据被删除，子表数据会设置为NULL。

    一对多：

    拿之前的User表为例，假如现在要添加一个功能，要保存用户的邮箱帐号，并且邮箱帐号可以有多个，这时候就必须创建一个新的表，用来存储用户的邮箱，然后通过user.id来作为外键进行引用，先来看下邮箱表的实现： ```python from sqlalchemy import ForeignKey from sqlalchemy.orm import relationship

class Address(Base): tablename = ‘address’ id = Column(Integer,primary_key=True) email_address = Column(String,nullable=False)

  1. # User表的外键，指定外键的时候，是使用的是数据库表的名称，而不是类名
  2. user_id = Column(Integer,ForeignKey('users.id'))
  3. # 在ORM层面绑定两者之间的关系，第一个参数是绑定的表的类名，
  4. # 第二个参数back_populates是通过User反向访问时的字段名称
  5. user = relationship('User',back_populates="addresses")
  6. def __repr__(self):
  7.     return "<Address(email_address='%s')>" % self.email_address
  8. # 重新修改User表，添加了addresses字段，引用了Address表的主键

class User(Base): tablename = ‘users’ id = Column(Integer,primary_key=True) name = Column(String(50)) fullname = Column(String(50)) password = Column(String(100))

  1. # 在ORM层面绑定和`Address`表的关系
  2. addresses = relationship("Address",order_by=Address.id,back_populates="user")
  1. 其中，在`User`表中添加的`addresses`字段，可以通过`User.addresses`来访问和这个user相关的所有address。在`Address`表中的`user`字段，可以通过`Address.user`来访问这个user。达到了双向绑定。表关系已经建立好以后，接下来就应该对其进行操作，先看以下代码：
  2. ```python
  3. jack = User(name='jack',fullname='Jack Bean',password='gjffdd')
  4. jack.addresses = [Address(email_address='jack@google.com'),
  5.                   Address(email_address='j25@yahoo.com')]
  6. session.add(jack)
  7. session.commit()

首先，创建一个用户，然后对这个jack用户添加两个邮箱，最后再提交到数据库当中，可以看到这里操作Address并没有直接进行保存，而是先添加到用户里面，再保存。

一对一：

一对一其实就是一对多的特殊情况，从以上的一对多例子中不难发现，一对应的是User表，而多对应的是Address，也就是说一个User对象有多个Address。因此要将一对多转换成一对一，只要设置一个User对象对应一个Address对象即可，看以下示例：

  1. class User(Base):
  2.     __tablename__ = 'users'
  3.     id = Column(Integer,primary_key=True)
  4.     name = Column(String(50))
  5.     fullname = Column(String(50))
  6.     password = Column(String(100))
  7.     # 设置uselist关键字参数为False
  8.     addresses = relationship("Address",back_populates='addresses',uselist=False)
  10. class Address(Base):
  11.     __tablename__ = 'addresses'
  12.     id = Column(Integer,primary_key=True)
  13.     email_address = Column(String(50))
  14.     user_id = Column(Integer,ForeignKey('users.id')
  15.     user = relationship('Address',back_populates='user')

从以上例子可以看到，只要在User表中的addresses字段上添加uselist=False就可以达到一对一的效果。设置了一对一的效果后，就不能添加多个邮箱到user.addresses字段了，只能添加一个：

  1. user.addresses = Address(email_address='ed@google.com')

多对多：

多对多需要一个中间表来作为连接，同理在sqlalchemy中的orm也需要一个中间表。假如现在有一个Teacher和一个Classes表，即老师和班级，一个老师可以教多个班级，一个班级有多个老师，是一种典型的多对多的关系，那么通过sqlalchemy的ORM的实现方式如下：

  1. association_table = Table('teacher_classes',Base.metadata,
  2.   Column('teacher_id',Integer,ForeignKey('teacher.id')),
  3.   Column('classes_id',Integer,ForeignKey('classes.id'))
  4. )
  6. class Teacher(Base):
  7.     __tablename__ = 'teacher'
  8.     id = Column(Integer,primary_key=True)
  9.     tno = Column(String(10))
  10.     name = Column(String(50))
  11.     age = Column(Integer)
  12.     classes = relationship('Classes',secondary=association_table,back_populates='teachers')
  14. class Classes(Base):
  15.     __tablename__ = 'classes'
  16.     id = Column(Integer,primary_key=True)
  17.     cno = Column(String(10))
  18.     name = Column(String(50))
  19.     teachers = relationship('Teacher',secondary=association_table,back_populates='classes')

要创建一个多对多的关系表，首先需要一个中间表，通过Table来创建一个中间表。上例中第一个参数teacher_classes代表的是中间表的表名，第二个参数是Base的元类，第三个和第四个参数就是要连接的两个表，其中Column第一个参数是表示的是连接表的外键名，第二个参数表示这个外键的类型，第三个参数表示要外键的表名和字段。
创建完中间表以后，还需要在两个表中进行绑定，比如在Teacher中有一个classes属性，来绑定Classes表，并且通过secondary参数来连接中间表。同理，Classes表连接Teacher表也是如此。定义完类后，之后就是添加数据，请看以下示例：

  1. teacher1 = Teacher(tno='t1111',name='xiaotuo',age=10)
  2. teacher2 = Teacher(tno='t2222',name='datuo',age=10)
  3. classes1 = Classes(cno='c1111',name='english')
  4. classes2 = Classes(cno='c2222',name='math')
  5. teacher1.classes = [classes1,classes2]
  6. teacher2.classes = [classes1,classes2]
  7. classes1.teachers = [teacher1,teacher2]
  8. classes2.teachers = [teacher1,teacher2]
  9. session.add(teacher1)
  10. session.add(teacher2)
  11. session.add(classes1)
  12. session.add(classes2)