1、創建模型

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

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

　　作者詳細模型：把作者的詳情放到詳情表，包含生日，手機號，家庭住址等信息。作者詳情模型和作者模型之間是一對一（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；

2、添加表記錄

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

3、查詢表記錄

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

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

　　 ① 一對多關系，“多”的一方創建關聯字段並通過ForeignKey方法建立關聯關系，即關聯字段所在的表（ForeignKey方法所在的表）去查詢另一個表時為正向查詢；反之為反向查詢。

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

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

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

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

    from book.models import Book,Publish
    # 1、正向查詢（按字段：publish）（多查一）
    # 查詢主鍵為1的書籍的出版社所在城市
    book_obj = Book.objects.filter(pk=1).first()
    publish_obj = book_obj.publish  # 主鍵為1的書籍對象關聯的出版社對象
    print(publish_obj.city)
    
    # 2、反向查詢（按表名：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
    # 1、正向查詢（按字段：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)

    # 2、反向查詢（按表名：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
    # 1、正向查詢（按字段：authorDetail）
    felix=Author.objects.filter(name=‘felix‘).first()
    print(felix.authorDetail.telephone)

    # 2、反向查詢（按表名：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()    # 與人民出版社關聯的所有書籍對象集合

4、補充

（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版本要求必須寫，否則報錯；

5、多表查詢

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

6、聚合查詢

語法：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‘)}

7、分組查詢

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)

8、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)

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

10、其他

靜態文件設置：

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

Django系列（四）：多表操作