Django基础教程（四十五）Django数据库查询接口之删除对象：别乱删！Django数据库删除操作避坑指南，从删库到跑路只有一步之遥

原创 于 2025-10-10 08:03:39 发布 · 349 阅读 · 9 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据库 #django #oracle

哎呀，说到数据库删除操作，各位Django玩家是不是又爱又恨？点一下删除，爽是爽了，但手滑的瞬间冷汗都能浸透后背——别问我怎么知道的，谁还没经历过几次“删库一时爽，跑路火葬场”的惊魂时刻呢？

今天，咱们就来深挖Django的删除操作，别看它只是ORM里一个小小的delete()方法，里面的门道可比你想象的多得多。准备好了吗？系好安全带，我们要发车了！

一、基础删除：从“精准刺杀”到“批量清场”

先来看看最简单的删除场景。假设我们有个博客系统，模型长这样：

from django.db import models

class Article(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    is_published = models.BooleanField(default=False)
    created_at = models.DateTimeField(auto_now_add=True)

单条删除：精准刺杀

# 找到那个可怜的文章
article = Article.objects.get(id=1)

# 确认过眼神，是要删的人
article.delete()

这就完成了最简单的删除。但注意啦，这里有个新手常踩的坑：

# 危险操作！可能会误删！
article = Article.objects.filter(title__contains='临时').delete()

看到没？filter()后面直接接delete()，这意味着所有匹配的记录都会被瞬间送走。所以，除非你确定要批量删除，否则老实用get()更安全。

批量删除：高效清场
当你确实需要清理数据时，批量删除能让你事半功倍：

# 删除所有草稿文章
draft_articles = Article.objects.filter(is_published=False)
count = draft_articles.delete()
print(f"成功送走了{count}篇草稿")

这里的delete()方法会返回一个字典，告诉你每个模型删除了多少记录。不过要记住，批量删除不调用单个对象的delete方法，这点我们后面会详细说。

二、删除的“连锁反应”：外键关系下的惊魂时刻

现实世界的数据很少是孤立的。一旦引入外键关系，删除操作就变成了拆弹现场——剪错线可就全炸了！

考虑这个扩展模型：

class Comment(models.Model):
    article = models.ForeignKey(Article, on_delete=models.CASCADE)
    content = models.TextField()

看到那个on_delete=models.CASCADE了吗？这就是传说中的“连锁删除”。一旦文章被删，所有相关评论都会自动陪葬。

# 删一送N的经典案例
article = Article.objects.get(id=1)
article.delete()  # 这篇文章的所有评论也会一起消失

除了CASCADE，Django还提供了其他几种删除策略：

  • PROTECT：防止删除，如果有相关对象存在，会抛出ProtectedError
  • SET_NULL：设置外键为NULL（需要字段允许为空）
  • SET_DEFAULT：设置外键为默认值
  • SET()：设置外键为指定值
  • DO_NOTHING：什么也不做（数据库级别可能报错）

来个实战例子：

class Author(models.Model):
    name = models.CharField(max_length=100)

class Book(models.Model):
    author = models.ForeignKey(
        Author, 
        on_delete=models.PROTECT,  # 有书在，作者就不能删
        null=True,
        blank=True
    )
    title = models.CharField(max_length=100)

# 尝试删除有书的作者
author = Author.objects.get(id=1)
try:
    author.delete()  # 这里会抛出ProtectedError！
except models.ProtectedError as e:
    print(f"删不了啊！还有{len(e.protected_objects)}本书关联着这个作者")
三、进阶玩法：软删除——给数据“留条活路”

在真实业务场景中，物理删除往往太危险了。这时候，“软删除”就该登场了。

基础版软删除：

class SoftDeleteArticle(models.Model):
    title = models.CharField(max_length=200)
    is_deleted = models.BooleanField(default=False)
    deleted_at = models.DateTimeField(null=True, blank=True)
    
    def soft_delete(self):
        self.is_deleted = True
        self.deleted_at = timezone.now()
        self.save()
    
    # 重写delete，改为软删除
    def delete(self, using=None, keep_parents=False):
        self.soft_delete()

# 查询时要排除已删除的
active_articles = SoftDeleteArticle.objects.filter(is_deleted=False)

高级版软删除：自定义管理器
上面的方法有个问题：每次查询都要手动过滤。太麻烦了！我们来个更优雅的解决方案：

class SoftDeleteManager(models.Manager):
    def get_queryset(self):
        return super().get_queryset().filter(is_deleted=False)

class SoftDeleteArticle(models.Model):
    # ... 字段同上
    
    objects = SoftDeleteManager()  # 默认只返回未删除的
    all_objects = models.Manager()  # 这个可以看到所有
    
    def hard_delete(self):
        """真正的物理删除"""
        super().delete()

# 现在查询默认看不到已删除的
articles = SoftDeleteArticle.objects.all()  # 只有未删除的

# 想看到所有的得用这个
all_articles = SoftDeleteArticle.all_objects.all()

软删除的好处显而易见：误删了还能找回来，而且可以记录删除时间，便于审计。

四、事务处理：删除操作的“安全绳”

当删除操作比较复杂时，一定要使用事务来保证数据一致性。

from django.db import transaction

def safe_delete_operation(article_id):
    try:
        with transaction.atomic():
            article = Article.objects.select_for_update().get(id=article_id)
            
            # 记录删除前的状态（用于可能的恢复）
            backup_data = {
                'title': article.title,
                'content': article.content
            }
            
            # 删除相关资源
            article.comments.all().delete()
            article.tags.clear()
            
            # 最后删除文章本身
            article.delete()
            
            # 记录删除日志
            DeletionLog.objects.create(
                model_name='Article',
                instance_id=article_id,
                backup_data=backup_data
            )
            
    except Article.DoesNotExist:
        print("文章不存在，删除失败")
    except Exception as e:
        print(f"删除过程中出错: {str(e)}")
        # 事务会自动回滚

这个例子展示了如何在事务中执行复杂的删除操作，确保要么全部成功，要么全部回滚。

五、信号：删除前的“最后警报”

Django的信号系统可以在删除操作前后执行自定义逻辑，非常适合做一些清理工作或者权限检查。

from django.db.models.signals import pre_delete, post_delete
from django.dispatch import receiver

@receiver(pre_delete, sender=Article)
def check_article_deletion(sender, instance, **kwargs):
    """删除前的检查"""
    if instance.is_published:
        raise Exception("已发布的文章不能删除！")

@receiver(post_delete, sender=Article)
def cleanup_after_deletion(sender, instance, **kwargs):
    """删除后的清理"""
    # 比如删除相关的文件、缓存等
    print(f"文章《{instance.title}》已被删除，执行清理操作...")
六、实战：完整的删除示例

来看一个综合性的例子，把今天学的都用上：

# models.py
class Category(models.Model):
    name = models.CharField(max_length=100)
    description = models.TextField(blank=True)

class Article(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    category = models.ForeignKey(Category, on_delete=models.PROTECT)
    is_published = models.BooleanField(default=False)
    created_at = models.DateTimeField(auto_now_add=True)
    
    def __str__(self):
        return self.title

# views.py
def delete_article_safely(request, article_id):
    """安全删除文章视图"""
    if request.method == 'POST':
        try:
            with transaction.atomic():
                article = Article.objects.get(id=article_id)
                
                # 检查权限
                if not request.user.has_perm('blog.delete_article'):
                    return JsonResponse({'error': '权限不足'}, status=403)
                
                # 备份数据
                ArticleBackup.objects.create(
                    original_id=article.id,
                    title=article.title,
                    content=article.content,
                    deleted_by=request.user.username
                )
                
                # 执行删除
                article.delete()
                
                messages.success(request, f'文章《{article.title}》已成功删除')
                return redirect('article_list')
                
        except Article.DoesNotExist:
            messages.error(request, '文章不存在')
        except Exception as e:
            messages.error(request, f'删除失败: {str(e)}')
    
    return render(request, 'confirm_delete.html', {'article': article})

对应的模板文件：

<!-- confirm_delete.html -->
<!DOCTYPE html>
<html>
<head>
    <title>确认删除</title>
</head>
<body>
    <h1>确认删除</h1>
    <p>你确定要删除文章《{{ article.title }}》吗？</p>
    
    <form method="post">
        {% csrf_token %}
        <button type="submit" style="background-color: #ff4444; color: white;">
            确认删除
        </button>
        <a href="{% url 'article_list' %}">取消</a>
    </form>
</body>
</html>
七、总结：删除操作的最佳实践

好了，经过这一趟深度游，我们来总结一下Django删除操作的要领：

  1. 谨慎使用批量删除：特别是生产环境，先用filter()确认数据范围
  2. 理解外键的连锁反应：根据业务需求合理设置on_delete参数
  3. 优先考虑软删除：给重要数据留个“后悔药”
  4. 复杂操作要用事务：保证数据一致性
  5. 善用信号机制：在删除前后执行必要的业务逻辑
  6. 做好权限控制：不是谁都能随便删数据
  7. 记录删除日志：便于审计和问题追踪

记住，在数据库世界里，删除往往是最不可逆的操作。每次调用delete()之前，都问问自己：这数据真的不需要了吗？有备份吗？能恢复吗？

毕竟，咱们程序员的口号应该是：可以写bug，但不能删数据！🚀

希望这篇指南能让你在Django的删除操作上游刃有余，从此告别“删库跑路”的噩梦。Happy coding！（当然，是安全的coding～）

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

值引力

持续创作，多谢支持！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值