查詢表記錄
看專業的官網文檔，做專業的程式員！
查詢相關API
<1> all(): 查詢所有結果——QuerySet
<2> filter(**kwargs): 它包含了與所給篩選條件相比對的對象——QuerySet
<3> get(**kwargs): 傳回與所給篩選條件相比對的對象，傳回結果有且隻有一個，
如果符合篩選條件的對象超過一個或者沒有都會抛出錯誤。——model
<5> exclude(**kwargs): 它包含了與所給篩選條件不比對的對象——queryset
<4> values(*field): 傳回一個ValueQuerySet——一個特殊的QuerySet，運作後得到的并不是一系列
model的執行個體化對象，而是一個可疊代的字典序列
<9> values_list(*field): 它與values()非常相似，它傳回的是一個可疊代的元組序列，values傳回的是一個字典序列
<6> order_by(*field): 對查詢結果排序——queryset
<7> reverse(): 對查詢結果反向排序——queryset
<8> distinct(): 從傳回結果中剔除重複紀錄——queryset
<10> count(): 傳回資料庫中比對查詢(QuerySet)的對象數量。——int
<11> first(): 傳回第一條記錄——model
<12> last(): 傳回最後一條記錄——model
<13> exists(): 如果QuerySet包含資料，就傳回True，否則傳回False——bool
注意：一定區分object與querySet的差別 ！！！
雙下劃線之單表查詢
models.Tb1.objects.filter(id__lt=10, id__gt=1) # 擷取id大于1 且 小于10的值
models.Tb1.objects.filter(id__in=[11, 22, 33]) # 擷取id等于11、22、33的資料
models.Tb1.objects.exclude(id__in=[11, 22, 33]) # not in
models.Tb1.objects.filter(name__contains="ven")
models.Tb1.objects.filter(name__icontains="ven") # icontains大小寫不敏感
models.Tb1.objects.filter(id__range=[1, 2]) # 範圍bettwen and
類似的還有：startswith，istartswith, endswith, iendswith
date字段還可以：
models.Class.objects.filter(first_day__year=2017) # 擷取個數
#
# models.Tb1.objects.filter(name='seven').count()
# 大于，小于
#
# models.Tb1.objects.filter(id__gt=1) # 擷取id大于1的值
# models.Tb1.objects.filter(id__gte=1) # 擷取id大于等于1的值
# models.Tb1.objects.filter(id__lt=10) # 擷取id小于10的值
# models.Tb1.objects.filter(id__lte=10) # 擷取id小于10的值
# models.Tb1.objects.filter(id__lt=10, id__gt=1) # 擷取id大于1 且 小于10的值
# in
#
# models.Tb1.objects.filter(id__in=[11, 22, 33]) # 擷取id等于11、22、33的資料
# models.Tb1.objects.exclude(id__in=[11, 22, 33]) # not in
# isnull
# Entry.objects.filter(pub_date__isnull=True)
# contains
#
# models.Tb1.objects.filter(name__contains="ven")
# models.Tb1.objects.filter(name__icontains="ven") # icontains大小寫不敏感
# models.Tb1.objects.exclude(name__icontains="ven")
# range
#
# models.Tb1.objects.filter(id__range=[1, 2]) # 範圍bettwen and
# 其他類似
#
# startswith，istartswith, endswith, iendswith,
# order by
#
# models.Tb1.objects.filter(name='seven').order_by('id') # asc
# models.Tb1.objects.filter(name='seven').order_by('-id') # desc
# group by
#
# from django.db.models import Count, Min, Max, Sum
# models.Tb1.objects.filter(c1=1).values('id').annotate(c=Count('num'))
# SELECT "app01_tb1"."id", COUNT("app01_tb1"."num") AS "c" FROM "app01_tb1" WHERE "app01_tb1"."c1" = 1 GROUP BY "app01_tb1"."id"
# limit 、offset
#
# models.Tb1.objects.all()[10:20]
# regex正則比對，iregex 不區分大小寫
#
# Entry.objects.get(title__regex=r'^(An?|The) +')
# Entry.objects.get(title__iregex=r'^(an?|the) +')
# date
#
# Entry.objects.filter(pub_date__date=datetime.date(2005, 1, 1))
# Entry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1))
# year
#
# Entry.objects.filter(pub_date__year=2005)
# Entry.objects.filter(pub_date__year__gte=2005)
# month
#
# Entry.objects.filter(pub_date__month=12)
# Entry.objects.filter(pub_date__month__gte=6)
# day
#
# Entry.objects.filter(pub_date__day=3)
# Entry.objects.filter(pub_date__day__gte=3)
# week_day
#
# Entry.objects.filter(pub_date__week_day=2)
# Entry.objects.filter(pub_date__week_day__gte=2)
# hour
#
# Event.objects.filter(timestamp__hour=23)
# Event.objects.filter(time__hour=5)
# Event.objects.filter(timestamp__hour__gte=12)
# minute
#
# Event.objects.filter(timestamp__minute=29)
# Event.objects.filter(time__minute=46)
# Event.objects.filter(timestamp__minute__gte=29)
# second
#
# Event.objects.filter(timestamp__second=31)
# Event.objects.filter(time__second=2)
# Event.objects.filter(timestamp__second__gte=31) 例子
基于對象的跨表查詢
基于對象查詢（子查詢）
一對多
正向查詢，按字段
Book-------------------->Publish
<---------------------
反向查詢,按表名小寫_set:book_set
obj=Book.objects.fliter(title="python").first()
obj.publish
多對多
正向查詢，按字段
Book-------------------->Author
<--------------------- 查詢,按表名小寫_set:book_set obj=Book.objects.fliter(title="python").first() obj.author.all() # [obj,....] 一對一： 正向查詢，按字段 Book-------------------->Author <--------------------- 查詢,按表名小寫 基于queryset查詢 正向查詢，按字段 A-------------------->B <--------------------- 查詢,按表名小寫 一對多查詢（Publish 與 Book）
正向查詢(按字段：publish)：
# 查詢nid=1的書籍的出版社所在的城市
book_obj=Book.objects.get(nid=1)
print(book_obj.publish.city) # book_obj.publish 是nid=1的書籍對象關聯的出版社對象 反向查詢(按表名：book_set)：
# 查詢人民出版社出版過的所有書籍
publish=Publish.objects.get(name="人民出版社")
book_list=publish.book_set.all() # 與人民出版社關聯的所有書籍對象集合
for book_obj in book_list:
print(book_obj.title) 一對一查詢(Author 與 AuthorDetail)
正向查詢(按字段：authorDetail)：
# 查詢egon作者的手機号
author_egon=Author.objects.get(name="egon")
print(author_egon.authorDetail.telephone) 反向查詢(按表名：author)：
# 查詢所有住址在北京的作者的姓名
authorDetail_list=AuthorDetail.objects.filter(addr="beijing")
for obj in authorDetail_list:
print(obj.author.name) 多對多查詢 (Author 與 Book)
正向查詢(按字段：authors)：
# 金瓶眉所有作者的名字以及手機号
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)：
# 查詢egon出過的所有書籍的名字
author_obj = Author.objects.get(name="egon")
book_list = author_obj.book_set.all() # 與egon作者相關的所有書籍
for book_obj in book_list:
print(book_obj.title) 注意：
你可以通過在 ForeignKey() 和ManyToManyField的定義中設定 related_name 的值來覆寫 FOO_set 的名稱。例如，如果 Article model 中做一下更改： publish = ForeignKey(Blog, related_name='bookList')，那麼接下來就會如我們看到這般：
# 查詢 人民出版社出版過的所有書籍
publish = Publish.objects.get(name="人民出版社")
book_list = publish.bookList.all() # 與人民出版社關聯的所有書籍對象集合 基于雙下劃線的跨表查詢
Django 還提供了一種直覺而高效的方式在查詢(lookups)中表示關聯關系，它能自動确認 SQL JOIN 聯系。要做跨關系查詢，就使用兩個下劃線來連結模型(model)間關聯字段的名稱，直到最終連結到你想要的 model 為止。
關鍵點：正向查詢按字段，反向查詢按表名。
# 練習1: 查詢人民出版社出版過的所有書籍的名字與價格(一對多)
# 正向查詢 按字段:publish
queryResult=Book.objects
.filter(publish__name="人民出版社")
.values_list("title","price")
# 反向查詢 按表名:book
queryResult=Publish.objects .filter(name="人民出版社") .values_list("book__title","book__price") # 練習2: 查詢egon出過的所有書籍的名字(多對多) # 正向查詢 按字段:authors: queryResult=Book.objects .filter(authors__name="yuan") .values_list("title") # 反向查詢 按表名:book queryResult=Author.objects .filter(name="yuan") .values_list("book__title","book__price") # 練習3: 查詢人民出版社出版過的所有書籍的名字以及作者的姓名 # 正向查詢 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") # 練習4: 手機号以151開頭的作者出版過的所有書籍名稱以及出版社名稱 queryResult=Book.objects .filter(authors__authorDetail__telephone__regex="151") .values_list("title","publish__name") 注意：
反向查詢時，如果定義了related_name ，則用related_name替換表名，例如： publish = ForeignKey(Blog, related_name='bookList')：
# 練習1: 查詢人民出版社出版過的所有書籍的名字與價格(一對多)
# 反向查詢 不再按表名:book,而是related_name:bookList
queryResult=Publish.objects
.filter(name="人民出版社")
.values_list("bookList__title","bookList__price") 練習：
class Book(models.Model):
title = models.CharField(max_length=32)
publishDate = models.DateField()
price = models.DecimalField(max_digits=5, decimal_places=2) # 999.99
# 建立一對多的關聯字段 : 是與某個書籍對象關聯的出版社對象(注意，隻有一個對象)
publish=models.ForeignKey("Publish")
# 建立的多對多的關系
authors=models.ManyToManyField("Author")
class Publish(models.Model):
nid = models.AutoField(primary_key=True)
name=models.CharField( max_length=32)
email=models.EmailField()
class Author(models.Model):
name=models.CharField(max_length=32)
age=models.IntegerField()
class AuthorDetail(models.Model):
addr=models.CharField(max_length=32)
email=models.EmailField()
author=models.OneToOneField("Author")
基于圖書管理系統的表關系與資料，進行如下查詢
要求：1-5查詢分别基于對象查詢，雙下劃線查詢，以及找到對應翻譯的sql語句
1、查詢人民出版社出版過的價格大于100的書籍的作者的email
2、查詢alex出版過的所有書籍的名稱以及書籍的出版社的名稱
3、查詢2011年出版社過的所有書籍的作者名字以及出版社名稱
4、查詢住在沙河并且email以123開頭的作者寫過的所有書籍名稱以及書籍的出版社名稱
5、查詢年齡大于20歲的作者在哪些出版社出版過書籍
6、查詢每一個出版社的名稱以及出版過的書籍個數
7、查詢每一個作者的名字以及出版過的所有書籍的最高價格
8、查詢每一本書的名字，對應出版社名稱以及作者的個數 View Code
聚合查詢與分組查詢
先了解sql中的聚合與分組概念
聚合：aggregate(*args, **kwargs)
# 計算所有圖書的平均價格
>>> from django.db.models import Avg
>>> Book.objects.all().aggregate(Avg('price'))
{'price__avg': 34.35} 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'))
{'price__avg': 34.35, 'price__max': Decimal('81.20'), 'price__min': Decimal('12.99')} 分組：annotate()
為調用的QuerySet中每一個對象都生成一個獨立的統計值（統計方法用聚合函數）。
跨表分組與單表分組：
1、單表分組：
查詢每個出版社有多少本書：
Book.objects.all().values("publish").annotate(Count("title"))
2、跨表分組：
每一個什麼，則用這個表查詢，即以什麼分組
(1) 練習：統計每一本書的作者個數
bookList=Book.objects.annotate(authorsNum=Count('authors'))
for book_obj in bookList:
print(book_obj.title,book_obj.authorsNum) SELECT
"app01_book"."nid",
"app01_book"."title",
"app01_book"."publishDate",
"app01_book"."price",
"app01_book"."pageNum",
"app01_book"."publish_id",
COUNT("app01_book_authors"."author_id") AS "authorsNum"
FROM "app01_book" LEFT OUTER JOIN "app01_book_authors"
ON ("app01_book"."nid" = "app01_book_authors"."book_id")
GROUP BY
"app01_book"."nid",
"app01_book"."title",
"app01_book"."publishDate",
"app01_book"."price",
"app01_book"."pageNum",
"app01_book"."publish_id" sql
解析：
'''
Book.objects.annotate(authorsNum=Count('authors'))
拆分解析：
Book.objects等同于Book.objects.all(),翻譯成的sql類似于： select id,name,.. from Book
這樣得到的對象一定是每一本書對象，有n本書籍記錄，就分n個組，不會有重複對象，每一組再由annotate分組統計。''' (2) 如果想對所查詢對象的關聯對象進行聚合：
練習：統計每一個出版社的最便宜的書
publishList=Publish.objects.annotate(MinPrice=Min("book__price"))
for publish_obj in publishList:
print(publish_obj.name,publish_obj.MinPrice) annotate的傳回值是querySet，如果不想周遊對象，可以用上valuelist：
queryResult= Publish.objects
.annotate(MinPrice=Min("book__price"))
.values_list("name","MinPrice")
print(queryResult) 解析同上。
方式2:
queryResult=Book.objects.values("publish__name").annotate(MinPrice=Min('price')) ＃ 思考： if 有一個出版社沒有出版過書會怎樣？ 解析：
'''
檢視 Book.objects.values("publish__name")的結果和對應的sql語句
可以了解為values内的字段即group by的字段''' (3) 統計每一本以py開頭的書籍的作者個數：
queryResult=Book.objects
.filter(title__startswith="Py")
.annotate(num_authors=Count('authors')) (4) 統計不止一個作者的圖書：
queryResult=Book.objects
.annotate(num_authors=Count('authors'))
.filter(num_authors__gt=1) (5) 根據一本圖書作者數量的多少對查詢集 QuerySet進行排序:
Book.objects.annotate(num_authors=Count('authors')).order_by('num_authors') (6) 查詢各個作者出的書的總價格:
# 按author表的所有字段 group by
queryResult=Author.objects
.annotate(SumPrice=Sum("book__price"))
.values_list("name","SumPrice")
print(queryResult)
# 按authors__name group by
queryResult2=Book.objects.values("authors__name")
.annotate(SumPrice=Sum("price"))
.values_list("authors__name","SumPrice")
print(queryResult2) F查詢與Q查詢
F查詢
在上面所有的例子中，我們構造的過濾器都隻是将字段值與某個常量做比較。如果我們要對兩個字段的值做比較，那該怎麼做呢？
Django 提供 F() 來做這樣的比較。F() 的執行個體可以在查詢中引用字段，來比較同一個 model 執行個體中兩個不同字段的值。
# 查詢評論數大于收藏數的書籍
from django.db.models import F
Book.objects.filter(commnetNum__lt=F('keepNum')) Django 支援 F() 對象之間以及 F() 對象和常數之間的加減乘除和取模的操作。
# 查詢評論數大于收藏數2倍的書籍
Book.objects.filter(commnetNum__lt=F('keepNum')*2) 修改操作也可以使用F函數,比如将每一本書的價格提高30元：
Book.objects.all().update(price=F("price")+30) 引申：
如果要修改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(")"))) Q查詢
filter() 等方法中的關鍵字參數查詢都是一起進行“AND” 的。 如果你需要執行更複雜的查詢（例如OR 語句），你可以使用Q 對象。
from django.db.models import Q
Q(title__startswith='Py') Q 對象可以使用& 和| 操作符組合起來。當一個操作符在兩個Q 對象上使用時，它産生一個新的Q 對象。
bookList=Book.objects.filter(Q(authors__name="yuan")|Q(authors__name="egon")) 等同于下面的SQL WHERE 子句：
WHERE name ="yuan" OR name ="egon" 你可以組合& 和| 操作符以及使用括号進行分組來編寫任意複雜的Q 對象。同時，Q 對象可以使用~ 操作符取反，這允許組合正常的查詢和取反(NOT) 查詢：
bookList=Book.objects.filter(Q(authors__name="yuan") & ~Q(publishDate__year=2017)).values_list("title") 查詢函數可以混合使用Q 對象和關鍵字參數。所有提供給查詢函數的參數（關鍵字參數或Q 對象）都将"AND”在一起。但是，如果出現Q 對象，它必須位于所有關鍵字參數的前面。例如：
bookList=Book.objects.filter(Q(publishDate__year=2016) | Q(publishDate__year=2017),
title__icontains="python"
) 轉載于:https://www.cnblogs.com/guoyunlong666/p/8975889.html
![【MySQL資料庫】資料庫索引事務1.索引2.事務[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)