Django系列（四）：多表操做

一、建立模型

例：咱們來假定下面這些概念，字段和關係

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

　　做者詳細模型：把做者的詳情放到詳情表，包含生日，手機號，家庭住址等信息。做者詳情模型和做者模型之間是一對一（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創建一對一的關係，author表自動加authorDetail_id字段
    authorDetail = models.OneToOneField(to="AuthorDetail", on_delete=models.CASCADE)


class AuthorDetail(models.Model):
    nid = models.AutoField(primary_key=True)
    birthday = models.DateField()
    telephone = models.CharField(max_length=32)
    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_id
    publish = models.ForeignKey(to="Publish", to_field="nid", on_delete=models.CASCADE)
    # 與Author表創建多對多的關係,ManyToManyField能夠建在兩個模型中的任意一個，自動建立第三張表book_authors，且第三張表有book_id和author_id字段
    authors = models.ManyToManyField(to='Author', )

 

 注意事項：

　　　　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；

二、添加表記錄

(1)、一對一

    from book.models import Author,AuthorDetail

    tel='110'
    addr='北京'
    name='felix'
    age=18
    birthday='2018-10-10'

    # 先添加做者詳細信息
    authorDetail_obj = AuthorDetail.objects.create(telephone=tel, addr=addr,birthday=birthday)
    # 再添加做者，由於他依賴AuthorDetail表
    Author.objects.create(
        name=name,
        age=age,
        authorDetail=authorDetail_obj)

 （2）、一對多（給關聯字段天機記錄）

    from book.models import Publish, Book

    publish_obj = Publish.objects.create(nid=1,name='felix',city='杭州')
    book_obj = Book.objects.create(
        title="python從入門到放棄",
        publishDate="2012-12-12",
        price=100,
        publish_id=1,  # 字段值賦給字段名
        publish=publish_obj)  # 對象賦值對象

（3）、多對多（核心是給第三張關係表添加記錄）

from book.models import Book, Author
    # book_obj爲當前生成的書籍對象
    book_obj = Book.objects.create(
        title="追風箏的人",
        price=200,
        publishDate="2012-11-12",
        publish_id=1)
    # 查詢出爲書籍綁定的做者對象
    felix = Author.objects.filter(name="felix").first()  # 若felix在Author表主鍵是2
    haha = Author.objects.filter(name="haha").first()  # 若haha在Author表主鍵是1
    # 因Book表與Author表綁定多對多關係,即向關係表book_authors中添加紀錄
    book_obj.authors.add(felix, haha)  # 將某些特定的 model 對象添加到被關聯對象集合

多對多關係的其餘經常使用API

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

例如：

    from book.models import Author, Book
    felix_obj = Author.objects.filter(name="felix").first()
    book = Book.objects.filter(nid=2).first()
    # 解除nid爲2的書籍與做者felix的關係， 
    book.authors.remove(felix_obj)  # 即刪除第三張表中書籍是2，做者是felix的記錄
    # 假設已知felix的id爲1 ，則能夠直接根據id解除關係
    book.authors.remove(1)  # 即刪除第三張表中book_id是2，author_id是1的記錄

    # 刪除nid=2的書籍的全部做者記錄
    book.authors.clear()  # 刪除book_id爲2的全部記錄，無論author_id爲多少

    # 只爲nid=2的做者綁定一個id爲1的做者
    book.authors.set(1)  # 至關於先解除，即clear()，再綁定，即add(1)

三、查詢表記錄

（1）、正向查詢和反向查詢

由關聯字段所在的表去查詢非關聯字段所在的表，就是正向查詢，反之爲反向查詢。例如：

　　 ① 一對多關係，「多」的一方建立關聯字段並經過ForeignKey方法創建關聯關係，即關聯字段所在的表（ForeignKey方法所在的表）去查詢另外一個表時爲正向查詢；反之爲反向查詢。

　　 ② 多對多關係，任一方建立關聯字段並經過ManyToMany方法創建關聯關係，即關聯字段所在的表（ManyToMany方法所在的表）去查詢另外一個表時爲正向查詢；反之爲反向查詢。

　　 ③ 一對一關係，任一方經過建立關聯字段並經過OneToOne方法創建關聯關係，即關聯字段所在的表（OneToOne方法所在的表）去查詢另外一個表時爲正向查詢；反之爲反向查詢。

（2）、基於對象跨表查詢（會被翻譯成sql子查詢）

a、一對多查詢（Publish表和Book表，且Book表爲關聯字段所在的表）

    from book.models import Book,Publish
    # 一、正向查詢（按字段：publish）（多查一）
    # 查詢主鍵爲1的書籍的出版社所在城市
    book_obj = Book.objects.filter(pk=1).first()
    publish_obj = book_obj.publish  # 主鍵爲1的書籍對象關聯的出版社對象
    print(publish_obj.city)
    
    # 二、反向查詢（按表名：book_set）（一查多）
    # 查詢蘋果出版社出版的全部書籍名稱
    publish = Publish.objects.get(name="哈哈出版社")
    book_list = publish.book_set.all()  # 與哈哈出版社關聯的全部書籍對象集合（QuerySet類型）
    for book_obj in book_list:
        print(book_obj.title)

b、多對多查詢（Author與Book）

    from book.models import Book,Author
    # 一、正向查詢（按字段：authors）
    # 查詢金瓶眉這本書全部做者的名字以及手機號
    book_obj = Book.objects.filter(title="python從入門到放棄")[0]
    print('book_obj',book_obj.authors)
    authors_list = book_obj.authors.all()
    for author_obj in authors_list:
        print(author_obj.name, author_obj.authorDetail.telephone)

    # 二、反向查詢（按表名：book_set）
    # 查詢felix寫的全部書籍的名字
    author_obj = Author.objects.get(name="felix")
    book_list = author_obj.book_set.all()  # 與felix做者相關的全部書籍
    for book_obj in book_list:
        print(book_obj.title)

c、一對一查詢（Author與AuthorDetail）

    from book.models import Author,AuthorDetail
    # 一、正向查詢（按字段：authorDetail）
    felix=Author.objects.filter(name='felix').first()
    print(felix.authorDetail.telephone)

    # 二、反向查詢（按表名：author）
    authorDetail_list = AuthorDetail.objects.filter(addr="北京")
    for obj in authorDetail_list:
        print(obj.author.name)

注意：你能夠經過在ForeignKey()和ManyToManyField()的定義中設置 related_name 的值來覆寫「表名_set」的名稱。例如，若是 Book表中作如下更改：

    publish = models.ForeignKey(Publish, related_name='bookList', on_delete=models.CASCADE)

使用：

    # 查詢人民出版社出版過的全部書籍
    publish=Publish.objects.get(name="人民出版社")
    book_list=publish.bookList.all()    # 與人民出版社關聯的全部書籍對象集合

四、補充

（1）、ForeignKey(to="Publish", to_field="nid", on_delete=models.CASCADE)方法參數解釋

to="Publish"：表示跟Publish表創建一對多關係，也能夠直接寫成"Publish"（須要帶引號，不帶引號則models.py中創建表時有順序要求，即關聯表Publish在前邊）；
to_field="nid"：跟關聯表（這裏是Publish表）的哪一個字段創建聯繫，此參數不寫則默認跟主鍵字段創建聯繫；
on_delete=models.CASCADE：級聯刪除（即同步刪除，同步更新），Django1.11版本默認就是級聯刪除，可不寫，但2版本要求必須寫，不然報錯；

五、多表查詢

（1）、基於雙下劃線的跨表查詢

Django 還提供了一種直觀而高效的方式在查詢(lookups)中表示關聯關係，它能自動確認 SQL JOIN 聯繫。要作跨關係查詢，就使用兩個下劃線來連接模型(model)間關聯字段的名稱，直到最終連接到你想要的model 爲止。

語法：正向查詢按字段，反向查詢按表名小寫，用來告訴ORM引擎join哪張表。

a、一對多查詢

實例一：查詢哈哈出版社出版過的全部書籍的名字與價格

    from book.models import Book, Publish
    # 正向查詢 按字段：publish
    result = Book.objects.filter(publish__name='哈哈出版社').values_list('title', 'price')
    print('result',result)
    # 反向查詢 按表名小寫：book
    result2 = Publish.objects.filter('哈哈出版社').values_list('book__title', 'book__price')
    print('result2',result2)

實例二：查詢python從入門到放棄這本書的出版社的名字和郵箱

    # 正向查詢
    Book.objects.filter(title="python").values("publish__name", "publish__email")

    # 反向查詢
    Publish.objects.filter(book__title="python").values("name", "email")

b、多對多查詢

實例一：查詢felix出過的全部書籍的名字

    # 正向查詢 按字段：authors:
    queryResult = Book.objects.filter(authors__name="felix").values_list("title")
    # 反向查詢 按表名小寫：book
    queryResult = Author.objects.filter(name="felix").values_list("book__title", "book__price")

實例二：查詢python從入門到放棄這本書的做者的年齡

    # 正向查詢
    Book.objects.filter(title="python").values("author__age")
    # 反向查詢
    Author.objects.filter(book__title="python").values("age")

c、一對一查詢

實例一：查詢felix的手機號

    # 正向查詢 按字段：authorDetail
    ret = Author.objects.filter(name="felix").values("authorDetail__telephone")
    # 反向查詢 按表名小寫：author
    ret = AuthorDetail.objects.filter(author__name="felix").values("telephone")

實例二：查詢手機號以110開頭的做者的名字

    # 正向查詢
    Author.objects.filter(authorDetail__telephone__startswith="110").values("name")
    # 反向查詢
    AuthorDetail.objects.filter(telephone__startswith="110").values("author__name")

d、連續跨表查詢

實例一：查詢哈哈出版社出版過的全部書籍的名字以及做者的姓名

    # 正向查詢
    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")

實例二：手機號以151開頭的做者出版過的全部書籍名稱以及出版社名稱

    # 方式1：
    queryResult=Book.objects.filter(authors__authorDetail__telephone__startswith="151").values_list("title","publish__name")
    # 方式2：
    ret=Author.objects.filter(authorDetail__telephone__startswith="151").values("book__title","book__publish__name")

e、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 # 首先導入聚合函數Avg ret = Book.objects.all().aggregate(Avg('price')) print(ret) # 結果爲：{'price__avg': 34.35}

       aggregate()是QuerySet 的一個終止子句，意思是說，它返回一個包含一些鍵值對的字典。鍵的名稱是聚合值的標識符，值是計算出來的聚合值。鍵的名稱是按照字段和聚合函數的名稱自動生成出來的。若是你想要爲聚合值指定一個名稱，能夠向聚合子句提供它。而且all()方法也能夠不寫，默認查詢全部，以下示例：

    ret = Book.objects.aggregate(average_price=Avg('price')) print(ret) # 結果爲：{'average_price': 34.35}

       若是你但願生成不止一個聚合函數，你能夠向aggregate()子句中添加另外一個參數。因此，若是你也想知道全部圖書價格的最大值和最小值，能夠這樣查詢：

    from django.db.models import Avg, Max, Min # 導入聚合函數 ret = Book.objects.aggregate(Avg('price'), Max('price'), Min('price')) print(ret) # 結果爲：{'price__avg': 34.35, 'price__max': Decimal('81.20'), 'price__min': Decimal('12.99')}

七、分組查詢

a、單表分組查詢

實例一：查詢每個部門名稱以及對應的員工數，員工表以下：

emp表：
    id  name  age   salary    dep
    1   felix  12    2000     銷售部
    2   haha  22    3000     人事部
    3   hehe   22    5000     人事部
    
    SQL語句：select dep,Count(*) from emp group by dep;
    ORM：emp.objects.values("dep").annotate(c=Count("id")

b、多表分組查詢

實例一：查詢每個部門名稱以及對應的員工數，表以下：

emp表：
     id  name  age   salary   dep_id
    1   felix   12   2000       1
    2   haha  22   3000       2
    3   hehe   22   5000       2

dep表：
     id   name 
     1    銷售部
     2    人事部

emp－dep：
     id  name  age   salary   dep_id   id   name 
     1   felix   12   2000       1      1    銷售部
     2   haha  22   3000       2      2    人事部
     3   hehe   22   5000       2      2    人事部

    SQL語句：select dep.name,Count(*) from emp left join dep on emp.dep_id=dep.id group by dep.id;

    ORM：dep.objetcs.values("id").annotate(c=Count("emp")).values("name","c")

總結：

　　 1）annotate()爲調用的QuerySet中每個對象都生成一個獨立的統計值（統計方法用聚合函數）。

　　 2）跨表分組查詢本質就是將關聯表join成一張表，再按單表的思路進行分組查詢。

c、查詢實例

示例一：統計每個出版社的最便宜的書

    publishList = Publish.objects.annotate(MinPrice=Min("book__price")) for publish_obj in publishList: print(publish_obj.name,publish_obj.MinPrice)

annotate的返回值是querySet，若是不想遍歷對象，能夠用上value_list()方法，以下：

    queryResult = Publish.objects.annotate(MinPrice=Min("book__price")).values_list("name","MinPrice") 　　　　 print(queryResult)

示例二：統計每一本書的做者個數

　　 ret = Book.objects.annotate(authorsNum=Count('authors__name'))

示例三：統計每一本以py開頭的書籍的做者個數

    queryResult = Book.objects.filter(title__startswith="Py").annotate(num_authors=Count('authors'))

示例四：統計不止一個做者的圖書

    queryResult = Book.objects.annotate(num_authors=Count('authors')).filter(num_authors__gt=1)

示例五：根據一本圖書做者數量的多少對查詢集 QuerySet進行排序

    queryResult = Book.objects.annotate(num_authors=Count('authors')).order_by('num_authors')

示例六：查詢各個做者出的書的總價格

    # 按author表的全部字段 group by queryResult = Author.objects.annotate(SumPrice=Sum("book__price")).values_list("name","SumPrice") 　　　　 print(queryResult)

八、F查詢

在上面全部的例子中，咱們構造的過濾器都只是將字段值與某個常量作比較。若是咱們要對兩個字段的值作比較，那該怎麼作呢？

       Django 提供 F() 來作這樣的比較。F()的實例能夠在查詢中引用字段，來比較同一個 model 實例中兩個不一樣字段的值。

       示例一：查詢評論數大於收藏數的書籍

    from django.db.models import F # 導入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函數 Q(title__startswith='Py') # 將要關鍵字查詢條件放入Q方法中

　　Q 對象可使用&和|操做符組合起來。當一個操做符在兩個Q對象上使用時，它產生一個新的Q 對象。

       示例一：

    bookList=Book.objects.filter(Q(authors__name="felix")|Q(authors__name="haha")) # 上面等同於下面的SQL WHERE子句： WHERE name ="felix" OR name ="haha"

       示例二：你能夠組合「&」和「|」操做符以及使用括號進行分組來編寫任意複雜的Q 對象。同時，Q 對象可使用「~」操做符取反，這容許組合正常的查詢和取反(NOT) 查詢：

    booklist = Book.objects.filter(Q(authors__name="felix") & ~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）在項目目錄下建立static文件夾；

2）項目中用到的靜態資源如圖片，js文件，bootstrap文件等放到static中（static中再分別建立img、js、bootstrap、css文件夾用於存放這些文件）；

3）在項目的settings.py文件中，STATIC_URL = "/static/" 下邊加上以下代碼：

    STATICFILES_URLS = [
        os.join.path(BASE_DIR, "static") ]