Django - ORM - 進階

時間 2020-06-09

標籤 django orm 進階欄目 Python 简体版

原文原文鏈接

1、多表操做

建立模型

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

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

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

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

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

模型創建以下：數據庫

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

生成表以下：django

注意事項：緩存

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

添加表記錄

操做前先簡單的錄入一些數據：app

publish表：ide

author表：

authordetail表:

一對多

 
         1 
       
         2 
       
         3 
       
         4 
       
         5 
       
         6 
       
         方式 
         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 
         )

核心：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：

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

一對多查詢（Publish與Book）

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

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

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

 
         1 
       
         2 
       
         3 
       
         4 
       
         5 
       
         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)：

 
         1 
       
         2 
       
         egon 
         = 
         Author.objects. 
         filter 
         (name 
         = 
         "egon" 
         ).first() 
        
         print 
         (egon.authorDetail.telephone)

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

 
         1 
       
         2 
       
         3 
       
         4 
       
         5 
       
         # 查詢全部住址在北京的做者的姓名 
        
         authorDetail_list 
         = 
         AuthorDetail.objects. 
         filter 
         (addr 
         = 
         "beijing" 
         ) 
        
         for 
         obj  
         in 
         authorDetail_list: 
        
         print 
         (obj.author.name)

多對多查詢（Author與Book）

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

 
         1 
       
         2 
       
         3 
       
         4 
       
         5 
       
         6 
       
         # 金瓶眉全部做者的名字以及手機號 
        
         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)：

 
         1 
       
         2 
       
         3 
       
         4 
       
         5 
       
         6 
       
         # 查詢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 中作一下更改：

 
         1 
       
         publish  
         = 
         ForeignKey(Book, related_name 
         = 
         'bookList' 
         )

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

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

3、基於雙下劃的跨表查詢

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

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

一對一查詢

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

一對多查詢

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

    # 正向查詢 按字段: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")

進階練習（連續跨表）

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


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

4、聚合查詢與分組查詢

聚合

aggregate(*args, **kwargs)

 
         1 
       
         2 
       
         3 
       
         4 
       
         # 計算全部圖書的平均價格 
        
         >>>  
         from 
         django.db.models  
         import 
         Avg 
        
         >>> Book.objects. 
         all 
         ().aggregate(Avg( 
         'price' 
         )) 
        
         { 
         'price__avg' 
         :  
         34.35 
         }

aggregate()是QuerySet 的一個終止子句，意思是說，它返回一個包含一些鍵值對的字典。鍵的名稱是聚合值的標識符，值是計算出來的聚合值。鍵的名稱是按照字段和聚合函數的名稱自動生成出來的。若是你想要爲聚合值指定一個名稱，能夠向聚合子句提供它。

 
         1 
       
         2 
       
         >>> Book.objects.aggregate(average_price 
         = 
         Avg( 
         'price' 
         )) 
        
         { 
         'average_price' 
         :  
         34.35 
         }

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

 
    
     
      
         1 
       

         2 
       

         3 
       
 
       
         >>>  
         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 alex 12   2000 銷售部 egon 22   3000 人事部 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 alex 12   2000       1 egon 22   3000       2 wen 22   5000       2 dep id name 銷售部 人事部 emp－dep: id name age salary dep_id id name alex 12   2000       1      1 銷售部 egon 22   3000       2      2 人事部 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) 練習：統計每個出版社的最便宜的書

 
         1 
       
         2 
       
         3 
       
         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進行排序:

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

5、F查詢與Q查詢（F更新數據庫得字段，Q構造複雜條件）

F查詢

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

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

 
         1 
       
         2 
       
         3 
       
         4 
       
         # 查詢評論數大於收藏數的書籍 
        
         from 
         django.db.models  
         import 
         F 
        
         Book.objects. 
         filter 
         (commnetNum__lt 
         = 
         F( 
         'keepNum' 
         ))

Django 支持 F() 對象之間以及 F() 對象和常數之間的加減乘除和取模的操做。

 
         1 
       
         2 
       
         # 查詢評論數大於收藏數2倍的書籍 
        
         Book.objects. 
         filter 
         (commnetNum__lt 
         = 
         F( 
         'keepNum' 
         ) 
         * 
         2 
         )

修改操做也可使用F函數,好比將每一本書的價格提升30元：

 
         1 
       
         Book.objects. 
         all 
         ().update(price 
         = 
         F( 
         "price" 
         ) 
         + 
         30 
         )

Q查詢

filter() 等方法中的關鍵字參數查詢都是一塊兒進行「AND」的。若是你須要執行更復雜的查詢（例如OR 語句），你可使用Q 對象。

 
         1 
       
         2 
       
         from 
           
         django.db.models  
         import 
           
         Q 
        
         Q(title__startswith 
         = 
         'Py' 
         )

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

 
         1 
       
         bookList 
         = 
         Book.objects. 
         filter 
         (Q(authors__name 
         = 
         "yuan" 
         )|Q(authors__name 
         = 
         "egon" 
         ))

等同於下面的SQL WHERE 子句：

 
         1 
       
         WHERE name  
         = 
         "yuan" 
           
         OR name  
         = 
         "egon"

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

 
         1 
       
         bookList 
         = 
         Book.objects. 
         filter 
         (Q(authors__name 
         = 
         "yuan" 
         ) & ~Q(publishDate__year 
         = 
         2017 
         )).values_list( 
         "title" 
         )

查詢函數能夠混合使用Q 對象和關鍵字參數。全部提供給查詢函數的參數（關鍵字參數或Q 對象）都將"AND」在一塊兒。可是，若是出現Q 對象，它必須位於全部關鍵字參數的前面。例如：

 
         1 
       
         2 
       
         3 
       
         bookList 
         = 
         Book.objects. 
         filter 
         (Q(publishDate__year 
         = 
         2016 
         ) | Q(publishDate__year 
         = 
         2017 
         ), 
        
         title__icontains 
         = 
         "python" 
        
         )

# 查詢是字段名稱
# Book.objects.filter(Q(title='yuan')|Q(price='123'))

# Q() 查詢放str,

search_connection = Q()
search_connection.connector = 'or'
for search_field in self.search_fields:
 search_connection.children.append((search_field,key_words))

data_list = self.model.objects.all().filter(search_connection)

6、QuerySet

可切片

使用Python 的切片語法來限制查詢集記錄的數目。它等同於SQL 的LIMIT 和OFFSET 子句。

 
         1 
       
         >>> Entry.objects. 
         all 
         ()[:5]      # (LIMIT 5)

>>> Entry.objects.all()[5:10]    # (OFFSET 5 LIMIT 5)

不支持負的索引（例如Entry.objects.all()[-1]）。一般，查詢集的切片返回一個新的查詢集 —— 它不會執行查詢。

可迭代

articleList=models.Article.objects.all()

for article in articleList:
    print(article.title)

惰性查詢

查詢集是惰性執行的 —— 建立查詢集不會帶來任何數據庫的訪問。你能夠將過濾器保持一成天，直到查詢集須要求值時，Django 纔會真正運行這個查詢。

 
        1 
      
        2 
      
        3 
      
        4 
      
        5 
      
        6 
      
        queryResult=models.Article.objects. 
        all 
        () #  
        not  
        hits  
        database 
       
        print(queryResult) # hits  
        database 
       
        for  
        article  
        in  
        queryResult: 
       
        print(article.title)    # hits  
        database

通常來講，只有在「請求」查詢集的結果時纔會到數據庫中去獲取它們。當你確實須要結果時，查詢集經過訪問數據庫來求值。

緩存機制

每一個查詢集都包含一個緩存來最小化對數據庫的訪問。理解它是如何工做的將讓你編寫最高效的代碼。

在一個新建立的查詢集中，緩存爲空。首次對查詢集進行求值 —— 同時發生數據庫查詢 ——Django 將保存查詢的結果到查詢集的緩存中並返回明確請求的結果（例如，若是正在迭代查詢集，則返回下一個結果）。接下來對該查詢集的求值將重用緩存的結果。

請牢記這個緩存行爲，由於對查詢集使用不當的話，它會坑你的。例如，下面的語句建立兩個查詢集，對它們求值，而後扔掉它們：

 
        1 
      
        2 
      
        print([a.title  
        for  
        a  
        in  
        models.Article.objects. 
        all 
        ()]) 
       
        print([a.create_time  
        for  
        a  
        in  
        models.Article.objects. 
        all 
        ()])

這意味着相同的數據庫查詢將執行兩次，顯然倍增了你的數據庫負載。同時，還有可能兩個結果列表並不包含相同的數據庫記錄，由於在兩次請求期間有可能有Article被添加進來或刪除掉。爲了不這個問題，只需保存查詢集並從新使用它：

 
        1 
      
        2 
      
        3 
      
        queryResult=models.Article.objects. 
        all 
        () 
       
        print([a.title  
        for  
        a  
        in  
        queryResult]) 
       
        print([a.create_time  
        for  
        a  
        in  
        queryResult])

什麼時候查詢集不會被緩存?

查詢集不會永遠緩存它們的結果。當只對查詢集的部分進行求值時會檢查緩存，若是這個部分不在緩存中，那麼接下來查詢返回的記錄都將不會被緩存。因此，這意味着使用切片或索引來限制查詢集將不會填充緩存。

例如，重複獲取查詢集對象中一個特定的索引將每次都查詢數據庫：

 
        1 
      
        2 
      
        3 
      
        >>> queryset  
        =  
        Entry.objects. 
        all 
        () 
       
        >>>  
        print  
        queryset[ 
        5 
        ]  
        # Queries the database 
       
        >>>  
        print  
        queryset[ 
        5 
        ]  
        # Queries the database again

然而，若是已經對所有查詢集求值過，則將檢查緩存：

 
        1 
      
        2 
      
        3 
      
        4 
      
        >>> queryset  
        =  
        Entry.objects. 
        all 
        () 
       
        >>> [entry  
        for  
        entry  
        in  
        queryset]  
        # Queries the database 
       
        >>>  
        print  
        queryset[ 
        5 
        ]  
        # Uses cache 
       
        >>>  
        print  
        queryset[ 
        5 
        ]  
        # Uses cache

下面是一些其它例子，它們會使得所有的查詢集被求值並填充到緩存中：

 
        1 
      
        2 
      
        3 
      
        4 
      
        >>> [entry  
        for  
        entry  
        in  
        queryset] 
       
        >>>  
        bool 
        (queryset) 
       
        >>> entry  
        in  
        queryset 
       
        >>>  
        list 
        (queryset)

注：簡單地打印查詢集不會填充緩存。

queryResult=models.Article.objects.all()

print (queryResult) # hits database

print (queryResult) # hits database

exists()與iterator()方法

exists：

簡單的使用if語句進行判斷也會徹底執行整個queryset而且把數據放入cache，雖然你並不須要這些數據！爲了不這個，能夠用exists()方法來檢查是否有數據：

if queryResult.exists():
    #SELECT (1) AS "a" FROM "blog_article" LIMIT 1; args=()
        print("exists...")

iterator:

當queryset很是巨大時，cache會成爲問題。

處理成千上萬的記錄時，將它們一次裝入內存是很浪費的。更糟糕的是，巨大的queryset可能會鎖住系統進程，讓你的程序瀕臨崩潰。要避免在遍歷數據的同時產生queryset cache，可使用iterator()方法來獲取數據，處理完數據就將其丟棄。

objs = Book.objects.all().iterator()
# iterator()能夠一次只從數據庫獲取少許數據，這樣能夠節省內存
for obj in objs:
    print(obj.title)
#BUT,再次遍歷沒有打印,由於迭代器已經在上一次遍歷(next)到最後一次了,沒得遍歷了
for obj in objs:
    print(obj.title)

固然，使用iterator()方法來防止生成cache，意味着遍歷同一個queryset時會重複執行查詢。因此使 #用iterator()的時候要小心，確保你的代碼在操做一個大的queryset時沒有重複執行查詢。

總結:

queryset的cache是用於減小程序對數據庫的查詢，在一般的使用下會保證只有在須要的時候纔會查詢數據庫。使用exists()和iterator()方法能夠優化程序對內存的使用。不過，因爲它們並不會生成queryset cache，可能會形成額外的數據庫查詢。　

7、中介模型

處理相似搭配 pizza 和 topping 這樣簡單的多對多關係時，使用標準的ManyToManyField 就能夠了。可是，有時你可能須要關聯數據到兩個模型之間的關係上。

例如，有這樣一個應用，它記錄音樂家所屬的音樂小組。咱們能夠用一個ManyToManyField 表示小組和成員之間的多對多關係。可是，有時你可能想知道更多成員關係的細節，好比成員是什麼時候加入小組的。

對於這些狀況，Django 容許你指定一箇中介模型來定義多對多關係。你能夠將其餘字段放在中介模型裏面。源模型的ManyToManyField 字段將使用through 參數指向中介模型。對於上面的音樂小組的例子，代碼以下：

 
        1 
      
        2 
      
        3 
      
        4 
      
        5 
      
        6 
      
        7 
      
        8 
      
        9 
      
        10 
      
        11 
      
        12 
      
        13 
      
        14 
      
        15 
      
        16 
      
        17 
      
        18 
      
        19 
      
        20 
      
        from  
        django.db  
        import  
        models 
       
        class  
        Person(models.Model): 
       
        name  
        =  
        models.CharField(max_length 
        = 
        128 
        ) 
       
        def  
        __str__( 
        self 
        ):               
        # __unicode__ on Python 2 
       
        return  
        self 
        .name 
       
        class  
        Group(models.Model): 
       
        name  
        =  
        models.CharField(max_length 
        = 
        128 
        ) 
       
        members  
        =  
        models.ManyToManyField(Person, through 
        = 
        'Membership' 
        ) 
       
        def  
        __str__( 
        self 
        ):               
        # __unicode__ on Python 2 
       
        return  
        self 
        .name 
       
        class  
        Membership(models.Model): 
       
        person  
        =  
        models.ForeignKey(Person) 
       
        group  
        =  
        models.ForeignKey(Group) 
       
        date_joined  
        =  
        models.DateField() 
       
        invite_reason  
        =  
        models.CharField(max_length 
        = 
        64 
        )

既然你已經設置好ManyToManyField 來使用中介模型（在這個例子中就是Membership），接下來你要開始建立多對多關係。你要作的就是建立中介模型的實例：

 
        1 
      
        2 
      
        3 
      
        4 
      
        5 
      
        6 
      
        7 
      
        8 
      
        9 
      
        10 
      
        11 
      
        12 
      
        13 
      
        14 
      
        15 
      
        16 
      
        >>> ringo  
        =  
        Person.objects.create(name 
        = 
        "Ringo Starr" 
        ) 
       
        >>> paul  
        =  
        Person.objects.create(name 
        = 
        "Paul McCartney" 
        ) 
       
        >>> beatles  
        =  
        Group.objects.create(name 
        = 
        "The Beatles" 
        ) 
       
        >>> m1  
        =  
        Membership(person 
        = 
        ringo, group 
        = 
        beatles, 
       
        ...     date_joined 
        = 
        date( 
        1962 
        ,  
        8 
        ,  
        16 
        ), 
       
        ...     invite_reason 
        = 
        "Needed a new drummer." 
        ) 
       
        >>> m1.save() 
       
        >>> beatles.members. 
        all 
        () 
       
        [<Person: Ringo Starr>] 
       
        >>> ringo.group_set. 
        all 
        () 
       
        [<Group: The Beatles>] 
       
        >>> m2  
        =  
        Membership.objects.create(person 
        = 
        paul, group 
        = 
        beatles, 
       
        ...     date_joined 
        = 
        date( 
        1960 
        ,  
        8 
        ,  
        1 
        ), 
       
        ...     invite_reason 
        = 
        "Wanted to form a band." 
        ) 
       
        >>> beatles.members. 
        all 
        () 
       
        [<Person: Ringo Starr>, <Person: Paul McCartney>]

與普通的多對多字段不一樣，你不能使用add、 create和賦值語句（好比，beatles.members = [...]）來建立關係：

 
        1 
      
        2 
      
        3 
      
        4 
      
        5 
      
        6 
      
        # THIS WILL NOT WORK 
       
        >>> beatles.members.add(john) 
       
        # NEITHER WILL THIS 
       
        >>> beatles.members.create(name 
        = 
        "George Harrison" 
        ) 
       
        # AND NEITHER WILL THIS 
       
        >>> beatles.members  
        =  
        [john, paul, ringo, george]

爲何不能這樣作？這是由於你不能只建立 Person和 Group之間的關聯關係，你還要指定 Membership模型中所須要的全部信息；而簡單的add、create 和賦值語句是作不到這一點的。因此它們不能在使用中介模型的多對多關係中使用。此時，惟一的辦法就是建立中介模型的實例。

remove()方法被禁用也是出於一樣的緣由。可是clear() 方法倒是可用的。它能夠清空某個實例全部的多對多關係：

 
        1 
      
        2 
      
        3 
      
        4 
      
        5 
      
        >>>  
        # Beatles have broken up 
       
        >>> beatles.members.clear() 
       
        >>>  
        # Note that this deletes the intermediate model instances 
       
        >>> Membership.objects. 
        all 
        () 
       
        []

8、查詢優化

表數據

class UserInfo(AbstractUser): """ 用戶信息 """ nid = models.BigAutoField(primary_key=True) nickname = models.CharField(verbose_name='暱稱', max_length=32) telephone = models.CharField(max_length=11, blank=True, null=True, unique=True, verbose_name='手機號碼') avatar = models.FileField(verbose_name='頭像',upload_to = 'avatar/',default="/avatar/default.png") create_time = models.DateTimeField(verbose_name='建立時間', auto_now_add=True) fans = models.ManyToManyField(verbose_name='粉絲們', to='UserInfo', through='UserFans', related_name='f', through_fields=('user', 'follower')) def __str__(self): return self.username class UserFans(models.Model): """ 互粉關係表 """ nid = models.AutoField(primary_key=True) user = models.ForeignKey(verbose_name='博主', to='UserInfo', to_field='nid', related_name='users') follower = models.ForeignKey(verbose_name='粉絲', to='UserInfo', to_field='nid', related_name='followers') class Blog(models.Model): """ 博客信息 """ nid = models.BigAutoField(primary_key=True) title = models.CharField(verbose_name='我的博客標題', max_length=64) site = models.CharField(verbose_name='我的博客後綴', max_length=32, unique=True) theme = models.CharField(verbose_name='博客主題', max_length=32) user = models.OneToOneField(to='UserInfo', to_field='nid') def __str__(self): return self.title class Category(models.Model): """ 博主我的文章分類表 """ nid = models.AutoField(primary_key=True) title = models.CharField(verbose_name='分類標題', max_length=32) blog = models.ForeignKey(verbose_name='所屬博客', to='Blog', to_field='nid') class Article(models.Model): nid = models.BigAutoField(primary_key=True) title = models.CharField(max_length=50, verbose_name='文章標題') desc = models.CharField(max_length=255, verbose_name='文章描述') read_count = models.IntegerField(default=0) comment_count= models.IntegerField(default=0) up_count = models.IntegerField(default=0) down_count = models.IntegerField(default=0) category = models.ForeignKey(verbose_name='文章類型', to='Category', to_field='nid', null=True) create_time = models.DateField(verbose_name='建立時間') blog = models.ForeignKey(verbose_name='所屬博客', to='Blog', to_field='nid') tags = models.ManyToManyField( to="Tag", through='Article2Tag', through_fields=('article', 'tag'), ) class ArticleDetail(models.Model): """ 文章詳細表 """ nid = models.AutoField(primary_key=True) content = models.TextField(verbose_name='文章內容', ) article = models.OneToOneField(verbose_name='所屬文章', to='Article', to_field='nid') class Comment(models.Model): """ 評論表 """ nid = models.BigAutoField(primary_key=True) article = models.ForeignKey(verbose_name='評論文章', to='Article', to_field='nid') content = models.CharField(verbose_name='評論內容', max_length=255) create_time = models.DateTimeField(verbose_name='建立時間', auto_now_add=True) parent_comment = models.ForeignKey('self', blank=True, null=True, verbose_name='父級評論') user = models.ForeignKey(verbose_name='評論者', to='UserInfo', to_field='nid') up_count = models.IntegerField(default=0) def __str__(self): return self.content class ArticleUpDown(models.Model): """ 點贊表 """ nid = models.AutoField(primary_key=True) user = models.ForeignKey('UserInfo', null=True) article = models.ForeignKey("Article", null=True) models.BooleanField(verbose_name='是否贊') class CommentUp(models.Model): """ 點贊表 """ nid = models.AutoField(primary_key=True) user = models.ForeignKey('UserInfo', null=True) comment = models.ForeignKey("Comment", null=True) class Tag(models.Model): nid = models.AutoField(primary_key=True) title = models.CharField(verbose_name='標籤名稱', max_length=32) blog = models.ForeignKey(verbose_name='所屬博客', to='Blog', to_field='nid') class Article2Tag(models.Model): nid = models.AutoField(primary_key=True) article = models.ForeignKey(verbose_name='文章', to="Article", to_field='nid') tag = models.ForeignKey(verbose_name='標籤', to="Tag", to_field='nid')

View Code

select_related

簡單使用

對於一對一字段（OneToOneField）和外鍵字段（ForeignKey），可使用select_related 來對QuerySet進行優化。

select_related 返回一個QuerySet，當執行它的查詢時它沿着外鍵關係查詢關聯的對象的數據。它會生成一個複雜的查詢並引發性能的損耗，可是在之後使用外鍵關係時將不須要數據庫查詢。

簡單說，在對QuerySet使用select_related()函數後，Django會獲取相應外鍵對應的對象，從而在以後須要的時候沒必要再查詢數據庫了。

下面的例子解釋了普通查詢和select_related() 查詢的區別。

查詢id=2的文章的分類名稱,下面是一個標準的查詢：

 
        1 
      
        2 
      
        3 
      
        4 
      
        5 
      
        # Hits the database. 
       
        article 
        = 
        models.Article.objects.get(nid 
        = 
        2 
        ) 
       
        # Hits the database again to get the related Blog object. 
       
        print 
        (article.category.title)

''' SELECT "blog_article"."nid", "blog_article"."title", "blog_article"."desc", "blog_article"."read_count", "blog_article"."comment_count", "blog_article"."up_count", "blog_article"."down_count", "blog_article"."category_id", "blog_article"."create_time", "blog_article"."blog_id", "blog_article"."article_type_id" FROM "blog_article" WHERE "blog_article"."nid" = 2; args=(2,) SELECT "blog_category"."nid", "blog_category"."title", "blog_category"."blog_id" FROM "blog_category" WHERE "blog_category"."nid" = 4; args=(4,) '''

View Code

若是咱們使用select_related()函數：

 
        articleList=models.Article.objects.select_related( 
        "category" 
        ). 
        all 
        () 
       
        for  
        article_obj  
        in  
        articleList: 
       
        #  Doesn't hit the  
        database 
        , because article_obj.category 
       
        #  has been prepopulated  
        in  
        the previous query. 
       
        print(article_obj.category.title)

SELECT "blog_article"."nid", "blog_article"."title", "blog_article"."desc", "blog_article"."read_count", "blog_article"."comment_count", "blog_article"."up_count", "blog_article"."down_count", "blog_article"."category_id", "blog_article"."create_time", "blog_article"."blog_id", "blog_article"."article_type_id", "blog_category"."nid", "blog_category"."title", "blog_category"."blog_id" FROM "blog_article" LEFT OUTER JOIN "blog_category" ON ("blog_article"."category_id" = "blog_category"."nid");

View Code

多外鍵查詢

這是針對category的外鍵查詢，若是是另一個外鍵呢？讓咱們一塊兒看下：

 
        1 
      
        2 
      
        article=models.Article.objects.select_related( 
        "category" 
        ).get(nid=1) 
       
        print(article.articledetail)

觀察logging結果，發現依然須要查詢兩次，因此須要改成：

 
        1 
      
        2 
      
        article=models.Article.objects.select_related( 
        "category" 
        , 
        "articledetail" 
        ).get(nid=1) 
       
        print(article.articledetail)

或者：

article=models.Article.objects
　　　　　　　　　　　　　.select_related("category")
　　　　　　　　　　　　　.select_related("articledetail")
　　　　　　　　　　　　　.get(nid=1)  # django 1.7 支持鏈式操做
print(article.articledetail)

SELECT "blog_article"."nid", "blog_article"."title", ...... "blog_category"."nid", "blog_category"."title", "blog_category"."blog_id", "blog_articledetail"."nid", "blog_articledetail"."content", "blog_articledetail"."article_id" FROM "blog_article" LEFT OUTER JOIN "blog_category" ON ("blog_article"."category_id" = "blog_category"."nid") LEFT OUTER JOIN "blog_articledetail" ON ("blog_article"."nid" = "blog_articledetail"."article_id") WHERE "blog_article"."nid" = 1; args=(1,)

View Code

深層查詢

 
        1 
      
        2 
      
        3 
      
        4 
      
        # 查詢id=1的文章的用戶姓名 
       
        article=models.Article.objects.select_related( 
        "blog" 
        ).get(nid=1) 
       
        print(article.blog. 
        user 
        .username)

依然須要查詢兩次：

SELECT "blog_article"."nid", "blog_article"."title", ...... "blog_blog"."nid", "blog_blog"."title", FROM "blog_article" INNER JOIN "blog_blog" ON ("blog_article"."blog_id" = "blog_blog"."nid") WHERE "blog_article"."nid" = 1; SELECT "blog_userinfo"."password", "blog_userinfo"."last_login", ...... FROM "blog_userinfo" WHERE "blog_userinfo"."nid" = 1;

View Code

這是由於第一次查詢沒有query到userInfo表，因此，修改以下：

 
        1 
      
        2 
      
        article=models.Article.objects.select_related( 
        "blog__user" 
        ).get(nid=1) 
       
        print(article.blog. 
        user 
        .username)

SELECT "blog_article"."nid", "blog_article"."title", ...... "blog_blog"."nid", "blog_blog"."title", ...... "blog_userinfo"."password", "blog_userinfo"."last_login", ...... FROM "blog_article" INNER JOIN "blog_blog" ON ("blog_article"."blog_id" = "blog_blog"."nid") INNER JOIN "blog_userinfo" ON ("blog_blog"."user_id" = "blog_userinfo"."nid") WHERE "blog_article"."nid" = 1;

View Code

總結

select_related主要針一對一和多對一關係進行優化。
select_related使用SQL的JOIN語句進行優化，經過減小SQL查詢的次數來進行優化、提升性能。
能夠經過可變長參數指定須要select_related的字段名。也能夠經過使用雙下劃線「__」鏈接字段名來實現指定的遞歸查詢。
沒有指定的字段不會緩存，沒有指定的深度不會緩存，若是要訪問的話Django會再次進行SQL查詢。
也能夠經過depth參數指定遞歸的深度，Django會自動緩存指定深度內全部的字段。若是要訪問指定深度外的字段，Django會再次進行SQL查詢。
也接受無參數的調用，Django會盡量深的遞歸查詢全部的字段。但注意有Django遞歸的限制和性能的浪費。
Django >= 1.7，鏈式調用的select_related至關於使用可變長參數。Django < 1.7，鏈式調用會致使前邊的select_related失效，只保留最後一個。

prefetch_related()

對於多對多字段（ManyToManyField）和一對多字段，可使用prefetch_related()來進行優化。

prefetch_related()和select_related()的設計目的很類似，都是爲了減小SQL查詢的數量，可是實現的方式不同。後者是經過JOIN語句，在SQL查詢內解決問題。可是對於多對多關係，使用SQL語句解決就顯得有些不太明智，由於JOIN獲得的表將會很長，會致使SQL語句運行時間的增長和內存佔用的增長。如有n個對象，每一個對象的多對多字段對應Mi條，就會生成Σ(n)Mi 行的結果表。

prefetch_related()的解決方法是，分別查詢每一個表，而後用Python處理他們之間的關係。

 
        1 
      
        2 
      
        3 
      
        4 
      
        5 
      
        # 查詢全部文章關聯的全部標籤 
       
        article_obj=models.Article.objects. 
        all 
        () 
       
        for  
        i  
        in  
        article_obj: 
       
        print(i.tags. 
        all 
        ())  #4篇文章: hits  
        database  
        5

改成prefetch_related：

 
        1 
      
        2 
      
        3 
      
        4 
      
        5 
      
        # 查詢全部文章關聯的全部標籤 
       
        article_obj=models.Article.objects.prefetch_related( 
        "tags" 
        ). 
        all 
        () 
       
        for  
        i  
        in  
        article_obj: 
       
        print(i.tags. 
        all 
        ())  #4篇文章: hits  
        database  
        2

SELECT "blog_article"."nid", "blog_article"."title", ...... FROM "blog_article"; SELECT ("blog_article2tag"."article_id") AS "_prefetch_related_val_article_id", "blog_tag"."nid", "blog_tag"."title", "blog_tag"."blog_id" FROM "blog_tag" INNER JOIN "blog_article2tag" ON ("blog_tag"."nid" = "blog_article2tag"."tag_id") WHERE "blog_article2tag"."article_id" IN (1, 2, 3, 4);

View Code

9、extra

extra(select=None, where=None, params=None, 
      tables=None, order_by=None, select_params=None)

有些狀況下，Django的查詢語法難以簡單的表達複雜的 WHERE 子句，對於這種狀況, Django 提供了 extra() QuerySet修改機制 — 它能在 QuerySet生成的SQL從句中注入新子句

extra能夠指定一個或多個參數,例如 select, where or tables. 這些參數都不是必須的，可是你至少要使用一個!要注意這些額外的方式對不一樣的數據庫引擎可能存在移植性問題.(由於你在顯式的書寫SQL語句),除非萬不得已,儘可能避免這樣作

參數之select

The select 參數可讓你在 SELECT 從句中添加其餘字段信息，它應該是一個字典，存放着屬性名到 SQL 從句的映射。

queryResult=models.Article
　　　　　　　　　　　.objects.extra(select={'is_recent': "create_time > '2017-09-05'"})

結果集中每一個 Entry 對象都有一個額外的屬性is_recent, 它是一個布爾值，表示 Article對象的create_time 是否晚於2017-09-05.

練習：

# in sqlite:
    article_obj=models.Article.objects
　　　　　　　　　　　　　　.filter(nid=1)
　　　　　　　　　　　　　　.extra(select={"standard_time":"strftime('%%Y-%%m-%%d',create_time)"})
　　　　　　　　　　　　　　.values("standard_time","nid","title")
    print(article_obj)
    # <QuerySet [{'title': 'MongoDb 入門教程', 'standard_time': '2017-09-03', 'nid': 1}]>

參數之where / tables

您可使用where定義顯式SQL WHERE子句 - 也許執行非顯式鏈接。您可使用tables手動將表添加到SQL FROM子句。

where和tables都接受字符串列表。全部where參數均爲「與」任何其餘搜索條件。

舉例來說：

queryResult=models.Article
　　　　　　　　　　　.objects.extra(where=['nid in (1,3) OR title like "py%" ','nid>2'])

10、總體插入

建立對象時，儘量使用bulk_create()來減小SQL查詢的數量。例如：

Entry.objects.bulk_create([
    Entry(headline="Python 3.0 Released"),
    Entry(headline="Python 3.1 Planned")
])

...更優於：

Entry.objects.create(headline="Python 3.0 Released")
Entry.objects.create(headline="Python 3.1 Planned")

注意該方法有不少注意事項，因此確保它適用於你的狀況。

這也能夠用在ManyToManyFields中，因此：

my_band.members.add(me, my_friend)

...更優於：

my_band.members.add(me)
my_band.members.add(my_friend)

...其中Bands和Artists具備多對多關聯。

https://www.cnblogs.com/yuanchenqi/articles/8963244.html
https://www.cnblogs.com/yuanchenqi/articles/7570003.htm

11、補充 - query

　　# 查詢沙河出版社 出版社的 書名 價格

    # ret = Publish.objects.filter(name='沙河出版社').values('book__title','book__price')

    # 還有一種寫法：
    # ret = Book.objects.filter(publish__name='沙河出版社').values('title','price')
    #     # print(ret)

    # print(ret.query) # 查詢單條語句的 sql
    """ SELECT "app01_book"."title", "app01_book"."price" FROM "app01_publish" LEFT OUTER JOIN "app01_book" ON ("app01_publish"."nid" = "app01_book"."publish_id") WHERE "app01_publish"."name" = 沙河出版社 """
    """ SELECT "app01_book"."title", "app01_book"."price" FROM "app01_book" INNER JOIN "app01_publish" ON ("app01_book"."publish_id" = "app01_publish"."nid") WHERE "app01_publish"."name" = 沙河出版社 """

    """ select Book.title,Book.price from Publish inner join Book on Publish.pk = Book.publish_id where publish.name = '沙河出版社' """

12、補充 - only defer selected_related prefetch_related （和性能相關得）

ORM補充： a. 需求: 只取某n列 queryset=[ {},{}] models.User.objects.all().values( 'id','name') queryset=[ (),()] models.User.objects.all().values_list( 'id','name') queryset=[ obj,obj] result = models.User.objects.all().only('id','name','age')        # 只取
        # result = models.User.objects.all().defer('id','name','age') # 排除
        for item in reuslt: print(item.id,item.name,item.age) b. 需求: 打印全部用戶姓名以及部門名稱 class depart: title = .... class User: name = ... dp = FK(depart) # select * from user 
        # result = models.User.objects.all()
        # for item in result:
        # print(item.name)
        
        # select * from user left join depart on user.dp_id = depart.id 
        # result = models.User.objects.all().selected_related('dp') # 性能上提升
        # for item in result:
            #print(item.name,item.dp.title )

- only - defer - seleted_related - prefetch_related 示例： class Depart(models.Model): 5個部門 title = models.CharField(...) class User(models.Model): 10個用戶 name = models.CharField(...) email = models.CharField(...) dp = models.FK(Depart) 1.之前的你：11次單表查詢 result = User.objects.all() for item in result: print(item.name,item.dp.title) 2. seleted_related，主動作連表查詢（1次鏈表）（支持onetoone FK） result = User.objects.all().seleted_related('dp') for item in result: print(item.name,item.dp.title) 問題：若是鏈表多，性能愈來愈差。 3. prefetch_related：2次單表查詢 (還支持m2m) # select * from user ;
                # 經過python代碼獲取：dp_id = [1,2]
                # select * from depart where id in dp_id
                result = User.objects.all().prefetch_related('dp') for item in result: print(item.name,item.dp.title) 贈送： 爲何要有FK； 如何沒有FK，全部的數據就都得存在一張表裏；浪費硬盤；下降了查詢速度，插入有約束； 可是： 數據量比較大，不會使用FK，容許出現數據冗餘。由於單表查詢速度快。

十3、orm操做，偏原生sql, using ... 選擇數據庫

- select_related,連表操做，至關於主動作join - prefeth_related,屢次單表操做，先查詢想要的數據，而後構造條件,如：id=[1,2,3]，再次查詢其餘表根據id作條件。 - only - defer - F 更新數據庫字段 - Q 構造複雜條件 - 經過ORM寫偏原生SQL： https://www.cnblogs.com/wupeiqi/articles/6216618.html - extra Entry.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,)) Entry.objects.extra(where=['headline=%s'], params=['Lennon']) Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"]) Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid']) - raw # 執行原生SQL
                models.UserInfo.objects.raw('select * from userinfo') # 若是SQL是其餘表時，必須將名字設置爲當前UserInfo對象的主鍵列名
                models.UserInfo.objects.raw('select id as nid from 其餘表') # 爲原生SQL設置參數
                models.UserInfo.objects.raw('select id as nid from userinfo where nid>%s', params=[12,]) name_map = {'first': 'first_name', 'last': 'last_name', 'bd': 'birth_date', 'pk': 'id'} Person.objects.raw('SELECT * FROM some_other_table', translations=name_map) - 原生SQL from django.db import connection, connections cursor = connection.cursor()  # cursor = connections['default'].cursor()
                cursor.execute("""SELECT * from auth_user where id = %s""", [1]) row = cursor.fetchone() # fetchall()/fetchmany(..)
 PS: 選擇數據庫 queryset = models.Course.objects.using('default').all()