Django之F和Q查询等其他查询

 

1. 内容回顾

 

1. 外键的查询操作

1. 正向查找（详见day69内容回顾时间.py）

　　　1. 基于对象的查询（SQL：子查询）

　　　2. 基于双下划线的跨表查询（SQL:join）

 

2. 反向查找（详见day69内容回顾时间.py）

　　1. 基于对象的查询

　　2. 基于双下划线的跨表查询

 

2. 多对多关系

 

ManyToManyField()多设置在正向查询多的那一边。

 

1. 三种建立多对多关系的方式

　　1. 自己创建第三张表，分别外键关联两张表

 

　　2. ORM自带的ManyToManyField()建立多对多关联关系

　　ORM提供了一堆方法，操作方便：

　　1. all()

　　2. set()

　　3. add()

　　4. remove()

　　5. clear()

　　6. create()

　　3. 自己创建第三张表，并且设置ManyToManyField()关联关系（中介者模型）

　　books = models.ManyToManyField(to="Book", through="Author2Book", through_fields=("author", "book"))

 

　　注意事项：

　　　　1. through="Author2Book",设置通过哪张表建立多对多关系

　　　　2.through_fields=("a", "book")，设置关联字段的顺序

　　优点：

　　　　1. 我可以自行扩展第三张表存储的字段

　　　　2. 可以使用连表查询的快捷方法

　　缺点：

　　　　1.要自己建第三张表

　　　　2. 无法使用 . set()、add()、remove()、clear()、create()

　　　　而是通过 models.Author2Book.objects 直接操作第三张表！！！

3. 聚合

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

　　# 求所有书的平均价格

　　models.Book.objects.all().aggregate(avg_price=Avg("price"))  --> 字典{“avg_price”： xx}

 

4. 分组

　　1. SQL语句 分组

 

　　　　# 求部门的平均薪资

　　　　SELECT AVG("salary") FROM employee GROUP BY dept;

 

　　　　# 连表查询

　　　　SELECT dept2.name, AVG(salary) FROM employee2 INNER JOIN dept2 ON employee2.dept_id = dept2.id GROUP 　　　　BY dept_id;

 

　　2. ORM

　　　　# 求部门的平均薪资

　　　　models.Employee.objects.values("dept").annotate(salary_avg=Avg("salary")).values("dept", "salary_avg")

　　　　# 连表查询

　　　　models.Employee2.objects.values("dept__name").annotate(salary_avg=Avg("salary")).values("dept__name", 　　　　"salary_avg")

 

2. 今日内容

1. F查询

　　1. 两个字段之间作比较

　　　　models.Product.objects.filter(maichu__gt=F("kucun"))

　　2. 字符串拼接

　　　　from django.db.models.functions import Concat

　　　　from django.db.models import Value

　　　　models.Product.objects.update(name=Concat(F("name"), Value("新款")))

 

　　2. update修改字段和对象.属性修改字段的区别：

　　　　1. 对象.属性方法会更新所有字段

　　　　2. update方法只会更新你修改的那个字段

    实例

查询评论数大于收藏数的书籍

from django.db.models import F
models.Book.objects.filter(commnet_num__gt=F('keep_num'))

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

models.Book.objects.filter(commnet_num__lt=F('keep_num')*2)

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

models.Book.objects.all().update(price=F("price")+30)

2. Q查询

　　1. 多个查询条件做 交集 并集 取反操作时

　　2. 如果Q查询和关键字查询同时存在时，Q查询要放在关键字查询的前面！！！

　　示例1：

查询作者名是小仙女或小魔女的

models.Book.objects.filter(Q(authors__name="小仙女")|Q(authors__name="小魔女"))

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

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

>>> models.Book.objects.filter(Q(author__name="小仙女") & ~Q(publish_date__year=2018)).values_list("title")
<QuerySet [('番茄物语',)]>

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

例如：查询出版年份是2017或2018，书名中带物语的所有书。

>>> models.Book.objects.filter(Q(publish_date__year=2018) | Q(publish_date__year=2017), title__icontains="物语")
<QuerySet [<Book: 番茄物语>, <Book: 香蕉物语>, <Book: 橘子物语>]>

　　F和Q查询实例

引申：

如果要修改char字段咋办？

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

>>> 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(")")))

 

from django.db.models import F

 

    # models.Product.objects.filter(maichu__gt=10)  # 卖出数大于10

    # 查询出卖出数大于库存数的商品

    # ret = models.Product.objects.filter(maichu__gt=F("kucun"))

    # print(ret)

 

    # 将每个商品的价格提高50块

    # models.Product.objects.update(price=F("price")+50)

 

    # 将所有商品的名称后面加一个 '新款'

    # from django.db.models.functions import Concat

    # from django.db.models import Value

    # models.Product.objects.update(name=Concat(F("name"), Value("新款")))

 

    # 卖出数大于100 并且 价格小于100块的

    # models.Product.objects.filter(maichu__gt=100, price__lt=100)

    # Q查询

    from django.db.models import Q

    # 查询 卖出数大于100 或者 价格小于100块的

    # ret = models.Product.objects.filter(Q(maichu__gt=100)|Q(price__lt=100))

    # print(ret)

 

    # 查询 库存数是100 并且 卖出数不是0 的产品

 

    # ret = models.Product.objects.filter(Q(kucun=100) & ~Q(maichu=0))

    # print(ret)

 

    # 查询产品名包含新款， 并且库存数大于60的

    # ret = models.Product.objects.filter(Q(kucun__gt=60), name__contains="新款")

    # print(ret)

 

4. 事务

1. 什么是事务？

　　数据的原子性、隔离性、持久性、一致性

         实例：

          

2. Django ORM事务

　　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)

# 去产品表 将卖出数+1， 库存数-1 (报错)

# models.Product.objects.get(id=1).update(kucun=F("kucun")-1, maichu=F("maichu")+1)

# 能执行成功

models.Product.objects.filter(id=1).update(kucun=F("kucun")-1, maichu=F("maichu")+1)

except Exception as e:

print€

 # 不开启事务

   # try:

    #     # 创建一条订单数据

    #     models.Order.objects.create(num="110110110", product_id=1, count=1)

    #     # 去产品表 将卖出数+1， 库存数-1

    #     models.Product.objects.get(id=1).update(kucun=F("kucun") - 1, maichu=F("maichu") + 1)

    # except Exception as e:

    #     print(e)

5. 补充（了解有个印象就可）

1. select_related和prefetch_related

　　1. select_related 利用 SQL的JOIN来减少查询数据库的次数

　　适用于一对一和多对一的查询的情况

　　2. prefetch_related 利用 Python 来做类似JOIN操作

2. bulk_create

其他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):
   # 是否有结果

6，random复习

import random

# ["66676869", "69656863", ...]

# ret = []

# for j in range(100):

#     list1 = []

#     for i in range(4):

#         list1.append(str(random.randint(65, 99)))

#     ret.append("".join(list1))

# print(ret)

 

# 列表生成式

ret2 = [ "".join([str(random.randint(65, 99)) for i in range(4)]) for j in range(100)]

print(ret2)

一个python小例子，和orm批量插入（重要重要）

# only

 

    # ret = models.Product.objects.only("id", "name")

    # print(ret)

    import random

    # list1 = []

    # for i in range(4):

    #     list1.append(random.randint(65, 99))

 

    # 批量插入

    # ["66676869", "69656863", ...]

 

 

    data = ["".join([str(random.randint(65, 99)) for i in range(4)]) for j in range(100)]

    # for i in data:

    #     models.A.objects.create(name=i)

 

    obj_list = [models.A(name=i) for i in data]

    # 批量插入

    models.A.objects.bulk_create(obj_list)

 

7. ORM执行原生SQL的方法

1. extra

　　# # 查询书籍名称和出版时间（年月）

　　# ret = models.Book.objects.all().extra(select={"zhangzhao": "DATE_FORMAT(publish_date, '%%Y-%%m')"}).values("title", 　　"zhangzhao")

　　# print(ret)

　　# from django.db.models import Count

# # 将 书籍 按 年月 归档   最后2018-06:2

# ret = models.Book.objects.extra(select={"zhangzhao": "DATE_FORMAT(publish_date, '%%Y-%%m')"}).values("zhangzhao").annotate(num=Count("id")).values("zhangzhao", "num")

# print(ret)

 

2. 类似pymysql方式

from django.db import connection

cursor = connection.cursor()  # cursor = connections['default'].cursor()

cursor.execute("""SELECT * from app01_book where id = %s""", [1])

row = cursor.fetchone()

print(row)

其他：

 

# extra
# 在QuerySet的基础上继续执行子语句
# extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)

# select和select_params是一组，where和params是一组，tables用来设置from哪个表
# 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'])

举个例子：
models.UserInfo.objects.extra(
                    select={'newid':'select count(1) from app01_usertype where id>%s'},
                    select_params=[1,],
                    where = ['age>%s'],
                    params=[18,],
                    order_by=['-age'],
                    tables=['app01_usertype']
                )
                """
                select 
                    app01_userinfo.id,
                    (select count(1) from app01_usertype where id>1) as newid
                from app01_userinfo,app01_usertype
                where 
                    app01_userinfo.age > 18
                order by 
                    app01_userinfo.age desc
                """

# 执行原生SQL
# 更高灵活度的方式执行原生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()

 

3. 作业、任务

1. ORM知识点都整理一下（博客）

2. 上课演示的例子 要自己敲一遍

 

4. 复习

1. MySQL相关？

01. 列举常见的关系型数据库和非关系型都有那些？

02. MySQL常见数据库引擎及比较？

03. 简述数据三大范式？

04. 什么是事务？MySQL如何支持事务？

05. 简述数据库设计中一对多和多对多的应用场景？

06. 如何基于数据库实现商城商品计数器？

07. 简述触发器、函数、视图、存储过程？

08. MySQL索引种类

09. 索引在什么情况下遵循最左前缀的规则？

10. 主键和外键的区别？

11. MySQL常见的函数？

12. 列举 创建索引但是无法命中索引的8种情况。

13. 如何开启慢日志查询？

14. 数据库导入导出命令（结构+数据）？

15. 数据库优化方案？

16. char和varchar的区别？

17. 简述MySQL的执行计划？

18. 在对name做了唯一索引前提下，简述以下区别：

select * from tb where name = ‘Oldboy’

select * from tb where name = ‘Oldboy’ limit 1

 

2. jQuery选择器、样式操作、事件绑定

 

3. Python基础

1. random

2. 列表推导式

3. 装饰器

 答案见下一篇