表关系:

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

外键:

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

class Article(Base):
    __tablename__ = 'article'
    id = Column(Integer,primary_key=True,autoincrement=True)
    title = Column(String(50),nullable=False)
    content = Column(Text,nullable=False)
    uid = Column(Integer,ForeignKey('user.id'))

    def __repr__(self):
        return "<Article(title:%s)>" % self.title

class User(Base):
    __tablename__ = 'user'
    id = Column(Integer,primary_key=True,autoincrement=True)
    username = Column(String(50),nullable=False)

外键约束有以下几项:

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

一对多:

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

    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)
        # User表的外键,指定外键的时候,是使用的是数据库表的名称,而不是类名
        user_id = Column(Integer,ForeignKey('users.id'))
        # 在ORM层面绑定两者之间的关系,第一个参数是绑定的表的类名,
        # 第二个参数back_populates是通过User反向访问时的字段名称
        user = relationship('User',back_populates="addresses")

        def __repr__(self):
            return "<Address(email_address='%s')>" % self.email_address

    # 重新修改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))
        # 在ORM层面绑定和`Address`表的关系
        addresses = relationship("Address",order_by=Address.id,back_populates="user")

其中,在User表中添加的addresses字段,可以通过User.addresses来访问和这个user相关的所有address。在Address表中的user字段,可以通过Address.user来访问这个user。达到了双向绑定。表关系已经建立好以后,接下来就应该对其进行操作,先看以下代码:

  jack = User(name='jack',fullname='Jack Bean',password='gjffdd')
  jack.addresses = [Address(email_address='jack@google.com'),
                  Address(email_address='j25@yahoo.com')]
  session.add(jack)
  session.commit()

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

一对一:

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

  class User(Base):
    __tablename__ = 'users'
    id = Column(Integer,primary_key=True)
    name = Column(String(50))
    fullname = Column(String(50))
    password = Column(String(100))
    # 设置uselist关键字参数为False
    addresses = relationship("Address",back_populates='addresses',uselist=False)
  class Address(Base):
    __tablename__ = 'addresses'
    id = Column(Integer,primary_key=True)
    email_address = Column(String(50))
    user_id = Column(Integer,ForeignKey('users.id')
    user = relationship('Address',back_populates='user')

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

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

多对多:

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

  association_table = Table('teacher_classes',Base.metadata,
  Column('teacher_id',Integer,ForeignKey('teacher.id')),
  Column('classes_id',Integer,ForeignKey('classes.id'))
  )
  class Teacher(Base):
    __tablename__ = 'teacher'
    id = Column(Integer,primary_key=True)
    tno = Column(String(10))
    name = Column(String(50))
    age = Column(Integer)
    classes = relationship('Classes',secondary=association_table,back_populates='teachers')
  class Classes(Base):
    __tablename__ = 'classes'
    id = Column(Integer,primary_key=True)
    cno = Column(String(10))
    name = Column(String(50))
    teachers = relationship('Teacher',secondary=association_table,back_populates='classes')

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

  teacher1 = Teacher(tno='t1111',name='xiaotuo',age=10)
  teacher2 = Teacher(tno='t2222',name='datuo',age=10)
  classes1 = Classes(cno='c1111',name='english')
  classes2 = Classes(cno='c2222',name='math')
  teacher1.classes = [classes1,classes2]
  teacher2.classes = [classes1,classes2]
  classes1.teachers = [teacher1,teacher2]
  classes2.teachers = [teacher1,teacher2]
  session.add(teacher1)
  session.add(teacher2)
  session.add(classes1)
  session.add(classes2)
最后修改:2020年7月13日 08:56