1.什麼是ORM？
ORM，即Object-Relational Mapping（對象關係映射），它的作用是在關係型數據庫和業務實體對象之間作一個映射，這樣，我們在具體的操作業務對象的時候，就不需要再去和複雜的SQL語句打交道，只需簡單的操作對象的屬性和方法。
2.ORM的優缺點是什麼？
優點：擺脫複雜的SQL操作，適應快速開發；讓數據結構變得簡潔；數據庫遷移成本更低（如從mysql->oracle）
缺點：性能較差、不適用於大型應用；複雜的SQL操作還需通過SQL語句實現
創建表(建立模型)
實例：我們來假定下面這些概念，字段和關係
作者模型：一個作者有姓名和年齡。
作者詳細模型：把作者的詳情放到詳情表，包含生日，手機號，家庭住址等信息。作者詳情模型和作者模型之間是一對一的關係（one-to-one）
出版商模型：出版商有名稱，所在城市以及email。
書籍模型： 書籍有書名和出版日期，一本書可能會有多個作者，一個作者也可以寫多本書，所以作者和書籍的關係就是多對多的關聯關係(many-to-many);一本書只應該由一個出版商出版，所以出版商和書籍是一對多關聯關係(one-to-many)。
模型建立如下：
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") 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() 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) keepNum=models.IntegerField() commentNum=models.IntegerField() # 與Publish建立一對多的關係,外鍵字段建立在多的一方 publish=models.ForeignKey(to="Publish",to_field="nid") # 與Author表建立多對多的關係,ManyToManyField可以建在兩個模型中的任意一個，自動創建第三張表 authors=models.ManyToManyField(to='Author')
通過logging可以查看翻譯成的sql語句
LOGGING = {
'version': 1,
'disable_existing_loggers': False,
'handlers': {
'console':{
'level':'DEBUG',
'class':'logging.StreamHandler',
},
},
'loggers': {
'django.db.backends': {
'handlers': ['console'],
'propagate': True,
'level':'DEBUG',
},
}
} 注意事項：
1. 表的名稱myapp_modelName，是根據 模型中的元數據自動生成的，也可以覆寫爲別的名稱
2. id 字段是自動添加的
3. 對於外鍵字段，Django 會在字段名上添加"_id" 來創建數據庫中的列名
4. 這個例子中的CREATE TABLE SQL 語句使用PostgreSQL 語法格式，要注意的是Django 會根據settings 中指定的數據庫類型來使用相應的SQL 語句。
5. 定義好模型之後，你需要告訴Django _使用_這些模型。你要做的就是修改配置文件中的INSTALL_APPSZ中設置，在其中添加models.py所在應用的名稱。
6. 外鍵字段 ForeignKey 有一個 null=True 的設置(它允許外鍵接受空值 NULL)，你可以賦給它空值 None 。
字段選項
每個字段有一些特有的參數，例如，CharField需要max_length參數來指定VARCHAR數據庫字段的大小。還有一些適用於所有字段的通用參數。 這些參數在文檔中有詳細定義，這裏我們只簡單介紹一些最常用的：
1. models.AutoField 自增列 = int(11)
如果沒有的話，默認會生成一個名稱爲 id 的列，如果要顯示的自定義一個自增列，必須將給列設置爲主鍵 primary_key=True。
2. models.CharField 字符串字段
必須 max_length 參數
3. models.BooleanField 布爾類型=tinyint(1)
不能爲空，Blank=True
4. models.ComaSeparatedIntegerField 用逗號分割的數字=varchar
繼承CharField，所以必須 max_lenght 參數
5. models.DateField 日期類型 date
對於參數，auto_now = True 則每次更新都會更新這個時間；auto_now_add 則只是第一次創建添加，之後的更新不再改變。
6. models.DateTimeField 日期類型 datetime
同DateField的參數
7. models.Decimal 十進制小數類型 = decimal
必須指定整數位max_digits和小數位decimal_places
8. models.EmailField 字符串類型（正則表達式郵箱） =varchar
對字符串進行正則表達式
9. models.FloatField 浮點類型 = double
10. models.IntegerField 整形
11. models.BigIntegerField 長整形
integer_field_ranges = {
'SmallIntegerField': (-32768, 32767),
'IntegerField': (-2147483648, 2147483647),
'BigIntegerField': (-9223372036854775808, 9223372036854775807),
'PositiveSmallIntegerField': (0, 32767),
'PositiveIntegerField': (0, 2147483647),
}
12. models.IPAddressField 字符串類型（ip4正則表達式）
13. models.GenericIPAddressField 字符串類型（ip4和ip6是可選的）
參數protocol可以是：both. ipv4. ipv6
驗證時，會根據設置報錯
14. models.NullBooleanField 允許爲空的布爾類型
15. models.PositiveIntegerFiel 正Integer
16. models.PositiveSmallIntegerField 正smallInteger
17. models.SlugField 減號. 下劃線. 字母. 數字
18. models.SmallIntegerField 數字
數據庫中的字段有：tinyint. smallint. int. bigint
19. models.TextField 字符串=longtext
20. models.TimeField 時間 HH:MM[:ss[.uuuuuu]]
21. models.URLField 字符串，地址正則表達式
22. models.BinaryField 二進制
23. models.ImageField 圖片
24. models.FilePathField 文件添加表記錄
普通字段
方式1
publish_obj=Publish(name="人民出版社",city="北京",email="[email protected]") publish_obj.save() # 將數據保存到數據庫
方式2 <br>返回值publish_obj是添加的記錄對象
publish_obj=Publish.objects.create(name="人民出版社",city="北京",email="[email protected]")<br><br>方式3<br>表.objects.create(**request.POST.dict())
外鍵字段
方式1:
publish_obj=Publish.objects.get(nid=1) Book.objects.create(title="金瓶眉",publishDate="2012-12-12",price=665,pageNum=334,publish=publish_obj)
方式2:
Book.objects.create(title="金瓶眉",publishDate="2012-12-12",price=665,pageNum=334,publish_id=1)
關鍵點：book_obj.publish是什麼？
多對多字段
book_obj=Book.objects.create(title="追風箏的人",publishDate="2012-11-12",price=69,pageNum=314,publish_id=1) author_yuan=Author.objects.create(name="yuan",age=23,authorDetail_id=1) author_egon=Author.objects.create(name="egon",age=32,authorDetail_id=2) book_obj.authors.add(author_egon,author_yuan) # 將某個特定的 model 對象添加到被關聯對象集合中。 ======= book_obj.authors.add(*[]) book_obj.authors.create() #創建並保存一個新對象，然後將這個對象加被關聯對象的集合中，然後返回這個新對象。
關鍵點：book_obj.authors是什麼？
解除關係：
book_obj.authors.remove() # 將某個特定的對象從被關聯對象集合中去除。 ====== book_obj.authors.remove(*[])
book_obj.authors.clear() #清空被關聯對象集合。
class RelatedManager
"關聯管理器"是在一對多或者多對多的關聯上下文中使用的管理器。它存在於下面兩種情況：
ForeignKey關係的“另一邊”。像這樣：
from django.db import models
class Reporter(models.Model):
# ...
pass
class Article(models.Model):
reporter = models.ForeignKey(Reporter)
在上面的例子中，管理器reporter.article_set擁有下面的方法。
ManyToManyField關係的兩邊：
class Topping(models.Model):
# ...
pass
class Pizza(models.Model):
toppings = models.ManyToManyField(Topping)
這個例子中，topping.pizza_set 和pizza.toppings都擁有下面的方法。
add(obj1[, obj2, ...])
把指定的模型對象添加到關聯對象集中。
例如：
>>> b = Blog.objects.get(id=1)
>>> e = Entry.objects.get(id=234)
>>> b.entry_set.add(e) # Associates Entry e with Blog b.
在上面的例子中，對於ForeignKey關係，e.save()由關聯管理器調用，執行更新操作。然而，在多對多關係中使用add()並不會調用任何 save()方法，而是由QuerySet.bulk_create()創建關係。
create(**kwargs)
創建一個新的對象，保存對象，並將它添加到關聯對象集之中。返回新創建的對象：
>>> b = Blog.objects.get(id=1)
>>> e = b.entry_set.create(
... headline='Hello',
... body_text='Hi',
... pub_date=datetime.date(2005, 1, 1)
... )
# No need to call e.save() at this point -- it's already been saved.
這完全等價於（不過更加簡潔於）：
>>> b = Blog.objects.get(id=1)
>>> e = Entry(
... blog=b,
... headline='Hello',
... body_text='Hi',
... pub_date=datetime.date(2005, 1, 1)
... )
>>> e.save(force_insert=True)
要注意我們並不需要指定模型中用於定義關係的關鍵詞參數。在上面的例子中，我們並沒有傳入blog參數給create()。Django會明白新的 Entry對象blog 應該添加到b中。
remove(obj1[, obj2, ...])
從關聯對象集中移除執行的模型對象：
>>> b = Blog.objects.get(id=1)
>>> e = Entry.objects.get(id=234)
>>> b.entry_set.remove(e) # Disassociates Entry e from Blog b.
對於ForeignKey對象，這個方法僅在null=True時存在。
clear()
從關聯對象集中移除一切對象。
>>> b = Blog.objects.get(id=1)
>>> b.entry_set.clear()
注意這樣不會刪除對象 —— 只會刪除他們之間的關聯。
就像 remove() 方法一樣，clear()只能在 null=True的ForeignKey上被調用。
注意
對於所有類型的關聯字段，add()、create()、remove()和clear()都會馬上更新數據庫。換句話說，在關聯的任何一端，都不需要再調用save()方法。
直接賦值：
通過賦值一個新的可迭代的對象，關聯對象集可以被整體替換掉。
>>> new_list = [obj1, obj2, obj3]
>>> e.related_set = new_list
如果外鍵關係滿足null=True，關聯管理器會在添加new_list中的內容之前，首先調用clear()方法來解除關聯集中一切已存在對象的關聯。否則， new_list中的對象會在已存在的關聯的基礎上被添加。
查詢表記錄
查詢相關API
<1> all(): 查詢所有結果
<2> filter(**kwargs): 它包含了與所給篩選條件相匹配的對象
<3> get(**kwargs): 返回與所給篩選條件相匹配的對象，返回結果有且只有一個，
如果符合篩選條件的對象超過一個或者沒有都會拋出錯誤。
<5> exclude(**kwargs): 它包含了與所給篩選條件不匹配的對象
<4> values(*field): 返回一個ValueQuerySet——一個特殊的QuerySet，運行後得到的並不是一系列
model的實例化對象，而是一個可迭代的字典序列
<9> values_list(*field): 它與values()非常相似，它返回的是一個元組序列，values返回的是一個字典序列
<6> order_by(*field): 對查詢結果排序
<7> reverse(): 對查詢結果反向排序
<8> distinct(): 從返回結果中剔除重複紀錄
<10> count(): 返回數據庫中匹配查詢(QuerySet)的對象數量。
<11> first(): 返回第一條記錄
<12> last(): 返回最後一條記錄
<13> exists(): 如果QuerySet包含數據，就返回True，否則返回False
注意：一定區分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
基於對象的跨表查詢
一對多查詢（Publish 與 Book）
正向查詢(按字段：publish)：
# 查詢nid=1的書籍的出版社所在的城市<br>
book_obj=Book.objects.get(nid=1)<br>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")聚合查詢與分組查詢
聚合：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) 練習：統計每一本書的作者個數
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"
(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'))
注意：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)
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"
)
修改表記錄
注意：
<1> 第二種方式修改不能用get的原因是：update是QuerySet對象的方法，get返回的是一個model對象，它沒有update方法，而filter返回的是一個QuerySet對象(filter裏面的條件可能有多個條件符合，比如name＝'alvin',可能有兩個name＝'alvin'的行數據)。
<2>在“插入和更新數據”小節中，我們有提到模型的save()方法，這個方法會更新一行裏的所有列。 而某些情況下，我們只需要更新行裏的某幾列。
此外，update()方法對於任何結果集（QuerySet）均有效，這意味着你可以同時更新多條記錄update()方法會返回一個整型數值，表示受影響的記錄條數。
注意，這裏因爲update返回的是一個整形，所以沒法用query屬性；對於每次創建一個對象，想顯示對應的raw sql，需要在settings加上日誌記錄部分
刪除表記錄
刪除方法就是 delete()。它運行時立即刪除對象而不返回任何值。例如：
e.delete()
你也可以一次性刪除多個對象。每個 QuerySet 都有一個 delete() 方法，它一次性刪除 QuerySet 中所有的對象。
例如，下面的代碼將刪除 pub_date 是2005年的 Entry 對象：
Entry.objects.filter(pub_date__year=2005).delete()
要牢記這一點：無論在什麼情況下，QuerySet 中的 delete() 方法都只使用一條 SQL 語句一次性刪除所有對象，而並不是分別刪除每個對象。如果你想使用在 model 中自定義的 delete() 方法，就要自行調用每個對象的delete 方法。(例如，遍歷 QuerySet，在每個對象上調用 delete()方法)，而不是使用 QuerySet 中的 delete()方法。
在 Django 刪除對象時，會模仿 SQL 約束 ON DELETE CASCADE 的行爲，換句話說，刪除一個對象時也會刪除與它相關聯的外鍵對象。例如：
b = Blog.objects.get(pk=1)
# This will delete the Blog and all of its Entry objects.
b.delete()
要注意的是： delete() 方法是 QuerySet 上的方法，但並不適用於 Manager 本身。這是一種保護機制，是爲了避免意外地調用 Entry.objects.delete() 方法導致 所有的 記錄被誤刪除。如果你確認要刪除所有的對象，那麼你必須顯式地調用：
Entry.objects.all().delete()