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 10class 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()#  获取出版社对象的idpk = pub_obj.pk#  给书籍的关联出版社字段 publish_id 传出版社对象的idbook = 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()#  获取作者对象的idpk = chong.pk#  获取书籍对象book = models.Book.objects.filter(title="冲灵剑法").first()#  给书籍对象的 authors 属性用 add 方法传作者对象的idbook.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.nameprint(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 osif __name__ == '__main__':os.environ.setdefault("DJANGO_SETTINGS_MODULE", "BMS.settings")import djangodjango.setup()import datetimefrom app01 import modelstry:from django.db import transactionwith transaction.atomic():new_publisher = models.Publisher.objects.create(name="火星出版社")models.Book.objects.create(title="橘子物语", publish_date=datetime.date.today(), publisher_id=10)  # 指定一个不存在的出版社idexcept 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)

8. Django 模型（二）相关推荐

  1. Django模型(二)

    Django模型(二) 文章目录 Django模型(二) 一.字段查询 1.查看mysql数据库日志 二.条件运算符 1.查询等 2.模糊查询 3.空查询 4. 范围查询 5. 比较查询 6).日期查 ...

  2. Django基础五之Django模型层(二)多表操作

    Django基础五之Django模型层(二)多表操作 一 创建模型 表和表之间的关系 一对一.多对一.多对多 # 作者表 比较常用的信息放在这个表中 class Author(models.Model ...

  3. python路由编程_Python Django基础二之URL路由系统

    MVC和MTV框架 MVC Web服务器开发领域里著名的MVC模式,所谓MVC就是把Web应用分为模型(M),控制器(C)和视图(V)三层,他们之间以一种插件式的.松耦合的方式连接在一起,模型负责业务 ...

  4. Web开发-Django模型层

    Django模型层 简述 Django框架处理业务的逻辑一般如下(省略图,源于网络,侵删) 可以看到,Django自带了一套ORM机制,这也是Django框架的核心-"全面",将一 ...

  5. Django模型(三)

    Django模型(三) 文章目录 Django模型(三) 一.模型类关系 1.关系字段类型 2.一对多关系 3.多对多关系 二.关联查询 1.通过对象执行关联查询 2.通过模型类执行关联查询 三.自关 ...

  6. Django模型(一)

    Django模型(一) 文章目录 Django模型(一) 一.配置Django使用mysql数据库 二.案例 1.定义模型类 2.打开booktest/models.py文件 3.迁移 4.测试数据 ...

  7. django模型的元数据Meta

    模型的元数据,指的是"除了字段外的所有内容",例如排序方式.数据库表名.人类可读的单数或者复数名等等.所有的这些都是非必须的,甚至元数据本身对模型也是非必须的.但是,我要说但是,有 ...

  8. Django模型系统（一）

    装饰器补充 django模型系统 一,数据库的链接配置 二,Django的ORM简介 三,模型的创建与激活 四,数据的增删改查 一,数据库的链接配置 django  链接mysql的配置流程: -安装 ...

  9. Django项目实践3 - Django模型（字段、数据库操作及模型继承）

    http://blog.csdn.net/pipisorry/article/details/45725953 Django数据库字段类型(Field types) AutoField class A ...

最新文章

  1. IE8不能正常登录网上银行的解决方法
  2. [unreal4入门系列之三] 初探UE4安装文件目录结构
  3. 机器学习（MACHINE LEARNING）MATLAB非线性曲线拟合方法
  4. 常用排序算法之——堆排序
  5. Cocoapods ----- pod install报错
  6. 类方法的实例python_Python Class 的实例方法/类方法/静态方法
  7. Python_str 的内部功能介绍
  8. 【论文阅读】Deep Adversarial Subspace Clustering
  9. 修改、读取txt文档
  10. python查找指定字符所在行号_在python中获取当前位置所在的行号和函数名
  11. oracle gather trace,Oracle 12C R2-新特性-新增两个视图:方便查看trace文件和内容
  12. 报文交换（串行）和分组交换（并行）
  13. c语言随机生成算式的对错判断,蔡奇宏软件工程第二次作业--四则运算
  14. 如何评价周志华老师的新书《机器学习理论导引》“宝箱书”？
  15. JAVA版商城 B2B2C商城 多用户入驻商城 直播带货商城 新零售商城 o2o商城 拼团商城 分销商城 直播商城 短视频商城 VR商城 社交电商 分销商城 saas商城spring cloud商城
  16. S7-200 SMART间接寻址功能说明（指针的使用）
  17. 纯净简洁绿色的解压缩软件
  18. 【阿里云】学生成长计划领取资格考试答案分享
  19. 网站群发站内信数据库表设计
  20. Date: 7 Dec, Saturday 佳能交流空间

热门文章

  1. python灰色波浪线,PyCharm关闭碍眼的波浪线图文详解
  2. 华为鸿蒙搁浅,华为系统突然搁浅 背后大棋浮出水面 太高了
  3. JS打开选择本地文件的对话框
  4. 基于html的网页设计毕业论文,个人主页设计（网页设计毕业论文）
  5. 黑魂复刻游戏的玩家输入模块——Unity随手记（2021.3.14）
  6. 推荐模型评价指标 AUC
  7. GET提交中%5B与%5D代表什么意思？
  8. 从感知觉现象引发的对人工智能的一些思考
  9. 数据结构：“大根堆、小根堆”的向上调整算法和向下调整算法
  10. 什么是HashMap？