SQLAlchemy-表关系

   

表关系  

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

   

ForeignKey

1. # -*- coding: utf-8 -*-  
2. from sqlalchemy.ext.declarative import declarative_base  
3. from sqlalchemy import Column # 列  
4. from sqlalchemy import Integer, String, ForeignKey  # 属性  
5. from sqlalchemy import create_engine  
6. from sqlalchemy.orm import relationship #  
7.       
8. Base = declarative_base()  # django models  
9.       
10. class Article(Base):  
11.     __tablename__ = "article"  
12.       
13.     id = Column(Integer, primary_key=True, autoincrement=True)  
14.     title = Column(String(30), nullable=False)  
15.     content = Column(String(30), nullable=False)  
16.     uid = Column(Integer, ForeignKey('user.id'))  
17.       
18.     def __repr__(self):  
19.         return "<Article(title:%s)>" % self.title  
20.       
21.       
22. class Users(Base):  
23.     __tablename__ = 'user'  
24.     id = Column(Integer, primary_key=True, autoincrement=True)  
25.     username = Column(String(50), nullable=False)  
26.       
27. engine = create_engine("mysql+pymysql://root:redhat@192.168.32.71:3306/my_sql?charset=utf8")  
28. # 去engine数据库中创建所有继承Base的表  
29. Base.metadata.create_all(engine)  
30.       
31.       
32. 外键约束有以下几项：  
33.       
34.     RESTRICT：父表数据被删除，会阻止删除。默认就是这一项。  
35.     NO ACTION：在MySQL中，同RESTRICT。  
36.     CASCADE：级联删除。  
37.     SET NULL：父表数据被删除，子表数据会设置为NULL。

   

一对多

1. # 一对多  
2. class Address(Base):  
3.     __tablename__ = 'address'  
4.     id = Column(Integer, primary_key=True)  
5.     email_address = Column(String(30), nullable=False)  
6.       
7.     # FK  
8.     # User表的外键，指定外键的时候，是使用的是数据库表的名称，而不是类名  
9.     user_id = Column(Integer, ForeignKey('users.id'))  
10.       
11.     # 在ORM层面绑定两者之间的关系，第一个参数是绑定的表的类名，  
12.     # 第二个参数back_populates是通过User反向访问时的字段名称  
13.     user = relationship('User', back_populates="addresses")  
14.       
15.     def __repr__(self):  
16.         return "<Address(email_address='%s')>" % self.email_address  
17.       
18.       
19. class User(Base):  
20.     __tablename__ = 'users'  
21.     id = Column(Integer, primary_key=True)  
22.     name = Column(String(50))  
23.       
24.     # 在ORM层面绑定和`Address`表的关系  
25.     addresses = relationship("Address", order_by=Address.id, back_populates="user")  
26.       
27. # 注意：  
28. # 在User表中添加的addresses字段，可以通过User.addresses来访问和这个user相关的所有address  
29. # 在Address表中的user字段，可以通过Address.user来访问这个user。达到了双向绑定  

例子

1. Session = sessionmaker(engine)  
2. db_session = Session()  
3.       
4. peach = User(name='peach')  
5. peach.addresses = [Address(email_address='1234@qq.com'),  
6.                    Address(email_address='2345@qq.com')]  
7.       
8. db_session.add(peach)  
9. db_session.commit()  
10. db_session.close() 

   

一对一

1. # 一对一  
2. class Address(Base):  
3.     __tablename__ = 'addresses'  
4.     id = Column(Integer, primary_key=True)  
5.     email_address = Column(String(50))  
6.     user_id = Column(Integer, ForeignKey('users.id'))  
7.     user = relationship('User', back_populates='addresses')  
8.       
9. class User(Base):  
10.     __tablename__ = 'users'  
11.     id = Column(Integer,primary_key=True)  
12.     name = Column(String(50))  
13.     # 设置uselist关键字参数为False  
14.     addresses = relationship("Address", back_populates='user', uselist=False)  
15.       
16. # 只要在User表中的addresses字段上添加uselist=False就可以达到一对一的效果  
17. # 设置了一对一的效果后，就不能添加多个邮箱到user.addresses字段了  

例子

1. peach = User(name='peach')  
2. peach.addresses = Address(email_address='1234@qq.com')  

   

多对多

1.  # 多对多  
2. from sqlalchemy import Table  
3.     
4. # 要创建一个多对多的关系表，首先需要一个中间表，通过Table来创建一个中间表  
5. association_table = Table('teacher_classes',  # 中间表的表名  
6.                           Base.metadata,  # Base的元类  
7.                           Column('teacher_id', Integer, ForeignKey('teacher.id')),  
8.                           Column('classes_id', Integer, ForeignKey('classes.id'))) # 要连接的两个表  
9.                           # Column 第一个参数是表示的是连接表的外键名  
10.                           # Column 第二个参数表示这个外键的类型  
11.                           # Column 第三个参数表示要外键的表名和字段  
12. class Teacher(Base):  
13.     __tablename__ = 'teacher'  
14.     id = Column(Integer,primary_key=True)  
15.     name = Column(String(50))  
16.     classes = relationship('Classes', secondary=association_table, back_populates='teachers')  # 通过secondary参数来连接中间表  
17.     
18.     
19. class Classes(Base):  
20.     __tablename__ = 'classes'  
21.     id = Column(Integer,primary_key=True)  
22.     name = Column(String(50))  
23.     teachers = relationship('Teacher',secondary=association_table,back_populates='classes')  # 通过secondary参数来连接中间表 

例子

1.  Base.metadata.create_all(engine)  
2. Session = sessionmaker(engine)  
3. db_session = Session()  
4.     
5. teacher1 = Teacher(name='Teacher1')  
6. teacher2 = Teacher(name='teacher2')  
7. classes1 = Classes(name='classes1')  
8. classes2 = Classes(name='classes2')  
9.     
10. teacher1.classes = [classes1, classes2]  
11. classes1.teachers = [teacher1]  
12.     
13. db_session.add(teacher1)  
14. db_session.add(teacher2)  
15. db_session.add(classes1)  
16. db_session.add(classes2)  
17.     
18. db_session.close()