Django之ORM字段及查詢優化

一：常用字段

（1）AutoFiled字段：

（1）作用：

　　（1）int自動遞增字段，其必須傳入primary_key = True 

　　（2）如果模型表中沒有自增列 會自動創建一個名為id的自增列

　　（3）類似於主鍵字段

（2）IntegerField：

（1）作用：

　　（1）整數類型 其范圍在-2147483648 to 2147483647（手機號不會用其存儲 位數不夠 一般使用字符串存儲手機號）

　　（2）相當於整形字段

（3）CharField：

（1）作用：

　　（1）字符類型 必須提供max_length參數

　　（2）相當於字符串類型

　　（3）其類似mysql中的varchar類型，在模型表中是沒有char字段的

（3）DateField：

（1）作用：

　　（1）日期字段，年月日格式

　　（2）類似於python中datetime.time（）

（4）DateTimeField：

（1）作用：

　　（1）日期字段，年月日格式

　　（2）類似於python中datetime.datetime（）

AutoField(Field)
        - int自增列，必須填入參數 primary_key=True

    BigAutoField(AutoField)
        - bigint自增列，必須填入參數 primary_key=True

        注：當model中如果沒有自增列，則自動會創建一個列名為id的列
        from django.db import models

        class UserInfo(models.Model):
            # 自動創建一個列名為id的且為自增的整數列
            username = models.CharField(max_length=32)

        class Group(models.Model):
            # 自定義自增列
            nid = models.AutoField(primary_key=True)
            name = models.CharField(max_length=32)

    SmallIntegerField(IntegerField):
        - 小整數 -32768 ～ 32767

    PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
        - 正小整數 0 ～ 32767
    IntegerField(Field)
        - 整數列(有符號的) -2147483648 ～ 2147483647

    PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
        - 正整數 0 ～ 2147483647

    BigIntegerField(IntegerField):
        - 長整型(有符號的) -9223372036854775808 ～ 9223372036854775807

    BooleanField(Field)
        - 布爾值類型

    NullBooleanField(Field):
        - 可以為空的布爾值

    CharField(Field)
        - 字符類型
        - 必須提供max_length參數， max_length表示字符長度

    TextField(Field)
        - 文本類型

    EmailField(CharField)：
        - 字符串類型，Django Admin以及ModelForm中提供驗證機制

    IPAddressField(Field)
        - 字符串類型，Django Admin以及ModelForm中提供驗證 IPV4 機制

    GenericIPAddressField(Field)
        - 字符串類型，Django Admin以及ModelForm中提供驗證 Ipv4和Ipv6
        - 參數：
            protocol，用於指定Ipv4或Ipv6， 'both',"ipv4","ipv6"
            unpack_ipv4， 如果指定為True，則輸入::ffff:192.0.2.1時候，可解析為192.0.2.1，開啟此功能，需要protocol="both"

    URLField(CharField)
        - 字符串類型，Django Admin以及ModelForm中提供驗證 URL

    SlugField(CharField)
        - 字符串類型，Django Admin以及ModelForm中提供驗證支持 字母、數字、下划線、連接符（減號）

    CommaSeparatedIntegerField(CharField)
        - 字符串類型，格式必須為逗號分割的數字

    UUIDField(Field)
        - 字符串類型，Django Admin以及ModelForm中提供對UUID格式的驗證

    FilePathField(Field)
        - 字符串，Django Admin以及ModelForm中提供讀取文件夾下文件的功能
        - 參數：
                path,                      文件夾路徑
                match=None,                正則匹配
                recursive=False,           遞歸下面的文件夾
                allow_files=True,          允許文件
                allow_folders=False,       允許文件夾

    FileField(Field)
        - 字符串，路徑保存在數據庫，文件上傳到指定目錄
        - 參數：
            upload_to = ""      上傳文件的保存路徑
            storage = None      存儲組件，默認django.core.files.storage.FileSystemStorage

    ImageField(FileField)
        - 字符串，路徑保存在數據庫，文件上傳到指定目錄
        - 參數：
            upload_to = ""      上傳文件的保存路徑
            storage = None      存儲組件，默認django.core.files.storage.FileSystemStorage
            width_field=None,   上傳圖片的高度保存的數據庫字段名（字符串）
            height_field=None   上傳圖片的寬度保存的數據庫字段名（字符串）

    DateTimeField(DateField)
        - 日期+時間格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]

    DateField(DateTimeCheckMixin, Field)
        - 日期格式      YYYY-MM-DD

    TimeField(DateTimeCheckMixin, Field)
        - 時間格式      HH:MM[:ss[.uuuuuu]]

    DurationField(Field)
        - 長整數，時間間隔，數據庫中按照bigint存儲，ORM中獲取的值為datetime.timedelta類型

    FloatField(Field)
        - 浮點型

    DecimalField(Field)
        - 10進制小數
        - 參數：
            max_digits，小數總長度
            decimal_places，小數位長度

    BinaryField(Field)
        - 二進制類型

 字段合集

對應關系：
    'AutoField': 'integer AUTO_INCREMENT',
    'BigAutoField': 'bigint AUTO_INCREMENT',
    'BinaryField': 'longblob',
    'BooleanField': 'bool',
    'CharField': 'varchar(%(max_length)s)',
    'CommaSeparatedIntegerField': 'varchar(%(max_length)s)',
    'DateField': 'date',
    'DateTimeField': 'datetime',
    'DecimalField': 'numeric(%(max_digits)s, %(decimal_places)s)',
    'DurationField': 'bigint',
    'FileField': 'varchar(%(max_length)s)',
    'FilePathField': 'varchar(%(max_length)s)',
    'FloatField': 'double precision',
    'IntegerField': 'integer',
    'BigIntegerField': 'bigint',
    'IPAddressField': 'char(15)',
    'GenericIPAddressField': 'char(39)',
    'NullBooleanField': 'bool',
    'OneToOneField': 'integer',
    'PositiveIntegerField': 'integer UNSIGNED',
    'PositiveSmallIntegerField': 'smallint UNSIGNED',
    'SlugField': 'varchar(%(max_length)s)',
    'SmallIntegerField': 'smallint',
    'TextField': 'longtext',
    'TimeField': 'time',
    'UUIDField': 'char(32)',

ORM字段與MySQL字段對應關系

二：常用字段參數

（1）null

（1）作用：

　　（1）表示某個字段可以設置為空

　　（2）當給模型表新增字段的時候可以將給字段設置為空 進行新增

（2）使用方式：

email = models.EmailField(null=True)  # 將該字段設置為空

（2）unique

（1）作用：表示某個字段唯一 不能重復

（2）使用方式：

  email = models.EmailField(unique=True)  # 將該字段設置唯一 只是演示使用方式

（3）default

（1）作用：給某個字段設置默認值

（2）使用方式：

email = models.EmailField(default='[e-mail]')  # 只是演示使用方式

（4）auto_now_add

（1）作用：創建數據記錄的時候 會把當前時間記錄

（2）使用方式：

    create_time = models.DateField(auto_now_add=True)

（5）auto_now

（1）作用：只要數據被更新 當前時間都會被記錄

（2）使用方式

    create_time = models.DateField(auto_now=True)

三：關系字段

（1）ForeignKey

（1）作用：

　　（1）外鍵類型在ORM中用來表示外鍵關聯關系，一般把ForeignKey字段設置在 '一對多'中'多'的一方。

　　（2）ForeignKey可以和其他表做關聯關系同時也可以和自身做關聯關系。

（1）字段參數

（1）to

　　（1）作用：設置要關聯的表

（1）to_field

　　（1）作用：設置要關聯的表的字段

（1）on_delete

　　（1）作用：當刪除關聯表中的數據時，當前表與其關聯的行的行為。

（1）models.CASCADE

　　（1）作用：刪除關聯數據，與之關聯也刪除

（1）db_constraint

　　（1）作用：是否在數據庫中創建外鍵約束，默認為True。

models.DO_NOTHING
刪除關聯數據，引發錯誤IntegrityError


models.PROTECT
刪除關聯數據，引發錯誤ProtectedError


models.SET_NULL
刪除關聯數據，與之關聯的值設置為null（前提FK字段需要設置為可空）


models.SET_DEFAULT
刪除關聯數據，與之關聯的值設置為默認值（前提FK字段需要設置默認值）


models.SET

刪除關聯數據，
a. 與之關聯的值設置為指定值，設置：models.SET(值)
b. 與之關聯的值設置為可執行對象的返回值，設置：models.SET(可執行對象)

def func():
    return 10

class MyModel(models.Model):
    user = models.ForeignKey(
        to="User",
        to_field="id"，
        on_delete=models.SET(func)
    )

（2）OneToOneField

（1）作用：

　　（1）一對一字段

　　（2）通常一對一字段用來擴展已有字段。(通俗的說就是一個人的所有信息不是放在一張表里面的，簡單的信息一張表，隱私的信息另一張表，之間通過一對一外鍵關聯)

（2）字段參數

（1）to

　　（1）作用：設置要關聯的表。

to_field

　　（1）作用：設置要關聯的字段。

on_delete

　　（1）作用：當刪除關聯表中的數據時，當前表與其關聯的行的行為。(參考上面的例子)

四：測試操作

（1）作用：在進行一般操作時先配置一下參數，使得我們可以直接在Django頁面中運行我們的測試腳本

（2）在Python腳本中調用Django環境

 

這樣就可以直接運行你的test.py文件來運行測試

（3）必知必會13條

操作下面的操作之前，我們實現創建好了數據表，這里主要演示下面的操作，不再細講創建准備過程

<1> all(): 查詢所有結果

<2> filter(**kwargs): 它包含了與所給篩選條件相匹配的對象

<3> get(**kwargs): 返回與所給篩選條件相匹配的對象，返回結果有且只有一個，如果符合篩選條件的對象超過一個或者沒有都會拋出錯誤。

<4> exclude(**kwargs): 它包含了與所給篩選條件不匹配的對象

<5> values(*field): 返回一個ValueQuerySet——一個特殊的QuerySet，運行后得到的並不是一系列model的實例化對象，而是一個可迭代的字典序列

<6> values_list(*field): 它與values()非常相似，它返回的是一個元組序列，values返回的是一個字典序列

<7> order_by(*field): 對查詢結果排序

<8> reverse(): 對查詢結果反向排序，請注意reverse()通常只能在具有已定義順序的QuerySet上調用(在model類的Meta中指定ordering或調用order_by()方法)。

<9> distinct(): 從返回結果中剔除重復紀錄(如果你查詢跨越多個表，可能在計算QuerySet時得到重復的結果。此時可以使用distinct()，注意只有在PostgreSQL中支持按字段去重。)

<10> count(): 返回數據庫中匹配查詢(QuerySet)的對象數量。

<11> first(): 返回第一條記錄

<12> last(): 返回最后一條記錄

<13> exists(): 如果QuerySet包含數據，就返回True，否則返回False

（4）13個必會操作總結

返回QuerySet對象的方法有

（1）all()

（2）filter()

（3）exclude()

（4）order_by()

（5）reverse()

（6）distinct()

特殊的QuerySet

（1）values()       返回一個可迭代的字典序列

（2）values_list() 返回一個可迭代的元祖序列

返回具體對象的

（1）get()

（2）first()

last()

返回布爾值的方法有

exists()

返回數字的方法有

count()

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'console':{
            'level':'DEBUG',
            'class':'logging.StreamHandler',
        },
    },
    'loggers': {
        'django.db.backends': {
            'handlers': ['console'],
            'propagate': True,
            'level':'DEBUG',
        },
    }
}

 五：下划線單表查詢

（1）表格數據

 

 例如：

# 查詢價格大於200的書籍
    book_obj = models.Book.objects.filter(price__gt=200).first()
    print(book_obj)   # 水滸傳

    # 查詢價格小於200的數據
    book_obj1 = models.Book.objects.filter(price__lt=200).values('title','price')
    print(book_obj1)  # <QuerySet [{'title': '三國演義', 'price': Decimal('99.99')}, {'title': '紅樓夢', 'price': Decimal('199.99')}]>


    # 查詢價格小於等於199.99的書籍
    book_obj = models.Book.objects.filter(price__lte=199.99).values('title','price')
    print(book_obj)  # <QuerySet [{'title': '三國演義', 'price': Decimal('99.99')}, {'title': '紅樓夢', 'price': Decimal('199.99')}]>

    # 查詢價格大於於等於199.99的書籍
    book_obj = models.Book.objects.filter(price__gte=199.99).values('title','price')
    print(book_obj)  # <QuerySet [{'title': '水滸傳', 'price': Decimal('1999.99')}, {'title': '西游記', 'price': Decimal('999.99')}]>

      # 價格要么是199,999,1999 python對數字不敏感 所以此時寫成整形
    res = models.Book.objects.filter(price__in=[199,999,1999]).values('title','price')
    print(res)  # <QuerySet [{'title': '紅樓夢', 'price': Decimal('199.00')}, {'title': '水滸傳', 'price': Decimal('1999.00')}, {'title': '西游記', 'price': Decimal('999.00')}]>

    # 價格范圍在（99-199）顧頭顧尾
    res1 = models.Book.objects.filter(price__range=(99,199)).values('title','price')
    print(res1)  # <QuerySet [{'title': '三國演義', 'price': Decimal('99.00')}, {'title': '紅樓夢', 'price': Decimal('199.00')}]>

    # 拿書名包含sr的
    res2 = models.Book.objects.filter(title__contains='sr')
    print(res2)  # <QuerySet [<Book: 水滸傳sr>]> 僅僅只能去小寫

    res3 = models.Book.objects.filter(title__icontains='sr')
    print(res3)  # <QuerySet [<Book: 三國演義SR>, <Book: 水滸傳sr>]> 忽略大小寫

    # 查詢書名以什么開頭
    res4 = models.Book.objects.filter(title__startswith='三')
    print(res4)  # <QuerySet [<Book: 三國演義SR>]>
    res5 = models.Book.objects.filter(title__endswith='r')
    print(res5)  # <QuerySet [<Book: 水滸傳sr>]>

六：ForeignKey增刪改查

（1）增加

例如：

    # 方法一
    models.Book.objects.create(title='聊齋',price=666.66,publish_id=2)

    # 方法二
    book_obj = models.Publish.objects.filter(pk=2).first()  
    models.Book.objects.create(title='你的名字',price=888.88,publish=book_obj)  

PS：

　　（1）在方法一中 如果直接寫表格中的字段 需要填寫關聯另外一張表的主鍵

　　（2）在方法二中 通過獲取另外一張表生成的對象 然后在本地關聯這個對象

（2）修改

例如：

　　# 數字版的
    models.Book.objects.filter(pk=5).update(title='為了你 木子李')

    # 傳對象版本的
    publish_obj = models.Publish.objects.filter(name='南方').first()

    models.Book.objects.filter(title='為了你 木子李').update(publish=publish_obj)

（3）刪除

 models.Book.objects.filter(pk=5).delete()

七、多對多增刪改查

（1）增加

book_obj = models.Book.objects.filter(pk=10).first()
    res = book_obj.author   # 跳到另外一張表
    res.add(1,2)  # 給book添加了兩個作者
    
    author1 = models.Author.objects.filter(pk=1).first()
    author2 = models.Author.objects.filter(pk=2).first()

    book_obj = models.Book.objects.filter(pk=3).first()
    res = book_obj.author  
    res.add(author1,author2)

PS：

　　（1）在添加值中 既可以寫數字也可以寫對象

　　（2）同時支持一次性填寫多個

（2）修改

# 將主鍵為3的書本 作者改成id為5
    book_obj = models.Book.objects.filter(pk=3).first()
    res = book_obj.author
    res.set(5)  # 報錯 'int' object is not iterable 必須傳入一個可迭代對象
    res.set([5,]) #

    # 將主鍵為10的書本 作者改成id為3和5
    book_obj1 = models.Book.objects.filter(pk=10).first()
    author3 = models.Author.objects.filter(pk=3).first()
    author5 = models.Author.objects.filter(pk=5).first()
    res = book_obj1.author
    res.set([author3,author5])

PS：

　　（1）set()括號內 需要傳一個可迭代對象 
　　（2）可迭代對象中 可以是多個數字組合
　　（3）也可以是多個對象組合 但是不能混合使用

（3）刪除

# 將主鍵為3的書籍作者刪除
    book_obj = models.Book.objects.filter(pk=3).first()
    res = book_obj.author
    res.remove(5)

    # 將主鍵值為10的對應作者id為3與5刪除
    book_obj = models.Book.objects.filter(pk=10).first()
    author3 = models.Author.objects.filter(pk=3).first()
    author5 = models.Author.objects.filter(pk=5).first()
    res = book_obj.author
    res.remove(author3,author5)

    # 將主鍵值為3的書籍所對應的作者都刪除
    book_obj = models.Book.objects.filter(pk=3).first()
    res = book_obj.author
    res.clear()

PS：

　　（1）remove()括號內既可以傳數字 也可以傳對象 

　　（2）並且支持傳對個 逗號隔開即可

　　（3）clear括號內不需要傳任何參數 直接清除所有

八：跨表查詢

（1）正向與反向的概念

一對一
正向：author---關聯字段在author表里--->authordetail        按字段
反向：authordetail---關聯字段在author表里--->author        按表名小寫


一對多
正向：book---關聯字段在book表里--->publish        按字段
反向：publish---關聯字段在book表里--->book        按表名小寫_set.all() 因為一個出版社對應着多個圖書

多對多
正向：book---關聯字段在book表里--->author        按字段
反向：author---關聯字段在book表里--->book        按表名小寫_set.all() 因為一個作者對應着多個圖書

PS：

　　（1）正向查詢通過關聯字段

　　（2）反向查詢通過表名小寫即可

# 1.查詢書籍id是3 的出版社名稱
    book_obj = models.Book.objects.filter(pk=3).first()
    res = book_obj.publish  # 關聯字段 調到出版社表格
    print(res.name)  # 南方


    # 2.查詢書籍id是6 的作者姓名
    book_obj = models.Book.objects.filter(pk=6).first()
    res = book_obj.author
    # print(res)  # app01.Author.None 當查詢結果又多個的時候 會顯示None
    res1 = res.all()
    print(res1)  # <QuerySet [<Author: SR>]>


    # 3.查詢作者是SR的家庭住址
    author_obj = models.Author.objects.filter(name='SR').first()
    res = author_obj. author_detail
    print(res.addr)  # 南京

    # 4.查詢出版社是東方出版社出版的書籍
    publish_obj = models.Publish.objects.filter(name='東方').first()
    res = publish_obj.book_set
    print(res)  # app01.Book.None
    print(res.all())  # <QuerySet [<Book: 三國演義SR>]>

PS：

　　（1）如果查詢結果有多個的時候 需要用到_set

　　（2）否則直接表名小寫即可

# 查詢SR這個作者的年齡和手機號
    #正向查詢
    author_obj = models.Author.objects.filter(name='SR').first()
    res = author_obj.author_detail
    print(res.addr)  # 南京
    print(res.phone) # 110
    
    # 反向查詢
    res = models.AuthorDetail.objects.filter(author__name='SR').values('addr','phone')
    print(res)  # <QuerySet [{'addr': '南京', 'phone': 110}]>
    
    # 查詢手機號是130的作者年齡
    # 正向
    author_obj = models.AuthorDetail.objects.filter(phone=130).first()
    res = author_obj.author
    print(res.age)  # 18

    # 反向
    res = models.Author.objects.filter(author_detail__phone=130).values('age')
    print(res)  # <QuerySet [{'age': 18}]>
    
    # 查詢書籍id是6 的作者的電話號碼
    book_obj = models.Book.objects.filter(pk=6).values('author__author_detail__phone')
    print(book_obj)  # <QuerySet [{'author__author_detail__phone': 110}]>

  # 1.查詢出版社為北方出版社的所有圖書的名字和價格
    res = models.Publish.objects.filter(name='北方出版社').values('book__title','book__price')
    print(res)

    # 2.查詢北方出版社出版的價格大於19的書
    res = models.Book.objects.filter(price__gt=19,publish__name='北方出版社').values('title','publish__name')
    print(res)

（2）聚合查詢/分組查詢

# 聚合查詢(aggregate)

from django.db.models import Max,Min,Count,Avg,Sum

# res = models.Book.objects.aggregate(Sum('price'))
res1 = models.Book.objects.aggregate(Avg('price'))
res2 = models.Book.objects.aggregate(Count('price'))
res3 = models.Book.objects.aggregate(Max('price'))
res4 = models.Book.objects.aggregate(Min('price'))
res5 = models.Book.objects.aggregate(Max('price'),Min('price'),Count('pk'),Avg('price'),Sum('price'))

# 統計每一本書的作者個數
    from django.db.models import Max, Min, Count, Avg, Sum  
    res = models.Book.objects.annotate(author_num = Count('authors')).values('author_num','title')  # author_num 其別名
    print(res)

    # 統計出每個出版社賣的最便宜的書的價格
    res = models.Publish.objects.annotate(mmp = Min('book__price')).values('name','mmp')
    print(res)

    # 統計不止一個作者的圖書
    res = models.Book.objects.annotate(author_num=Count('authors')).filter(author_num__gt=1)
    print(res)

（3）F/Q查詢

　　（1）F查詢:

　　　　（1）可以進行多個字段的比較

　　　　（2）本質就是從數據庫獲取某個字段的值

# 查詢庫存數大於賣出數的書籍
    res = models.Book.objects.filter(kucun__gt=F('maichu'))
    print(res)


    # 將書籍庫存數全部增加1000
    models.Book.objects.update(kucun=F('kucun')+1000)

    # 把所有書名后面加上'新款'

    from django.db.models.functions import Concat
    from django.db.models import Value

    ret3 = models.Book.objects.update(title=Concat(F('title'), Value('新款')))
    models.Book.objects.update(title = F('title')+'新款')  # 不能這么寫

　　（2）Q查詢

　　　　（1）filter() 等方法中逗號隔開的條件是與的關系。 

　　　　（2）如果你需要執行更復雜的查詢（例如OR語句），你可以使用Q對象。

from django.db.models import Q
    # 查詢書籍名稱是三國演義或者價格是444.44
    res = models.Book.objects.filter(title='三國演義',price=444.44)  # filter只支持and關系
    res1 = models.Book.objects.filter(Q(title='三國演義'),Q(price=444))  # 如果用逗號 那么還是and關系
    res2 = models.Book.objects.filter(Q(title='三國演義')|Q(price=444))
    res3 = models.Book.objects.filter(~Q(title='三國演義')|Q(price=444))
    print(res2)

 q = Q()
    q.connector = 'or'  # 修改查詢條件的關系   默認是and
    q.children.append(('title__contains','三國演義'))  # 往列表中添加篩選條件
    q.children.append(('price__gt',444))  # 往列表中添加篩選條件
    res = models.Book.objects.filter(q)  # filter支持你直接傳q對象  但是默認還是and關系
    print(res)

 九：事務

（1）作用：

　　（1）將多個sql操作變成原子性操作，要么同時成功 如果有一條數據失敗了 則回滾

　　（2）保證數據的一致性

（2）使用方式：

# 事務
    # 買一本 跟老男孩學Linux 書
    # 在數據庫層面要做的事兒
    # 1. 創建一條訂單數據
    # 2. 去產品表 將賣出數+1， 庫存數-1
    from django.db.models import F
    from django.db import transaction
    # 開啟事務處理
    try:
        with transaction.atomic():
            # 創建一條訂單數據
            models.Order.objects.create(num="110110111", product_id=1, count=1)
            # 能執行成功
            models.Product.objects.filter(id=1).update(kucun=F("kucun")-1, maichu=F("maichu")+1)
    except Exception as e:
        print(e)

十：數據庫優化機制

（1）惰性查詢

（1）作用

　　（1）ORM查詢數據庫都是惰性查詢 只有當你真正需要數據的時候 才會將數據返回給你

　　（2）其減小了對數據庫的操作 降低了數據庫的壓力

（2）例如：

 （2）only與defer

（1）only:圖解

（2）defer圖解:

 （3）select_related與prefetch_related

（1）select_related圖解:

（2）prefetch_related

##################################################################
# PUBLIC METHODS THAT ALTER ATTRIBUTES AND RETURN A NEW QUERYSET #
##################################################################

def all(self)
    # 獲取所有的數據對象

def filter(self, *args, **kwargs)
    # 條件查詢
    # 條件可以是：參數，字典，Q

def exclude(self, *args, **kwargs)
    # 條件查詢
    # 條件可以是：參數，字典，Q

def select_related(self, *fields)
    性能相關：表之間進行join連表操作，一次性獲取關聯的數據。

    總結：
    1. select_related主要針一對一和多對一關系進行優化。
    2. select_related使用SQL的JOIN語句進行優化，通過減少SQL查詢的次數來進行優化、提高性能。

def prefetch_related(self, *lookups)
    性能相關：多表連表操作時速度會慢，使用其執行多次SQL查詢在Python代碼中實現連表操作。

    總結：
    1. 對於多對多字段（ManyToManyField）和一對多字段，可以使用prefetch_related()來進行優化。
    2. prefetch_related()的優化方式是分別查詢每個表，然后用Python處理他們之間的關系。

def annotate(self, *args, **kwargs)
    # 用於實現聚合group by查詢

    from django.db.models import Count, Avg, Max, Min, Sum

    v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id'))
    # SELECT u_id, COUNT(ui) AS `uid` FROM UserInfo GROUP BY u_id

    v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id')).filter(uid__gt=1)
    # SELECT u_id, COUNT(ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1

    v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id',distinct=True)).filter(uid__gt=1)
    # SELECT u_id, COUNT( DISTINCT ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1

def distinct(self, *field_names)
    # 用於distinct去重
    models.UserInfo.objects.values('nid').distinct()
    # select distinct nid from userinfo

    注：只有在PostgreSQL中才能使用distinct進行去重

def order_by(self, *field_names)
    # 用於排序
    models.UserInfo.objects.all().order_by('-id','age')

def extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
    # 構造額外的查詢條件或者映射，如：子查詢

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

 def reverse(self):
    # 倒序
    models.UserInfo.objects.all().order_by('-nid').reverse()
    # 注：如果存在order_by，reverse則是倒序，如果多個排序則一一倒序


 def defer(self, *fields):
    models.UserInfo.objects.defer('username','id')
    或
    models.UserInfo.objects.filter(...).defer('username','id')
    #映射中排除某列數據

 def only(self, *fields):
    #僅取某個表中的數據
     models.UserInfo.objects.only('username','id')
     或
     models.UserInfo.objects.filter(...).only('username','id')

 def using(self, alias):
     指定使用的數據庫，參數為別名（setting中的設置）


##################################################
# PUBLIC METHODS THAT RETURN A QUERYSET SUBCLASS #
##################################################

def raw(self, raw_query, params=None, translations=None, using=None):
    # 執行原生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)

    # 指定數據庫
    models.UserInfo.objects.raw('select * from userinfo', using="default")

    ################### 原生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(..)


def values(self, *fields):
    # 獲取每行數據為字典格式

def values_list(self, *fields, **kwargs):
    # 獲取每行數據為元祖

def dates(self, field_name, kind, order='ASC'):
    # 根據時間進行某一部分進行去重查找並截取指定內容
    # kind只能是："year"（年）, "month"（年-月）, "day"（年-月-日）
    # order只能是："ASC"  "DESC"
    # 並獲取轉換后的時間
        - year : 年-01-01
        - month: 年-月-01
        - day  : 年-月-日

    models.DatePlus.objects.dates('ctime','day','DESC')

def datetimes(self, field_name, kind, order='ASC', tzinfo=None):
    # 根據時間進行某一部分進行去重查找並截取指定內容，將時間轉換為指定時區時間
    # kind只能是 "year", "month", "day", "hour", "minute", "second"
    # order只能是："ASC"  "DESC"
    # tzinfo時區對象
    models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.UTC)
    models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.timezone('Asia/Shanghai'))

    """
    pip3 install pytz
    import pytz
    pytz.all_timezones
    pytz.timezone(‘Asia/Shanghai’)
    """

def none(self):
    # 空QuerySet對象


####################################
# METHODS THAT DO DATABASE QUERIES #
####################################

def aggregate(self, *args, **kwargs):
   # 聚合函數，獲取字典類型聚合結果
   from django.db.models import Count, Avg, Max, Min, Sum
   result = models.UserInfo.objects.aggregate(k=Count('u_id', distinct=True), n=Count('nid'))
   ===> {'k': 3, 'n': 4}

def count(self):
   # 獲取個數

def get(self, *args, **kwargs):
   # 獲取單個對象

def create(self, **kwargs):
   # 創建對象

def bulk_create(self, objs, batch_size=None):
    # 批量插入
    # batch_size表示一次插入的個數
    objs = [
        models.DDD(name='r11'),
        models.DDD(name='r22')
    ]
    models.DDD.objects.bulk_create(objs, 10)

def get_or_create(self, defaults=None, **kwargs):
    # 如果存在，則獲取，否則，創建
    # defaults 指定創建時，其他字段的值
    obj, created = models.UserInfo.objects.get_or_create(username='root1', defaults={'email': '1111111','u_id': 2, 't_id': 2})

def update_or_create(self, defaults=None, **kwargs):
    # 如果存在，則更新，否則，創建
    # defaults 指定創建時或更新時的其他字段
    obj, created = models.UserInfo.objects.update_or_create(username='root1', defaults={'email': '1111111','u_id': 2, 't_id': 1})

def first(self):
   # 獲取第一個

def last(self):
   # 獲取最后一個

def in_bulk(self, id_list=None):
   # 根據主鍵ID進行查找
   id_list = [11,21,31]
   models.DDD.objects.in_bulk(id_list)

def delete(self):
   # 刪除

def update(self, **kwargs):
    # 更新

def exists(self):
   # 是否有結果

 QuerySet方法大全