sqlalchemy级联一记

下面详细介绍 SQLAlchemy 里单对单级联、单对多级联和多对多级联的实现，以及对应的 CRUD 操作，同时给出完整的代码示例。
单对单级联

实现思路

单对单关系意味着一个父对象只关联一个子对象，子对象也只关联一个父对象。可以通过设置 relationship 中的 uselist=False 来表示单对单关系，并且使用 cascade 参数实现级联操作。
代码示例

1. from sqlalchemy import create_engine, Column, Integer, String, ForeignKey
2. from sqlalchemy.orm import sessionmaker, relationship
3. from sqlalchemy.ext.declarative import declarative_base
5. # 创建基类
6. Base = declarative_base()
8. # 定义单对单关系的模型
9. class Parent(Base):
10.     __tablename__ = 'parent'
11.     id = Column(Integer, primary_key=True)
12.     name = Column(String)
13.     # 单对单关系，设置级联操作
14.     child = relationship("Child", back_populates="parent", uselist=False, cascade="all, delete-orphan")
17. class Child(Base):
18.     __tablename__ = 'child'
19.     id = Column(Integer, primary_key=True)
20.     name = Column(String)
21.     parent_id = Column(Integer, ForeignKey('parent.id'))
22.     parent = relationship("Parent", back_populates="child")
25. # 创建数据库引擎
26. engine = create_engine('sqlite:///test.db')
27. # 创建表
28. Base.metadata.create_all(engine)
29. # 创建会话
30. Session = sessionmaker(bind=engine)
31. session = Session()
33. # 创建操作
34. def create_one_to_one():
35.     parent = Parent(name='Parent')
36.     child = Child(name='Child')
37.     parent.child = child
38.     session.add(parent)
39.     session.commit()
40.     return parent
42. # 读取操作
43. def read_one_to_one():
44.     parent = session.query(Parent).first()
45.     if parent:
46.         print(f"Parent: {parent.name}, Child: {parent.child.name if parent.child else 'No child'}")
47.     return parent
49. # 更新操作
50. def update_one_to_one():
51.     parent = session.query(Parent).first()
52.     if parent:
53.         parent.name = 'Updated Parent'
54.         if parent.child:
55.             parent.child.name = 'Updated Child'
56.         session.commit()
57.     return parent
59. # 删除操作
60. def delete_one_to_one():
61.     parent = session.query(Parent).first()
62.     if parent:
63.         session.delete(parent)
64.         session.commit()

复制代码

单对多级联

实现思路

单对多关系表示一个父对象可以关联多个子对象，子对象只关联一个父对象。使用 relationship 建立关联，cascade 参数实现级联操作。
代码示例

1. # 定义单对多关系的模型
2. class Team(Base):
3.     __tablename__ = 'team'
4.     id = Column(Integer, primary_key=True)
5.     name = Column(String)
6.     # 单对多关系，设置级联操作
7.     players = relationship("Player", back_populates="team", cascade="all, delete-orphan")
10. class Player(Base):
11.     __tablename__ = 'player'
12.     id = Column(Integer, primary_key=True)
13.     name = Column(String)
14.     team_id = Column(Integer, ForeignKey('team.id'))
15.     team = relationship("Team", back_populates="players")
18. # 创建操作
19. def create_one_to_many():
20.     team = Team(name='Team A')
21.     player1 = Player(name='Player 1')
22.     player2 = Player(name='Player 2')
23.     team.players.extend([player1, player2])
24.     session.add(team)
25.     session.commit()
26.     return team
28. # 读取操作
29. def read_one_to_many():
30.     team = session.query(Team).first()
31.     if team:
32.         print(f"Team: {team.name}, Players: {[player.name for player in team.players]}")
33.     return team
35. # 更新操作
36. def update_one_to_many():
37.     team = session.query(Team).first()
38.     if team:
39.         team.name = 'Updated Team'
40.         for player in team.players:
41.             player.name = f"Updated {player.name}"
42.         session.commit()
43.     return team
45. # 删除操作
46. def delete_one_to_many():
47.     team = session.query(Team).first()
48.     if team:
49.         session.delete(team)
50.         session.commit()

复制代码

多对多级联

实现思路

多对多关系需要一个中间表来关联两个实体。通过 relationship 的 secondary 参数指定中间表，并使用 cascade 实现级联操作。
代码示例

1. # 定义中间表
2. association_table = Table('association', Base.metadata,
3.                           Column('student_id', Integer, ForeignKey('student.id')),
4.                           Column('course_id', Integer, ForeignKey('course.id'))
5.                           )
7. # 定义多对多关系的模型
8. class Student(Base):
9.     __tablename__ = 'student'
10.     id = Column(Integer, primary_key=True)
11.     name = Column(String)
12.     # 多对多关系，设置级联操作
13.     courses = relationship("Course", secondary=association_table, back_populates="students", cascade="all, delete")
16. class Course(Base):
17.     __tablename__ = 'course'
18.     id = Column(Integer, primary_key=True)
19.     name = Column(String)
20.     students = relationship("Student", secondary=association_table, back_populates="courses")
23. # 创建操作
24. def create_many_to_many():
25.     student = Student(name='Student')
26.     course1 = Course(name='Course 1')
27.     course2 = Course(name='Course 2')
28.     student.courses.extend([course1, course2])
29.     session.add(student)
30.     session.commit()
31.     return student
33. # 读取操作
34. def read_many_to_many():
35.     student = session.query(Student).first()
36.     if student:
37.         print(f"Student: {student.name}, Courses: {[course.name for course in student.courses]}")
38.     return student
40. # 更新操作
41. def update_many_to_many():
42.     student = session.query(Student).first()
43.     if student:
44.         student.name = 'Updated Student'
45.         for course in student.courses:
46.             course.name = f"Updated {course.name}"
47.         session.commit()
48.     return student
50. # 删除操作
51. def delete_many_to_many():
52.     student = session.query(Student).first()
53.     if student:
54.         session.delete(student)
55.         session.commit()

复制代码

测试代码

1. if __name__ == "__main__":
2.     # 单对单关系操作
3.     print("One-to-One Relationship:")
4.     create_one_to_one()
5.     read_one_to_one()
6.     update_one_to_one()
7.     read_one_to_one()
8.     delete_one_to_one()
10.     # 单对多关系操作
11.     print("\nOne-to-Many Relationship:")
12.     create_one_to_many()
13.     read_one_to_many()
14.     update_one_to_many()
15.     read_one_to_many()
16.     delete_one_to_many()
18.     # 多对多关系操作
19.     print("\nMany-to-Many Relationship:")
20.     create_many_to_many()
21.     read_many_to_many()
22.     update_many_to_many()
23.     read_many_to_many()
24.     delete_many_to_many()
26.     session.close()

复制代码

代码解释

• 单对单关系：Parent 和 Child 模型通过 relationship 建立一对一关联，uselist=False 明确为单对单，cascade="all, delete-orphan" 确保父对象删除时子对象也被删除。
  
• 单对多关系：Team 和 Player 模型建立一对多关联，Team 可关联多个 Player，同样使用 cascade="all, delete-orphan" 实现级联删除。
  
• 多对多关系：Student 和 Course 通过中间表 association_table 建立多对多关联，cascade="all, delete" 保证删除学生时相关课程关联也被删除。
  

注意事项

• 上述代码使用 SQLite 数据库，你可以根据需求更换数据库引擎。
  
• 每次操作完成后记得提交会话（session.commit()）和关闭会话（session.close()）。
  

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！