一 建立模型
表和表之間的關係前端
一對1、多對1、多對多 ，用book表和publish表本身來想一想關係，想一想裏面的操做，加外鍵約束和不加外鍵約束的區別，一對一的外鍵約束是在一對多的約束上加上惟一約束。python
實例：咱們來假定下面這些概念，字段和關係mysql
做者模型：一個做者有姓名和年齡。git
做者詳細模型：把做者的詳情放到詳情表，包含生日，手機號，家庭住址等信息。做者詳情模型和做者模型之間是一對一的關係（one-to-one）sql
出版商模型：出版商有名稱，所在城市以及email。數據庫
書籍模型： 書籍有書名和出版日期，一本書可能會有多個做者，一個做者也能夠寫多本書，因此做者和書籍的關係就是多對多的關聯關係(many-to-many);一本書只應該由一個出版商出版，因此出版商和書籍是一對多關聯關係(one-to-many)。django
模型創建以下：app
from django.db import models
# Create your models here.
class Author(models.Model): #比較經常使用的信息放到這個表裏面
nid = models.AutoField(primary_key=True)
name=models.CharField( max_length=32)
age=models.IntegerField()
# 與AuthorDetail創建一對一的關係，一對一的這個關係字段寫在兩個表的任意一個表裏面均可以
authorDetail=models.OneToOneField(to="AuthorDetail",to_field="nid",on_delete=models.CASCADE) #就是foreignkey+unique，
只不過不須要咱們本身來寫參數了，而且orm會自動幫你給這個字段名字
拼上一個_id，數據庫中字段名稱爲authorDetail_id
calss AuthorDetail(models.Model):#放置不經常使用的字段
class AuthorDetail(models.Model):#不經常使用的放到這個表裏面
nid = models.AutoField(primary_key=True)
birthday=models.DateField()
telephone=models.BigIntegerField()
addr=models.CharField( max_length=64)
class Publish(models.Model):
nid = models.AutoField(primary_key=True)
name=models.CharField( max_length=32)
city=models.CharField( max_length=32)
email=models.EmailField()
#多對多的表關係,咱們學mysql的時候是手動建立第三張表,而後寫上兩個字段,每一個字段做爲外鍵關聯到另外兩張多對多關係的表,
orm的manytomany自動幫咱們建立第三張表,兩種建立方式均可以,之後用orm自動建立第三張表,
由於手動建立第三張表咱們進行orm操做的時候,不少關於多對多的表之間的orm語句方法沒法使用
#若是想刪除某張表,只須要將這個表註銷掉,而後執行那兩個數據庫建立的同步指令就行了,自動刪除了就.
class Book(models.Model):
nid = models.AutoField(primary_key=True)
title = models.CharField( max_length=32)
publishDate=models.DateField()
price=models.DecimalField(max_digits=5,decimal_places=2)
#與publish創建一對多的關係,外鍵字段創建在多的一方,字段publish若是是外鍵字段,那麼它自動是int類型
publish 指向你關聯的字段,不寫這個,默認會自動關聯主鍵字段,on_delete級聯刪除
字段名稱不須要寫成publish_id,orm在線翻譯foreignkey的時候會自動給你這個字段拼上一個_id,
這個字段名稱在數據庫裏面就自動變成publish_id
#與Author表創建多對多的關係,ManeyToManeyFiled能夠創建在兩個模型中的任意一個,自動建立第三張表,而且注意一點,
你查看book表的時候,你看不到這個字段,
由於這個字段就是建立第三章標的意思,不是建立字段的意思,因此只能說這個book類裏面有authors這個字段屬性.
authors = models.MoneyToMoneyFiled(to='Author) #注意不論是一對多仍是多對多,寫to這個參數的時候,
最後後面的值是個字符串,否則你就須要將你要關聯的那個表放到這個表的上
二 添加表記錄
操做前先簡單的錄入一些數據,仍是create和save連個方法,和單表的區別是看看怎麼添加關聯字段的數據函數
一對多
方式一:
publish_obj = Publish.objects.get(nid=1) #拿到nid爲1的出版社對象
book_obj = Book.objects.create(title = "武林外傳",publishData="2012-12-12",
price=100,publish=publish_obj) #出版社對象做爲值傳給publish,其實就是自動將publish
字段變成publish_id,而後將publish_obj的id給取出來賦值給publish_id字段,必定要是
publish類的對象,不然報錯.
方拾二:
book_obj = Book.objects.create(title="武林外傳",publishData='2010-12-12',
price=1000,publish_id=1) #直接寫上id的值,這個是publish_id = xxx
方式一是publish=xxx(類對象)
上邊一段話的核心就是 publish後邊寫的是publish的類對象,而publish_id 寫的是一個具體的值.spa
多對多
方式一: 多對多通常在前端頁面上使用的時候是多選下拉框的樣子來給用戶選擇多個數據,這可讓用戶
選擇多個書籍,多個做者. #當前生成的書籍對象 book_obj = Book.objects.create(title='追風箏的人',price=200,publishData=
'2010-12-12',publish_id = 1) #爲書籍綁定的做者對象 yuan=Author.objects.filter(name="yuan").first() #在Author表中主鍵爲2的記錄,
注意取的是author的model對象 egon = Author.objects.filter(name='alex').first() #在Author表中的主鍵爲1 的記錄 #有人會說,咱們能夠直接給第三張表中添加數據啊,這個自動生成的第三張表你能經過models獲取到嗎,
是獲取不到的,用不了的固然若是知道這個表的名字,name你經過原生的sql語句能夠進行書的添加,因此要經過
orm間接地給第三張表添加數據,若是是你手動添加的第三張表你是能夠直接給第三張表添加數據的 #綁定多對多關係,既向關係表book_author中添加記錄,給書添加兩個做者,下面的語法就是告訴orm
給第三張表添加兩條數據. book_obj.authors add(yuan,egon) #將某些特定的model對象添加到被關聯到對象集合中.
=======book_obj是數據對象,authors是book表裏面那個多對多的關係字段名稱. #其實orm就是先經過book_obj的authors屬性找到第三張表,而後將book_obj的id值和兩個做者
對象的id值組合成兩條記錄添加到第三張表裏面去 方式二: book_obj.authors.add(1,2) book_obj.authors.add(*[1,2]) #這種方式用的最多,由於通常是給用戶選擇,用戶選擇的是多選,
選完後給你發送過來的就是一堆的id值
上邊這一段的核心是book_obj.authors.all()是什麼?
多對多關係經常使用的API:
book_obj.authors.remove() #將某個特定的對象從被關聯對象集合中去除. =====
book_obj.authors.remove(*[1,2])#將多對多的關係數據刪除 book_obj.authors.clear() #清空被關聯對象集合 book_obj.authors.set() #先清空再設置 =====
刪除示例:
book_obj = models.Book.objects.filter(nid=4)[0] #book_obj.authors.remove(2) #將第三張表中的這個book_obj對象對應的那個做者id爲2 的那條記錄
刪除 #book_obj.author.clear() #book_obj.author.set('2') #先清除掉全部的關係數據,而後只給這個書對象綁定這個id爲2的做者,
因此只剩一條記錄 3--2,好比用戶編輯數據的時候,
選擇做者發生了變化,那麼須要從新選擇,因此咱們就要先清空,而後再從新綁定關係數據,注意這裏寫的是字符串
,數字類型不能夠 book_obj.authors.set(['1',]) #這麼寫也能夠,可是注意列表中的元素是字符串,列表前面沒有*
一對一的和一對多的刪改和單表的刪改是同樣的,別忘了刪表的時候,咱們是作了級聯刪除的.
更新:
book_obj = models.Book.objects.get(id=1) #獲取一個書籍對象
data = {'title':'xxx','price':100} #這個書籍對象更新後的數據
models.Book.objects.filter(id=n).update(**data) #將新數據更新到原來的記錄中
book_obj.authors.set(author_list) #將數據和做者的多對多關係加上 #將數據和做者的多對多關係加上
models.Book.objects.filter(id=1).delete()
三 基於對象的跨表查詢
跨表查詢是分組查詢的基礎,F和Q查詢是最簡單的
一對多查詢(publish與Book)
正向查詢(按字段:publish): 關聯屬性字段所在的表查詢被關聯表的記錄就是正向查詢,反之就是反向查詢
查詢主鍵爲一的書籍的出版社所在的 城市 book_obj = models.Book.objects.filter(pk=1).first() #book_obj.publish是主鍵爲1 的書籍對象關聯的出版社對象,book對象.外鍵字段名稱
print(book_obj.publish.city)
反向查詢(按代表:book_set,由於加上_set就是反向查詢的意思,查詢出來的結果多是多條記錄的集合):
publish=Publish.objects.get(name="蘋果出版社")
#publish.book_set.all() :與蘋果書籍相關的全部書籍的對象集合,寫法:
小寫的代表_set.all(),獲得的queryset類型數據
book_list=publish.book_set.all()
for book_obj in book_list:
print(book_obj.title)
一對一查詢(Author與authorDtail)
正向查詢(按字段:authorDetail):
egon = Author.objects.filter(name='egon').first() print(egon.authorDetail.telephone) egon.authorDetail就拿到這個對象,由於一對一找的
就是一條記錄,注意寫法:做者對象.字段名,就拿到了這個關聯對象
反向查詢(按表名：author)：不須要_set，由於一對一正向反向都是找到一條記錄
# 查詢全部住址在北京的做者的姓名 authorDet=AuthorDetail.objects.filter(addr="beijing")[0] authorDet.author.name
在這裏咱們補充一點，由於你很快就要接觸到了，那就是form表單裏面的button按鈕和form表單外面的button按鈕的區別，form表單裏面的button按鈕其實和input type='submit'的標籤是有一樣的效果的，都可以提交form表單的數據，可是若是放在form表單外面的button按鈕，那就只是個普通的按鈕了。<button>提交</button>，還有一點，input type='submit'按鈕放到form表單外面那就成了一個普通的按鈕。
四 基於雙下劃線的跨表查詢(基於JOIN實現)
Django還提供了一種直觀而高效的方式在查詢(lookups)中表示關聯關係,她能自動確認SQL JOIN練習.要作跨關係查詢,就是用兩個下劃線來連接模型(model)之間關聯字段的名稱,直到鏈接到你想要的model爲止.
''' 基於雙下劃線的查詢就一句話:正向查詢該字段,反向查詢按表名大小寫用來告訴ORM引擎join哪張表,一對一,
一對多,多對多都是一個寫法,注意,咱們寫orm查詢的時候,哪一個表在前在後都沒問題,由於走的是join連表操做. '''
一對多查詢
#練習:查詢蘋果出版社出版過的全部書籍的名字與價格(一對多) #正向查詢 按字段:publish queryResult = Book.objects.filter(publish__name="蘋果出版社") #經過__orm將book表
和publish表進行join,而後找到全部記錄中publish.name='蘋果出版社'的記錄(注意publish是屬性名稱)
,而後select book.title,book.price的字段值 .values_list("title","price") #values或者values_list #反向查詢 按表名:book queryResult = Publish.objects.filter(name='蘋果出版社')
.value_list('book__title','book__price')
多對多查詢
#練習:查詢yuan出過的全部書籍的名字(多對多) #正向查詢 按字段:authors: queryResult = Book.objects.filter(authors__name="yuan") #反向查詢 按表名:book queryResult=Author.objects.filter(name="yuan")
.values_list("book__title","book_price")
一對一查詢
#查詢yuan的手機號
#正向查詢
ret = Author.objects.filter(name="yuan").values("authordetail__telephon")
#反向查詢
ret=AuthorDetail.objects.filter(author__name='yuan').values("telephone")進階
進階練習(連續跨表)
練習:查詢人民出版社出版過的全部書籍的名字以及做者的姓名
#正向查詢
queryResult=Book.object.filter(publish__name='人民出版社').values_list('title',
authors__name)
#反向查詢
queryResult=Publish.objects.filer(name='人民出版社').values_list('book_title',
'book_authors_age','book_authors__name')
練習: 手機號以151開頭的做者出版過的書籍名稱以及出版社名稱
#方式1
queryResult = Book_objects.fiter
(authors__authordetail__tel__startswith='151').value("title",publisher__name)
#方式二
ret = Author.objects.filter(authordetail__tel__startswith='151').
values("book__title","book__publisher__name")
related_name
反向查詢時,若是定義了related_name,則用related_name替換表名
publish = ForeignKey(Blog,related_name='bookList')
# 練習: 查詢人民出版社出版過的全部書籍的名字與價格(一對多)
# 反向查詢 再也不按表名:book,而是related_name:bookList
queryResult=Publish.objects
.filter(name="人民出版社")
.values_list("bookList__title","bookList__price")
五 聚合查詢 分組查詢 F查詢和Q查詢
聚合
aggregate(*arges,**kwarges)
#計算全部圖書的平均價格
from django.db.models import Avg
Book.objects.all().aggregate(Avg('price')) #或者起名字aggretate(a=Avg('price'))
aggregate()是QuerySet的一個終止子句,意思是說,他返回一個包含一些鍵值對的字典.鍵的名稱是聚合值的標識符,值是計算出來的聚合值.鍵的名稱是按照字段和聚合函數的名稱自動生成出來的,若是你想要成爲聚合值指定一個名稱,能夠向聚合子句提供它.
Book.objects.aggregate(average_price=Avg('price'))
{'average_price':34.35}
若是但願生成的不是 一個聚合,你能夠向aggregate()子句中添加另外一個參數.因此,若是你也想知道全部圖書的價格的最大值和最小值,能夠以下查詢:
from django.db.models import Avg,Max,Min
Book.objects.aggregate(Avg('price'),Max('price'),Min('price')})
#count('id'),count(1)也能夠統計個數,Book.objects.all().aggregete和
Book.objects.aggregate()，均可以
{'price__avg': 34.35, 'price__max': Decimal('81.20'),
'price__min': Decimal('12.99')}
分組
單表分組查詢
查詢每個部門名稱以及對應的員工數
emp:
id name age salary dep
1 alex 12 2000 銷售部
2 egon 22 3000 人事部
3 wen 22 5000 人事部
sql語句: select dep,count(*) from emp group by dep;
ORM:
emp.objects.values('dep').annotate(c=Count("id")) #注意
annotate裏面必須寫個聚合函數,否則沒有意義,而且必須有個別名=,別名隨便寫
,可是必需要有,用哪一個字段分組,values裏面就寫哪一個字段,annotate其實就是對分組結果的統計
,統計你須要什麼
'''
select dep,count('id') as c from emp grouby dep; #原生sql語句中的as c，不是必須有的
'''
多表分組查詢
查詢每一個部門名稱以及對應的員工數
emp:
id name age salary dep_id
1 alex 12 2000 1
2 egon 22 3000 2
3 wen 22 5000 2
dep
id name
1 銷售部
2 人事部
emp－dep:
id name age salary dep_id id name
1 alex 12 2000 1 1 銷售部
2 egon 22 3000 2 2 人事部
3 wen 22 5000 2 2 人事部
SQL原生語句:
'''
select dep.name,count(*) from emp inner join dep on emp.dep_id = dep.id
group by dep.id
'''
ORM:
dep.objects.values('id').annotate(c=Count("emp")).values("name","c")
#注意若是寫了其餘字段,那麼只有這兩個字段重複,纔算一組,合併到一塊兒來統計個數
annotate()掉用的是QuerySet中每個對象都生成一個獨立的統計值(統計方法用聚合函數).
總結: 跨表分組查詢本質就是將關聯表join成一張表,再按單表的思路進行分組查詢,既然是join連表,就可使用我們的雙下劃線進行連表了
#單表：
#查詢每個部門的id以及對應員工的平均薪水
ret = models.Emp.objects.values('dep_id').annotate(s=Avg('salary'))
#查詢每一個部門的id以及對對應的員工的最大年齡
ret = models.Emp.objects.values('dep_id').annotate(a=Max('age'))
#Emp表示表，values中的字段表示按照哪一個字段group by，annotate裏面是顯示分組統計的是什麼
#連表：
# 查詢每一個部門的名稱以及對應的員工個數和員工最大年齡
ret = models.Emp.objects.values('dep__name').annotate(a=Count('id')
,b=Max('age')) #注意，正向與反向的結果可能不一樣，若是反向查的時候，有的部門尚未員工，
那麼他的數據也會被統計出來，只不過值爲0，可是正向查的話只能統計出來有員工的部門的相關數據，
由於經過你是員工找部門，而不是經過部門找員工，結果集裏面的數據個數不一樣，可是你想要的統計結果是同樣的
#<QuerySet [{'a': 1, 'dep__name': '銷售部', 'b': 12},
{'a': 3, 'dep__name': '人事部', 'b': 22}]>
#使用雙下劃線進行連表，而後按照部門名稱進行分組，而後統計員工個數和最大年齡，
最後結果裏面顯示的是部門名稱、個數、最大年齡。
#注意：若是values裏面有多個字段的狀況：
ret = models.Emp.objects.values('dep__name','age').annotate(a=Count('id'),
b=Max('age')) #是按照values裏面的兩個字段進行分組，兩個字段同時相同纔算是一組，看下面的sql語句
'''
SELECT `app01_dep`.`name`, `app01_emp`.`age`, COUNT(`app01_emp`.`id`)
AS `a`, MAX(`app01_emp`.`age`) AS `b` FROM `app01_emp` INNER JOIN `app01_dep`
ON (`app01_emp`.`dep_id` = `app01_dep`.`id`) GROUP BY `app01_dep`.`name`,
`app01_emp`.`age`;
'''
F查詢
在上面全部的例子中，咱們構造的過濾器都只是將字段值與某個常量作比較。若是咱們要對兩個字段的值作比較，那該怎麼作呢？咱們在book表裏面加上兩個字段：評論數：commentNum，收藏數：KeepNum
Django 提供 F() 來作這樣的比較。F() 的實例能夠在查詢中引用字段，來比較同一個 model 實例中兩個不一樣字段的值。
|
1
2
3
4
|
# 查詢評論數大於收藏數的書籍
from
django.db.models
import
F
Book.objects.
filter
(commentNum__lt
=
F(
'keepNum'
))
|
Django 支持 F() 對象之間以及 F() 對象和常數之間的加減乘除和取模的操做。
|
1
2
|
# 查詢評論數大於收藏數2倍的書籍
Book.objects.
filter
(commentNum__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
=
"yuan"
)|Q(authors__name
=
"egon"
))
|
等同於下面的SQL WHERE 子句：
|
1
|
WHERE name
=
"yuan"
OR name
=
"egon"
|
你能夠組合& 和| 操做符以及使用括號進行分組來編寫任意複雜的Q 對象。同時，Q 對象可使用~ 操做符取反，這容許組合正常的查詢和取反(NOT) 查詢：
|
1
|
bookList
=
Book.objects.
filter
(Q(authors__name
=
"yuan"
) & ~Q(publishDate__year
=
2017
)).values_list(
"title"
)
bookList
=
Book.objects.
filter
(Q(Q(authors__name
=
"yuan"
) & ~Q(publishDate__year
=
2017
))&Q(id__gt=6)).values_list(
"title"
) #能夠進行Q嵌套，多層Q嵌套等，其實工做中比較經常使用
|
查詢函數能夠混合使用Q 對象和關鍵字參數。全部提供給查詢函數的參數（關鍵字參數或Q 對象）都將"AND」在一塊兒。可是，若是出現Q 對象，它必須位於全部關鍵字參數的前面。例如：
|
1
2
3
|
bookList
=
Book.objects.
filter
(Q(publishDate__year
=
2016
) | Q(publishDate__year
=
2017
),
title__icontains
=
"python" #也是and的關係，可是Q必須寫在前面
)
|