Django之ORM操做進階

時間  2019-11-30
標籤 django orm 進階 欄目 Python 简体版
原文   原文鏈接

一 、 必知必會的13條

1在項目中建立一個orm_test文件夾建立一個py文件html

此時就能夠在這個py文件中進行sql模型的查詢修改了，不用開啓項目可網頁了python

建立數據庫的表sql

from django.db import models


class MyCharField(models.Field):
    """自定義char類型的字段類"""

    def __init__(self, max_length, *args, **kwargs):
        self.max_length = max_length
        super(MyCharField, self).__init__(max_length=max_length, *args, **kwargs)

    def db_type(self, connection):
        """限定生成數據庫表的字段類型爲char，長度爲max_length指定的值"""
        return 'char(%s)' % self.max_length


class Person(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32, db_column='myname', verbose_name='姓名')
    age = models.IntegerField(null=True, blank=True)
    birth = models.DateField(auto_now=True)
    phone = MyCharField(max_length=11)
    sex = models.CharField(max_length=32, choices=((1, '男'), (2, '女')))

    def __str__(self):
        return 'Person %s %s' % (self.id, self.name)

    class Meta:
        ordering = ('id',)
        db_table = 'person'  # 數據庫中生成的表名稱 默認 app名稱 + 下劃線 + 類名

        verbose_name = '我的信息'  # admin中顯示的表名稱

        verbose_name_plural = '全部用戶信息'  # 至關於verbose_name加s

        # # 聯合索引
        # index_together = [
        #     ("pub_date", "deadline"),  # 應爲兩個存在的字段
        # ]
        #
        # # 聯合惟一索引
        # unique_together = (("driver", "restaurant"),)  # 應爲兩個存在的字段


# 出版社
class Publisher(models.Model):
    name = models.CharField(max_length=32)  # 出版社名稱

    def __str__(self):
        return '<Publisher %s-%s>' % (self.id, self.name)


# 書
class Book(models.Model):
    title = models.CharField(max_length=30)  # 書名
    price = models.IntegerField()  # 價格
    publisher = models.ForeignKey(to='Publisher',related_name='books',null=True)

    def __str__(self):
        return '<Book %s-%s>' % (self.id, self.title)


# 做者
class Author(models.Model):
    name = models.CharField(max_length=32)  # 做者名字
    books = models.ManyToManyField(to='Book',related_name='authors')  # 只是ORM層面創建的一個多對多關係，不是做者表的一個字段

    def __str__(self):
        return self.name
模型

 

　　

  
<1> all():                 查詢全部結果

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

進行操做測試

import os

if __name__ == "__main__":
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "orm_練習.settings")
    import django

    django.setup()

    from app01 import models

    ret = models.Person.objects.all()
    # ==》對象列表    全部Person的對象

    ret = models.Person.objects.get(id=2)
    # ==》返回一個對象，有且只有一個，查詢不到或者獲取多個都會報錯

    ret = models.Person.objects.filter(sex='1')
    # ==》返回一個對象列表，查詢知足條件的對象（不會報錯）

    ret = models.Person.objects.exclude(age='20')
    # ==》返回一個對象列表，查詢不知足條件的對象（不會報錯）

    ret = models.Person.objects.all().values('id', 'name', 'age')
    # for i in ret:
    #     print(i, type(i))
    # ==》字典序列  ，元素是{'id':1,'name':mjj,'age':20}
    # 沒有指定參數  獲取全部的字段數據
    # 指定參數     獲取指定字段數據

    ret = models.Person.objects.all().values_list('name', 'id')
    # for i in ret:
    #     print(i, type(i))
        # ==》元祖序列  ，元素是('mjj', 1) <class 'tuple'>
        # 沒有指定參數  獲取全部的字段數據
        # 指定參數     獲取指定字段數據



    ret = models.Person.objects.all().order_by('age','-id',)
    # order_by 排序  能夠指定多個字段

    ret =models.Person.objects.all().reverse()
    #得到對象列表，按照獲取的結果順序翻轉

    ret = models.Person.objects.all().distinct()
    # distinct  獲得對象列表，而且去重


    ret = models.Person.objects.all().count()
    # count 計數  返回的是個數字
    #
    ret = models.Person.objects.filter(id=100).first()
    #取篩選後的第一個對象，若是沒有就是None

    ret = models.Person.objects.filter(id=100).last()
    #取篩選後的最後一個對象，若是沒有就是None

    ret = models.Person.objects.all().exists()
    #判斷是否有值，  返回一個布爾值
    print(ret)

1.返回QuerySet對象的方法有

all()數據庫

filter()django

exclude()app

order_by()less

reverse()ide

distinct()函數

2.特殊的QuerySet

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

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

3.返回具體對象的

get()

first()

last()

4.返回布爾值的方法有：

exists()

5.返回數字的方法有

count()

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

import os

if __name__ == "__main__":
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "orm_練習.settings")
    import django

    django.setup()

    from app01 import models

    ret = models.Person.objects.filter(id__gt=1)  # greater than  大於
    ret = models.Person.objects.filter(id__lt=3)  # less than   小於
    ret = models.Person.objects.filter(id__gte=3)  # greater than equal  大於等於
    ret = models.Person.objects.filter(id__lte=1)  # less than equal  小於等於
    #
    ret = models.Person.objects.filter(id__in=[1,3])  #在這個[1,3]列表中，
    #
    ret = models.Person.objects.filter(id__gte=1, id__lte=3)  #大於等於1 和小於等於3的
    ret = models.Person.objects.filter(id__range=[0,3])   # id 在這個0-3的值中
    #
    ret = models.Person.objects.filter(name__contains='e')   # 名字中帶有'e'的
    ret = models.Person.objects.filter(name__icontains='e')  # 名字中帶'e'的  不分大小寫
    #
    ret = models.Person.objects.filter(name__startswith='e')   #開頭是'e'的
    ret = models.Person.objects.filter(name__istartswith='e')  # 開頭是'e'的  不分大小寫
    #
    ret = models.Person.objects.filter(name__endswith='x')  # 結尾是'e'的
    ret = models.Person.objects.filter(name__iendswith='x')  #結尾是'e'的  不分大小寫
    #
    ret = models.Person.objects.filter(birth__year=2018)  # 篩選斷 是2018年的
    ret = models.Person.objects.filter(birth__month=9)  # 篩選 是9月的


    print(ret)

 

ForeignKey操做

正向查找

一 、對象查找（跨表）

語法：

對象.關聯字段.字段 

示例：

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

 

練習

import os
import sys

if __name__ == "__main__":
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "orm_練習.settings")

    import django

    django.setup()

    from app01 import models

    # 基於對象查詢
    # 正向查詢  (外鍵在book中) ，用book對象查詢就是正向
    book_obj = models.Book.objects.get(id=2)
    # print(book_obj.price)  # 得到數的價格
    # print(book_obj.title)  # 得到書的名字
    # print(book_obj.publisher_id)  # 得到外鍵出版社的對應ID
    #
    # print(book_obj.publisher)
    # 或的id 爲 1 的出版社對象 ==》至關於models.Publisher.objects.get(id=1)

    obj = models.Book.objects.filter(publisher_id=models.Publisher.objects.get(name='沙河出版社').id)
    # 括號獲得是      （publisher_id = 出版社名字叫作'沙河出版社'的id）
    # obj獲得一個書籍對象的列表

    obj = models.Book.objects.filter(publisher__name='沙河出版社')
    # 按照出版社名字是'沙河出版社' 查找書籍對象   （和上一條結果同樣，過程不同）

    obj = models.Book.objects.all().values('title', 'publisher__name')
    # 書籍全部的對象的 （書籍名稱 和 出版社名稱） 的 對象序列

    # 反向查詢   用出版社查詢就是反向
    obj = models.Publisher.objects.get(id=1).books.all()
    # 出版社id爲1 的出版社對象  經過books（django第三方對象）（對應Publisher_id）
    # 得到 書籍對象

    obj = models.Publisher.objects.filter(id=models.Book.objects.get(title='自動化').publisher_id)
    # 括號裏 經過正向查找 找到出版社的id
    # 而後經過出版社 找到出版社對象

    obj = models.Publisher.objects.filter(books__title='python')
    obj = models.Publisher.objects.filter(books__id=2)
    # 括號裏  經過 表名__字段 第三方對象 獲取 對應的出版社

    obj = models.Publisher.objects.get(id=1)

    # obj.books.set(models.Book.objects.filter(id__in=[4,5]))
    # # 注意        覆蓋修改 書籍 id 爲 4 和 5 的 Publisher_id 爲 1
    # # 此時        書籍 id 爲 1- 3 的 Publisher_id 爲 null了
    #
    # obj.books.add(*models.Book.objects.filter(id__in=[4,5]))
    # #   添加修改 書籍id爲 4 和 5 的 Publisher_id爲1

    obj.books.remove(*models.Book.objects.filter(id__in=[2, 3]))
    # 刪除 書籍id爲2和3 的Publisher_id   斷開和出版社的外鍵關係
外鍵查詢練習

 

 

 

ManyToManyField

 

class RelatedManager

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

它存在於下面兩種狀況：

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

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

方法

1.create()

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

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

2.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])

3.set()

更新model對象的關聯對象。

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

4.remove()

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

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

5.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()方法。

聚合查詢和分組查詢

聚合

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

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

用到的內置函數：

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

示例：

ret= models.Book.objects.aggregate(Avg('price'))
print(ret)   # ==>{'price__avg': 13.233333}

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

ret = models.Book.objects.aggregate(平均價格=Avg('price'))
print(ret)  # ==>{'average_price': 13.233333}

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

ret = models.Book.objects.all().aggregate(平均價格 = Avg("price"), 最大價格= Max("price"),最小价格 = Min("price"))
print(ret)  # ==>{'平均價格': 15.97, '最大價格': Decimal('39.99'), '最小价格': Decimal('1.00')}
.values 的特殊之處 
ret = models.Book.objects.annotate(做者數量=Count('author')).values()
for i in ret:
    print(i)
#結果以下    ：count被命名後加進去了  能夠做爲字段去作條件了

{'id': 1, 'title': '跟金老闆學開車', 'publish_date': datetime.date(2018, 8, 3), 'price': Decimal('12.90'), 'memo': '1', 'publisher_id': 1, '做者數量': 2}
{'id': 2, 'title': '跟金老闆學開潛艇', 'publish_date': datetime.date(2017, 8, 10), 'price': Decimal('9.99'), 'memo': None, 'publisher_id': 1, '做者數量': 2}
{'id': 3, 'title': '跟老男孩學思想', 'publish_date': datetime.date(2018, 9, 3), 'price': Decimal('39.99'), 'memo': None, 'publisher_id': 2, '做者數量': 1}
{'id': 4, 'title': '跟egon學喊麥', 'publish_date': datetime.date(2018, 6, 12), 'price': Decimal('1.00'), 'memo': None, 'publisher_id': 4, '做者數量': 1}

 

分組

咱們在這裏先複習一下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：統計每一本書的做者個數

複製代碼 
ret = models.Book.objects.all().annotate(做者個數 = Count('author'))
for i in ret:
　　print(i.做者個數)
#結果以下
2
2
1
1
複製代碼

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

ret = models.Publisher.objects.all().annotate(最便宜的書 = Min('book__price'))
for i in ret:
    print(i.最便宜的書)   
#獲得

9.99
39.99
1.00
None

方法二：

ret = models.Book.objects.values('publisher__name').annotate(price_min = Min('price'))
print(ret)
<QuerySet [{'publisher__name': '沙河出版社', 'price_min': Decimal('1.00')}, {'publisher__name': '西二旗出版社', 'price_min': Decimal('39.99')}]>

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

ret = models.Book.objects.all().annotate(author_count = Count('author')).filter(author_count__gt=1).values()    #返回的是一個字典
# for i in ret:
    # print(i['author_count'])

ret = models.Book.objects.all().annotate(author_count=Count('author')).filter(author_count__gt=1)    # 返回來的是一個QuerySet對象
for i in ret:
    print(i.author_count)

# 結果同樣 都是 
2
2

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

ret = models.Book.objects.all().annotate(count=Count('author')).order_by('count')
print(ret)

ret = models.Book.objects.annotate(count=Count('author')).order_by('count')
print(ret)
#結果同樣
<QuerySet [<Book: <Book object: 3 跟老男孩學思想>>, <Book: <Book object: 4 跟egon學喊麥>>, <Book: <Book object: 1 跟金老闆學開車>>, <Book: <Book object: 2 跟金老闆學開潛艇>>]>

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

#ret = models.Author.objects.annotate(sum_price=Sum("書__價格")).values('名字字段','Sun的命名')
#  分析：             得到做者對象   分組      書的總價格                爲了獲得的   做者名字 和做者書籍的總價格
ret = models.Author.objects.annotate(sum_price=Sum("book__price")).values("name", "sum_price")


print(ret)    
# ==》  <QuerySet [{'name': '金老闆', 'sum_price': Decimal('22.89')}, 
#　　　　　　　　　　　{'name': '小哪吒', 'sum_price': Decimal('22.89')},
#　　　　　　　　　　  {'name': 'Alex', 'sum_price': Decimal('40.99')}]>


for i in ret:
    print(i['name'],i['sum_price'])
#  ==》金老闆  22.89
# 　　 小哪吒  22.89
#　　  Alex  40.99

F查詢和Q查詢

F查詢

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

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

示例1：

查詢售出數大於庫存數的書籍

from django.db.models import F
ret = models.Book.objects.filter(sale__gt=F('kucun'))   #（售出數量>庫存數量）可經過F動態獲取 同一個model實例中 兩個不一樣字段
for i in ret:
    print(i.title,i.sale,i.kucun)  # 查看書籍名稱 ，售出數量， 售出

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

#查詢庫存量的小於 售出量*2 的書籍
ret = models.Book.objects.filter(kucun__lt=F('sale') * 2)
print(ret)  # ==》<QuerySet [<Book: <Book object: 3 跟老男孩學思想>>, <Book: <Book object: 4 跟egon學喊麥>>]>

修改操做中有一個update方法

    # ret = models.Book.objects.filter(id=2).update(sale=100)   #這個不用保存  直接改庫

    # obj = models.Book.objects.get(id=2)
    # obj.sale='1000'
    # obj.save()

 

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

ret = models.Book.objects.all().update(sale=F('sale') + 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查詢

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

示例1：

查詢書籍id大於2和小於10的書籍

ret = models.Book.objects.filter(id__gt=2, id__lt=10)
print(ret)  # ==><QuerySet [<Book: <Book object: 4 跟egon學喊麥>>]>

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

例如：查詢id不爲3的書籍

ret = models.Book.objects.filter(~Q(id=3))  # ~ 是取反的意思

 

#若是查詢 小於2或者大於3的書籍呢（~ ：取反的意思）（__get：大於等於，__lte：小於等於）
ret = models.Book.objects.filter(~Q(id__gte=2)|~Q(id__lte=3))
print(ret)  # ==》<QuerySet [<Book: <Book object: 1 跟金老闆學開車>>, <Book: <Book object: 4 跟egon學喊麥>>]>

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

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

混合使用

例子：

# 1 .查詢價格大於10，而且銷售量大於30的

ret = models.Book.objects.filter(~Q(price__gte=10) & Q(sale__gte=30)).values('id','price','sale')

print(ret)  # <QuerySet [{'id': 2, 'price': Decimal('9.99'), 'sale': 150}, {'id': 4, 'price': Decimal('1.00'), 'sale': 175}]>



# 2.查詢出版時間是2018年或者2017年的，書名稱帶‘金老闆’的書籍

ret  = models.Book.objects.filter(Q(publish_date__year=2018) | Q(publish_date__year=2017), title__icontains="金老闆")
print(ret)  # <QuerySet [<Book: <Book object: 1 跟金老闆學開車>>, <Book: <Book object: 2 跟金老闆學開潛艇>>]>

事務

import os

if __name__ == "__main__":
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "orm_練習.settings")
    import django
    import datetime

    django.setup()

    from app01 import models

    try:
        # from django.db import transaction
        from django.db import transaction

        with transaction.atomic():
            # 給數據中出版社表 建立 幾個新的的出版社
            models.Publisher.objects.create(name="深圳出版社")
            models.Publisher.objects.create(name="深圳出版社1")
            # int(asd)    #  若是取消註釋  就會報錯    那麼這4各出版社建立都不會成功 （若是註釋那麼這四個出版社建立（事務）就算成功了）
            models.Publisher.objects.create(name="深圳出版社2")
            models.Publisher.objects.create(name="深圳出版社3")
            # 這4個新建立的出版社就是事務

    except Exception as e:
        print(str(e))
 

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

Django ORM執行原生SQL

# extra
# 在QuerySet的基礎上繼續執行子語句
# extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)

# select和select_params是一組，where和params是一組，tables用來設置from哪一個表
# 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'])

舉個例子：
models.UserInfo.objects.extra(
                    select={'newid':'select count(1) from app01_usertype where id>%s'},
                    select_params=[1,],
                    where = ['age>%s'],
                    params=[18,],
                    order_by=['-age'],
                    tables=['app01_usertype']
                )
                """
                select 
                    app01_userinfo.id,
                    (select count(1) from app01_usertype where id>1) as newid
                from app01_userinfo,app01_usertype
                where 
                    app01_userinfo.age > 18
                order by 
                    app01_userinfo.age desc
                """


# 執行原生SQL
# 更高靈活度的方式執行原生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()
ORM 執行原生SQL的方法

 

 

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):
   # 是否有結果
Queryset 方法大全

 

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語句。 

在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)
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程