8. Django 模型（二）

最新推荐文章于 2024-11-03 23:59:43 发布

原创最新推荐文章于 2024-11-03 23:59:43 发布 · 286 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#python

Django基础专栏收录该内容

14 篇文章

订阅专栏

本文深入探讨了Django ORM的高级特性，包括多表实例、聚合查询与分组查询、F查询与Q查询等，通过实例讲解了如何在实际项目中应用这些特性。

Django 模型（二）

版权声明：本博客来自路飞学城Python全栈开发培训课件，仅用于学习之用，严禁用于商业用途。
欢迎访问路飞学城官网：https://www.luffycity.com/

本节重点

多表实例
聚合查询与分组查询
F查询与Q查询
锁和事务
Django ORM执行原生SQL

1. 多表实例

表与表之间的关系可分为以下三种：

一对一: 一个人对应一个身份证号码，数据字段设置 unique。
一对多: 一个家庭有多个人，一般通过外键来实现。
多对多: 一个学生有多门课程，一个课程有很多学生，一般通过第三个表来实现关联。

1.1 创建模型

我们以图书管理为例创建如下模型：

# 图书信息
class Book(models.Model):
    title = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=5, decimal_places=2)
    pub_date = models.DateField()
    publish = models.ForeignKey("Publish", on_delete=models.CASCADE) # 一对多关系，一个出版社可以有多本图书
    authors = models.ManyToManyField("Author") # 多对多关系，一个作者可以有多本图书，一本图书也可以有多个作者

# 出版社信息
class Publish(models.Model):
    name = models.CharField(max_length=32)
    city = models.CharField(max_length=64)
    email = models.EmailField()

# 作者信息
class Author(models.Model):
    name = models.CharField(max_length=32)
    age = models.SmallIntegerField()
    au_detail = models.OneToOneField("AuthorDetail", on_delete=models.CASCADE) # 一对一关系

# 作者详细信息
class AuthorDetail(models.Model):
    gender_choices = (
        (0, "女"),
        (1, "男"),
        (2, "保密"),
    )
    gender = models.SmallIntegerField(choices=gender_choices)
    tel = models.CharField(max_length=32)
    addr = models.CharField(max_length=64)
    birthday = models.DateField()

说明：

EmailField 数据类型是邮箱格式，底层继承 CharField，进行了封装，相当于 MySQL 中的 varchar。
Django1.1 版本不需要联级删除：on_delete=models.CASCADE，Django2.2 需要。
一般不需要设置联级更新.
外键在一对多的多中设置：models.ForeignKey(“关联类名”, on_delete=models.CASCADE)。
OneToOneField = ForeignKey(…，unique=True)设置一对一。
若有模型类存在外键，创建数据时，要先创建外键关联的模型类的数据，不然创建包含外键的模型类的数据时，外键的关联模型类的数据会找不到。

1.2 关系字段说明

1.2.1 ForeignKey

外键类型在ORM中用来表示外键关联关系，一般把ForeignKey字段设置在 '一对多’中’多’的一方。

ForeignKey可以和其他表做关联关系同时也可以和自身做关联关系。

字段参数：

to

设置要关联的表
to_field

设置要关联的表的字段

related_name

反向操作时，使用的字段名，用于代替原反向查询时的’表名_set’。

实例：

建立模型

class Classes(models.Model):
    name = models.CharField(max_length=32)

class Student(models.Model):
    name = models.CharField(max_length=32)
    theclass = models.ForeignKey(to="Classes")

当我们要查询某个班级关联的所有学生（反向查询）时，我们会这么写：

models.Classes.objects.first().student_set.all()

当我们在ForeignKey字段中添加了参数 related_name 后，

class Student(models.Model):
    name = models.CharField(max_length=32)
    theclass = models.ForeignKey(to="Classes", related_name="students")

当我们要查询某个班级关联的所有学生（反向查询）时，我们会这么写：

models.Classes.objects.first().students.all()

related_query_name

反向查询操作时，使用的连接前缀，用于替换表名。
on_delete

当删除关联表中的数据时，当前表与其关联的行的行为。
models.CASCADE

删除关联数据，与之关联也删除
models.DO_NOTHING

删除关联数据，引发错误IntegrityError
models.PROTECT

删除关联数据，引发错误ProtectedError
models.SET_NULL

删除关联数据，与之关联的值设置为null（前提FK字段需要设置为可空）
models.SET_DEFAULT

删除关联数据，与之关联的值设置为默认值（前提FK字段需要设置默认值）

models.SET

删除关联数据，

a. 与之关联的值设置为指定值，设置：models.SET(值)
b. 与之关联的值设置为可执行对象的返回值，设置：models.SET(可执行对象)

def func():
    return 10

class MyModel(models.Model):
    user = models.ForeignKey(
        to="User",
        to_field="id"，
        on_delete=models.SET(func)
    )

db_constraint

是否在数据库中创建外键约束，默认为True。

1.2.2 OneToOneField

一对一字段。通常一对一字段用来扩展已有字段。

一对一的关联关系多用在当一张表的不同字段查询频次差距过大的情况下，将本可以存储在一张表的字段拆开放置在两张表中，然后将两张表建立一对一的关联关系。

class Author(models.Model):
    name = models.CharField(max_length=32)
    info = models.OneToOneField(to='AuthorInfo')
    

class AuthorInfo(models.Model):
    phone = models.CharField(max_length=11)
    email = models.EmailField()

字段参数：

to

设置要关联的表
to_field

设置要关联的字段。
on_delete

同ForeignKey字段。

1.2.3 ManyToManyField

用于表示多对多的关联关系。在数据库中通过第三张表来建立关联关系。

字段参数：

to

设置要关联的表
related_name

同ForeignKey字段。
related_query_name

同ForeignKey字段。

symmetrical

仅用于多对多自关联时，指定内部是否创建反向操作的字段。默认为True。

实例：

建立模型

class Person(models.Model):
    name = models.CharField(max_length=16)
    friends = models.ManyToManyField("self")

此时，person对象就没有person_set属性。

class Person(models.Model):
    name = models.CharField(max_length=16)
    friends = models.ManyToManyField("self", symmetrical=False)

此时，person对象现在就可以使用person_set属性进行反向查询。

through

在使用ManyToManyField字段时，Django将自动生成一张表来管理多对多的关联关系。

但我们也可以手动创建第三张表来管理多对多关系，此时就需要通过through来指定第三张表的表名。
through_fields

设置关联的字段。
db_table

默认创建第三张表时，数据库中表的名称。

1.2.4 多对多关联关系的三种方式

方式一： 自行创建第三张表

class Book(models.Model):
    title = models.CharField(max_length=32, verbose_name="书名")


class Author(models.Model):
    name = models.CharField(max_length=32, verbose_name="作者姓名")


# 自己创建第三张表，分别通过外键关联书和作者
class Author2Book(models.Model):
    author = models.ForeignKey(to="Author")
    book = models.ForeignKey(to="Book")

    class Meta:
        unique_together = ("author", "book")

方式二： 通过ManyToManyField自动创建第三张表

class Book(models.Model):
    title = models.CharField(max_length=32, verbose_name="书名")


# 通过ORM自带的ManyToManyField自动创建第三张表
class Author(models.Model):
    name = models.CharField(max_length=32, verbose_name="作者姓名")
    books = models.ManyToManyField(to="Book", related_name="authors")

方式三： 设置ManyTomanyField并指定自行创建的第三张表

class Book(models.Model):
    title = models.CharField(max_length=32, verbose_name="书名")


# 自己创建第三张表，并通过ManyToManyField指定关联
class Author(models.Model):
    name = models.CharField(max_length=32, verbose_name="作者姓名")
    books = models.ManyToManyField(to="Book", through="Author2Book", through_fields=("author", "book"))
    # through_fields接受一个2元组（'field1'，'field2'）：
    # 其中field1是定义ManyToManyField的模型外键的名（author），field2是关联目标模型（book）的外键名。


class Author2Book(models.Model):
    author = models.ForeignKey(to="Author")
    book = models.ForeignKey(to="Book")

    class Meta:
        unique_together = ("author", "book")

注意：

当我们需要在第三张关系表中存储额外的字段时，就要使用第三种方式。

但是当我们使用第三种方式创建多对多关联关系时，就无法使用set、add、remove、clear方法来管理多对多的关系了，需要通过第三张表的model来管理多对多关系。

1.2.5 元信息

ORM对应的类里面包含另一个Meta类，而Meta类封装了一些数据库的信息。主要字段如下:

db_table

ORM在数据库中的表名默认是 app_类名，可以通过db_table可以重写表名。
index_together

联合索引。
unique_together

联合唯一索引。
ordering

指定默认按什么字段排序。

只有设置了该属性，我们查询到的结果才可以被reverse()。

1.3 表结构

书籍表 Book：title 、 price 、 pub_date 、 publish（外键，多对一）、 authors（多对多）

出版社表 Publish：name 、 city 、 email

作者表 Author：name 、 age 、 au_detail（一对一）

作者详情表 AuthorDetail：gender 、 tel 、 addr 、 birthday

以下是表格关联说明：

在这里插入图片描述

我们在 MySQL 中执行以下 SQL 插入操作：

insert into app01_publish(name,city,email) 
values ("华山出版社", "华山", "hs@163.com"), ("明教出版社", "黑木崖", "mj@163.com")
 
# 先插入 authordetail 表中多数据
insert into app01_authordetail(gender,tel,addr,birthday) 
values (1,13432335433,"华山","1994-5-23"), 
		(1,13943454554,"黑木崖","1961-8-13"),
        (0,13878934322,"黑木崖","1996-5-20") 

# 再将数据插入 author，这样 author 才能找到 authordetail 
insert into app01_author(name,age,au_detail_id) 
values ("令狐冲",25,1), ("任我行",58,2), ("任盈盈",23,3)

1.4 ORM-添加数据

1.4.1 一对多(外键 ForeignKey)

方式一: 传对象的形式，返回值的数据类型是对象，书籍对象。

步骤：

a. 获取出版社对象
b. 给书籍的出版社属性 pulish 传出版社对象

# app01/views.py 文件代码：
def add_book(request):
    #  获取出版社对象
    pub_obj = models.Publish.objects.filter(pk=1).first()
    #  给书籍的出版社属性publish传出版社对象
    book = models.Book.objects.create(title="菜鸟教程", price=200, pub_date="2010-10-10", publish=pub_obj)
    print(book, type(book))
    return HttpResponse(book)

方式二: 传对象 id 的形式(由于传过来的数据一般是 id,所以传对象 id 是常用的)。

一对多中，设置外键属性的类(多的表)中，MySQL 中显示的字段名是:外键属性名_id。

返回值的数据类型是对象，书籍对象。

步骤：

a. 获取出版社对象的 id
b. 给书籍的关联出版社字段 pulish_id 传出版社对象的 id

# app01/views.py 文件代码：
def add_book(request):
    #  获取出版社对象
    pub_obj = models.Publish.objects.filter(pk=1).first()
    #  获取出版社对象的id
    pk = pub_obj.pk
    #  给书籍的关联出版社字段 publish_id 传出版社对象的id
    book = models.Book.objects.create(title="冲灵剑法", price=100, pub_date="2004-04-04", publish_id=pk)
    print(book, type(book))
    return HttpResponse(book)

1.4.2 多对多(ManyToManyField)

多对多(ManyToManyField)：在第三张关系表中新增数据。

方式一: 传对象形式，无返回值。

步骤：

a. 获取作者对象
b. 获取书籍对象
c. 给书籍对象的 authors 属性用 add 方法传作者对象

# app01/views.py 文件代码：
def add_book(request):
    #  获取作者对象
    chong = models.Author.objects.filter(name="令狐冲").first()
    ying = models.Author.objects.filter(name="任盈盈").first()
    #  获取书籍对象
    book = models.Book.objects.filter(title="菜鸟教程").first()
    #  给书籍对象的 authors 属性用 add 方法传作者对象
    book.authors.add(chong, ying)
    return HttpResponse(book)

方式二: 传对象id形式，无返回值。

步骤：

a. 获取作者对象的 id
b. 获取书籍对象
c. 给书籍对象的 authors 属性用 add 方法传作者对象的 id

# app01/views.py 文件代码：
def add_book(request):
    #  获取作者对象
    chong = models.Author.objects.filter(name="令狐冲").first()
    #  获取作者对象的id
    pk = chong.pk
    #  获取书籍对象
    book = models.Book.objects.filter(title="冲灵剑法").first()
    #  给书籍对象的 authors 属性用 add 方法传作者对象的id
    book.authors.add(pk)

1.5 关联管理器（对象调用）

前提：

多对多（双向均有关联管理器）
一对多（只有多的那个类的对象有关联管理器，即反向才有）

语法格式：

正向：属性名
反向：小写类名加 _set

注意： 一对多只能反向

常用方法：

add()

add()：用于多对多，把指定的模型对象添加到关联对象集（关系表）中。

注意： add() 在一对多(即外键)中，只能传对象（ QuerySet数据类型），不能传 id([id表])。

正向： 属性名

# *[]的使用
# 方式一：传对象
book_obj = models.Book.objects.get(id=1)
author_list = models.Author.objects.filter(id__gt=2)
book_obj.authors.add(*author_list)  # 将 id 大于2的作者对象添加到这本书的作者集合中
# 方式二：传对象 id
book_obj.authors.add(*[1,3]) # 将 id=1 和 id=3 的作者对象添加到这本书的作者集合中
return HttpResponse("ok")

反向： 小写表名_set

ying = models.Author.objects.filter(name="任盈盈").first()
book = models.Book.objects.filter(title="冲灵剑法").first()
ying.book_set.add(book)
return HttpResponse("ok")

create()

create()：创建一个新的对象，并同时将它添加到关联对象集之中。

返回新创建的对象。

pub = models.Publish.objects.filter(name="明教出版社").first()
wo = models.Author.objects.filter(name="任我行").first()
book = wo.book_set.create(title="吸星大法", price=300, pub_date="1999-9-19", publish=pub)
print(book, type(book))
return HttpResponse("ok")

remove()

remove()：从关联对象集中移除执行的模型对象。

对于 ForeignKey 对象，这个方法仅在 null=True（可以为空）时存在。

无返回值。
```
author_obj =models.Author.objects.get(id=1)
book_obj = models.Book.objects.get(id=1)
author_obj.book_set.remove(book_obj)
return HttpResponse("ok")
```
clear()

clear()：从关联对象集中移除一切对象，删除关联，不会删除对象。

对于 ForeignKey 对象，这个方法仅在 null=True（可以为空）时存在。

无返回值。
```
#  清空独孤九剑关联的所有作者
book = models.Book.objects.filter(title="菜鸟教程").first()
book.authors.clear()
```

注：对于所有类型的关联字段，add()、create()、remove()和clear(),set()都会马上更新数据库。换句话说，在关联的任何一端，都不需要再调用save()方法。

1.6 ORM-查询数据

1.6.1 基于对象的跨表查询

语法格式：

正向：属性名称
反向：小写类名_set(一对一除外，一对一反向不用加_set)

1.6.1.1 一对一

正向： 对象.属性

# 查询令狐冲的电话（正向）
author = models.Author.objects.filter(name="令狐冲").first()
res = author.au_detail.tel
print(res, type(res))
return HttpResponse("ok")

反向： 对象.小写类名，不用加 _set。

# 查询所有住址在黑木崖的作者的姓名（反向）
addr_list = models.AuthorDetail.objects.filter(addr="黑木崖")
for addr in addr_list:
    res = addr.author.name
    print(res,type(res))
return HttpResponse("ok")

1.6.1.2 一对多

正向： 对象.属性

# 查询主键为 1 的书籍的出版社所在的城市（正向）
book = models.Book.objects.filter(pk=1).first()
res = book.publish.city
print(res, type(res))
return HttpResponse("ok")

反向： 对象.小写类名_set

# 查询明教出版社出版的书籍名（反向）。
pub = models.Publish.objects.filter(name="明教出版社").first()
# 取出书籍表的所有书籍对象
res = pub.book_set.all()
# 遍历取出一个个书籍对象
for i in res:
    print(i.title)
return HttpResponse("ok")

1.6.1.2 多对多

正向： 对象.属性

# 菜鸟教程所有作者的名字以及手机号（正向）
book = models.Book.objects.filter(title="菜鸟教程").first()
res = book.authors.all()
for i in res:
    print(i.name, i.au_detail.tel)
return HttpResponse("ok")

反向： 对象.小写类名_set

# 查询任我行出过的所有书籍的名字（反向）
author = models.Author.objects.filter(name="任我行").first()
res = author.book_set.all()
for i in res:
    print(i.title)
return HttpResponse("ok")

1.6.2 基于双下划线的跨表查询

语法格式：

正向：属性名称__跨表的属性名称

反向：小写类名__跨表的属性名称

1.6.2.1 一对一

正向： 属性名称__跨表的属性名称

# 查询任我行的手机号（正向）
res = models.Author.objects.filter(name="任我行").values_list("au_detail__tel")

反向： 通过小写类名__跨表的属性名称

# 查询任我行的手机号（反向）
res = models.AuthorDetail.objects.filter(author__name="任我行").values_list("tel")

1.6.2.2 一对多

正向： 属性名称__跨表的属性名称

# 查询菜鸟出版社出版过的所有书籍的名字与价格（正向）
res = models.Book.objects.filter(publish__name="菜鸟出版社").values_list("title", "price")

反向： 通过小写类名__跨表的属性名称

# 查询菜鸟出版社出版过的所有书籍的名字与价格(反向)
res = models.Publish.objects.filter(name="菜鸟出版社").values_list("book__title","book__price")

1.6.2.3 多对多

正向： 属性名称__跨表的属性名称

# 查询任我行出过的所有书籍的名字
res = models.Book.objects.filter(authors__name="任我行").values_list("title")

反向： 通过小写类名__跨表的属性名称

# 查询任我行出过的所有书籍的名字
res = models.Author.objects.filter(name="任我行").values_list("book__title")

2. 聚合查询与分组查询

2.1 聚合查询（aggregate）

聚合查询函数是对一组值执行计算，并返回单个值。

Django 使用聚合查询前要先从 django.db.models 引入 Avg、Max、Min、Count、Sum（首字母大写）。

from django.db.models import Avg,Max,Min,Count,Sum  #   引入函数

聚合查询返回值的数据类型是字典。-
聚合函数 aggregate() 是 QuerySet 的一个终止子句，生成的一个汇总值，相当于 count()。-
使用 aggregate() 后，数据类型就变为字典，不能再使用 QuerySet 数据类型的一些 API 了。
日期数据类型(DateField)可以用 Max 和 Min。
返回的字典中：键的名称默认是（属性名称加上__聚合函数名），值是计算出来的聚合值。

如果要自定义返回字典的键的名称，可以起别名：

aggregate(别名 = 聚合函数名("属性名称"))

实例：

# 引入函数
from django.db.models import Avg,Max,Min,Count,Sum  #   引入函数

# 计算所有图书的平均价格
res = models.Book.objects.aggregate(Avg("price"))

# 计算所有图书的数量、最贵价格和最便宜价格
res=models.Book.objects.aggregate(c=Count("id"),max=Max("price"),min=Min("price"))

2.2 分组查询（annotate）

分组查询一般会用到聚合函数，所以使用前要先从 django.db.models 引入 Avg,Max,Min,Count,Sum（首字母大写）。

from django.db.models import Avg,Max,Min,Count,Sum  #   引入函数

返回值：

分组后，用 values 取值，则返回值是 QuerySet 数据类型里面为一个个字典；
分组后，用 values_list 取值，则返回值是 QuerySet 数据类型里面为一个个元组。

MySQL 中的 limit 相当于 ORM 中的 QuerySet 数据类型的切片。

注意：

annotate 里面放聚合函数。

values 或者 values_list 放在 annotate 前面： values 或者 values_list 是声明以什么字段分组，annotate 执行分组。
values 或者 values_list 放在annotate后面： annotate 表示直接以当前表的pk执行分组，values 或者 values_list 表示查询哪些字段，并且要将 annotate 里的聚合函数起别名，在 values 或者 values_list 里写其别名。

实例：

统计每一个出版社的最便宜的书的价格

res = models.Publish.objects.values("name").annotate(in_price = Min("book__price"))
print(res)

命令行中可以看到以下输出：

<QuerySet [{'name': '菜鸟出版社', 'in_price': Decimal('100.00')}, {'name': '明教出版社', 'in_price': Decimal('300.00')}]>

统计每一本书的作者个数

res = models.Book.objects.annotate(c = Count("authors__name")).values("title","c")
print(res)

命令行中可以看到以下输出：

<QuerySet [{'title': '菜鸟教程', 'c': 1}, {'title': '吸星大法', 'c': 1}, {'title': '冲灵剑法', 'c': 1}]>

统计每一本以"菜"开头的书籍的作者个数

res = models.Book.objects.filter(title__startswith="菜").annotate(c = Count("authors__name")).values("title","c")
print(res)

命令行中可以看到以下输出：

<QuerySet [{'title': '菜鸟教程', 'c': 1}]>

统计不止一个作者的图书名称

res = models.Book.objects.annotate(c = Count("authors__name")).filter(c__gt=0).values("title","c")
print(res)

命令行中可以看到以下输出：

<QuerySet [{'title': '菜鸟教程', 'c': 1}, {'title': '吸星大法', 'c': 1}, {'title': '冲灵剑法', 'c': 1}]>

根据一本图书作者数量的多少对查询集 QuerySet 进行降序排序

res = models.Book.objects.annotate(c = Count("authors__name")).order_by("-c").values("title","c")
print(res)

查询各个作者出的书的总价格

res = models.Author.objects.annotate(all = Sum("book__price")).values("name","all")
print(res)

3. F查询与Q查询

3.1 F查询

F() 的实例可以在查询中引用字段，来比较同一个 model 实例中两个不同字段的值。

之前构造的过滤器都只是将字段值与某个常量做比较，如果想要对两个字段的值做比较，就需要用到 F()。

使用前要先从 django.db.models 引入 F:

from django.db.models import F

用法：

F("字段名称")

F 动态获取对象字段的值，可以进行运算。

Django 支持 F() 对象之间以及 F() 对象和常数之间的加减乘除和取余的操作。

修改操作（update）也可以使用 F() 函数。

实例：

将每一本书的价格提高100元

res = models.Book.objects.update(price=F("price")+100)
print(res)

把所有书名后面加上(第一版)

from django.db.models.functions import Concat
from django.db.models import Value
models.Book.objects.all().update(title=Concat(F("title"), Value("("), Value("第一版"), Value(")")))

Django 支持 F() 对象之间以及 F() 对象和常数之间的加减乘除和取模的操作。

3.2 Q查询

之前构造的过滤器里的多个条件的关系都是 and，如果需要执行更复杂的查询（例如 or 语句），就可以使用 Q 。

Q 对象可以使用 & | ~ （与或非）操作符进行组合。

优先级从高到低：~ & |。

可以混合使用 Q 对象和关键字参数，Q 对象和关键字参数是用"and"拼在一起的（即将逗号看成 and ），但是 Q 对象必须位于所有关键字参数的前面。

使用前要先从 django.db.models 引入 Q:

from django.db.models import Q

用法：

Q(条件判断)

实例：

查询价格大于 350 或者名称以菜开头的书籍的名称和价格

from django.db.models import Q
res=models.Book.objects.filter(Q(price__gt=350)|Q(title__startswith="菜")).values("title","price")
print(res)

查询以"菜"结尾或者不是 2010 年 10 月份的书籍

res = models.Book.objects.filter(Q(title__endswith="菜") | ~Q(Q(pub_date__year=2010) & Q(pub_date__month=10)))
print(res)

查询出版日期是 2004 或者 1999 年，并且书名中包含有"菜"的书籍(Q 对象和关键字混合使用，Q 对象要在所有关键字的前面)
```
res = models.Book.objects.filter(Q(pub_date__year=2004) | Q(pub_date__year=1999), title__contains="菜")
print(res)  
```

4. 锁和事务

4.1 锁

select_for_update(nowait=False, skip_locked=False)

返回一个锁住行直到事务结束的查询集，如果数据库支持，它将生成一个 SELECT … FOR UPDATE 语句。

举个例子：

entries = Entry.objects.select_for_update().filter(author=request.user)

所有匹配的行将被锁定，直到事务结束。这意味着可以通过锁防止数据被其它事务修改。

一般情况下如果其他事务锁定了相关行，那么本查询将被阻塞，直到锁被释放。如果这不想要使查询阻塞的话，使用select_for_update(nowait=True)。如果其它事务持有冲突的锁, 那么查询将引发 DatabaseError 异常。你也可以使用select_for_update(skip_locked=True)忽略锁定的行。 nowait和skip_locked是互斥的，同时设置会导致ValueError。

目前，postgresql，oracle和mysql数据库后端支持select_for_update()。但是，MySQL不支持nowait和skip_locked参数。

使用不支持这些选项的数据库后端（如MySQL）将nowait=True或skip_locked=True转换为select_for_update()将导致抛出DatabaseError异常，这可以防止代码意外终止。

4.2 事务

import os

if __name__ == '__main__':
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "BMS.settings")
    import django
    django.setup()

    import datetime
    from app01 import models

    try:
        from django.db import transaction
        with transaction.atomic():
            new_publisher = models.Publisher.objects.create(name="火星出版社")
            models.Book.objects.create(title="橘子物语", publish_date=datetime.date.today(), publisher_id=10)  # 指定一个不存在的出版社id
    except Exception as e:
        print(str(e))

5. Django ORM执行原生SQL

在模型查询API不够用的情况下，我们还可以使用原始的SQL语句进行查询。

Django 提供两种方法使用原始SQL进行查询：一种是使用raw()方法，进行原始SQL查询并返回模型实例；另一种是完全避开模型层，直接执行自定义的SQL语句。

5.1 执行原生查询

raw()管理器方法用于原始的SQL查询，并返回模型的实例：

注意：raw()语法查询必须包含主键。

这个方法执行原始的SQL查询，并返回一个django.db.models.query.RawQuerySet 实例。这个RawQuerySet 实例可以像一般的QuerySet那样，通过迭代来提供对象实例。

举个例子：

class Person(models.Model):
    first_name = models.CharField(...)
    last_name = models.CharField(...)
    birth_date = models.DateField(...)

可以像下面这样执行原生SQL语句

>>> for p in Person.objects.raw('SELECT * FROM myapp_person'):
...     print(p)

raw()查询可以查询其他表的数据。

举个例子：

ret = models.Student.objects.raw('select id, tname as hehe from app02_teacher')
    for i in ret:
        print(i.id, i.hehe)

raw()方法自动将查询字段映射到模型字段。还可以通过translations参数指定一个把查询的字段名和ORM对象实例的字段名互相对应的字典

d = {'tname': 'haha'}
    ret = models.Student.objects.raw('select * from app02_teacher', translations=d)
    for i in ret:
        print(i.id, i.sname, i.haha)

原生SQL还可以使用参数，注意不要自己使用字符串格式化拼接SQL语句，防止SQL注入！

d = {'tname': 'haha'}
    ret = models.Student.objects.raw('select * from app02_teacher where id > %s', translations=d, params=[1,])
    for i in ret:
        print(i.id, i.sname, i.haha)

5.2 直接执行自定义SQL

有时候raw()方法并不十分好用，很多情况下我们不需要将查询结果映射成模型，或者我们需要执行DELETE、 INSERT以及UPDATE操作。在这些情况下，我们可以直接访问数据库，完全避开模型层。

我们可以直接从django提供的接口中获取数据库连接，然后像使用pymysql模块一样操作数据库。

from django.db import connection, connections
cursor = connection.cursor()  # cursor = connections['default'].cursor()
cursor.execute("""SELECT * from auth_user where id = %s""", [1])
ret = cursor.fetchone()
dent.objects.raw('select id, tname as hehe from app02_teacher')
    for i in ret:
        print(i.id, i.hehe)

raw()方法自动将查询字段映射到模型字段。还可以通过translations参数指定一个把查询的字段名和ORM对象实例的字段名互相对应的字典

d = {'tname': 'haha'}
    ret = models.Student.objects.raw('select * from app02_teacher', translations=d)
    for i in ret:
        print(i.id, i.sname, i.haha)

原生SQL还可以使用参数，注意不要自己使用字符串格式化拼接SQL语句，防止SQL注入！

d = {'tname': 'haha'}
    ret = models.Student.objects.raw('select * from app02_teacher where id > %s', translations=d, params=[1,])
    for i in ret:
        print(i.id, i.sname, i.haha)