Django基礎五之django模型層(二)多表操做

時間 2019-11-09

標籤 django 基礎模型欄目 Python 简体版

原文原文鏈接

本節目錄

一建立模型

　　表和表之間的關係python

　　　　一對1、多對1、多對多　，用book表和publish表本身來想一想關係，想一想裏面的操做，加外鍵約束和不加外鍵約束的區別，一對一的外鍵約束是在一對多的約束上加上惟一約束。mysql

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

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

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

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

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

　　模型創建以下：ide

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) #就是foreignkey+unique，只不過不須要咱們本身來寫參數了，而且orm會自動幫你給這個字段名字拼上一個_id，數據庫中字段名稱爲authorDetail_id

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

#多對多的表關係，咱們學mysql的時候是怎麼創建的，是否是手動建立一個第三張表，而後寫上兩個字段，每一個字段外鍵關聯到另外兩張多對多關係的表，orm的manytomany自動幫咱們建立第三張表，兩種方式創建關係均可以，之後的學習咱們暫時用orm自動建立的第三張表，由於手動建立的第三張表咱們進行orm操做的時候，不少關於多對多關係的表之間的orm語句方法沒法使用
#若是你想刪除某張表，你只須要將這個表註銷掉，而後執行那兩個數據庫同步指令就能夠了，自動就刪除了。
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若是是外鍵字段，那麼它自動是int類型
    publish=models.ForeignKey(to="Publish",to_field="nid",on_delete=models.CASCADE) #foreignkey裏面能夠加不少的參數，都是須要我們學習的，慢慢來，to指向表，to_field指向你關聯的字段，不寫這個，默認會自動關聯主鍵字段，on_delete級聯刪除
　　 字段名稱不須要寫成publish_id，orm在翻譯foreignkey的時候會自動給你這個字段拼上一個_id,這個字段名稱在數據庫裏面就自動變成了publish_id
    # 與Author表創建多對多的關係,ManyToManyField能夠建在兩個模型中的任意一個，自動建立第三張表，而且注意一點，你查看book表的時候，你看不到這個字段，由於這個字段就是建立第三張表的意思，不是建立字段的意思，因此只能說這個book類裏面有authors這個字段屬性
    authors=models.ManyToManyField(to='Author',) #注意不論是一對多仍是多對多，寫to這個參數的時候，最後後面的值是個字符串，否則你就須要將你要關聯的那個表放到這個表的上面

　　建立完這個表，咱們本身能夠經過navicat工具來看看數據庫裏面的那些表，出版社這個表裏面沒有任何的關係字段，這種單表的數據，咱們能夠先添加幾條數據，在進行下面的增刪改查的操做。函數

　　生成表以下：工具

　　注意事項：

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

　　我們的表裏麪包含了一對1、一對多、多對多的關係，咱們基於這幾個表來練習，未來不管有多少張表，都逃脫不了這三個關係，操做起來都是同樣的。

二添加表記錄

　　操做前先簡單的錄入一些數據：仍是create和save兩個方法，和單表的區別就是看看怎麼添加關聯字段的數據

　　publish表：

　　author表：

　　authordetail表:

　　一對多

方式1:
   publish_obj=Publish.objects.get(nid=1) #拿到nid爲1的出版社對象
   book_obj=Book.objects.create(title="金瓶眉",publishDate="2012-12-12",price=100,publish=publish_obj) #出版社對象做爲值給publish，其實就是自動將publish字段變成publish_id,而後將publish_obj的id給取出來賦值給publish_id字段，注意你若是不是publish類的對象確定會報錯的，別亂昂
  
方式2:
   book_obj=Book.objects.create(title="金瓶眉",publishDate="2012-12-12",price=100,publish_id=1)　　#這種是你已經知道這個出版社的id是1了的狀況下能夠這樣寫

　　核心：book_obj.publish與book_obj.publish_id是什麼？

　　多對多

    # 當前生成的書籍對象
    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(*[])

　　數據庫表紀錄生成以下：

　　book表

　　book_authors表

　　核心:book_obj.authors.all()是什麼？

　　多對多關係其它經常使用API：

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

　　接下來要學的查詢就是咱的重點，比較複雜。

三基於對象的跨表查詢

　　一對多查詢（Publish 與 Book）

　　　　正向查詢(按字段：publish)：

# 查詢主鍵爲1的書籍的出版社所在的城市
book_obj=Book.objects.filter(pk=1).first()
# book_obj.publish 是主鍵爲1的書籍對象關聯的出版社對象
print(book_obj.publish.city)

　　　　反向查詢(按表名：book_set)：

publish=Publish.objects.get(name="蘋果出版社")
#publish.book_set.all() : 與蘋果出版社關聯的全部書籍對象集合
book_list=publish.book_set.all()    
for book_obj in book_list:
       print(book_obj.title)

一對一查詢(Author與AuthorDetail)

　　正向查詢(按字段：authorDetail)：

egon=Author.objects.filter(name="egon").first()
print(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(Book, related_name 
           = 
           'bookList' 
           )

　　　　那麼接下來就會如咱們看到這般：

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

四基於雙下劃線的跨表查詢

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

'''
    正向查詢按字段,反向查詢按表名小寫用來告訴ORM引擎join哪張表
'''

一對多查詢

# 練習:  查詢蘋果出版社出版過的全部書籍的名字與價格(一對多)

    # 正向查詢 按字段:publish

    queryResult=Book.objects
　　　　　　　　　　　　.filter(publish__name="蘋果出版社")
　　　　　　　　　　　　.values_list("title","price")

    # 反向查詢 按表名:book

    queryResult=Publish.objects
　　　　　　　　　　　　　　.filter(name="蘋果出版社")
　　　　　　　　　　　　　　.values_list("book__title","book__price")

多對多查詢　　

# 練習: 查詢alex出過的全部書籍的名字(多對多)

    # 正向查詢 按字段:authors:
    queryResult=Book.objects
　　　　　　　　　　　　.filter(authors__name="yuan")
　　　　　　　　　　　　.values_list("title")

    # 反向查詢 按表名:book
    queryResult=Author.objects
　　　　　　　　　　　　　　.filter(name="yuan")
　　　　　　　　　　　　　　.values_list("book__title","book__price")

一對一查詢

    # 查詢alex的手機號
    
    # 正向查詢
    ret=Author.objects.filter(name="alex").values("authordetail__telephone")

    # 反向查詢
    ret=AuthorDetail.objects.filter(author__name="alex").values("telephone")

進階練習(連續跨表)

# 練習: 查詢人民出版社出版過的全部書籍的名字以及做者的姓名


    # 正向查詢
    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__regex="151")
　　　　　　　　　　　　.values_list("title","publish__name")
    # 方式2:    
    ret=Author.objects
              .filter(authordetail__telephone__startswith="151")
              .values("book__title","book__publish__name")

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 
           }

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' 
           )} 
          
 
       
 
      
    

分組

###################################－－單表分組查詢－－#######################################################

查詢每個部門名稱以及對應的員工數

emp:

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


sql語句:
select dep,Count(*) from emp group by dep;

ORM:
emp.objects.values("dep").annotate(c=Count("id")

###################################－－多表分組查詢－－###########################


多表分組查詢：

查詢每個部門名稱以及對應的員工數


emp:

id  name age   salary   dep_id
1   alex  12   2000       1
2   egon  22   3000       2
3   wen   22   5000       2


dep

id   name 
1    銷售部
2    人事部



emp－dep:

id  name age   salary   dep_id   id   name 
1   alex  12   2000       1      1    銷售部
2   egon  22   3000       2      2    人事部
3   wen   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")

class Emp(models.Model):
    name=models.CharField(max_length=32)
    age=models.IntegerField()
    salary=models.DecimalField(max_digits=8,decimal_places=2)
    dep=models.CharField(max_length=32)
    province=models.CharField(max_length=32)

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

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

查詢練習

(1) 練習：統計每個出版社的最便宜的書

 
           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)

'''


SELECT "app01_publish"."name", MIN("app01_book"."price")  AS "MinPrice" FROM "app01_publish" 
LEFT  JOIN "app01_book" ON ("app01_publish"."nid" = "app01_book"."publish_id") 
GROUP BY "app01_publish"."nid", "app01_publish"."name", "app01_publish"."city", "app01_publish"."email" 

'''

(2) 練習：統計每一本書的做者個數

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

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

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

六 ORM執行原生sql語句(瞭解)

　　在模型查詢API不夠用的狀況下，咱們還可使用原始的SQL語句進行查詢。

　　Django 提供兩種方法使用原始SQL進行查詢：一種是使用raw()方法，進行原始SQL查詢並返回模型實例；另外一種是徹底避開模型層，直接執行自定義的SQL語句。

　　執行原生查詢

　　　　raw()管理器方法用於原始的SQL查詢，並返回模型的實例：

　　　　注意：raw()語法查詢必須包含主鍵。

　　　　這個方法執行原始的SQL查詢，並返回一個django.db.models.query.RawQuerySet 實例。這個RawQuerySet 實例能夠像通常的QuerySet那樣，經過迭代來提供對象實例。

　　　　舉個例子：

class Person(models.Model):
    first_name = models.CharField(...)
    last_name = models.CharField(...)
    birth_date = models.DateField(...)

　　能夠像下面這樣執行原生SQL語句

>>> for p in Person.objects.raw('SELECT * FROM myapp_person'):
...     print(p)

　　raw()查詢能夠查詢其餘表的數據。

　　　　舉個例子：

ret = models.Student.objects.raw('select id, tname as hehe from app02_teacher')
    for i in ret:
        print(i.id, i.hehe)

　　raw()方法自動將查詢字段映射到模型字段。還能夠經過translations參數指定一個把查詢的字段名和ORM對象實例的字段名互相對應的字典

d = {'tname': 'haha'}
    ret = models.Student.objects.raw('select * from app02_teacher', translations=d)
    for i in ret:
        print(i.id, i.sname, i.haha)

　　原生SQL還可使用參數，注意不要本身使用字符串格式化拼接SQL語句，防止SQL注入！

d = {'tname': 'haha'}
    ret = models.Student.objects.raw('select * from app02_teacher where id > %s', translations=d, params=[1,])
    for i in ret:
        print(i.id, i.sname, i.haha)

　　直接執行自定義SQL

　　　　有時候raw()方法並不十分好用，不少狀況下咱們不須要將查詢結果映射成模型，或者咱們須要執行DELETE、 INSERT以及UPDATE操做。在這些狀況下，咱們能夠直接訪問數據庫，徹底避開模型層。

　　　　咱們能夠直接從django提供的接口中獲取數據庫鏈接，而後像使用pymysql模塊同樣操做數據庫。

from django.db import connection, connections
cursor = connection.cursor()  # cursor = connections['default'].cursor()
cursor.execute("""SELECT * from auth_user where id = %s""", [1])
ret = cursor.fetchone()

七 Python腳本中調用Django環境(django外部腳本使用models)

若是你想經過本身建立的python文件在django項目中使用django的models，那麼就須要調用django的環境：

import os

if __name__ == '__main__':
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "BMS.settings")
    import django
    django.setup()

    from app01 import models  #引入也要寫在上面三句以後

    books = models.Book.objects.all()
    print(books)