day69学习笔记之Django中ORM相关操作

1  基础必会操作

官方文档

学习内容来自博客Q1mi

1.1  在Python脚本中调用Django环境

例如在项目文件夹下新建一个py文件，此时为其加载Django项目的配置和变量信息，可进行如下操作

import os

if __name__ == '__main__':
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "BMS.settings")#BMS是自己的项目名称
    import django
    django.setup()

    from app01 import models

    books = models.Book.objects.all()#此时可以进行表的相关操作
    print(books)

1.2  基础必会的13条操作

 表格内容

 

<1> all():                 查询所有结果

ret = models.Person.objects.all()
#得到的ret是一个QuerySet列表：<QuerySet [<Person: <Person Object:张三>>, <Person: <Person Object:李四>>, <Person: <Person Object:王五>>, <Person: <Person Object:赵六>>]>

<2> filter(**kwargs):      它包含了与所给筛选条件相匹配的对象

# # 就算查询的结果只有一个，返回的也是QuerySet，我们要用索引的方式取出第一个元素
ret = models.Person.objects.filter(id=100)  # 不存在返回一个空的QuerySet，不会报错，例如：<QuerySet []>
ret = models.Person.objects.filter(id=1)[0]  #取值按列表索引取，得到的是一个Person对象；<Person Object:张三>

<3> get(**kwargs):         返回与所给筛选条件相匹配的对象，返回结果有且只有一个，如果符合筛选条件的对象超过一个或者没有都会抛出错误。

ret = models.Person.objects.get(name="王五")  #结果为：<Person Object:王五>

<4> exclude(**kwargs):     它包含了与所给筛选条件不匹配的对象

ret = models.Person.objects.exclude(id=1)  #查询除过id为1之外所有的记录，ret为：<QuerySet [<Person: <Person Object:李四>>, <Person: <Person Object:王五>>, <Person: <Person Object:赵六>>]>

<5> values(*field):        返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列model的实例化对象，而是一个可迭代的字典序列

ret = models.Person.objects.values("name", "age")  #不写字段名，默认查询所有字段
#ret为：<QuerySet [{'name': '张三', 'age': 18}, {'name': '李四', 'age': 33}, {'name': '王五', 'age': 22}, {'name': '赵六', 'age': 25}]>

<6> values_list(*field):   它与values()非常相似，它返回的是一个元组序列，values返回的是一个字典序列

ret = models.Person.objects.values_list("name", "age")
#ret为：<QuerySet [('张三', 18), ('李四', 33), ('王五', 22), ('赵六', 25)]>

<7> order_by(*field):      对查询结果排序

ret = models.Person.objects.all().order_by("age")
#ret为：<QuerySet [<Person: <Person Object:张三>>, <Person: <Person Object:王五>>, <Person: <Person Object:赵六>>, <Person: <Person Object:李四>>]>

• 补充：表格查询默认排序

#在models.py文件下对应表格类中定义Meta
class Person(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField(default=18)
    birthday = models.DateField(auto_now_add=True)

    def __str__(self):
        return "<Person Object:{}>".format(self.name)

    class Meta:
        ordering = ("birthday",)#表格查询结果默认按birthday从大到小排序

 

<8> reverse():             对查询结果反向排序，请注意reverse()通常只能在具有已定义顺序的QuerySet上调用(在model类的Meta中指定ordering或调用order_by()方法)。

ret = models.Person.objects.all().order_by("age").reverse()
#结果为：<QuerySet [<Person: <Person Object:李四>>, <Person: <Person Object:赵六>>, <Person: <Person Object:王五>>, <Person: <Person Object:张三>>]>

<9> count():              返回数据库中匹配查询(QuerySet)的对象数量。

ret = models.Person.objects.all().count()#结果为：4

<10> first():              返回第一条记录

ret = models.Person.objects.all().first()#结果为：<Person Object:张三>

<11> last():               返回最后一条记录

ret = models.Person.objects.all().last()  #结果为<Person Object:赵六>

<12> exists():             如果QuerySet包含数据，就返回True，否则返回False

ret = models.Person.objects.exists()  #结果为True
ret = models.Book.objects.exists()  #结果为False，因为book表里没有数据

<13> distinct():            从返回结果中剔除重复纪录(如果你查询跨越多个表，可能在计算QuerySet时得到重复的结果。此时可以使用distinct()，注意只有在PostgreSQL中支持按字段去重。)

1.3  单表查询之双下划线

# 查询id值大于1小于4的结果
ret = models.Person.objects.filter(id__gt=1, id__lt=4)

# 查询 id 在 [1, 3, 5, 7]中的结果
ret = models.Person.objects.filter(id__in=[1, 3, 5, 7])

# 查询 id 不在 [1, 3, 5, 7]中的结果
ret = models.Person.objects.exclude(id__in=[1, 3, 5, 7])

# contains 字段包含指定值的
ret = models.Person.objects.filter(name__contains="小")获取name字段包含"小"的

# icontains 字段包含指定值的（忽略大小，只针对英文字母检索）
ret = models..Person.objects.filter(name__icontains="ven")

# 判断id范围在1到3之间的数据，等价于SQL的bettwen and
ret = models.Person.objects.filter(id__range=[1,3])

类似的还有：startswith，istartswith, endswith, iendswith　

# 日期和时间字段补充写法
ret = models.Person.objects.filter(birthday__year=2000)
ret = models.Person.objects.filter(birthday__year=2000, birthday__month=5)#两个条件是and关系

注：基本都是返回QuerySet列表类型

 2  ForeignKey（外键）操作

 首先在models.py文件中建立如下表格类：

#出版社表格
class Publisher(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32, unique=True)

    def __str__(self):
        return "我是一个出版社对象:{}".format(self.name)

#书籍表格
class Book(models.Model):
    id = models.AutoField(primary_key=True)
    price = models.DecimalField(max_digits=5, decimal_places=2, default=99.99)
    kucun = models.IntegerField(default=1000)# 库存数
    maichu = models.IntegerField(default=0)# 卖出数
    title = models.CharField(max_length=32)
    # 外键
    publisher = models.ForeignKey(
        to="Publisher",
        on_delete=models.CASCADE,
        related_name="books", # related_name="books" 反向查询是用来代替 book_set的
        related_query_name="xxss", # 
        null=True
    )

    def __str__(self):
        return self.title

2.1  正向查找

2.1.1  基于对象跨表查询

语法：对象.关联字段.字段

 book_obj = models.Book.objects.all().first()
 ret = book_obj.publisher  # 和我这本书关联的出版社对象
 print(ret, type(ret))  #结果：我是一个出版社对象:沙河出版社 <class 'app01.models.Publisher'>
 ret = book_obj.publisher.name  # 和我这本书关联的出版社对象
 print(ret, type(ret))  结果：沙河出版社 <class 'str'>

2.1.2  基于字段跨表查询

语法：关联字段.字段

# 利用双下划线 跨表查询
ret = models.Book.objects.filter(id=1).values("publisher__name")
print(ret)  #结果：<QuerySet [{'publisher__name': '沙河出版社'}]>
ret = models.Book.objects.filter(id=1).values_list("publisher__name")
print(ret)  #结果：<QuerySet [('沙河出版社',)]>

2.2  反向查找

2.2.1  基于对象查询

语法：obj.表名_set

# 1. 基于对象查询
publisher_obj = models.Publisher.objects.get(id=1)  # 得到一个具体的对象
# ret = publisher_obj.book_set.all()  #当Book类中外键字段未设置related_name时，反向查询需要使用book_set
ret = publisher_obj.books.all()
print(ret)  #结果为：<QuerySet [<Book: 英语>, <Book: 语文>]>，返回书籍对象

2.2.2  基于字段查询

 语法：表名_字段

ret = models.Publisher.objects.filter(id=1).values_list("books__title")
# ret = models.Publisher.objects.filter(id=1).values_list("book__title")  #当Book类中外键字段未设置related_name时，反向查询使用book_title
# ret = models.Publisher.objects.filter(id=1).values_list("xxss__title")  #当Book类中外键字段设置related_query_name时，反向查询使用xxss_title
print(ret)  #结果为：<QuerySet [('英语',), ('语文',)]>

 注意：.get()方法和.first()方法得到的是具体的对象，对象是没有.values()和.values_list()方法；

           .filter()得到的是QuerySet对象，可以调用.values()和.values_list()方法；

3  ManyToManyField

3.1  class RelatedManager

"关联管理器"是在一对多或者多对多的关联上下文中使用的管理器。

它存在于下面两种情况：

1. 外键关系的反向查询
2. 多对多关联关系

简单来说就是当 点后面的对象 可能存在多个的时候就可以使用以下的方法。

在models.py文件中建立如下表格类：

class Author(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32)
    books = models.ManyToManyField(to="Book")

    def __str__(self):
        return self.name

在测试程序中：

author_obj = models.Author.objects.first()
ret = author_obj.books.all()  #查询第一个作者写的所有书
print(ret)  # 结果为：<QuerySet [<Book: 英语>, <Book: 数学>]>
print(type(author_obj.books))
# 结果为：<class 'django.db.models.fields.related_descriptors.create_forward_many_to_many_manager.<locals>.ManyRelatedManager'>

3.1.1  方法

create()

创建一个新的对象，保存对象，并将它添加到关联对象集之中，返回新创建的对象。

# 通过作者创建一本书,会自动保存，主要做了两件事：
# 1. 在app01_book表里面创建一本新书，2. 在作者和书的关系表(app01_author_books)中添加关联记录
author_obj.books.create(title="金老板自传", publisher_id=2)

appo1_book表：

appo1_author_books表：

 

add()

把指定的model对象添加到关联对象集中。

添加对象：

###添加一个对象
# 在金老板关联的书里面，再加一本id是4的书
book_obj = models.Book.objects.get(id=4)
author_obj.books.add(book_obj)

###添加多个对象
book_objs = models.Book.objects.filter(id__gt=5)
author_obj.books.add(*book_objs)  #注意加*号，要把列表打散再传进去

添加id：

author_obj.books.add(9)  #直接将id为9的书加到app01_author_books表中
# author_obj.books.add(*[3, 4])  #直接将id为1和2的的书加到app01_author_books表中

 

set()

更新model对象的关联对象。

book_obj = models.Author.objects.first()  #Author里面关联了Book
book_obj.books.set([4, 3])  #将app01_author_books表中的第一个作者关联的书籍id改为4和3，

  

remove()

从关联对象集中移除执行的model对象

###基于对象删除，删除的是app01_author_books表中的数据
# 从金老板关联的书里面把 开飞船 删掉
book_obj = models.Book.objects.get(title="跟金老板学开飞船")
author_obj.books.remove(book_obj)

###基于id删除
# 从金老板关联的书里面把 id是8的记录 删掉
author_obj.books.remove(8)

 

clear()

从关联对象集中移除一切对象

# 清空，此处王老板的id为2
# 把王老板关联的所有书都删掉，删除的是app01_author_books表中的数据
wang_obj = models.Author.objects.get(id=2)
wang_obj.books.clear()

注意：

对于ForeignKey对象，clear()和remove()方法仅在外键字段设置属性null=True时才可以使用。

# 找到id是2的出版社
publisher_obj = models.Publisher.objects.get(id=2)
publisher_obj.books.clear()  #将id为2的出版社与其关联的书籍的关联信息删除，删除的是app01_book表中对应的publisher_id字段的值

执行前：

 执行后：

 

举个例子：

ForeignKey字段没设置null=True时，

class Book(models.Model):
    title = models.CharField(max_length=32)
    publisher = models.ForeignKey(to=Publisher)

没有clear()和remove()方法：

>>> models.Publisher.objects.first().book_set.clear()
Traceback (most recent call last):
  File "<input>", line 1, in <module>
AttributeError: 'RelatedManager' object has no attribute 'clear'

当ForeignKey字段设置null=True时，

class Book(models.Model):
    name = models.CharField(max_length=32)
    publisher = models.ForeignKey(to=Class, null=True)

此时就有clear()和remove()方法：

>>> models.Publisher.objects.first().book_set.clear()

 

注意：

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

4  聚合查询和分组查询

4.1  聚合

aggregate()是QuerySet 的一个终止子句，意思是说，它返回一个包含一些键值对的字典。

键的名称是聚合值的标识符，值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的。

用到的内置函数：

from django.db.models import Avg, Sum, Max, Min, Count

示例：

# 聚合
from django.db.models import Avg, Sum, Max, Min, Count

#使用默认键名称：字段名__聚合函数名
ret = models.Book.objects.all().aggregate(Avg("price"))
print(ret)  #结果：{'price__avg': 51.998333}
ret = models.Book.objects.all().aggregate(Count("price"))
print(ret)  #结果：{'price__count': 6}返回的是Book表中的数据行数

#指定键名称：price_avg=...
ret = models.Book.objects.all().aggregate(price_avg=Avg("price"))
print(ret)  #结果：{'price_avg': 51.998333}  

#查询多个结果
ret = models.Book.objects.all().aggregate(price_avg=Avg("price"), price_max=Max("price"), price_min=Min("price"))
print(ret)  #结果：{'price_avg': 51.998333, 'price_max': Decimal('99.99'), 'price_min': Decimal('25.00')}

4.2  分组

我们在这里先复习一下SQL语句的分组。

假设现在有一张公司职员表：

 

我们使用原生SQL语句，按照部门分组求平均工资：

select dept,AVG(salary) from employee group by dept;

ORM查询:

from django.db.models import Avg
Employee.objects.values("dept").annotate(avg=Avg("salary").values(dept, "avg")

连表查询的分组：

 

SQL查询：

select dept.name,AVG(salary) from employee inner join dept on (employee.dept_id=dept.id) group by dept_id;

ORM查询：

from django.db.models import Avg
models.Dept.objects.annotate(avg=Avg("employee__salary")).values("name", "avg")

4.2.1  更多示例：

示例1：统计每一本书的作者个数

#相当于从book表反向查author表
ret = models.Book.objects.all().annotate(author_num=Count("author"))
print(ret)  #结果：<QuerySet [<Book: 英语>, <Book: 数学>, <Book: 语文>, <Book: 化学>, <Book: 地理>, <Book: 金老板自传>]>，是一个QuerySet对象，并且每个对象都多了一个author_num字段
for book in ret:
    print("书名：{}，作者数量：{}".format(book.title, book.author_num))
结果：
书名：英语，作者数量：1
书名：数学，作者数量：0
书名：语文，作者数量：2
书名：化学，作者数量：2
书名：地理，作者数量：0
书名：金老板自传，作者数量：0

示例2：统计每个作者写了几本书

ret = models.Author.objects.all().annotate(book_num=Count("books"))
print(ret)   #结果：<QuerySet [<Author: 金老板>, <Author: 王老板>, <Author: 陈老板>, <Author: 苑局长>]>
for author in ret:
    print("作者名：{}，书数量：{}".format(author.name, author.book_num))
结果：
作者名：金老板，书数量：2
作者名：王老板，书数量：1
作者名：陈老板，书数量：0
作者名：苑局长，书数量：2

示例3：统计作者数量大于1的书

ret = models.Book.objects.all().annotate(author_num=Count("author")).filter(author_num__gt=1)
print(ret)  #结果：<QuerySet [<Book: 语文>, <Book: 化学>]>

示例4：查询每个作者出的书的总价格

ret = models.Author.objects.all().annotate(price_sum=Sum("books__price")).values_list("name", "price_sum")
print(ret)  #结果为：<QuerySet [('金老板', Decimal('90.00')), ('王老板', Decimal('25.00')), ('陈老板', None), ('苑局长', Decimal('90.00'))]>
ret = models.Author.objects.all().annotate(price_sum=Sum("books__price"))
print(ret)  #结果为：<QuerySet [<Author: 金老板>, <Author: 王老板>, <Author: 陈老板>, <Author: 苑局长>]>
for i in ret:
    print(i.name, i.price_sum)
结果为：
金老板 90.00
王老板 25.00
陈老板 None
苑局长 90.00

注意：

ret = models.Author.objects.all().annotate(price_sum=Sum("books")).values_list("name", "price_sum")
print(ret)  #结果为<QuerySet [('金老板', Decimal('7')), ('王老板', Decimal('1')), ('陈老板', None), ('苑局长', Decimal('7'))]>，当不指定sum函数中book表中的字段名（例如books__price或books__kucun）时，默认按books__id求和

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

ret = models.Book.objects.all().annotate(author_num=Count("author")).order_by("author_num")  #从小到大排序
print(ret)  #结果：<QuerySet [<Book: 地理>, <Book: 金老板自传>, <Book: 数学>, <Book: 英语>, <Book: 化学>, <Book: 语文>]>

示例6：统计出每个出版社卖的最便宜的书的价格

#方法1
ret = models.Book.objects.values("publisher__name").annotate(min_price=Min("price"))
print(ret)  #结果：<QuerySet [{'publisher__name': '沙河出版社', 'min_price': Decimal('25.00')}, {'publisher__name': '五道口出版社', 'min_price': Decimal('34.00')}, {'publisher__name': '朝阳出版社', 'min_price': Decimal('59.00')}]>
#ORM对应的SQL语句：SELECT `app01_publisher`.`name`, MIN(`app01_book`.`price`) AS `min_price` FROM `app01_book` LEFT OUTER JOIN `app01_publisher` ON (`app01_book`.`publisher_id` = `app01_publisher`.`id`) GROUP BY `app01_publisher`.`name` ORDER BY NULL LIMIT 21;

#方法2
publisher_list = models.Publisher.objects.annotate(min_price=Min("books__price"))#publisher_list是一个Queryset列表，里面是多个publisher对象
#ORM对应的SQL语句为：SELECT `app01_publisher`.`id`, `app01_publisher`.`name`, MIN(`app01_book`.`price`) AS `min_price` FROM `app01_publisher` LEFT OUTER JOIN `app01_book` ON (`app01_publisher`.`id` = `app01_book`.`publisher_id`) GROUP BY `app01_publisher`.`id` ORDER BY NULL;
for obj in publisher_list:
    print(obj.min_price)
#结果：
25.00
34.00
59.00
None
None

 从以上两种方法中ORM对应的SQL语句结果来看，.annotate()方法会将涉及到的两个表格进行连表，然后再分组。

5  F查询和Q查询

5.1  F查询

在上面所有的例子中，我们构造的过滤器都只是将字段值与某个常量做比较。如果我们要对两个字段的值做比较，那该怎么做呢？

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

示例1：查找Book表中kucun字段值大于maichu字段值的对象

from django.db.models import F
ret = models.Book.objects.filter(kucun__gt=F("maichu"))
print(ret)  #结果：<QuerySet [<Book: 英语>, <Book: 数学>, <Book: 语文>, <Book: 化学>, <Book: 地理>, <Book: 金老板自传>]>，ret中包含多个book对象

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

# 刷单 把每一本书的maichu字段值都先加1再乘以3
# obj = models.Book.objects.first()
# obj.maichu = 1000 * 3
# obj.save()
# 具体的对象没有update()，QuerySet对象才有update()方法。

models.Book.objects.update(maichu=(F("maichu")+1)*3)

修改操作也可以使用F函数,比如将每一本书的价格提高30元

models.Book.objects.all().update(price=F("price")+30)
models.Book.objects.update(price=F("price")+30)
#上述两个语句结果一样

引申：

如果要修改char字段咋办？

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

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

5.2  Q查询

filter() 等方法中的关键字参数查询都是一起进行“AND” 的。 如果你需要执行更复杂的查询（例如OR语句），你可以使用Q对象。

示例1：查询 卖出数大于10，并且 价格小于40的所有书

ret = models.Book.objects.filter(maichu__gt=10, price__lt=40)
print(ret)  #结果：<QuerySet [<Book: 化学第一版>]>，是book对象的列表

示例2：查询 卖出数大于10，或者 价格小于40的所有书

ret = models.Book.objects.filter(Q(maichu__gt=10) | Q(price__lt=40))
print(ret)  #结果：<QuerySet [<Book: 英语第一版>, <Book: 数学第一版>, <Book: 语文第一版>, <Book: 化学第一版>]>

你可以组合& 和|  操作符以及使用括号进行分组来编写任意复杂的Q 对象。同时，Q 对象可以使用~ 操作符取反，这允许组合正常的查询和取反(NOT) 查询。

示例3：查询作者名字是小仙女并且不是2018年出版的书的书名。

#反向查询，从book表查author表
models.Book.objects.filter(Q(author__name="小仙女") & ~Q(publish_date__year=2018)).values_list("title")
#结果：<QuerySet [('番茄物语',)]>

查询函数可以混合使用Q 对象和关键字参数。所有提供给查询函数的参数（关键字参数或Q 对象）都将"AND”在一起。但是，如果出现Q 对象，它必须位于所有关键字参数的前面。

例如：查询 卖出数大于10，或者 价格小于40，并且书名中带“英语”的所有书

ret = models.Book.objects.filter(Q(maichu__gt=10) | Q(price__lt=40), title__contains="英语")
print(ret)  #结果：<QuerySet [<Book: 英语第一版>, <Book: 英语第二版>]>

6  锁和事务

6.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异常，这可以防止代码意外终止。

6.2  事务

 示例1：没有指定原子操作

import os

if __name__ == '__main__':
    # 加载Django项目的配置信息
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "ormday69.settings")
    # 导入Django，并启动Django项目
    import django
    django.setup()

    from app01 import models
    try:

        # 先创建一个出版社
        new_publisher = models.Publisher.objects.create(name="火星出版社")#(1)
        # 创建一本书
        models.Book.objects.create(
            title="橘子物语",
            price=11.11,
            kucun=10,
            maichu=10,
            publisher_id=1000  #(2)  # 指定一个不存在的出版社id
        )
    except Exception as e:
        print(str(e))
#执行到（2）处的时候程序会出错，但此时（1）处创建的新的出版社（“火星出版社”）已经在publisher表中创建好了。

 示例2：指定原子操作

import os

if __name__ == '__main__':
    # 加载Django项目的配置信息
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "ormday69.settings")
    # 导入Django，并启动Django项目
    import django
    django.setup()

    from app01 import models
    try:
        from django.db import transaction

        with transaction.atomic():
            # 先创建一个出版社
            new_publisher = models.Publisher.objects.create(name="火星出版社")  #（1）
            # 创建一本书
            models.Book.objects.create(
                title="橘子物语",
                price=11.11,
                kucun=10,
                maichu=10,
                publisher_id=1000  #（2）# 指定一个不存在的出版社id
            )
    except Exception as e:
        print(str(e))
#当执行到（2）处报错时，虽然（1）处的新出版社已经创建好了，但是由于指定了原子事务，数据库会回滚到with transaction.atomic():执行前的状态，即（1）处创建的出版社对象会被抹去，数据库恢复到之前的状态。

7  其他鲜为人知的操作（有个印象即可）

7.1  Django ORM执行原生SQL

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

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

7.1.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)

7.1.2  直接执行自定义SQL

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

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

from django.db import connection
cursor = connection.cursor()  # cursor = connections['default'].cursor()
cursor.execute("SELECT * from app01_book where id = %s", [1])
ret = cursor.fetchone()
print(ret)  #结果：(1, Decimal('25.00'), 11, 2, '英语第一版', 1)

7.2  QuerySet方法大全

##################################################################
# PUBLIC METHODS THAT ALTER ATTRIBUTES AND RETURN A NEW QUERYSET #
##################################################################

def all(self)
    # 获取所有的数据对象

def filter(self, *args, **kwargs)
    # 条件查询
    # 条件可以是：参数，字典，Q

def exclude(self, *args, **kwargs)
    # 条件查询
    # 条件可以是：参数，字典，Q

def select_related(self, *fields)
    性能相关：表之间进行join连表操作，一次性获取关联的数据。

    总结：
    1. select_related主要针一对一和多对一关系进行优化。
    2. select_related使用SQL的JOIN语句进行优化，通过减少SQL查询的次数来进行优化、提高性能。

def prefetch_related(self, *lookups)
    性能相关：多表连表操作时速度会慢，使用其执行多次SQL查询在Python代码中实现连表操作。

    总结：
    1. 对于多对多字段（ManyToManyField）和一对多字段，可以使用prefetch_related()来进行优化。
    2. prefetch_related()的优化方式是分别查询每个表，然后用Python处理他们之间的关系。

def annotate(self, *args, **kwargs)
    # 用于实现聚合group by查询

    from django.db.models import Count, Avg, Max, Min, Sum

    v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id'))
    # SELECT u_id, COUNT(ui) AS `uid` FROM UserInfo GROUP BY u_id

    v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id')).filter(uid__gt=1)
    # SELECT u_id, COUNT(ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1

    v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id',distinct=True)).filter(uid__gt=1)
    # SELECT u_id, COUNT( DISTINCT ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1

def distinct(self, *field_names)
    # 用于distinct去重
    models.UserInfo.objects.values('nid').distinct()
    # select distinct nid from userinfo

    注：只有在PostgreSQL中才能使用distinct进行去重

def order_by(self, *field_names)
    # 用于排序
    models.UserInfo.objects.all().order_by('-id','age')

def extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
    # 构造额外的查询条件或者映射，如：子查询

    Entry.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,))
    Entry.objects.extra(where=['headline=%s'], params=['Lennon'])
    Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"])
    Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid'])

 def reverse(self):
    # 倒序
    models.UserInfo.objects.all().order_by('-nid').reverse()
    # 注：如果存在order_by，reverse则是倒序，如果多个排序则一一倒序


 def defer(self, *fields):
    models.UserInfo.objects.defer('username','id')
    或
    models.UserInfo.objects.filter(...).defer('username','id')
    #映射中排除某列数据

 def only(self, *fields):
    #仅取某个表中的数据
     models.UserInfo.objects.only('username','id')
     或
     models.UserInfo.objects.filter(...).only('username','id')

 def using(self, alias):
     指定使用的数据库，参数为别名（setting中的设置）


##################################################
# PUBLIC METHODS THAT RETURN A QUERYSET SUBCLASS #
##################################################

def raw(self, raw_query, params=None, translations=None, using=None):
    # 执行原生SQL
    models.UserInfo.objects.raw('select * from userinfo')

    # 如果SQL是其他表时，必须将名字设置为当前UserInfo对象的主键列名
    models.UserInfo.objects.raw('select id as nid from 其他表')

    # 为原生SQL设置参数
    models.UserInfo.objects.raw('select id as nid from userinfo where nid>%s', params=[12,])

    # 将获取的到列名转换为指定列名
    name_map = {'first': 'first_name', 'last': 'last_name', 'bd': 'birth_date', 'pk': 'id'}
    Person.objects.raw('SELECT * FROM some_other_table', translations=name_map)

    # 指定数据库
    models.UserInfo.objects.raw('select * from userinfo', using="default")

    ################### 原生SQL ###################
    from django.db import connection, connections
    cursor = connection.cursor()  # cursor = connections['default'].cursor()
    cursor.execute("""SELECT * from auth_user where id = %s""", [1])
    row = cursor.fetchone() # fetchall()/fetchmany(..)


def values(self, *fields):
    # 获取每行数据为字典格式

def values_list(self, *fields, **kwargs):
    # 获取每行数据为元祖

def dates(self, field_name, kind, order='ASC'):
    # 根据时间进行某一部分进行去重查找并截取指定内容
    # kind只能是："year"（年）, "month"（年-月）, "day"（年-月-日）
    # order只能是："ASC"  "DESC"
    # 并获取转换后的时间
        - year : 年-01-01
        - month: 年-月-01
        - day  : 年-月-日

    models.DatePlus.objects.dates('ctime','day','DESC')

def datetimes(self, field_name, kind, order='ASC', tzinfo=None):
    # 根据时间进行某一部分进行去重查找并截取指定内容，将时间转换为指定时区时间
    # kind只能是 "year", "month", "day", "hour", "minute", "second"
    # order只能是："ASC"  "DESC"
    # tzinfo时区对象
    models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.UTC)
    models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.timezone('Asia/Shanghai'))

    """
    pip3 install pytz
    import pytz
    pytz.all_timezones
    pytz.timezone(‘Asia/Shanghai’)
    """

def none(self):
    # 空QuerySet对象


####################################
# METHODS THAT DO DATABASE QUERIES #
####################################

def aggregate(self, *args, **kwargs):
   # 聚合函数，获取字典类型聚合结果
   from django.db.models import Count, Avg, Max, Min, Sum
   result = models.UserInfo.objects.aggregate(k=Count('u_id', distinct=True), n=Count('nid'))
   ===> {'k': 3, 'n': 4}

def count(self):
   # 获取个数

def get(self, *args, **kwargs):
   # 获取单个对象

def create(self, **kwargs):
   # 创建对象

def bulk_create(self, objs, batch_size=None):
    # 批量插入
    # batch_size表示一次插入的个数
    objs = [
        models.DDD(name='r11'),
        models.DDD(name='r22')
    ]
    models.DDD.objects.bulk_create(objs, 10)

def get_or_create(self, defaults=None, **kwargs):
    # 如果存在，则获取，否则，创建
    # defaults 指定创建时，其他字段的值
    obj, created = models.UserInfo.objects.get_or_create(username='root1', defaults={'email': '1111111','u_id': 2, 't_id': 2})

def update_or_create(self, defaults=None, **kwargs):
    # 如果存在，则更新，否则，创建
    # defaults 指定创建时或更新时的其他字段
    obj, created = models.UserInfo.objects.update_or_create(username='root1', defaults={'email': '1111111','u_id': 2, 't_id': 1})

def first(self):
   # 获取第一个

def last(self):
   # 获取最后一个

def in_bulk(self, id_list=None):
   # 根据主键ID进行查找
   id_list = [11,21,31]
   models.DDD.objects.in_bulk(id_list)

def delete(self):
   # 删除

def update(self, **kwargs):
    # 更新

def exists(self):
   # 是否有结果

QuerySet方法大全

8  Django终端打印ORM操作对应的SQL语句

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'console':{
            'level':'DEBUG',
            'class':'logging.StreamHandler',
        },
    },
    'loggers': {
        'django.db.backends': {
            'handlers': ['console'],
            'propagate': True,
            'level':'DEBUG',
        },
    }
}

 注：代码放在settings.py文件中

9  复习

9.1  关系字段

1. ForeignKey(to="类名"，related_name=“xx”) --> 1对多 ，外键通常设置在多的那一边（例如book表和publisher表，外键设置在book表中）
2. ManyToMany(to="类名",related_name="xx") --> 多对多，通常设置在正向查询多的那一边（如果通过author表查book表的次数多，则多对多设置在author表中）

9.2  ORM一般操作

9.2.1  返回QuerySet对象的

1. all()
2. filter()
3. values()
4. values_list()
5. exclude()
6. order_by()
7. reverse()
8. distinct()

9.2.2  返回具体对象的

1. get()
2. first()
3. last()

9.2.3  返回布尔值的

1. exists()
4. 返回具体数值的
1. count()

9.3  F和Q

1. 当需要字段和字段作比较的时候用F查询
2. 当查询条件是 或 的时候 用Q查询，因为默认的filter参数都是且的关系