F查询与 Q 查询、事务以及数据库优化 defer/only

内容概要

• F查询
• Q查询
• 事务
• ORM 其它操作方法
  • choice 参数
  • date 字段如何只取出年月
• 数据库查询优化
  • only 与 defer
  • select_related和prefetch_related
  • bulk_create 批量插入数据
  • update()与save()的区别

内容详细

F查询

在之前的 ORM 数据操作例子中，做过滤操作时都是将字段值来和常量作比较，如果我们要对两个字段的值做比较，那就需要使用到 F（）查询

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

例子1：查询点赞数大于点踩数的文章

from django.db.models import F

res = models.Article.objects.filter(up_num__gt=F('down_num'))
print(res)

除此之外，Django 支持 F() 对象之间以及 F() 对象和常数之间的加减乘除和取模的操作。基于此可以对表中的数值类型进行数学运算

例子2：将每篇文章的点赞数添加10个

models.Article.objects.update(up_num=F('up_num') + 10)

注意： 如果是要进行char 类型的字段拼接字符串，就不能使用数值运算符+来拼接了

字符串拼接使用Concat，并且还要使用到 Value 函数拼接值，具体用法如下

例子3：给jason用户的文章标题后拼接 _jason 字符串

from django.db.models.functions import Concat
from django.db.models import Value

    
res = models.Article.objects.filter(blog__userinfo__username='jason').update(title=Concat(F('title'), Value('_jason')))
print(res)

Q查询

filter() 等方法中逗号隔开的筛选条件都是与（AND）的关系。 如果你需要执行更复杂的查询（例如OR语句），你可以使用Q对象。

例子1：查询点赞数大于50或者评论数大于10的文章

from django.db.models import Q

res = models.Article.objects.filter(Q(up_num__gt=50) | Q(comment_num__gt=10))
print(res)

例子2：查询点赞数小于50并且评论数大于10的文章

res = models.Article.objects.filter(Q(up_num__lt=50) & Q(comment_num__gt=10))
print(res)

事务

事务的定义:将多个sql语句操作变成原子性操作，要么同时成功，有一个失败则里面回滚到原来的状态，保证数据的完整性和一致性(NoSQL数据库对于事务则是部分支持)

# 事务
# 买一本 跟jason学Linux 书
# 在数据库层面要做的事儿
# 1. 创建一条订单数据
# 2. 去产品表 将卖出数+1， 库存数-1
from django.db.models import F
from django.db import transaction
# 开启事务处理
try:
  with transaction.atomic():
  # 创建一条订单数据
  models.Order.objects.create(num="110110111", product_id=1, count=1)
  # 能执行成功
  models.Product.objects.filter(id=1).update(kucun=F("kucun")-1, maichu=F("maichu")+1)
except Exception as e:
  print(e)

ORM 其它操作方法

choice 参数

class User(models.Model):
    gender_choices = (
    	(1, '男')，
        (2, '男')，
        (3, '男')，
    )
    gender = models.IntegerFeild(choices=gender_choices)

# 存值的时候就算不在列表内数字也可以存

# 取值： 数据对象.get_字段名_display()

user_obj = models.User.objects.filter(pk=1).first()
print(user_obj.get_gender_display())

date 字段如何只取出年月

在一些功能需求里，有时候是需要在date字段中只提取年和月来进行数据处理的，但双下划线方法__year 和 month 只能单独提取年或者日。

要解决这个问题，得借助 django 的 models模块中 TruncMonth 方法

user_obj = models.UserInfo.objects.filter(username=username).first()
blog = user_obj.blog

# 按照年月统计相应的文章数
date_list = models.Article.objects.filter(blog=blog).annotate(month=TruncMonth('create_time')).values('month').annotate(count_num=Count('pk')).values_list('month', 'count_num')

要实现以上效果，按照文章创建的年月来统计文章数

首先，文章创建时间在文章表中，文章表包括了所有用户创建的文章，得按照个人站点外键进行第一轮分组，使用 TruncMonth 方法得到month 字段，在根据 month 字段去统计文章数，获取列表套元组序列

数据库查询优化

ORM 语句特点：

惰性查询： 如果只是书写了 ORM 操作语句，后面并没有使用到查询出来的结果，ORM 会自动识别，不会执行改语句

知道要用到数据了才会走数据库

only 与 defer

only

article_QuerySet = models.article.objects.all()
for obj in article_QuerySet:
    print(obj.title)

以上 .all() 方法是在数据库中取出来全部的数据对象，数据对象.字段的方式可以拿到所有字段值

而使用 .only 这个 QuerySet 内置方法，可以只取出需要的字段，不会包含其它无关字段，减少内存资源占用和提高查询速度

article_QuerySet = models.article.objects.only('title')
for obj in article_QuerySet:
    print(obj.title)

# 此时obj中只有title字段的数据，要是obj.其它字段，则需要重新查询数据库获取

defer

除了defer筛选条件中的字段数据，其它字段数据都取出

article_QuerySet = models.article.objects.defer('title')
for obj in article_QuerySet:
    print(obj.create_time)

# 此时obj 中除了title字段，拥有其它所有字段值，如果要.title获取title字段的值则需要重新查询数据库

做这样细分化的ORM数据查询，可以根据需求，优化数据库查询，提升效率

select_related和prefetch_related

select_related和prefetch_related 查询跟跨表操作有关

select_related （相当于连表查询）

book_QuerySet = models.catecory.objects.all()
for obj in book_QuerySet:
    print(obj.blog.site_name)
# 这种做法因为涉及到外键查询，每循环一次都要进行一次数据库查询，过于频繁

# select_related 相当于连表查询（内连接），
# 缺点： 虽然每次查取的数据量很大，
# 优点： 但就不用频繁向数据库发出申请
book_QuerySet = models.catecory.objects.select_related('blog')  # 与Blog 表内连接,括号内放外键字段
for obj in book_QuerySet:
    print(obj.blog.site_name)

prefetch_related （相当于子查询，得到一个结果再进行下一步）

book_QuerySet = models.catecory.objects.prefetch_related('blog')
for obj in book_QuerySet:
    print(obj.blog.site_name)

bulk_create 批量插入数据

from faker import Faker,Factory
    faker = Faker('zh_CN') # 初始化成中文
    # 先定义一个空列表
    user_list = []
    for i in range(500):
        # 创建数据对象
        user_obj = models.User(name=faker.name(),phone=faker.phone_number(),address=faker.address())
        # 把数据对象添加到列表
        user_list.append(user_obj)

    models.User.objects.bulk_create(user_list)

update()与save()的区别

推荐使用 update()

因为 update() 只会把需要修改的字段做改动

而save()对象保存是把所有字段都更新了一遍

两者都是对数据的修改保存操作，但是save()函数是将数据列的全部数据项全部重新写一遍，而update()则是针对修改的项进行针对的更新效率高耗时少

所以以后对数据的修改保存用update()

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方法大全