很重要，都是精華

多表關系模型

一對一

一旦確定表關系是一對一，在兩張表中的任意一張表中建立關聯字段+Unique

一對多

一旦確定表關系是一對多，創建關聯字段在多的表中

多對多

一旦確定表關系是多對多，創建第三章關系表

ORM生成關系表模型

假定下面這些概念，字段和關系

作者模型：一個作者有姓名和年齡。

作者詳細模型：把作者的詳情放到詳情表，包含生日，手機號，家庭住址等信息。作者詳情模型和作者模型之間是一對一的關系（one-to-one）

出版商模型：出版商有名稱，所在城市以及email。

書籍模型： 書籍有書名和出版日期，一本書可能會有多個作者，一個作者也可以寫多本書，所以作者和書籍的關系就是多對多的關聯關系(many-to-many);一本書只應該由一個出版商出版，所以出版商和書籍是一對多關聯關系(one-to-many)。

模型建立如下：

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",on_delete=models.CASCADE
 
)

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)

    # 與Publish建立一對多的關系,外鍵字段建立在多的一方
    publish=models.ForeignKey(to="Publish",to_field="nid",on_delete=models.CASCADE)

    # 與Author表建立多對多的關系,ManyToManyField可以建在兩個模型中的任意一個，自動創建第三張表。而不是增加了一個字段。
    authors=models.ManyToManyField(to=‘Author‘,)

註意事項：

• 表的名稱myapp_modelName，是根據 模型中的元數據自動生成的，也可以覆寫為別的名稱　　
• id 字段是自動添加的
• 對於外鍵字段，Django 會在字段名上添加"_id" 來創建數據庫中的列名
• 這個例子中的CREATE TABLE SQL 語句使用PostgreSQL 語法格式，要註意的是Django 會根據settings 中指定的數據庫類型來使用相應的SQL 語句。
• 定義好模型之後，你需要告訴Django _使用_這些模型。你要做的就是修改配置文件中的INSTALL_APPSZ中設置，在其中添加models.py所在應用的名稱。
• 外鍵字段 ForeignKey 有一個 null=True 的設置(它允許外鍵接受空值 NULL)，你可以賦給它空值 None 。
• Django2.0 添加的外鍵中，要添加on_delete=models.CASCADE

添加表記錄

一對多

方式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)

兩種方法區別僅在於方式一的關聯鍵添加的是一個對象，方式二添加的是一個id值，但是他們運行後的結果都是一樣的

即：都會生成一個字段publish_id，而且，都可以使用book_obj.publish得到一個publish對象！

多對多

綁定方法

    # 當前生成的書籍對象
    book_obj=Book.objects.create(title="追風箏的人",price=200,publishDate="2012-11-12",publish_id=1)
    # 為書籍綁定的做作者對象
    yuan=Author.objects.filter(name="yuan").first() # 在Author表中主鍵為2的紀錄
    egon=Author.objects.filter(name="alex").first() # 在Author表中主鍵為1的紀錄

    # 綁定多對多關系,即向關系表book_authors中添加紀錄
    book_obj.authors.add(yuan,egon)    #  將某些特定的 model 對象添加到被關聯對象集合中。   =======    book_obj.authors.add(*[])或者使用鍵值（1,2）

註意：之前用authors=models.ManyToManyField(to=‘Author‘,)，無法用一對多的方法添加，因為沒有創建這個表的類，這個類是Django自己創建出來的

多對多關系其它常用API：

book_obj.authors.remove()      # 將某個特定的對象從被關聯對象集合中去除。    ======   book_obj.authors.remove(*[])
book_obj.authors.clear()       #清空被關聯對象集合
book_obj.authors.set()         #先清空再設置

more

例子：

######################綁定多對多的關系##############################################

    book_obj=Book.objects.create(title="西遊記",price=100,publishDate="2012-12-12",publish_id=1)

    egon=Author.objects.get(name="egon")
    alex=Author.objects.get(name="alex")

    #綁定多對多關系的API
    book_obj.authors.add(egon,alex)
    book_obj.authors.add(1,2,3)
    book_obj.authors.add(*[1,2,3])

    #解除多對多關系

    book=Book.objects.filter(nid=4).first()
    book.authors.remove(2)
    #book.authors.remove(*[1,2])

    book.authors.clear()


 

book_obj.authors.all()

    #查詢主鍵為4的書籍的所有作者的名字
    book=Book.objects.filter(nid=4).first()
    print(book.authors.all()) # [obj1,obj2...] queryset: 與這本書關聯的所有作者對象集合
    ret=book.authors.all().values("name")
    print(ret)


    關鍵點:

    一 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   alex
           2   egon

    book_obj.authors.all()    ------->   [alex,egon]

基於對象的跨表查詢

正向查詢和反向查詢的概念

A-B
關聯屬性在A表中

正向查詢: A------>B
反向查詢: B------>A

一對多

正向查詢:按字段
反向查詢:表名小寫_set.all()

    # 一對多查詢的正向查詢 : 查詢西遊記這本書的出版社的名字

    book_obj=Book.objects.filter(title="西遊記").first()
    print(book_obj.publish) # 與這本書關聯出版社對象
    print(book_obj.publish.name)
    對應sql:
    select publish_id from Book where title="西遊記"
    select name from Publish where id=1


    # 一對多查詢的反向查詢 : 查詢人民出版社出版過的書籍名稱

    publish=Publish.objects.filter(name="人民出版社").first()
    ret=publish.book_set.all()
    print(ret)

多對多

正向查詢:按字段
反向查詢:表名小寫_set.all()

# 多對多查詢的正向查詢 : 查詢西遊記這本書的所有作者的名字

    book_obj=Book.objects.filter(title="西遊記").first()
    author_list=book_obj.authors.all() # queryset對象  [author_obj1,...]

    for author in author_list:
        print(author.name)

    # 多對多查詢的反向查詢 : 查詢alex出版過的所有書籍名稱

    alex=Author.objects.filter(name="alex").first()

    book_list=alex.book_set.all()
    for book in book_list:
        print(book.title)

一對一

正向查詢:按字段
反向查詢:表名小寫

    # 一對一查詢的正向查詢 : 查詢alex的手機號

    alex=Author.objects.filter(name="alex").first()
    print(alex.authordetail.telephone)

    # 一對一查詢的反向查詢 : 查詢手機號為110的作者的名字和年齡

    ad=AuthorDetail.objects.filter(telephone="110").first()
    print(ad.author.name)
    print(ad.author.age)

基於雙下劃綫的跨表查詢

要點

要點一：

雙下劃線代表跨表，使用雙下劃線，即通知內部引擎的方式。

要點二:

正向查詢按字段,

反向查詢按表名小寫

此要求是對於跨表的！分清楚是正向還是反向很重要

要點三：

已知條件在哪張表，哪張表用字段，非那張表用雙下劃線跨表，匹配條件或者求值！

一對多

# 一對多查詢 : 查詢西遊記這本書的出版社的名字

    # 方式1:
    ret=Book.objects.filter(title="西遊記").values("publish__name")
    print(ret) # <QuerySet [{‘publish__name‘: ‘南京出版社‘}]>

    # 方式2:
    ret=Publish.objects.filter(book__title="西遊記").values("name")
    print(ret)

多對多

# 多對多查詢 : 查詢西遊記這本書的所有作者的名字

    # 方式1:
    # 需求: 通過Book表join與其關聯的Author表,屬於正向查詢:按字段authors通知ORM引擎join book_authors與author

    ret=Book.objects.filter(title="西遊記").values("authors__name")
    print(ret) # <QuerySet [{‘authors__name‘: ‘alex‘}, {‘authors__name‘: ‘egon‘}]>

    # 方式2:
    # 需求: 通過Author表join與其關聯的Book表,屬於反向查詢:按表名小寫book通知ORM引擎join book_authors與book表
    ret=Author.objects.filter(book__title="西遊記").values("name")
    print(ret) # <QuerySet [{‘name‘: ‘alex‘}, {‘name‘: ‘egon‘}]>

一對一

# 一對一查詢的查詢 : 查詢alex的手機號

    # 方式1:
    # 需求: 通過Author表join與其關聯的AuthorDetail表,屬於正向查詢:按字段authordetail通知ORM引擎join Authordetail表

    ret=Author.objects.filter(name="alex").values("authordetail__telephone")
    print(ret) # <QuerySet [{‘authordetail__telephone‘: 110}]>

    # # 方式2:
    # # 需求: 通過AuthorDetail表join與其關聯的Author表,屬於反向查詢:按表名小寫author通知ORM引擎join Author表
    ret=AuthorDetail.objects.filter(author__name="alex").values("telephone")
    print(ret) # <QuerySet [{‘telephone‘: 110}]>

連續跨表查詢

# 練習: 手機號以110開頭的作者出版過的所有書籍名稱以及書籍出版社名稱

    # 方式1:
    # 需求: 通過Book表join AuthorDetail表, Book與AuthorDetail無關聯,所以必需連續跨表
    ret=Book.objects.filter(authors__authordetail__telephone__startswith="110").values("title","publish__name")
    print(ret)
    #
    # 方式2:
    ret=Author.objects.filter(authordetail__telephone__startswith="110").values("book__title","book__publish__name")
    print(ret)

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")

聚合查詢

aggregate(*args, **kwargs) 聚合統計函數

返回值是一個字典

# 計算所有圖書的平均價格

>>> from django.db.models import Avg

>>> Book.objects.all().aggregate(Avg(‘price‘))

{‘price__avg‘: 34.35}

>>> Book.objects.aggregate(average_price=Avg(‘price‘))

{‘average_price‘: 34.35}

>>> from django.db.models import Avg, Max, Min，count

>>> 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中每一個對象都生成一個獨立的統計值（統計方法用聚合函數）。

返回值是queryset

單表分組查詢

emp:

5id  name age   salary    dep
  1   alex  12   2000     銷售部
  2   egon  22   3000     人事部
  3   wen   22   5000     人事部

    # 示例1
    # 查詢每一個部門的名稱以及員工的平均薪水

    SQL：select dep,Avg(salary) from emp group by dep

    ret=Emp.objects.values("dep").annotate(avg_salary=Avg("salary"))
    print(ret) # <QuerySet [{‘avg_salary‘: 5000.0, ‘dep‘: ‘保安部‘}, {‘avg_salary‘: 51000.0, ‘dep‘: ‘教學部‘}]>

    # 單表分組查詢的ORM語法: 單表模型.objects.values("group by的字段").annotate(聚合函數("統計字段"))

    # 示例2
    # 查詢每一個省份的名稱以及員工數

    ret=Emp.objects.values("province").annotate(c=Count("id"))
    print(ret) # <QuerySet [{‘province‘: ‘山東省‘, ‘c‘: 2}, {‘province‘: ‘河北省‘, ‘c‘: 1}]>

    # 補充知識點:

    ret=Emp.objects.all()
    print(ret)  # select * from emp
    ret=Emp.objects.values("name")
    print(ret)  # select name from emp

    Emp.objects.all().annotate(avg_salary=Avg("salary"))  # 在單表分組下，按照主鍵進行group by 沒有意義。

多表分組查詢

Book表

        id   title    date      price  publish_id
        1    紅樓夢    2012-12-12    101       1
        2    西遊記    2012-12-12    101       1
        3    三國演繹    2012-12-12    101       1
        4    水滸傳    2012-12-12    301       2


     Publish表
        id    name      addr   email
        1    人民出版社    北京       123@qq.com
        2    南京出版社    南京       [email protected]

    ## 示例1 查詢每一個出版社的名稱以及出版的書籍個數

    ret = Publish.objects.values("id").annotate(c=Count("book__title"))
    print(ret)  # <QuerySet [{‘nid‘: 1, ‘c‘: 3}, {‘nid‘: 2, ‘c‘: 1}]>

    ret = Publish.objects.values("name").annotate(c=Count("book__title"))
    print(ret)  # <QuerySet [{‘name‘: ‘人民出版社‘, ‘c‘: 3}, {‘name‘: ‘南京出版社‘, ‘c‘: 1}]>

    ret = Publish.objects.values("id").annotate(c=Count("book__title")).values("name", "c") 通過value取值
    print(ret)  # <QuerySet [{‘name‘: ‘人民出版社‘, ‘c‘: 3}, {‘name‘: ‘南京出版社‘, ‘c‘: 1}]>

    ## 示例2 查詢每一個作者的名字以及出版過的書籍的最高價格
    ret = Author.objects.values("pk").annotate(max_price=Max("book__price")).values("name", "max_price")
    print(ret)

    # 總結 跨表的分組查詢的模型:
    # 每一個後表模型.objects.values("pk").annotate(聚合函數(關聯表__統計字段))

    # 示例3 查詢每一個書籍的名稱以及對應的作者個數
    ret = Book.objects.values("pk").annotate(c=Count("authors__name")).values("title", "c")
    print(ret)

    #################### 跨表分組查詢的另一種玩法  ####################

    # 示例1 查詢每一個出版社的名稱以及出版的書籍個數
    # ret=Publish.objects.values("id").annotate(c=Count("book__title")).values("name","email","c") #ret是一個對象，裏面有所有的字段信息
    # ret=Publish.objects.all().annotate(c=Count("book__title")).values("name","c","city")  # all（）按照表publish的所有字段，結果一樣

  # ret=Publish.objects.all().annotate(c=Count("book__title"))顯示兩個publish 對象，而且加all 和不加all也是一樣的
    ret=Publish.objects.annotate(c=Count("book__title")).values("name","c","city")
    print(ret)

總結

# 總結 跨表的分組查詢的模型:
          # 每一個後的表模型.objects.values("pk").annotate(聚合函數(關聯表__統計字段)).values("表模型的所有字段以及統計字段")
          # 每一個後的表模型.objects.annotate(聚合函數(關聯表__統計字段)).values("表模型的所有字段以及統計字段")

臨時給表添加字段

直接在相應的類中添加新字段，

然後必須要添加默認數據，否則會報錯

然後重新遷移數據。

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")

web框架開發-Django模型層(2)-多表操作