一 创建模型
实例：我们来假定下面这些概念，字段和关系
作者模型：一个作者有姓名和年龄。
作者详细模型：把作者的详情放到详情表，包含生日，手机号，家庭住址等信息。作者详情模型和作者模型之间是一对一的关系（one-to-one）
出版商模型：出版商有名称，所在城市以及email。
书籍模型： 书籍有书名和出版日期，一本书可能会有多个作者，一个作者也可以写多本书，所以作者和书籍的关系就是多对多的关联关系(many-to-many);一本书只应该由一个出版商出版，所以出版商和书籍是一对多关联关系(one-to-many)。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
|
Book
id title price publish
1 php 100 人民出版社
2 python 200 老男孩出版社
3 go 100 人民出版社
4 java 300 人民出版社
为了存储出版社的邮箱，地址，在第一个表后面加字段
Book
id title price publish email addr
1 php 100 人民出版社 111 北京
2 python 200 老男孩出版社 222 上海
3 go 100 人民出版社 111 北京
4 java 300 人民出版社 111 北京
这样会有大量重复的数据，浪费空间
一对多：一个出版社对应多本书（关联信息建在多的一方，也就是book表中）
Book
id title price publish_id
1 php 100 1
2 python 200 1
3 go 100 2
4 java 300 1
Publish
id name email addr
1 人民出版社 111 北京
2 沙河出版社 222 沙河
总结：一旦确定表关系是一对多：在多对应的表中创建关联字段（在多的表里创建关联字段） ，publish_id
查询python这本书的出版社的邮箱(子查询)
select publish_id from Book where title=“python”
select email from Publish where id=1
多对多：一本书有多个作者，一个作者出多本书
Book
id title price publish_id
1 php 100 1
2 python 200 1
3 go 100 2
4 java 300 1
Author
id name age addr
1 alex 34 beijing
2 egon 55 nanjing
Book2Author
id book_id author_id
1 2 1
2 2 2
3 3 2
总结：一旦确定表关系是多对多：创建第三张关系表（创建中间表，中间表就三个字段，自己的id，书籍id和作者id） ：
id book_id author_id
|
注意：关联字段与外键约束没有必然的联系（建管理字段是为了进行查询，建约束是为了不出现脏数据）
在Models创建如下模型
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
classBook(models.Model):
nid = models.AutoField(primary_key=True)
name = models.CharField(max_length=32)
price = models.DecimalField(max_digits=5, decimal_places=2)
publish_date = models.DateField()
|
生成的表如下：
注意事项：
- 表的名称
myapp_modelName，是根据 模型中的元数据自动生成的，也可以覆写为别的名称
id 字段是自动添加的- 对于外键字段，Django 会在字段名上添加
"_id" 来创建数据库中的列名
- 这个例子中的
CREATE TABLE SQL 语句使用PostgreSQL 语法格式，要注意的是Django 会根据settings 中指定的数据库类型来使用相应的SQL 语句。
- 定义好模型之后，你需要告诉Django _使用_这些模型。你要做的就是修改配置文件中的INSTALL_APPSZ中设置，在其中添加
models.py所在应用的名称。
- 外键字段 ForeignKey 有一个 null=True 的设置(它允许外键接受空值 NULL)，你可以赋给它空值 None 。
二 添加表记录
一对多的
1
2
3
4
5
6
|
方式1:
publish_obj=Publish.objects.get(nid=1)
book_obj=Book.objects.create(title="",publishDate="2012-12-12",price=100,publish=publish_obj)
方式2:
book_obj=Book.objects.create(title="",publishDate="2012-12-12",price=100,publish_id=1)
|
核心：book_obj.publish与book_obj.publish_id是什么？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
关键点:
一 book_obj.publish=Publish.objects.filter(id=book_obj.publish_id).first()
二 book_obj.authors.all()
关键点:book.authors.all() # 与这本书关联的作者集合
1 book.id=3
2 book_authors
id book_id author_ID
3 3 1
4 3 2
3 author
id name
1 lqz
2 egon
book_obj.authors.all() -------> [lqz,egon]
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
pub=Publish.objects.create(name='egon出版社',email='445676@qq.com',city='山东')
print(pub)
|
多对多
1
2
3
4
5
6
7
8
|
book_obj=Book.objects.create(title="追风筝的人",price=200,publishDate="2012-11-12",publish_id=1)
yuan=Author.objects.filter(name="yuan").first()
egon=Author.objects.filter(name="alex").first()
book_obj.authors.add(yuan,egon)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
book = Book.objects.filter(name='红楼梦').first()
egon=Author.objects.filter(name='egon').first()
lqz=Author.objects.filter(name='lqz').first()
book.authors.add(lqz,egon)
book.authors.add(1,3)
book.authors.add(*[1,2])
book = Book.objects.filter(name='红楼梦').first()
book.authors.remove(1)
egon = Author.objects.filter(name='egon').first()
book.authors.remove(egon)
book.authors.remove(*[1,2])
book.authors.clear()
ret=book.authors.all()
ret=book.authors.all().values('name')
print(ret)
|
核心:book_obj.authors.all()是什么？
多对多关系其它常用API：
1
2
3
|
book_obj.authors.remove()
book_obj.authors.clear()
book_obj.authors.set()
|
三 基于对象的跨表查询
一对多查询（publish与book）
正向查询（按字段：publish）
1
2
3
4
|
book_obj=Book.objects.filter(pk=1).first()
|
反向查询（按表名：book_set）
1
2
3
4
5
|
publish=Publish.objects.get(name="苹果出版社")
|
1
2
3
4
5
6
7
8
9
|
book=Book.objects.filter(name='红楼梦').first()
print(book.publish)
|
一对一查询（Author 与 AuthorDetail）
正向查询(按字段：authorDetail)：
1
2
|
egon=Author.objects.filter(name="egon").first()
print(egon.authorDetail.telephone)
|
反向查询(按表名：author)：
1
2
3
4
5
|
authorDetail_list=AuthorDetail.objects.filter(addr="beijing")
for obj in authorDetail_list:
print(obj.author.name)
|
多对多查询 (Author 与 Book)
正向查询(按字段：authors)：
1
2
3
4
5
6
|
book_obj=Book.objects.filter(title="眉").first()
authors=book_obj.authors.all()
for author_obj in authors:
print(author_obj.name,author_obj.authorDetail.telephone)
|
反向查询(按表名：book_set)：
1
2
3
4
5
|
author_obj=Author.objects.get(name="egon")
book_list=author_obj.book_set.all()
|
1
2
3
4
5
6
7
8
9
10
|
book=Book.objects.filter(name='红楼梦').first()
ret=book.authors.all()
print(ret)
for auth in ret:
print(auth.name)
|
注意：
你可以通过在 ForeignKey() 和ManyToManyField的定义中设置 related_name 的值来覆写 FOO_set 的名称。例如，如果 Article model 中做一下更改：
1
|
publish = ForeignKey(Book, related_name='bookList')
|
那么接下来就会如我们看到这般:
1
2
3
4
|
publish=Publish.objects.get(name="人民出版社")
book_list=publish.bookList.all()
|
四 基于双下划线的跨表查询
Django 还提供了一种直观而高效的方式在查询(lookups)中表示关联关系，它能自动确认 SQL JOIN 联系。要做跨关系查询，就使用两个下划线来链接模型(model)间关联字段的名称，直到最终链接到你想要的model 为止。
1
2
3
|
'''
正向查询按字段,反向查询按表名小写用来告诉ORM引擎join哪张表
'''
|
一对多查询
1
2
3
4
5
6
7
8
9
|
queryResult=Book.objects.filter(publish__name="苹果出版社").values_list("title","price")
queryResult=Publish.objects.filter(name="苹果出版社").values_list("book__title","book__price")
查询的本质一样，就是select from的表不一样
|
多对多查询
1
2
3
4
5
6
7
|
queryResult=Book.objects.filter(authors__name="lqz").values_list("title")
queryResult=Author.objects.filter(name="lqz").values_list("book__title","book__price")
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
|
一对一查询
1
2
3
4
5
6
7
|
ret=Author.objects.filter(name="lqz").values("authordetail__telephone")
ret=AuthorDetail.objects.filter(author__name="lqz").values("telephone")
|
进阶练习(连续跨表)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
queryResult=Book.objects.filter(publish__name="人民出版社").values_list("title","authors__name")
queryResult=Publish.objects.filter(name="人民出版社").values_list("book__title","book__authors__age","book__authors__name")
queryResult=Book.objects.filter(authors__authorDetail__telephone__regex="151").values_list("title","publish__name")
ret=Author.objects.filter(authordetail__telephone__startswith="151").values("book__title","book__publish__name")
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
|
1
|
publish = ForeignKey(Blog, related_name='bookList')
|
1
2
3
|
queryResult=Publish.objects.filter(name="人民出版社").values_list("bookList__title","bookList__price")
|
反向查询时，如果定义了related_name ，则用related_name替换表名
五 聚合查询与分组查询
聚合
aggregate(args, *kwargs)
1
2
3
4
|
from django.db.models import Avg
Book.objects.all().aggregate(Avg('price'))
|
aggregate()是QuerySet 的一个终止子句，意思是说，它返回一个包含一些键值对的字典。键的名称是聚合值的标识符，值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的。如果你想要为聚合值指定一个名称，可以向聚合子句提供它。
1
2
|
Book.objects.aggregate(average_price=Avg('price'))
|
如果你希望生成不止一个聚合，你可以向aggregate()子句中添加另一个参数。所以，如果你也想知道所有图书价格的最大值和最小值，可以这样查询：
1
2
3
|
from django.db.models import Avg, Max, Min
Book.objects.aggregate(Avg('price'), Max('price'), Min('price'))
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
from django.db.models import Avg,Count,Max,Min
ret=Book.objects.all().aggregate(Avg('price'))
|
分组
annotate()为调用的QuerySet中每一个对象都生成一个独立的统计值（统计方法用聚合函数）。
总结 ：跨表分组查询本质就是将关联表join成一张表，再按单表的思路进行分组查询。
查询练习
练习：统计每一本书作者个数
1
2
3
4
5
6
7
|
from django.db.models import Avg, Max, Sum, Min, Max, Count
book_list = models.Book.objects.all().annotate(author_num=Count("authors"))
for book in book_list:
print(book.name)
print(book.author_num)
book_list = models.Book.objects.all().annotate(author_num=Count("authors")).values('name','author_num')
print(book_list)
|
练习：统计每一个出版社的最便宜的书
1
2
3
|
publishList=Publish.objects.annotate(MinPrice=Min("book__price"))
for publish_obj in publishList:
print(publish_obj.name,publish_obj.MinPrice)
|
annotate的返回值是querySet，如果不想遍历对象，可以用上valuelist：
1
2
|
queryResult= Publish.objects.annotate(MinPrice=Min("book__price")).values_list("name","MinPrice")
print(queryResult)
|
练习：统计每一本以py开头的书籍的作者个数：
1
|
queryResult=Book.objects.filter(title__startswith="Py").annotate(num_authors=Count('authors'))
|
练习：统计不止一个作者的图书：（作者数量大于一）
1
2
|
ret=models.Book.objects.annotate(author_num=Count("authors")).filter(author_num__gt=1).values('name','author_num')
print(ret)
|
练习：根据一本图书作者数量的多少对查询集 QuerySet进行排序:
1
|
Book.objects.annotate(num_authors=Count('authors')).order_by('num_authors')
|
练习：查询各个作者出的书的总价格:
1
2
|
ret=models.Author.objects.annotate(sum_price=Sum("book__price")).values("name", "sum_price")
print(ret)
|
练习：查询每个出版社的名称和书籍个数
1
2
|
ret=models.Publish.objects.all().annotate(c=Count('book__name')).values('name','c')
print(ret)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
|
'''
查询每一个部门名称以及对应的员工数
book:
id name price publish
1 金品 11.2 1
2 西游 14.2 2
3 东游 16.2 2
4 北邮 19.2 3
'''
|
总计：
# annotate() 内写聚合函数
# values在前表示group by的字段
# values在后表示取某几个字段
# filter在前表示where
# filter在后表示having
View Code
六 F查询与Q查询
F查询
在上面所有的例子中，我们构造的过滤器都只是将字段值与某个常量做比较。如果我们要对两个字段的值做比较，那该怎么做呢？
Django 提供 F() 来做这样的比较。F() 的实例可以在查询中引用字段，来比较同一个 model 实例中两个不同字段的值。
1
2
3
|
# 查询评论数大于收藏数的书籍
from django.db.models import F
Book.objects.filter(commnetNum__lt=F('keepNum'))
|
Django 支持 F() 对象之间以及 F() 对象和常数之间的加减乘除和取模的操作。
1
2
|
Book.objects.filter(commnetNum__lt=F('keepNum')*2)
|
修改操作也可以使用F函数,比如将每一本书的价格提高30元：
1
|
Book.objects.all().update(price=F("price")+30)
|
Q查询
filter() 等方法中的关键字参数查询都是一起进行“AND” 的。 如果你需要执行更复杂的查询（例如OR 语句），你可以使用Q 对象。
1
2
|
from django.db.models import Q
Q(title__startswith='Py')
|
Q 对象可以使用& 和| 操作符组合起来。当一个操作符在两个Q 对象上使用时，它产生一个新的Q 对象。
1
|
bookList=Book.objects.filter(Q(authors__name="lqz")|Q(authors__name="egon"))
|
等同于下面的SQL WHERE 子句：
1
|
WHERE name ="lqz" OR name ="egon"
|
你可以组合& 和| 操作符以及使用括号进行分组来编写任意复杂的Q 对象。同时，Q 对象可以使用~ 操作符取反，这允许组合正常的查询和取反(NOT) 查询：
查询函数可以混合使用Q 对象和关键字参数。所有提供给查询函数的参数（关键字参数或Q 对象）都将”AND”在一起。但是，如果出现Q 对象，它必须位于所有关键字参数的前面。例如：
1
|
bookList=Book.objects.filter(Q(publishDate__year=2016) | Q(publishDate__year=2017), title__icontains="python")
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
from django.db.models import F,Q
|
# defer和only(查询优化相关)
# only保持是book对象，但是只能使用only指定的字段
# books = models.Book.objects.all().only('name')
# print(books[0].name)
# print(books[0].price) # 能出来，
# books = models.Book.objects.all().only('name')
#
# print(books[0].__dict__)
books = models.Book.objects.all().defer('name','price')
print(books[0].__dict__)
defer和only
# 事物：ACID，事物的隔离级别（搜），锁， 行级锁，表级锁
# djanog orm中使用事物：原子性操作，要么都成功，要么都失败
# 新增一个作者详情，新增一个作者
# 事物的三个粒度
# 1 局部使用
from django.db import transaction
with transaction.atomic(): # 都在事物中，要么都成功，要么都失败
author_detail=models.AuthorDetail.objects.create(addr='xxx',phone='123',sex=1)
# raise Exception('抛了异常')
author=models.Author.objects.create(name='llqz',age=19,author_detail=author_detail)
# 2 视图函数装饰器,这一个视图函数都在一个事物中
# @transaction.atomic
# def index(request):
# return HttpResponse('ok')
# 3 整个http请求，在事物中，在setting.py中配置
'''
DATABASES = {
'default': {
...
'PORT': 3306,
'ATOMIC_REQUEST': True,
}
}
'ATOMIC_REQUEST': True,
设置为True统一个http请求对应的所有sql都放在一个事务中执行（要么所有都成功，要么所有都失败）。
'''
事务（请求，装饰器，局部）
七 查询练习
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
查找所有书名里包含红楼的书
查找出版日期是2017年的书
查找出版日期是2017年的书名
查找价格大于10元的书
查找价格大于10元的书名和价格
查找在北京的出版社
查找名字以沙河开头的出版社
查找作者名字里面带“小”字的作者
查找年龄大于30岁的作者
查找手机号是155开头的作者
查找手机号是155开头的作者的姓名和年龄
查找书名是“红楼梦”的书的出版社
查找书名是“红楼梦”的书的出版社所在的城市
查找书名是“红楼梦”的书的出版社的名称
查找书名是“红楼梦”的书的所有作者
查找书名是“红楼梦”的书的作者的年龄
查找书名是“红楼梦”的书的作者的手机号码
查找书名是“红楼梦”的书的作者的地址
查找书名是“红楼梦”的书的作者的邮箱
|
每天逼着自己写点东西，终有一天会为自己的变化感动的。这是一个潜移默化的过程，每天坚持编编故事，自己不知不觉就会拥有故事人物的特质的。 Explicit is better than implicit.(清楚优于含糊)
