四级嵌套模型Subject>Topic>Content>Block的级联删除实现方法咨询

这里提供两种生产环境常用的实现思路，可根据你的技术栈选型：

方案1：数据库层外键级联删除（最可靠、性能最优） #

依靠数据库原生的外键ON DELETE CASCADE约束实现，只要层级外键配置正确，删除父级时数据库会自动触发所有嵌套子级的删除，不需要写额外业务代码。
以下是两种主流Python ORM的配置示例：

Django ORM 配置 #

只需要给每个关联的外键字段设置on_delete=models.CASCADE即可：

from django.db import models

class Subject(models.Model):
    name = models.CharField(max_length=100)
    # 其他自定义字段

class Topic(models.Model):
    subject = models.ForeignKey(Subject, on_delete=models.CASCADE, related_name='topics')
    name = models.CharField(max_length=100)
    # 其他自定义字段

class Content(models.Model):
    topic = models.ForeignKey(Topic, on_delete=models.CASCADE, related_name='contents')
    text = models.TextField()
    # 其他自定义字段

class Block(models.Model):
    content = models.ForeignKey(Content, on_delete=models.CASCADE, related_name='blocks')
    block_type = models.CharField(max_length=50)
    # 其他自定义字段

配置完成后删除任意父级，所有嵌套子级都会自动被删除，完全匹配你的需求。

SQLAlchemy 配置 #

给关联关系设置cascade="all, delete"参数即可：

from sqlalchemy import Column, Integer, String, Text, ForeignKey
from sqlalchemy.orm import relationship
from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

class Subject(Base):
    __tablename__ = 'subjects'
    id = Column(Integer, primary_key=True)
    name = Column(String(100))
    topics = relationship("Topic", back_populates="subject", cascade="all, delete")

class Topic(Base):
    __tablename__ = 'topics'
    id = Column(Integer, primary_key=True)
    subject_id = Column(Integer, ForeignKey('subjects.id'))
    name = Column(String(100))
    subject = relationship("Subject", back_populates="topics")
    contents = relationship("Content", back_populates="topic", cascade="all, delete")

class Content(Base):
    __tablename__ = 'contents'
    id = Column(Integer, primary_key=True)
    topic_id = Column(Integer, ForeignKey('topics.id'))
    text = Column(Text)
    topic = relationship("Topic", back_populates="contents")
    blocks = relationship("Block", back_populates="content", cascade="all, delete")

class Block(Base):
    __tablename__ = 'blocks'
    id = Column(Integer, primary_key=True)
    content_id = Column(Integer, ForeignKey('contents.id'))
    block_type = Column(String(50))
    content = relationship("Content", back_populates="blocks")

方案2：业务代码层手动实现（适用于禁止使用外键的场景） #

如果你的项目规范不允许使用数据库外键，可以在业务逻辑层手动实现级联删除，注意要按照「最底层子级→父级」的顺序删除，避免出现约束报错，同时需要加事务包裹，避免中间步骤出错导致数据不一致。
通用实现逻辑（伪代码，可适配任意语言框架）：

• 删除Subject逻辑：

function deleteSubject(subjectId):
    // 查询当前Subject下所有Topic
    topicList = Topic.query.filter(subject_id = subjectId).all()
    for topic in topicList:
        // 调用Topic删除方法
        deleteTopic(topic.id)
    // 最后删除Subject本身
    Subject.delete.filter(id = subjectId).execute()

• 删除Topic逻辑：

function deleteTopic(topicId):
    // 查询当前Topic下所有Content
    contentList = Content.query.filter(topic_id = topicId).all()
    for content in contentList:
        // 调用Content删除方法
        deleteContent(content.id)
    // 最后删除Topic本身
    Topic.delete.filter(id = topicId).execute()

• 删除Content逻辑：

function deleteContent(contentId):
    // 先删除当前Content下所有Block
    Block.delete.filter(content_id = contentId).execute()
    // 最后删除Content本身
    Content.delete.filter(id = contentId).execute()

注意：手动实现时一定要加事务，任意一步执行失败直接回滚所有操作，避免出现部分删除的脏数据。

内容的提问来源于stack exchange，提问作者Timo Müller