Django ORM操做及進階

1.通常操做

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

經過模型類.objects屬性能夠調用以下函數，實現對模型類對應的數據表的查詢。

函數名	功能	返回值	說明
get	返回表中知足條件的一條且只能有一條數據。	返回值是一個模型類對象。	參數中寫查詢條件。 1) 若是查到多條數據，則拋異常MultipleObjectsReturned。 2)查詢不到數據，則拋異常：DoesNotExist。
all	返回模型類對應表格中的全部數據。	返回值是QuerySet類型	查詢集
filter	返回知足條件的數據。	返回值是QuerySet類型	參數寫查詢條件。
exclude	返回不知足條件的數據。	返回值是QuerySet類型	參數寫查詢條件。
order_by	對查詢結果進行排序。	返回值是QuerySet類型	參數中寫根據哪些字段進行排序。

 

1.1必知必會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

 

 

 

返回QuerySet對象的方法有

all()

filter()

exclude()

order_by()

reverse()

distinct()

特殊的QuerySet

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

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

返回具體對象的

get()

first()

last()

返回布爾值的方法有：

exists()

返回數字的方法有

count()

1.2查詢集

all, filter, exclude, order_by調用這些函數會產生一個查詢集，QuerySet類對象能夠繼續調用上面的全部函數。

 

查詢集特性

1）惰性查詢：只有在實際使用查詢集中的數據的時候纔會發生對數據庫的真正查詢。
2）緩存：當使用的是同一個查詢集時，第一次使用的時候會發生實際數據庫的查詢，而後把結果緩存起來，以後再使用這個查詢集時，使用的是緩存中的結果。

 

限制查詢集

能夠對一個查詢集進行取下標或者切片操做來限制查詢集的結果。

對一個查詢集進行切片操做會產生一個新的查詢集，下標不容許爲負數。

取出查詢集第一條數據的兩種方式:

方式	說明
b[0]	若是b[0]不存在，會拋出IndexError異常
b[0:1].get()	若是b[0:1].get()不存在，會拋出DoesNotExist異常。

exists:判斷一個查詢集中是否有數據。True False

 

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

 

模糊查詢

 

 

例：查詢書名包含'傳'的圖書。contains
BookInfo.objects.filter(btitle__contains='傳')

例：查詢書名以'部'結尾的圖書 endswith 開頭:startswith
BookInfo.objects.filter(btitle__endswith='部')

models.Tb1.objects.filter(name__contains="ven") # 獲取name字段包含"ven"的 models.Tb1.objects.filter(name__icontains="ven") # icontains大小寫不敏感

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

 

 

　

 

空查詢 isnull

例：查詢書名不爲空的圖書。isnull
select * from booktest_bookinfo where btitle is not null;
BookInfo.objects.filter(btitle__isnull=False)

 

 

 

比較查詢

　__gt 大於
　　__gte 大於等於
　　__lt 小於
　　__lte 小於等於

例：查詢id大於3的圖書。

Select * from booktest_bookinfo where id>3;

BookInfo.objects.filter(id__gt=3)

 

models.Tb1.objects.filter(id__lt=10, id__gt=1) # 獲取id大於1 且 小於10的值

 

範圍查詢 in

例：查詢id爲1或3或5的圖書。

select * from booktest_bookinfo where id in (1,3,5);
BookInfo.objects.filter(id__in = [1,3,5])

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(id__range=[1, 3]) # id範圍是1到3的，等價於SQL的bettwen and

 

 

 

日期查詢

例：查詢1980年發表的圖書。

BookInfo.objects.filter(bpub_date__year=1980)

例：查詢1980年1月1往後發表的圖書。

from datetime import date

BookInfo.objects.filter(bpub_date__gt=date(1980,1,1))

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

 

 

exclude方法示例：

例：查詢id不爲3的圖書信息。

BookInfo.objects.exclude(id=3)

 

order_by方法示例：

做用：進行查詢結果進行排序。

例：查詢全部圖書的信息，按照id從小到大進行排序。

BookInfo.objects.all().order_by('id')

例：查詢全部圖書的信息，按照id從大到小進行排序。

BookInfo.objects.all().order_by('-id')

例：把id大於3的圖書信息按閱讀量從大到小排序顯示。

BookInfo.objects.filter(id__gt=3).order_by('-bread')

 

 

 

2.ForeignKey操做

在一對多關係中，一對應的類咱們把它叫作一類，多對應的那個類咱們把它叫作多類，咱們把多類中定義的創建關聯的類屬性叫作關聯屬性。

models.py

 

from django.db import models

# Create your models here.
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',)

 

 

 

 

views.py

 

from django.shortcuts import render,HttpResponse

# Create your views here.


from app01 import models

def query(request):

    # #####################基於對象查詢(子查詢)##############################
    #                按字段（publish）
    # 一對多   book  ----------------->  publish
    #               <----------------
    #                 book_set.all()

    # 正向查詢按字段：

    # 查詢python這本書籍的出版社的郵箱

    # python=models.Book.objects.filter(title="python").first()
    # print(python.publish.email)


    # 反向查詢按     表名小寫_set.all()

    # 蘋果出版社出版的書籍名稱

    # publish_obj=models.Publish.objects.filter(name="蘋果出版社").first()
    # for obj in publish_obj.book_set.all():
    #     print(obj.title)

    #                按字段（authors.all()）
    # 多對多   book  ----------------------->  author
    #               <----------------
    #                  book_set.all()


    # 查詢python做者的年齡
    # python = models.Book.objects.filter(title="python").first()
    # for author in python.authors.all():
    #     print(author.name ,author.age)

    # 查詢alex出版過的書籍名稱

    # alex=models.Author.objects.filter(name="alex").first()
    # for book in alex.book_set.all():
    #     print(book.title)

    #                  按字段 authorDetail
    # 多對多   author  ----------------------->  authordetail
    #                <----------------
    #                  按表名  author


    #查詢alex的手機號
    # alex=models.Author.objects.filter(name='alex').first()
    # print(alex.authorDetail.telephone)


    # 查詢家在山東的做者名字

    # ad_list=models.AuthorDetail.objects.filter(addr="shandong")
    #
    # for ad in ad_list:
    #     print(ad.author.name)



    '''
    對應sql:

       select publish_id from Book where title="python"
       select email from Publish where nid =   1
    
    
    '''




    # #####################基於queryset和__查詢（join查詢）############################

    # 正向查詢：按字段  反向查詢：表名小寫


    # 查詢python這本書籍的出版社的郵箱
    # ret=models.Book.objects.filter(title="python").values("publish__email")
    # print(ret.query)

    '''
    select publish.email from Book 
    left join Publish on book.publish_id=publish.nid 
    where book.title="python"
    '''

    # 蘋果出版社出版的書籍名稱
    # 方式1：
    ret1=models.Publish.objects.filter(name="蘋果出版社").values("book__title")
    print("111111111====>",ret1.query)
    #方式2：
    ret2=models.Book.objects.filter(publish__name="蘋果出版社").values("title")
    print("2222222222====>", ret2.query)

    #查詢alex的手機號
    # 方式1：
    ret=models.Author.objects.filter(name="alex").values("authorDetail__telephone")

    # 方式2：
    models.AuthorDetail.objects.filter(author__name="alex").values("telephone")

    # 查詢手機號以151開頭的做者出版過的書籍名稱以及書籍對應的出版社名稱

    ret=models.Book.objects.filter(authors__authorDetail__telephone__startswith="151").values('title',"publish__name")
    print(ret.query)


    return HttpResponse("OK")

 

 

 

2.1正向查找

對象查找（跨表）

語法：

對象.關聯字段.字段

 

示例：

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

3.ManyToManyField

class RelatedManager

"關聯管理器"是在一對多或者多對多的關聯上下文中使用的管理器。

它存在於下面兩種狀況：

1. 外鍵關係的反向查詢
2. 多對多關聯關係

簡單來講就是當 點後面的對象 可能存在多個的時候就可使用如下的方法。

方法

create()

建立一個新的對象，保存對象，並將它添加到關聯對象集之中，返回新建立的對象。

>>> import datetime
>>> models.Author.objects.first().book_set.create(title="番茄物語", publish_date=datetime.date.today())

add()

把指定的model對象添加到關聯對象集中。

添加對象

>>> author_objs = models.Author.objects.filter(id__lt=3)
>>> models.Book.objects.first().authors.add(*author_objs)

添加id

>>> models.Book.objects.first().authors.add(*[1, 2])

set()

更新model對象的關聯對象。

>>> book_obj = models.Book.objects.first()
>>> book_obj.authors.set([2, 3])

remove()

從關聯對象集中移除執行的model對象

>>> book_obj = models.Book.objects.first()
>>> book_obj.authors.remove(3)

clear()

從關聯對象集中移除一切對象。

>>> book_obj = models.Book.objects.first()
>>> book_obj.authors.clear()

注意：

對於ForeignKey對象，clear()和remove()方法僅在null=True時存在。

舉個例子：

ForeignKey字段沒設置null=True時，

class Book(models.Model):
    title = models.CharField(max_length=32)
    publisher = models.ForeignKey(to=Publisher)

沒有clear()和remove()方法：

>>> models.Publisher.objects.first().book_set.clear()
Traceback (most recent call last):
  File "<input>", line 1, in <module>
AttributeError: 'RelatedManager' object has no attribute 'clear'

當ForeignKey字段設置null=True時，

class Book(models.Model):
    name = models.CharField(max_length=32)
    publisher = models.ForeignKey(to=Class, null=True)

此時就有clear()和remove()方法：

>>> models.Publisher.objects.first().book_set.clear()

 

注意：

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

4.聚合查詢和分組查詢

聚合

 

做用：對查詢結果進行聚合操做。

 

sum count avg max min

 

aggregate：調用這個函數來使用聚合。 返回值是一個字典

 

使用前需先導入聚合類：

 

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

 

例：查詢全部圖書的數目。

BookInfo.objects.all().aggregate(Count('id'))

{'id__count': 5}

例：查詢全部圖書閱讀量的總和。

BookInfo.objects.aggregate(Sum('bread'))

{'bread__sum': 126}

count函數 返回值是一個數字

做用：統計知足條件數據的數目。

例：統計全部圖書的數目。

BookInfo.objects.all().count()

BookInfo.objects.count()

例：統計id大於3的全部圖書的數目。

BookInfo.objects.filter(id__gt=3).count()

aggregate()是QuerySet 的一個終止子句，意思是說，它返回一個包含一些鍵值對的字典。

鍵的名稱是聚合值的標識符，值是計算出來的聚合值。鍵的名稱是按照字段和聚合函數的名稱自動生成出來的。

 

用到的內置函數：

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

示例：

>>> from django.db.models import Avg, Sum, Max, Min, Count
>>> models.Book.objects.all().aggregate(Avg("price"))
{'price__avg': 13.233333}

若是你想要爲聚合值指定一個名稱，能夠向聚合子句提供它。

>>> models.Book.objects.aggregate(average_price=Avg('price'))
{'average_price': 13.233333}

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

>>> models.Book.objects.all().aggregate(Avg("price"), Max("price"), Min("price"))
{'price__avg': 13.233333, 'price__max': Decimal('19.90'), 'price__min': Decimal('9.90')}

分組

咱們在這裏先複習一下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")

更多示例：

示例1：統計每一本書的做者個數

>>> book_list = models.Book.objects.all().annotate(author_num=Count("author"))
>>> for obj in book_list:
...     print(obj.author_num)
...
2
1
1

示例2：統計出每一個出版社買的最便宜的書的價格

>>> publisher_list = models.Publisher.objects.annotate(min_price=Min("book__price"))
>>> for obj in publisher_list:
...     print(obj.min_price)
...     
9.90
19.90

方法二：

>>> models.Book.objects.values("publisher__name").annotate(min_price=Min("price"))
<QuerySet [{'publisher__name': '沙河出版社', 'min_price': Decimal('9.90')}, {'publisher__name': '人民出版社', 'min_price': Decimal('19.90')}]>

示例3：統計不止一個做者的圖書

>>> models.Book.objects.annotate(author_num=Count("author")).filter(author_num__gt=1)
<QuerySet [<Book: 番茄物語>]>

示例4：根據一本圖書做者數量的多少對查詢集 QuerySet進行排序

>>> models.Book.objects.annotate(author_num=Count("author")).order_by("author_num")
<QuerySet [<Book: 香蕉物語>, <Book: 橘子物語>, <Book: 番茄物語>]>

示例5：查詢各個做者出的書的總價格

>>> models.Author.objects.annotate(sum_price=Sum("book__price")).values("name", "sum_price")
<QuerySet [{'name': '小精靈', 'sum_price': Decimal('9.90')}, {'name': '小仙女', 'sum_price': Decimal('29.80')}, {'name': '小魔女', 'sum_price': Decimal('9.90')}]>

5.F查詢和Q查詢

5.1F查詢

 

做用：用於類屬性之間的比較。

 

使用以前須要先導入：

 

from django.db.models import F

 

例：查詢圖書閱讀量大於評論量圖書信息。

BookInfo.objects.filter(bread__gt=F('bcomment'))

例：查詢圖書閱讀量大於2倍評論量圖書信息。

BookInfo.objects.filter(bread__gt=F('bcomment')*2)

 

 

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

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

示例1：

查詢評論數大於收藏數的書籍

from django.db.models import F
models.Book.objects.filter(commnet_num__gt=F('keep_num'))

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

models.Book.objects.filter(commnet_num__lt=F('keep_num')*2)

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

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

引伸：

若是要修改char字段咋辦？

如：把全部書名後面加上(初版)

>>> from django.db.models.functions import Concat
>>> from django.db.models import Value
>>> models.Book.objects.all().update(title=Concat(F("title"), Value("("), Value("初版"), Value(")")))

 

Q查詢

 

做用：用於查詢時條件之間的邏輯關係。not and or，能夠對Q對象進行&|~操做。

 

使用以前須要先導入：

 

from django.db.models import Q

 

例：查詢id大於3且閱讀量大於30的圖書的信息。

BookInfo.objects.filter(id__gt=3, bread__gt=30)

BookInfo.objects.filter(Q(id__gt=3)&Q(bread__gt=30))

例：查詢id大於3或者閱讀量大於30的圖書的信息。

BookInfo.objects.filter(Q(id__gt=3)|Q(bread__gt=30))

例：查詢id不等於3圖書的信息。

BookInfo.objects.filter(~Q(id=3))

 

 

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

示例1：

查詢做者名是小仙女或小魔女的

models.Book.objects.filter(Q(authors__name="小仙女")|Q(authors__name="小魔女"))

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

示例：查詢做者名字是小仙女而且不是2018年出版的書的書名。

>>> models.Book.objects.filter(Q(author__name="小仙女") & ~Q(publish_date__year=2018)).values_list("title")
<QuerySet [('番茄物語',)]>

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

例如：查詢出版年份是2017或2018，書名中帶物語的全部書。

>>> models.Book.objects.filter(Q(publish_date__year=2018) | Q(publish_date__year=2017), title__icontains="物語")
<QuerySet [<Book: 番茄物語>, <Book: 香蕉物語>, <Book: 橘子物語>]>

6.鎖和事務

6.1鎖

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異常，這能夠防止代碼意外終止。

6.2事務

import os if __name__ == '__main__': os.environ.setdefault("DJANGO_SETTINGS_MODULE", "BMS.settings") import django django.setup() import datetime from app01 import models try: from django.db import transaction with transaction.atomic():#原子性操做要麼都成功，要麼都失敗 new_publisher = models.Publisher.objects.create(name="火星出版社") models.Book.objects.create(title="橘子物語", publish_date=datetime.date.today(), publisher_id=10) # 指定一個不存在的出版社id except Exception as e: print(str(e))

 

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

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

7.2QuerySet方法大全

##################################################################
# 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方法大全

QuerySet方法大全

 

 

7.3Django終端打印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語句。 

7.4在Python腳本中調用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)