查询集
查询集表示从数据库中获取的对象集合，在管理器上调用某些过滤器方法会返回查询集，查询集可以含有零个、一个或多个过滤器。过滤器基于所给的参数限制查询的结果，从Sql的角度，查询集和select语句等价，过滤器像where和limit子句。
过滤器
返回查询集的过滤器如下：
# all()：返回所有数据。
list = BookInfo.objects.all()
# filter()：返回满足条件的数据。
list = BookInfo.objects.filter(id__gt=2)
# exclude()：返回满足条件之外的数据，相当于sql语句中where部分的not关键字。
list = BookInfo.objects.exclude(id=1)
# order_by()：对结果进行排序。
list = BookInfo.objects.all().order_by()
返回单个值的过滤器如下:
get()：返回单个满足条件的对象
如果未找到会引发"模型类.DoesNotExist"异常。
如果多条被返回，会引发"模型类.MultipleObjectsReturned"异常。
count()：返回当前查询结果的总条数。
aggregate()：聚合，返回一个字典。
判断某一个查询集中是否有数据:
exists()：判断查询集中是否有数据，如果有则返回True，没有则返回False。
两大特性
- (1) 惰性执行：创建查询集不会访问数据库，直到调用数据时，才会访问数据库，调用数据的情况包括迭代、序列化、与if合用。
- (2) 缓存：使用同一个查询集，第一次使用时会发生数据库的查询，然后把结果缓存下来，再次使用这个查询集时会使用缓存的数据。
我们在应用查询集时有两种状态,下面是两个查询集，无法重用缓存,每次查询都会与数据库进行一次交互，增加了数据库的负载。
from booktest.models import BookInfo
# 建立一个查询集，与数据库发生一次交互
[book.id for book in BookInfo.objects.all()]
# 再次新建一个查询集，再次与数据库发生交互
[book.id for book in BookInfo.objects.all()]
下面是经过存储后，可以重用查询集，第二次使用缓存中的数据。
# 创建一个查询集
list = BookInfo.objects.all()
# 执行查询集
[book.id for book in list]
# 复用以前的查询集，不会去数据库中在此执行，实际应用的是缓存内数据
[book.id for book in list]
限制查询集
可以对查询集进行取下标或切片操作，等同于sql中的limit和offset子句。
-
注意：
1.不支持负数索引。
2.对查询集进行切片后返回一个新的查询集，不会立即执行查询。
3.如果获取一个对象，直接使用[0]，等同于[0:1].get()，但是如果没有数据，[0]引发 IndexError异常，[0:1].get()如果没有数据引发does not exist异常。
如果获取一个对象，可以直接使用对象[0]，等同于[0:1].get()，但是如果没有数据，[0]引发IndexError异常，[0:1].get()如果没有数据引发DoesNotExist异常。
>>> books = BookInfo.objects.filter(id__lte=3)
>>> books
[<BookInfo: BookInfo object>, <BookInfo: BookInfo object>, <BookInfo: BookInfo object>]
>>> books2 = books[:2] # 切片会返回新的对象
>>> books2
[<BookInfo: BookInfo object>, <BookInfo: BookInfo object>]
>>> books3 = books[0:1]
>>> books3
[<BookInfo: BookInfo object>]
>>> books4 = books[0:0]
>>> books4
[]
>>> books4[0]
# 上面会引发IndexError异常。
>>> books4[0:0].get()
# 上面会引发DoesNotExist异常。
>>> books4.exists()
False
>>> books3.exists()
True
模型类关系
关系型数据库的关系包括三种类型：
-
一对多关系
ForeignKey：将字段定义在多的一端中。
例：图书类-英雄类
#定义图书模型类BookInfo
class BookInfo(models.Model):
btitle = models.CharField(max_length=20)#书名
bpub_date = models.DateField()#发布日期
bread = models.IntegerField(default=0)#阅读量
bcomment = models.IntegerField(default=0)#评论量
isDelete = models.BooleanField(default=False)#逻辑删除
#定义英雄模型类HeroInfo
class HeroInfo(models.Model):
hname = models.CharField(max_length=20)#姓名
hgender = models.BooleanField(default=True)#性别
isDelete = models.BooleanField(default=False)#逻辑删除
hcomment = models.CharField(max_length=200)#描述信息
hbook = models.ForeignKey('BookInfo')
#英雄与图书表的关系为一对多，所以属性定义在英雄模型类中
-
多对多关系
ManyToManyField：将字段定义在任意一端中。
例：新闻类-新闻类型类 体育新闻 国际新闻
class TypeInfo(models.Model):
tname = models.CharField(max_length=20) #新闻类别
class NewsInfo(models.Model):
ntitle = models.CharField(max_length=60) #新闻标题
ncontent = models.TextField() #新闻内容
npub_date = models.DateTimeField(auto_now_add=True) #新闻发布时间
ntype = models.ManyToManyField('TypeInfo')
#通过ManyToManyField建立TypeInfo类和NewsInfo类之间多对多的关系
-
一对一关系
OneToOneField：将字段定义在任意一端中。
例：员工基本信息类-员工详细信息类. 员工工号
class EmployeeBasicInfo(models.Model):
name = models.CharField(max_length=20)# 姓名
gender = models.BooleanField(default=False)# 性别
age = models.IntegerField()# 年龄
employee_detail = models.OneToOneField('EmployeeDetailInfo')# 关系属性
# 员工详细信息类
class EmployeeDetailInfo(models.Model):
addr = models.CharField(max_length=256) #地址
关联查询
一对多关联查询
- 由一到多的访问语法：
一对应的模型类对象.多对应的模型类名小写_set
例：查询id为1的图书关联的英雄信息
b = BookInfo.objects.get(id=1)
b.heroinfo_set.all()
- 由多到一的访问语法:
多对应的模型类对象.多对应的模型类中的关系类属性名
例：查询id为1的英雄 所属的 图书信息
h = HeroInfo.objects.get(id=1)
h.hbook
通过模型类执行关联查询
由多模型类条件查询一模型类数据:
语法如下：
关联模型类名小写属性名条件运算符=值
如果没有"__运算符"部分，表示等于，结果和sql中的inner join相同。
例：查询图书，要求图书中英雄的描述包含'八'。
BookInfo.objects.filter(heroinfo__hcontent__contains='八')
由一模型类条件查询多模型类数据: 语法如下：
一模型类关联属性名一模型类属性名条件运算符=值
例：查询书名为“天龙八部”的所有英雄。
HeroInfo.objects.filter(hbook__btitle='天龙八部')
例题
- 查询性别为男的英雄
heros = HeroInfo.objects.filter(hgender=True)
[hero.hname for hero in heros]
- 查询姓黄的男性英雄
from django.db.models import Q
heros = HeroInfo.objects.filter(Q(hname__contains='黄')&Q(hgender=True)
[hero.hname for hero in heros]
- 查询图书名为“天龙八部”的英雄
heros = HeroInfo.objects.filter(hbook__btitle='天龙八部')
[hero.hname for hero in heros]
- 查询编号小于5或性别为女的英雄
from django.db.models import Q
heros = HeroInfo.objects.filter(Q(id__lt=5)|Q(hgender=False))
[hero.name for hero in heros]
- 查询女生总人数
HeroInfo.objects.filter(hgender=False).count()
自关联
对于地区信息、分类信息等数据，表结构非常类似，每个表的数据量十分有限，为了充分利用数据表的大量数据存储功能，可以设计成一张表，内部的关系字段指向本表的主键，这就是自关联的表结构。
- 关系属性使用self指向本类，要求null和blank允许为空，因为一级数据是没有父级的
打开booktest/models.py文件，定义AreaInfo类。
#定义地区模型类，存储省、市、区县信息
class AreaInfo(models.Model):
atitle=models.CharField(max_length=30)#名称
aParent=models.ForeignKey('self',null=True,blank=True)#关系
迁移。
python manage.py makemigrations
python manage.py migrate
打开mysql命令行，导入数据。打开booktest/views.py文件，定义视图area和它的下级地区。
def area(request):
area = AreaInfo.objects.filter(aParent__isnull=True)
return render(request,'area/index.html',{'area':area})
def larea(request,bid):
areas = AreaInfo.objects.filter(aParent_id=int(bid))
aname = AreaInfo.objects.get(id=int(bid))
return render(request,'area/index2.html',{'areas':areas,'aname':aname})
打开booktest/urls.py文件，新建url。
urlpatterns = [
url(r'^$',views.area ),
url(r'^(\d+)$',views.larea)
]
在templates/booktest目录下，新建index.html文件和index2.html文件。
index.html
<html>
<head>
<title>地区</title>
</head>
<body>
<ul>
{%for a in area%}
<li><a href="{{ a.id }}">{{a.atitle}}</a></li>
{%endfor%}
</ul>
</body>
</html>
index2.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title></title>
</head>
<body>
<h1>上级地区:{{ aname.aParent.atitle }}</h1>
<br>
<hr>
<h2>当前地区:{{ aname.atitle }}</h2>
<br>
<hr>
<ul>
{% for area in areas %}
<li><a href="{{ area.id }}">{{ area.atitle }}</a> </li>
{% endfor %}
</ul>
</body>
</html>
