接着第七章的数据查询
这里写数据‘排除’查询
在SQL语句中是 NOT
这里是
在Q查询前使用~即可
# sql语句：SELECT * FROM index_vocation where not(job='网站设计')
In [4]: from django.db.models import Q
In [5]: v = Vocation.objects.filter(~Q(job='网站设计'))
In [6]: v
Out[6]: <QuerySet [<Vocation: 2>, <Vocation: 5>, <Vocation: 7>, <Vocation: 8>, <Vocation: 11>, <Vocation: 12>]>
In [7]: v[3].job
Out[7]: 'zz'
还可以使用exclude实现不等于查询
In [8]: v = Vocation.objects.exclude(job='网站设计')
In [9]: v
Out[9]: <QuerySet [<Vocation: 2>, <Vocation: 5>, <Vocation: 7>, <Vocation: 8>, <Vocation: 11>, <Vocation: 12>]>
In [10]: v[3].job
Out[10]: 'zz'
使用count方法统计查询数据的数据量
In [12]: v = Vocation.objects.filter(job='网站设计').count()
In [13]: v
Out[13]: 1
去重查询
distinct方法无需设置参数，去重方法根据values设置的字段执行
sql语句：select distinct job from index_vocation where job=''网站设计
In [16]: v = Vocation.objects.values('job').filter(job='网站设计').distinct()
In [17]: v
Out[17]: <QuerySet [{'job': '网站设计'}]>
In [18]: v = Vocation.objects.values('job').filter(job='网站设计')
In [19]: v
Out[19]: <QuerySet [{'job': '网站设计'}]>
更具字段id降序排列，降序只要在order_by里面的字段前面加'-'即可
order_by还可设置多字段排列，在它的参数中传入多个字段即可
In [21]: v = Vocation.objects.order_by('-id')
In [22]: v
Out[22]: <QuerySet [<Vocation: 12>, <Vocation: 11>, <Vocation: 8>, <Vocation: 7>, <Vocation: 5>, <Vocation: 3>, <Vocation: 2>]>
聚合查询(不理解实现)
主要是下方的sum何用;求和，对job进行group by 分组(sql语句，django的实现更简洁)
可参考该资料https://www.cnblogs.com/jingfengling/p/5962182.html
实现对数据值求和，求平均值等。由annotate和aggregate方法实现
annotate类似于SQL里面的GROUP BY方法
如果不设置values，默认对主键进行GROUP BY分组
# sql:select job,sum(id) as 'id_sum' from index_vocation group by job
In [23]: from django.db.models import Sum,Count
In [24]: v = Vocation.objects.values('job').annotate(Sum('id'))
In [25]: print(v.query)
SELECT "index_vocation"."job", SUM("index_vocation"."id") AS "id__sum" FROM "index_vocation" GROUP BY "index_vocation"."job"
aggregate是计算某个字段的值并只返回计算结果
# sql: select count(id) as 'id_count' from index_vocation
In [35]: v = Vocation.objects.aggregate(id_count=Count('id'))
In [36]: v
Out[36]: {'id_count': 7}
In [37]: v['id_count']
Out[37]: 7
union、intersection和difference语法
每次查询结果的字段必须相同，第一次查询为v1,第二次为v2
In [48]: v1 = Vocation.objects.filter(payment=6666)
In [49]: v1
Out[49]: <QuerySet [<Vocation: 2>, <Vocation: 5>]>
In [50]: v2 = Vocation.objects.filter(payment=6667)
In [51]: v2
Out[51]: <QuerySet [<Vocation: 3>, <Vocation: 7>, <Vocation: 8>, <Vocation: 11>, <Vocation: 12>]>
使用sql的union来组合两个或多个查询结果的并集
获取两次查询结果的并集
In [52]: v1.union(v2)
Out[52]: <QuerySet [<Vocation: 2>, <Vocation: 3>, <Vocation: 5>, <Vocation: 7>, <Vocation: 8>, <Vocation: 11>, <Vocation: 12>]>
使用sql的intersect来获取两个或多个查询结果的交集
获取两次查询结果的交集
In [53]: v1.intersection(v2)
Out[53]: <QuerySet []>
使用sql语句的except来获取两个或多个查询结果的差
以v2为共同数据，去除v1和v2的共同数据
In [54]: v2.difference(v1)
Out[54]: <QuerySet [<Vocation: 3>, <Vocation: 7>, <Vocation: 8>, <Vocation: 11>, <Vocation: 12>]>
若想使用不等于，大于等模糊的查询，可以使用如下的匹配符
只要在查询字段的末端使用相应的匹配符，就能实现不同的数据查询方式
匹配符
可作用在filter和get上
__exact 精确等于，如sql的like'xxx'
__iexact 精确等于并忽略大小写
__contains 模糊匹配，如sql的like'%荣耀%'
__icontains 模糊匹配，忽略大小写
__gt 大于
__gte 大于等于
__lt 小于
__lte小于等于
__in 判断是否在列表内
startswith 以...开头
istartwith 以...开头并忽略大小写
__endswith 以...结尾
__iendswith 以...结尾并忽略大小写
__range 在...范围内
__year 日期字段的年份
__month 日期字段的月份
__day 日期字段的天数
__isnull 判断是否为空
查询小于等于payment为6667的数据
In [56]: v2 = Vocation.objects.filter(payment__lte=6667)
In [57]: v2
Out[57]: <QuerySet [<Vocation: 2>, <Vocation: 3>, <Vocation: 5>, <Vocation: 7>, <Vocation: 8>, <Vocation: 11>, <Vocation: 12>]>
多表查询
正向查询
一对多里面的多的外键查询
In [65]: v = Vocation.objects.filter(id=2).first()
In [66]: v
Out[66]: <Vocation: 2>
## 通过外键name去查询模型PersonInfo所对应的数据
In [67]: v.name.hireDate
Out[67]: datetime.date(2018, 9, 18)
反向查询
查询主体是一对多模型中的一，通过一查询到与他关联到的模型多的数据
查询模型PersonInfo某行数据对象p
这里一对多数据库一为 PersonInfo，多为Vocation
In [68]: p = PersonInfo.objects.filter(id=2).first()
In [69]: p
Out[69]: <PersonInfo: Tim>
# 方法一
#vocation_set的返回值为queryset对象，即查询结果
# vocation_set为模型Vocation的名称小写
# 模型Vocation的外键字段name不能设置参数related_name
# 若设置参数related_name,则无法使用vocation_set
In [70]: v= p.vocation_set.first()
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-70-ff74ffcfbda9> in <module>
----> 1 v= p.vocation_set.first()
AttributeError: 'PersonInfo' object has no attribute 'vocation_set'
## 方法二
# 由模型Vocation的外键字段name的参数related_name实现
# 外键字段name必须设置参数related_name才有效，否则无法查询。
# 将外键字段name的参数related_name设为personinfo
In [76]: p = PersonInfo.objects.filter(id=4).first()
In [77]: v= p.personinfo.first()
In [78]: v
Out[78]: <Vocation: 3>
In [79]: v.job
Out[79]: '网站设计'
正向查询和反向查询还可在查询条件(filter,get)里使用,无论是正向查询还是反向查询，他们在数据库里需要执行两次SQL查询，第一次是查询某张数据表的数据，再通过外键关联获取另外一张数据表的数据信息。
为了减少查询次数，提高查询效率，
可以使用select_related或prefetch_related方法实现，该方法只需执行依次SQL查询就能实现多表查询。
select_related方法
执行依次SQL查询就能实现多表查询。
#select_related,针对一对一或一对多，使用sql的join语句进行优化的
通过减少sql查询的次数来进行优化和提高性能
# 以PersonInfo为查询对象
# 使用left outer join方式查询两个数据表
# 查询模型PersonInfo的字段name和模型Vocation的字段payment
# select_related参数为personinfo，代表外键字段name的参数related_name
# 若要得到其他数据表的关联数据，则可用双下划线'__'连接字段名
# 双下划线连接字段名必须是外键字段名或外键字段参数related_name
In [92]: p = PersonInfo.objects.select_related('personinfo').values('name','personinfo__payment')
In [93]: print(p.query)
SELECT "index_personinfo"."name", "index_vocation"."payment" FROM "index_personinfo" LEFT OUTER JOIN "index_vocation" ON ("index_personinfo"."id" = "index_vocation"."name_id")
# 可以看下p的类型
In [94]: p = PersonInfo.objects.select_related('personinfo')
In [95]: print(type(p))
<class 'django.db.models.query.QuerySet'>
In [96]: p.values('name','personinfo__payment') # 参数一为一中的此段，参数二为多中的字段，要加双下划线(一对多数据库)
Out[96]: <QuerySet [{'name': 'Lucy', 'personinfo__payment': 6666}, {'name': 'Tim', 'personinfo__payment': None}, {'name': 'Mary', 'personinfo__payment': 6667}, {'name': 'Mary', 'personinfo__payment': 6667}, {'name': 'Mary', 'personinfo__payment': 6667}, {'name': 'Mary', 'personinfo__payment': 6667}, {'name': 'Mary', 'personinfo__payment': 6667}, {'name': 'Tony', 'personinfo__payment': 6666}]>
以模型Vocation为查询对象
select_related使用INNER JOIN 方式查询两个数据表
select_related的参数为name,代表外键字段name
In [98]: v = Vocation.objects.select_related('name').values('name','name__age')
In [99]: v
Out[99]: <QuerySet [{'name': 1, 'name__age': 20}, {'name': 4, 'name__age': 24}, {'name': 4, 'name__age': 24}, {'name': 4, 'name__age': 24}, {'name': 4, 'name__age': 24}, {'name': 4, 'name__age': 24}, {'name': 5, 'name__age': 25}]>
In [101]: print(v.query)
SELECT "index_vocation"."name_id", "index_personinfo"."age" FROM "index_vocation" INNER JOIN "index_personinfo" ON ("index_vocation"."name_id" = "index_personinfo"."id")
select_related还支持3个或3个以上的数据表同时查询
就是通关外键两两关联
这样的查询都是通过一张表的数据，查询另外一张表的数据
本例中的模型关系，模型Person通过外键living关联模型City，模型City通过外键province关联模型Province，从而使3个模型形成一种递进关系。
下方的参数说明：
···
living是模型Person的外键字段，该字段指向模型City
province是模型City的外键字段，该字段指向模型Province
···
In [107]: P = Person.objects.select_related('living__province').get(name='Lucy')
In [108]: P.living.province
Out[108]: <Province: 浙江省>
prefetch_related
是分别查询每张数据表，然后由python语法来处理他们之间的关系，对于多对多查询，prefetch_related更有优势
而select_related是由SQL语句的join实现的，使用会增加数据查询时间和内存占用。
本例是创建两个模型分别为performer和program,这里面分别添加人员信息和节目信息，然后设置两表为多对多就会生成一张多对多字段的表，该表名字是设置多对多的那张表名_多对多的外键字段名(_是连接两个字段名)，该表的字段如何设置不清楚；是用他们的主键做关联，数据好像也要自己插入
代码如下，不知为何打印出所有的数据
这应该想要的是查询喜洋洋扮演演员有多少个把,这里查询出来了，performer所对应的是演员人名，再多对多表中program为节目名称，program_id与performer_id一一对应，这里只取了喜洋洋的id1对应了以他performer表的所有id
# 查询模型Program的某行数据
In [109]: p = Program.objects.prefetch_related('performer').filter(name='喜洋洋').first()
# 根据外键字段performer获取当前数据的多对多多线
In [110]: p.performer.all()
Out[110]: <QuerySet [<Performer: Lily>, <Performer: Lilei>, <Performer: Tom>, <Performer: Hanmei>]>
In [111]: p
Out[111]: <Program: 喜洋洋>
In [112]: p.performer
Out[112]: <django.db.models.fields.related_descriptors.create_forward_many_to_many_manager.<locals>.ManyRelatedManager at 0x1d2ad52ca20>
In [113]: p.performer.first()
Out[113]: <Performer: Lily>
多对多的表在数据库中查找不出来
NameError: name 'people_name_many_to_many' is not defined
第七章剩余部分
extraSQL语句的执行方法
源码位置:django/db/models/query.py
适用于ORM难以实现的查询条件，将查询条件使用原生SQL语法实现，此方法需要模型对象，在某种程度上可防止SQL注入。
该字段共有6个参数
order_by:设置数据的排序方式
where设置查询条件
params为where提供数值(where设置了字符串格式化%s)
select 新增查询字段
select_params为select的%s提供数值
table 连接其他数据表，可实现多表查询
where和params参数的使用
# where设置查询条件，params为where提供数值(where设置了字符串格式化%s)
In [3]: Vocation.objects.extra(where=['job=%s'],params=['网站设计'])
Out[3]: <QuerySet [<Vocation: 3>]>
select,select_params
# 新增查询字段select,select_params为select的%s提供数值
In [5]: v = Vocation.objects.extra(select={'seat':'%s'},select_params=['seatInfo'])
In [6]: print(v.query)
SELECT (seatInfo) AS "seat", "index_vocation"."id", "index_vocation"."job", "index_vocation"."title", "index_vocation"."payment", "index_vocation"."name_id" FROM "index_vocation"
tables连接其他数据表，可实现多表查询
# 连接其他数据表
In [7]: v = Vocation.objects.extra(tables=['index_personinfo'])
In [8]: print(v.query)
SELECT "index_vocation"."id", "index_vocation"."job", "index_vocation"."title", "index_vocation"."payment", "index_vocation"."name_id" FROM "index_vocation" , "index_personinfo"
raw的功能和extra相同，实现数据库查询
raw源码位置在:django/db/models/query.py
字段参数
raw_quert是必选参数，sql语句
parames:如果raw_quert设置字符串格式化%s，那么该参数为raw_quert提供值
translations:为查询的字段设置别名
using:数据库对象，即Django所连接的数据库
raw_query
raw_quert是必选参数，sql语句
In [9]: v = Vocation.objects.raw('select * from index_vocation')
In [10]: v[0]
Out[10]: <Vocation: 2>
execute语法
它执行sql语句无需经过Django的ORM框架，他连接数据库类似于使用第三方模块mysqlclient，可通过游标的方式来执行sql语句
# 导入连接的模块
In [25]: from django.db import connection
# 产生游标
In [26]: cursor = connection.cursor()
# 执行sql语句
In [27]: cursor.execute('select * from index_vocation')
Out[27]: <django.db.backends.sqlite3.base.SQLiteCursorWrapper at 0x13607385dc8>
# 读取第一行数据
In [28]: cursor.fetchone()
Out[28]: (2, '文员', '前台文员', 6666, 1)
# 读取全部数据
In [29]: cursor.fetchall()
Out[29]:
[(3, '网站设计', '前端开发', 6667, 4),
(5, '项目经理', '项目负责人', 6666, 5),
(7, 'jj', 'hh', 6667, 4),
(8, 'zz', 'java', 6667, 4),
(11, 'aa1', 'ss1', 6667, 4),
(12, 'aa2', 'ss2', 6667, 4)]
execute能够执行所有的sql语句，但很容易受到sql注入攻击，一般不建议使用该方法实现数据操作。
数据库事务
django的事务定义在transaction.py文件中。
该文件定义了两个类和16个函数方法
开发中常用的函数方法如下：
atomic() :在视图函数视图类中使用事务
savepoint():开启事务
savepoint_rollback():回滚事务
savepoint_commit()：提交事务
实例views.py
from django.shortcuts import render
from .models import *
from django.db import transaction
from django.db.models import F
@transaction.atomic # 使函数支持事务操作
def index(request):
# 开启事务保护
sid = transaction.savepoint()
try:
id = request.GET.get('id', '') # ?/id=xxx，这样就可以在url中传入参数了
if id:
v = Vocation.objects.filter(id=id) # 提取Url中输入的id
v.update(payment=F('payment') + 1) # 更新payment加1
print('Done') # 执行语句在控制台会输出啊
# 提交事务
# 如不设置，当程序执行完成后，会自动提交事务
# transaction.savepoint_commit(sid)
else:
# 全表的payment字段自减1
Vocation.objects.update(payment=F('payment') - 1)
# 事务回滚，将全表payment字段自减1的操作撤回
transaction.savepoint_rollback(sid)
except Exception as e:
# 事务回滚
transaction.savepoint_rollback(sid)
return render(request, 'index.html', locals())
使用with模块实现事务操作
除了使用装饰器@transaction.atomic外
还可以使用with模块实现事务操作
def index(request):
# 开启事务保护
# sid = transaction.savepoint()
with transaction.atomic():
sid = transaction.savepoint()
....
当网站的数据量越来越庞大时，使用单个数据库处理很容易使数据库系统瘫痪，从而导致整个网站瘫痪。
为了减轻数据库系统的压力，django可以同时连接和使用多个数据库。
项目同时配置两个mysql数据库
两个mysql数据库名分别为db1,db2
# 配置多数据库
# 新增dbRouter.py文件编写类DbAppsRouter
DATABASE_ROUTERS = ['MyDjango.dbRouter.DbAppsRouter']
DATABASE_APPS_MAPPING = { # 设置数据库与项目应用的映射关系
# 设置每个App的模型使用的数据库
# {'app_name':'database_name',}
'admin': 'defualt',
'index': 'db1', # 代表index的models.py所定义的模型都在数据库db1里创建数据表
'user': 'db2',
}
多个数据库实现需要编写的配置文件，貌似什么都不用更改，只需要在settings.py中配置正确即可
from django.conf import settings
DATABASE_MAPPING = settings.DATABASE_APPS_MAPPING # 从配置文件获取DATABASE_APPS_MAPPING的值
class DbAppsRouter(object):
"""
A router to control all database operations on models for different
databases.
In case an app is not set in settings.DATABASE_APPS_MAPPING, the router
will fallback to the `default` database.
Settings example:
DATABASE_APPS_MAPPING = {'app1': 'db1', 'app2': 'db2'}
类DbAppsRouter根据变量DATABASE_MAPPING(数据库与项目的映射关系)来设置数据库的
读取(类方法 db_for_read)、写入(类方法 db_for_write)、数据表关系(类方法 allow_relation)和数据迁移(类方法 allow_migrate)
"""
def db_for_read(self, model, **hints): # 读取
""""Point all read operations to the specific database."""
if model._meta.app_label in DATABASE_MAPPING:
return DATABASE_MAPPING[model._meta.app_label]
return None
def db_for_write(self, model, **hints): # 写入
"""Point all write operations to the specific database."""
if model._meta.app_label in DATABASE_MAPPING:
return DATABASE_MAPPING[model._meta.app_label]
return None
def allow_relation(self, obj1, obj2, **hints): #数据表关系
"""Allow any relation between apps that use the same database."""
db_obj1 = DATABASE_MAPPING.get(obj1._meta.app_label)
db_obj2 = DATABASE_MAPPING.get(obj2._meta.app_label)
if db_obj1 and db_obj2:
if db_obj1 == db_obj2:
return True
else:
return False
return None
# 用于创建数据表
def allow_migrate(self, db, app_label, model_name=None, **hints): # 数据迁移
if db in DATABASE_MAPPING.values():
return DATABASE_MAPPING.get(app_label) == db
elif app_label in DATABASE_MAPPING:
return False
return None
两个不同的数据库中无法建立数据表关系(一对多等关系)，
这样并不能创建mysql数据库，这样python manage.py migrate语句只在Sqlite3数据库里床火箭DJango内置功能的数据表。若要为多个mysql数据库设定指定数据表，需要在migrate指令中设置参数
--database==数据库名
python manage.py migrate s --database==数据库名
但我执行这个报错，我去
django.db.utils.ConnectionDoesNotExist: The connection =db2 doesn't exist
笔记来源：Django Web应用开发实战