[TimLinux] django model关于QuerySet

1. 获取执行过的sql命令

from django.db import connections
connections['default'].queries

2. 获取QuerySet将执行的sql语句

qs = Entries.object.all()
print(qs.query)

3. 单一模型：增删改查

模型示例：

from django.db import models
class Student(models.Model):
    name = models.CharField(max_length=30)
    sex = models.CharField(max_length=30)

3.1. 增

#构造函数方式增加数据
s1 = Student(name='Tim', sex='Male')
s1.save()  #只有这步才执行了insert操作。

#管理对象方式增加数据
s1 = Student.objects.create()  #已经执行了一次insert操作了。
s1.name = "Tim"
s1.sex = "Male"
s1.save()  #这步是update操作

3.2. 删

# query set方式删除：这个方式，只执行了一次sql
qs = Student.objects.filter(pk=1)  # 这个返回的是QuerySet
qs.delete()

# 对象方式删除：这个方式，执行了两次sql
s1 = Student.objects.get(pk=1)  # 这个返回的是RA对象
s1.delete()

3.3. 改

#直接在qs上操作数据的更新，对应的是sql的 update语句
from django.db import models
from django.db.models import functions

qs = Student.objects.filter(id__in=[1,2,3])
qs.update(name=functions.Concat('name', models.Value("appendStr"), output_field=models.CharField))

#操作对象的方式，对应的是，select，然后针对每一行，update。
qs = Student.objects.filter(id__in=[1,2,3])
for t in qs:
    t.name = t.name + "appendStr"
    t.save()

3.4. 查

查询接口分为两类，返回新的QuerySet对象的接口，和不返回QuerySet对象的接口，清单如下：

#返回新的QuerySet对象的接口
filter             exclude         annotate        order_by      reverse
distinct           values          values_list     dates         none
all                union           intersection    difference    select_related
prefetch_related   extra           defer           only          using
select_for_update  raw

#不返回QuerySet对象的接口
get     create     get_or_create      update_or_create   bulk_create
count   in_bulk    iterator           latest             earliest
first   last       aggregate          exists             update
delete  as_manager

QuerySet特点：

链式过滤：
每一次过滤得到的QuerySet都是唯一的
QuerySet是惰性的

QuerySet真实发生SQL操作的时机：

迭代操作：
切片操作：LIMIT SQL语句
Pickling/Caching：
repr()函数：
len()函数：建议是用Count()
list()函数：
bool()函数：建议使用exists()

3.4.1. 返回QuerySet对象函数

filter(**kwargs)：只接收关键字参数，格式为Field lookup语法格式，多个参数间是 AND 关系，使用models.Q可以修改参数间的关系。
exclude(**kwargs)：与 filter 一样的参数格式，选择的方式为取反（NOT），是在整个参数之外增加NOT(参数逻辑)，参数内还是 AND 关系
annotate(*args, **kwargs)：aggregate()是聚合操作，annotate则是在聚合的基础上进行了GROUP BY操作。针对的对象是：由”查询表达式”获取的QuerySet对象中的每一个对象。
- 查询表达式（Query Expressions）：一个简单的值、模型（或关联模型）中的一个字段的引用、或者一个聚合表达式（Aggregate：avg，sum，count等）。查询表达式描述了一个值、或者一种运算：使用在更新（update）、创建（create）、过滤（filter）、排序（order by）、注解（annotate）、聚合（aggregate）中。许多内建表达式帮助我们写查询。表达式可以组合、或者在某些场景下嵌套来组成更复杂的运算。
  - 支持数学运算：支持加、减、乘、除、取模数学运算，以及指数操作（使用Python常量、变量、或者其他表达式来实现）
    - 加法：Company.objects.filter( num_employees__gt=F('num_chairs') + F('num_chairs) ) 字段值翻倍
    - 乘法：Company.objects.filter( num_employees__gt=F('num_chairs') * 2 ) 字段值翻倍
    - 减法：Company.objects.annotate( chairs_needed=F('num_employees') - F('num_chairs') )
  - 内建表达式：被定义在 django.db.models.expressions 和 django.db.models.aggregates 中，通常import django.db.models即可使用
    - F()表达式：数据库内，对字段进行运算操作，没必要将值先存入Python，然后再计算。F()表达式会在每次调用save()操作都执行一次
    - Func()表达式：所以调用数据函数表达式的基础表达式。
    - Aggregate()表达式：封装GROUP BY, 是其他聚合类Sum, Count等的父类。
    - Value()表达式：表达式中需要传递值（整数、bool、字符串）时，直接使用Value对值进行转换后使用。
    - ExpressionWrapper()表达式：简单包装另外一个表达式，并提供访问属性（output_field），F()表达式做算术运算时常用到。
    - Subquery()表达式：添加子查询到一个QuerySet对象中。
    - RawSQL表达式：无法写复杂的WHERE从句时，直接使用RawSQL表达式实现。
- QuerySet对象中的每一个对象：
  - annotate中的每一个参数，都将被添加到QuerySet返回的每一个对象中。
  - 关键字参数，将成为返回对象的属性名。
  - 匿名参数，返回的对象属性名，将由"字段名__聚合函数名"组成，全小写格式。
  - 只有聚合函数引用单一字段时，可以使用匿名参数，其他都必须使用关键字参数。

# 1. F()表达式
#--------------------------------
# 不好的操作方式
reporter = Reporters.objects.get(name='Tintin')
reporter.stories_filed += 1 # select stories_filed from reporter where name='Tintin'; 然后把字段存入Python内存，并处理
reporter.save() # update reporter set stories_filed=5 where id=1; 写入的时候是具体的值。

# 好的操作方式：使用F()表达式
from django.db.models import F
reporter = Reporters.objects.get(name='Tintin')
reporter.stories_filed = F('stories_filed') + 1
reporter.save()  # update reporter set stories_filed=stories_filed+1 where name='Tintin';

# 更好的方式：使用F()表达式
reporter = Repoters.objects.get(name='Tintin')
reporter.update( stories_filed=F('stories_filed') + 1 )

# 甚至一次操作所有对象
Repoters.objects.all().update( stories_filed=F('stories_filed') + 1 )

# F()表达式的注意事项：每次调用save都会执行F表达式，以下的示例，stories_filed将被增加2.
reporter = Reporters.objects.get(name='Tintin')
reporter.stories_filed = F('stories_filed') + 1
reporter.save()

reporter.name = 'Tintin Jr.'
reporter.save()

# F()表达式还可以用在：filter、annotate中。

# 2. Func()表达式
#--------------------------------
# 所有函数都可以通过Func表达式来实现
from django.db.models import Func, F
queryset.annotate( field_lower=Func(F('field'), function='LOWER') ) # sql: SELECT ..., LOWER(field) AS field_lower FROM ...

# 通过继承Func，实现自定义函数接口
class Lower(Func):
    function = 'LOWER'
queryset.annotate( field_lower=Lower('field') )

# 3. Aggregate()表达式
#--------------------------------
# 是Func表达式的一个特定场景，使用GROUP BY从句，所有聚合函数都是继承自Aggregate表达式：Sum，Count。
# Aggregate是表达式、包装表达式，为此可以实现一些复杂的运算
Company.objects.annotate( managers_required=(Count('num_employees') / 4) + Count('num_managers') )

# 4. Value() 表达式
#--------------------------------
F('field') + 1 === F('field') + Value(1)
F('field') + '-append' # 这个会报错
F('field') + Value('-append') # 这样也会报错
Concat( 'field', Value('-append'), output_field=CharField ) # 这样就不会报错了

# 5. ExpressionWrapper()表达式
#--------------------------------
Ticket.objects.annotate( expires=ExpressionWrapper( F('active_at') + F('duration'), output_field=DateTimeField() ) )

# 6. Subquery() 表达式
#--------------------------------
# 给一个QuerySet添加一个明确的子查询
# OuterRef('pk') 引用外部QuerySet数据库中的pk字段, 与同一个model中的F()表达式类似
# 子查询需要使用values()指定返回单一的列属性值，以下例子只返回了 emails.

newest = Comment.objects.filter(post=OuterRef('pk')).order_by('-created_at')
Post.objects.annotate(newest_commenter_email=Subquery(newest.values('emails')[:1]))
# PostgreSQL语句：
# SELECT post.id, (子查询在这里) AS newest_commenter_email FROM post;
# 子查询： SELECT comment.emails FROM comment WHERE comment.post_id=post.id ORDER BY created_at DESC LIMIT 1;

# Exists() 是Subquery()类的子类，使用的是SQL的 EXISTS语句
from django.db.models import Exists, OuterRef
from datetime import timedelta
from django.utils import timezone
one_day_ago = timezone.now() - timedelta(days=1)
recent_comments = Comment.objects.filter( post=OuterRef('pk'), created_at__gte=one_day_ago )
Post.objects.annotate( recent_comment=Exists(recent_comments) )
# PostgreSQL语句：
# SELECT post.id, post.published_at, EXISTS(子查询) AS recent_comment FROM post;
# 子查询：SELECT comment.id, comment.post_id, comment.email, comment.craeted_at FROM comment 
#        WHERE (comment.craeted_at >= YYYY-MM-DD HH:MM:SS AND comment.post_id=post.id);

# 过滤子查询，需要先在annotate中运行子查询，然后filter过滤字段值
# 在子查询表达式中使用聚合

# 7. Raw SQL表达式
#--------------------------------
from django.db.models.expressions import RawSQL
queryset.annotate( val=RawSQL('select col from sometable where othercol=%s', (someparam,) )

order_by：
reverse：
distinct：
values：
values_list：
dates：
datetimes：
none：
all：
union：
intersection：
difference：
select_related：
prefetch_related：
extra：
defer：
only：
using：
select_for_update：
raw：

3.4.2. 不返回QuerySet对象函数

get：
create：
get_or_create：
update_or_create：
bulk_create：
count：
in_bulk：
iterator：
latest：
earliest：
first：
last：
aggregate：
exists：
update：
delete：
as_manager：

3.5. Field查询

Field lookup：用来指定SQL查询中WHERE从句部分内容的，作为filter、exclude、get函数的关键字参数，格式：字段名__查询类型，字段名来自model的定义部分，然后带双下划线，接下来为Django语句支持的查询类型关键字：

# i开头表示，忽略大小写
# exact， 对应SQL语句： =
# iexact，对应SQL语句： LIKE (LIKE是不区分大小写的）
# contains，对应SQL语句： LIKE BINARY （LIKE BINARY是区分大小写的）
# icontain，对应SQL语句： LIKE

exact  iexact   contains    icontains    in        gt         gte 
lt     lte      startswith  istartswith  endswith  iendswith  range
date   year     month       day          week      week_day   time
hour   minute   second      isnull       search    regex      iregex

#查询示例： name是字段名，exact是查询关键字，中间使用双下划线连接
Student.objects.filter(name__exact="tim")
# SQL: SELECT `student`.`id` `student`.`name` FROM `student` WHERE `student`.`name` = 'tim';

Student.objects.filter(name__iexact="tim")
# SQL: SELECT `student`.`id` `student`.`name` FROM `student` WHERE `student`.`name` LIKE 'tim';


Student.objects.filter(name__contain="tim")
# SQL: SELECT `student`.`id` `student`.`name` FROM `student` WHERE `student`.`name` LIKE BINARY '%tim%';

Student.objects.filter(name__icontain="tim")
# SQL: SELECT `student`.`id` `student`.`name` FROM `student` WHERE `student`.`name` LIKE '%tim%';