Django之ORM進階

時間 2019-12-14

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

原文原文鏈接

老師的博客：http://www.javashuo.com/article/p-emhmbenx-bp.htmlhtml

ORM相關練習題：http://www.javashuo.com/article/p-bmkubvhy-bx.htmlpython

首先是如何在python腳本中調用Django項目環境mysql

在項目新建個py文件，而後輸入如下代碼：git

import os

if __name__ == '__main__':
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "BMS.settings")#BMS表示項目的名稱
    import django
    django.setup()

    from app01 import models

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

固然你也可在pycharm中的console中跑起來程序員

可是比較麻煩，並且每次更改後須要從新啓動項目sql

通常操做

看專業的官網文檔，作專業的程序員！數據庫

必需掌握的十三條：

<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

下面是課上敲的代碼django

import os

if __name__ == '__main__':
    # 加載Django的配置信心
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day68.settings")#day68是項目名稱
    # 導入Django項目，而且跑起來
    import django
    django.setup()
    from app01 import models
    # < 1 > all(): 查詢全部結果
    info1=models.Test_Day68.objects.all()

    # < 2 > filter(**kwargs): 它包含了與所給篩選條件相匹配的對象 filter沒有查詢到，不會報錯，會返回一個空的Queryset就，而get則報錯
    # 就算查詢的結果只有一個，返回的也是QuerySet，咱們要用索引的方式取出第一個元素
    info2=models.Test_Day68.objects.filter(id=1)[0]
    print(info2)

    # < 3 > get(**kwargs): 返回與所給篩選條件相匹配的對象，返回結果有且只有一個，若是符合篩選條件的對象超過一個或者沒有都會拋出錯誤。
    info3 = models.Test_Day68.objects.filter(id=1)[0]
    print(info3)

    # < 4 > exclude(**kwargs): 它包含了與所給篩選條件不匹配的對象,返回的也是QuerySet
    info4=models.Test_Day68.objects.exclude(id=1)
    print(info4)

    # < 5 > values(*field): 返回一個ValueQuerySet——一個特殊的QuerySet，運行後獲得的並非一系列model的實例化對象，而是一個可迭代的字典序列
    #全部的取到了
    info5=models.Test_Day68.objects.values("id","name")
    for i in info5:
        print("info5:",i)

    # < 6 > values_list(*field): 它與values()
    # 很是類似，它返回的是一個元組序列，values返回的是一個字典序列,返回的也是QuerySet，
    info6 = models.Test_Day68.objects.values_list("id", "name")
    print("info6:",info6,type(info6))

    # < 7 > order_by(*field): 對查詢結果排序,返回的也是QuerySet，，
    info7 = models.Test_Day68.objects.all().order_by("id","birthday")
    print("info7:",info7)

    # < 8 > reverse(): 對查詢結果反向排序，請注意reverse(),返回的也是QuerySet，
    # 一般只能在具備已定義順序的QuerySet上調用(在model類的Meta中指定ordering或調用order_by()
    # 方法)。
    info8 = models.Test_Day68.objects.all().order_by("id", "birthday").reverse()
    print("info8:", info8)

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

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

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

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

    # < 13 > exists(): 若是QuerySet包含數據，就返回True，不然返回False
    info13 = models.Test_Day68.objects.all().exists()
    print("info13:", info13)

複習

返回QuerySet對象的方法有

all()後端

filter()瀏覽器

exclude()

order_by()

reverse()

distinct()

特殊的QuerySet

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

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

返回具體對象的

get()

first()

last()

返回布爾值的方法有：

exists()

返回數字的方法有

count()

單表查詢之神奇的雙下劃線

models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 獲取id大於1 且 小於10的值
 
models.Tb1.objects.filter(id__in=[11, 22, 33])   # 獲取id等於十一、22、33的數據
models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in
 
models.Tb1.objects.filter(name__contains="ven")  # 獲取name字段包含"ven"的
models.Tb1.objects.filter(name__icontains="ven") # icontains大小寫不敏感
 
models.Tb1.objects.filter(id__range=[1, 3])      # id範圍是1到3的，等價於SQL的bettwen and
 
相似的還有：startswith，istartswith, endswith, iendswith　

date字段還能夠：
models.Class.objects.filter(first_day__year=2017)

上課代碼：

# models.Tb1.objects.filter(id__lt=10, id__gt=1)  # 獲取id大於1 且 小於10的值
    info1=models.Book.objects.filter(id__gt=1,id__lt=4) #gt=greater than lt=lower than
    print(info1)

    # models.Tb1.objects.filter(id__in=[11, 22, 33])  # 獲取id等於十一、22、33的數據
    # models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in
    print(models.Book.objects.filter(id__in=[1,2,3]))
    print(models.Book.objects.exclude(id__in=[1]))

    # models.Tb1.objects.filter(name__contains="ven")  # 獲取name字段包含"ven"的
    # models.Tb1.objects.filter(name__icontains="ven")  # icontains大小寫不敏感
    print(models.publisher.objects.filter(name__contains="出版社"))
    print(models.publisher.objects.filter(name__contains="2"))
    # models.Tb1.objects.filter(id__range=[1, 3])  # id範圍是1到3的，等價於SQL的bettwen and

    # 相似的還有：startswith，istartswith, endswith, iendswith　

    # date字段還能夠：
    # models.Class.objects.filter(first_day__year=2017)
    print(models.Test_Day68.objects.filter(birthday__year=1995))

上課代碼

FOReign_key操做

forengin_key查詢時有正向查詢和反向查詢

正向查詢

book_obj = models.Book.objects.first()  # 第一本書對象
print(book_obj.publisher)  # 獲得這本書關聯的出版社對象
print(book_obj.publisher.name)  # 獲得出版社對象的名稱

或者

print(models.Book.objects.values_list("publisher__name"))

反向查詢

對象查找

語法：

obj.表名_set

示例：

publisher_obj = models.Publisher.objects.first()  # 找到第一個出版社對象
books = publisher_obj.book_set.all()  # 找到第一個出版社出版的全部書
titles = books.values_list("title")  # 找到第一個出版社出版的全部書的書名

字段查找

語法：

表名__字段

示例：

titles = models.Publisher.objects.values_list("book__title")

補充：

在class中設置時：若是添加了

related_name="qu"

例如：

publisher=models.ForeignKey(to="Publisher",related_name="qu")

則對象查詢則變爲：

對象查詢：
    publisher_obj = models.Publisher.objects.first()
    print(publisher_obj.qu.all())
    字段查詢
    print(models.Publisher.objects.values_list("qu__name"))

ManyToManyField

這個有點複雜，先把建立的表拿出來，這樣便於理解

#出版社列表
class Publisher(models.Model):
    id=models.AutoField(primary_key=True)
    name=models.CharField(max_length=32, null=False)
    def __str__(self):
        return "id:{},name:{}".format(self.id,self.name)
#書籍列表
class Book(models.Model):
    id=models.AutoField(primary_key=True)
    name=models.CharField(max_length=32,null=False)
    publisher=models.ForeignKey(to="Publisher",related_name="qu")
    def __str__(self):
        return "id:{},name:{},publisher:{}".format(self.id, self.name, self.publisher.name)

#做者列表
class Author(models.Model):
    id=models.AutoField(primary_key=True)
    name=models.CharField(max_length=32,null=False)
    book=models.ManyToManyField(to="Book")
    def __str__(self):
        print("嚶嚶嚶")
        return self

各大表類

方法

# 查詢
    author_obj = models.Author.objects.filter(id=1)[0]
    print(author_obj.book.all())

    #    create()
    # 經過做者建立一本書,會自動保存
    # 作了兩件事：
    # 1. 在book表裏面建立一本新書，2. 在做者和書的關係表中添加關聯記錄
    author_obj=models.Author.objects.filter(id=1)[0]
    author_obj.book.create(name="金老闆的輝煌的一輩子",publisher_id=3)

    # add（）
    author_obj.book.add(5)
    """
    等價於
    book_obj=models.Book.objects.get(id=5)
    author_obj.book.add(book_obj)
    """
    # 添加多本
    book_obj=models.Book.objects.filter(id__lt=5)
    author_obj2=models.Author.objects.get(id=4)
    author_obj2.book.add(*book_obj) # 要把列表打散再傳進去

    # remove 移除
    author_obj.book.remove(3)
    # 同理，能夠同上面的各項操做

    #clear 清除
    author_obj3=models.Author.objects.get(id=2)
    author_obj3.book.clear()

    #額外補充 外鍵的反向操做
    publisher_obj=models.Publisher.objects.get(id=2)
    #注意此時的外鍵設置能爲空才行，null=true
    publisher_obj.qu.clear()

注意：

對於全部類型的關聯字段，add()、create()、remove()和clear(),set()都會立刻更新數據庫。換句話說，在關聯的任何一端，都不須要再調用save()方法。

聚合查詢和分組查詢

聚合

使用方法：

在上面的Book表中加上

price=models.DecimalField(max_digits=5,decimal_places=2,default=999.99)

而後聚合操做：

from django.db.models import Avg, Sum, Max, Min, Count
    print(models.Book.objects.all().aggregate(全部書的平均價格=Avg("price")))
    #輸出結果：{'全部書的平均價格': 171.825}

    print(models.Book.objects.all().aggregate(Sum("price"), Max("price"), Min("price"),Count("price")))
    """輸出結果：
    {'price__sum': Decimal('1030.95'),
     'price__min': Decimal('1.99'), 
    'price__max': Decimal('555.99'), 
    'price__count': 6}
    """

分組操做

下面是老師博客複製粘貼的

咱們在這裏先複習一下SQL語句的分組。

假設如今有一張公司職員表：

咱們使用原生SQL語句，按照部分分組求平均工資：

select dept,AVG(salary) from employee group by dept;

ORM查詢:

from django.db.models import Avg
Employee.objects.values("dept").annotate(avg=Avg("salary").values(dept, "avg")

連表查詢的分組：

SQL查詢：

select dept.name,AVG(salary) from employee inner join dept on (employee.dept_id=dept.id) group by dept_id;

ORM查詢：

from django.db.models import Avg
models.Dept.objects.annotate(avg=Avg("employee__salary")).values("name", "avg")

下面是本身的拙見：

下來看下面的代碼：

ret=models.Book.objects.all().annotate(author_conut=Count("author"))

而後經過配置settting獲得翻譯的SQL語句：

"""
SELECT 
`app01_book`.`id`,
 `app01_book`.`price`,
  `app01_book`.`name`,
   `app01_book`.`publisher_id`,
    COUNT(`app01_author_book`.`author_id`) AS `author_conut` 
    FROM `app01_book` LEFT OUTER JOIN `app01_author_book` 
    ON (`app01_book`.`id` = `app01_author_book`.`book_id`) 
    GROUP BY `app01_book`.`id` ORDER BY NULL; args=()
"""

簡單來講就是經過找Book表上的id與Author表中的manytomanyfield的多打對上的表進行連表，而後經過Book.id 相等來進行連表

在看代碼：

ret=models.Book.objects.all().annotate(author_conut=Count("price"))

同理SQL語句是：

"""
SELECT
    `app01_book`.`id`,
`app01_book`.`price`,
`app01_book`.`name`,
`app01_book`.`publisher_id`,
COUNT(`app01_book`.`publisher_id`) AS `author_conut`
FROM `app01_book` GROUP BY `app01_book`.`id` ORDER BY NULL; args=()
"""

直接經過id來進行分組

因此在上面能夠看出，若是是跨表操做的話，就是先經過id相等，而後在進行id分組。若是單表的話，直接根據id分組；

好吧我知道了。他通常是根據最開始的那一行來（及id）取得

不知道是否是我是否是沒有找到正確的方法，因此得出以上的結論

下面又是新發現：

經過特定分組：

ret1=models.Book.objects.values("price").annotate(sum=Sum("price"))。values（"author__id","book"）

這樣就是按price分組，經過前面的values來肯定分組的方法，經過後面的values獲得你想要的數據

# 分組查詢
    ret=models.Book.objects.all().annotate(author_conut=Count("author"))
    """author與book表經過多對多鏈接起來
    SELECT 
    `app01_book`.`id`,
     `app01_book`.`price`,
      `app01_book`.`name`,
       `app01_book`.`publisher_id`,
        COUNT(`app01_author_book`.`author_id`) AS `author_conut` 
        FROM `app01_book` LEFT OUTER JOIN `app01_author_book` 
        ON (`app01_book`.`id` = `app01_author_book`.`book_id`) 
        GROUP BY `app01_book`.`id` ORDER BY NULL; args=()
    """
    # for i in ret:
        # print(i.name,i.author_conut,sep="****")
    # SQL語句翻譯
    models.Book.objects.all().annotate(author_conut=Count("price"))
    """price是book表中屬性
    SELECT
        `app01_book`.`id`,
    `app01_book`.`price`,
    `app01_book`.`name`,
    `app01_book`.`publisher_id`,
    COUNT(`app01_book`.`publisher_id`) AS `author_conut`
    FROM `app01_book` GROUP BY `app01_book`.`id` ORDER BY NULL; args=()
    """
    # 查詢每一本書的做者個數
    ret1=models.Book.objects.annotate(num=Count("author__id"))
    for i in ret1:
        print("{}:{}".format(i.name,i.num))
    # 查詢各個做者出的書的總價格
    ret2=models.Author.objects.annotate(sumprice=Sum("book__price"))
    for i in ret2:
        print("{}出的書籍的總價格是{}".format(i.name,i.sumprice))
        """ SELECT 
        `app01_author`.`id`,
         `app01_author`.`name`,
          SUM(`app01_book`.`price`) AS `sumprice`
           FROM `app01_author` LEFT OUTER JOIN `app01_author_book` 
           ON (`app01_author`.`id` = `app01_author_book`.`author_id`) 
           LEFT OUTER JOIN `app01_book` ON 
           (`app01_author_book`.`book_id` = `app01_book`.`id`)
            GROUP BY `app01_author`.`id` ORDER BY NULL; args=()"""

從上面能夠看出，可是設計多對可能是，ORM的做法是把三張表連在一塊在進行選擇

總結下就是若是涉及單個分組是就是id的分組，涉及多個表時，就把id以及外鍵的id連表，再進行分組。涉及多對可能是，就是三張表連到一塊；
而後涉及多個標的信號就是annotate(sumprice=Sum("book__price"))裏面的參數涉及其餘的表裏面的屬性，裏面的屬性都是雙下劃線哦

F查詢和Q查詢

F查詢

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

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

在bookclass添加：

　　 name=models.CharField(max_length=32,null=False)
    # 賣出的本書
    maichu = models.IntegerField(default=1000)
    # 庫存的本書
    kucun = models.IntegerField(default=999)

 # F查詢
    # 將id大於價格得書籍找出來
    from django.db.models import F
    ret =models.Book.objects.filter(id__gt=F("price"))
    print(ret)
    # 刷單 把每一本書的賣出數都乘以2
    """單個系統改數據
    obj = models.Book.objects.first()
    obj.maichu = 1000 * 3
    obj.save()
    具體的對象沒有update()，QuerySet對象纔有update()方法。
    """
    models.Book.objects.update(maichu=F("maichu")*2)
    # 給每一本書的書名後面加上
    # 初版
    from django.db.models.functions import Concat
    from django.db.models import Value
    models.Book.objects.update(title= Concat(F("title"), Value("初版")))

Q查詢

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

　　 # Q查詢
    from django.db.models import Q
    # 查詢 賣出數大於1000，而且 價格小於100的全部書
    ret = models.Book.objects.filter(maichu__gt=1000,price__lt=100)
    print(ret)
    # 查詢 賣出數大於1000，或者 價格小於100的全部書
    ret = models.Book.objects.filter(Q(maichu__gt=1000) | Q(price__lt=100))
    print(ret)
    # Q查詢和字段查詢同時存在時， 字段查詢要放在Q查詢的後面
    ret = models.Book.objects.filter(Q(maichu__gt=1000) | Q(price__lt=100), title__contains="金老闆")
    print(ret)

鎖和事務

鎖

select_for_update(nowait=False, skip_locked=False)

返回一個鎖住行直到事務結束的查詢集，若是數據庫支持，它將生成一個 SELECT ... FOR UPDATE 語句。

舉個例子：

entries = Entry.objects.select_for_update().filter(author=request.user)

全部匹配的行將被鎖定，直到事務結束。這意味着能夠經過鎖防止數據被其它事務修改。

通常狀況下若是其餘事務鎖定了相關行，那麼本查詢將被阻塞，直到鎖被釋放。若是這不想要使查詢阻塞的話，使用select_for_update(nowait=True)。若是其它事務持有衝突的鎖, 那麼查詢將引起 DatabaseError 異常。你也可使用select_for_update(skip_locked=True)忽略鎖定的行。 nowait和skip_locked是互斥的，同時設置會致使ValueError。

目前，postgresql，oracle和mysql數據庫後端支持select_for_update()。可是，MySQL不支持nowait和skip_locked參數。

使用不支持這些選項的數據庫後端（如MySQL）將nowait=True或skip_locked=True轉換爲select_for_update()將致使拋出DatabaseError異常，這能夠防止代碼意外終止。

事務

    try:
        from django.db import transaction

        with transaction.atomic():
            # 先建立一個出版社
            new_publisher = models.Publisher.objects.create(name="火星出版社")
            # 建立一本書
            models.Book.objects.create(
                title="橘子物語",
                price=11.11,
                kucun=10,
                maichu=10,
                publisher_id=1000  # 指定一個不存在的出版社id
            )
    except Exception as e:
        print(str(e))

其餘不爲人知的操做（有個印象便可）

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

QuerySet方法大全

##################################################################
# 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):
   # 是否有結果

Django終端打印SQL語句

在Django項目的settings.py文件中，在最後複製粘貼以下代碼：

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

即爲你的Django項目配置上一個名爲django.db.backends的logger實例便可查看翻譯後的SQL語句。

關於多對多的三種寫法

第一種

ORM自動建立第三張表

#出版社列表
class Publisher(models.Model):
    id=models.AutoField(primary_key=True)
    name=models.CharField(max_length=32, null=False)

#書籍列表
class Book(models.Model):
    id=models.AutoField(primary_key=True)
    price=models.DecimalField(max_digits=5,decimal_places=2,default=999.99)
    name=models.CharField(max_length=32,null=False)
    publisher=models.ForeignKey(to="Publisher",related_name="qu",null=True)

#做者列表
class Author(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32,null=False)
    book = models.ManyToManyField(to="Book")

import os
import sys


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

    from app01 import models
    # 第一張表：
    ret = models.Author.objects.all().get(id=1).book.all()
    for i in ret:
        print(i.name)
    # 雙下劃線查詢：
    ret=models.Author.objects.filter(id=1)
    print(ret.values_list("book__name"))
　　 # 從做者關聯的書裏面移除id是1的書
　　 models.Author.objects.get(id=1).book.remove(1)

第二種

手動建立第三張表

本身建立第三張表，利用外鍵分別關聯做者和書
關聯查詢比較麻煩，由於沒辦法使用ORM提供的便利方法

#出版社列表
class Publisher(models.Model):
    id=models.AutoField(primary_key=True)
    name=models.CharField(max_length=32, null=False)

#書籍列表
class Book(models.Model):
    id=models.AutoField(primary_key=True)
    name=models.CharField(max_length=32,null=False)
    publisher=models.ForeignKey(to="Publisher",related_name="qu",null=True)

#做者列表
class Author(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32,null=False)
    # book = models.ManyToManyField(to="Book")

# 手動建立第三張表
class Author2Book(models.Model):
    id=models.AutoField(primary_key=True)
    author=models.ForeignKey(to="Author")
    book=models.ForeignKey(to="Book")

from app02 import models
    # 查詢做者id爲1的全部書籍
    # 首先查到全部做者的id爲1的全部書籍的id號碼
    ret=models.Author.objects.filter(id=1).values_list("author2book__book")#注意小寫
    ret=[i[0] for i in ret]
    #而後經過id查書名
    info=models.Book.objects.filter(id__in=ret).values_list("name")
    print(info)

　　# 從做者關聯的書裏面移除id是1的書
　　# 沒有django ORM 封裝的那些快捷方式了，咱們要本身親自改第三張表
    models.Author2Book.objects.get(author_id=1, book_id=1).delete()

第三種

手動建立，可是可使用第一種的查詢方式

使用ORM 的ManyToManyFiled()
使用此種方式建立多對多表的時候，沒有 add() remove() 等方法

#出版社列表
class Publisher(models.Model):
    id=models.AutoField(primary_key=True)
    name=models.CharField(max_length=32, null=False)

#書籍列表
class Book(models.Model):
    id=models.AutoField(primary_key=True)
    name=models.CharField(max_length=32,null=False)
    publisher=models.ForeignKey(to="Publisher",related_name="qu",null=True)

#做者列表
class Author(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32,null=False)
    book = models.ManyToManyField(to="Book",through="Author2Book",through_fields=("author","book"))
    # 第一個字段： 多對多設置在哪一張表裏， 第三張表經過什麼字段找到這張表 就把這個字段寫在前面
# 手動建立第三張表
class Author2Book(models.Model):
    id=models.AutoField(primary_key=True)
    author=models.ForeignKey(to="Author")
    book=models.ForeignKey(to="Book")
    details=models.CharField(max_length=32)

    class Meta:
        # 創建惟一約束
        unique_together = ("author", "book")

from app03 import models
    ret=models.Author.objects.get(id=1).book.all()
    for i in ret:
        print(i.name)
    # 從做者關聯的書裏面移除id是1的書
    # 沒有django ORM 封裝的那些快捷方式了，咱們要本身親自改第三張表
    ret=models.Author2Book.objects.filter(author_id=1).all()
    for i in ret:
        i.delete()

csrf簡單應用

5. csrf簡單用法

    什麼是CSRF ?
        跨站請求僞造，
        
        
    問題：
        1. 釣魚網站的頁面和正經網站的頁面對瀏覽器來講有什麼區別？ （頁面是怎麼來的？）
            釣魚網站的頁面是由 釣魚網站的服務端給你返回的
            
            正經網站的網頁是由 正經網站的服務端給你返回的
            
            
        2. Django中內置了一個專門處理csrf問題的中間件
            django.middleware.csrf.CsrfViewMiddleware
            
            這個中間件作的事情：
                1. 在render返回頁面的時候，在頁面中塞了一個隱藏的input標籤
                
                用法：
                    咱們在頁面上 form表單 裏面 寫上 {% csrf_token %}
                    
                <input type="hidden" name="csrfmiddlewaretoken" value="8gthvLKulM7pqulNl2q3u46v1oEbKG7BSwg6qsHBv4zf0zj0UcbQmpbAdijqyhfE">
                
                2. 當你提交POST數據的時候，它幫你作校驗，若是校驗不經過就拒絕此次請求