ORM常用字段及方式

創建小型數據庫

 

模型層

 

•      ORM常用字段
  

AutoField

int自增列，必須填入參數 primary_key=True。當model中如果沒有自增列，則自動會創建一個列名為id的列。

IntegerField

一個整數類型,范圍在 -2147483648 to 2147483647。(一般不用它來存手機號(位數也不夠)，直接用字符串存，)

CharField

字符類型，必須提供max_length參數， max_length表示字符長度。

DateField

日期字段，日期格式  YYYY-MM-DD，相當於Python中的datetime.date()實例。

DateTimeField

日期時間字段，格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]，相當於Python中的datetime.datetime()實例。

class User(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField()
    register_time = models.DateField()

1. 字段的參數

null

用於表示某個字段可以為空。

unique

如果設置為unique=True 則該字段在此表中必須是唯一的 。

db_index

如果db_index=True 則代表着為此字段設置索引。

default

為該字段設置默認值。

　　2.DateField和DateTimeField

auto_now_add

配置auto_now_add=True，創建數據記錄的時候會把當前時間添加到數據庫。

auto_now

配置上auto_now=True，每次更新數據記錄的時候會更新該字段。

 

• 　關系字段

ForeignKey

 

 

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

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

字段參數

to

設置要關聯的表

to_field

設置要關聯的表的字段

on_delete

當刪除關聯表中的數據時，當前表與其關聯的行的行為。

models.CASCADE

刪除關聯數據，與之關聯也刪除

db_constraint

是否在數據庫中創建外鍵約束，默認為True。

• 　　OneToOneField

一對一字段。

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

字段參數

to

設置要關聯的表。

to_field

設置要關聯的字段。

on_delete

當刪除關聯表中的數據時，當前表與其關聯的行的行為。(參考下面的例子)

ef func():
    return 10

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

返回QuerySet對象的方法有
all()

filter()

exclude()

order_by()

reverse()

distinct()

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

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

返回具體對象的
get()

first()

last()

返回布爾值的方法有：
exists()

返回數字的方法有
count()

單表查詢操作演示表

 

# 單表查詢表
class User(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField()
    register_time = models.DateField()

    def __str__(self):
        return '對象的名字:%s'%self.name

 

 # 新增數據
    # 基於create創建
    # user_obj = models.User.objects.create(name='tank',age=73,register_time='2019-2-14')
    # print(user_obj.register_time)
    # 基於對象的綁定方法創建
    # user_obj = models.User(name='kevin',age=30,register_time='2019-1-1')
    # user_obj.save()
    # from datetime import datetime
    # ctime = datetime.now()
    # models.User.objects.create(name='egon', age=18, register_time=ctime)


    # 修改數據
    # 基於對象
    # user_obj = models.User.objects.filter(name='jason').first()
    # user_obj.age = 17
    # user_obj.save()
    # 基於queryset
    # models.User.objects.filter(name='kevin').update(age=66)


    # 刪除數據
    # 基於queryset
    # models.User.objects.filter(name='egon').delete()
    # 基於對象
    # user_obj = models.User.objects.filter(name='owen').first()
    # user_obj.delete()


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

    # < 2 > filter(**kwargs): 它包含了與所給篩選條件相匹配的對象
    # res = models.User.objects.filter(name='jason',age=17)
    # filter內可以放多個限制條件但是需要注意的是多個條件之間是and關系
    # print(res)

    # < 3 > get(**kwargs): 返回與所給篩選條件相匹配的對象，返回結果有且只有一個，如果符合篩選條件的對象超過一個或者沒有都會拋出錯誤。（源碼就去摟一眼～詮釋為何只能是一個對象）
    # 不推薦使用

    # < 4 > exclude(**kwargs): 它包含了與所給篩選條件不匹配的對象
    # res = models.User.objects.exclude(name='jason')
    # print(res)
    # < 5 > order_by(*field): 對查詢結果排序('-id') / ('price')
    # res = models.User.objects.order_by('age')   # 默認是升序
    # res = models.User.objects.order_by('-age')  # 可以在排序的字段前面加一個減號就是降序
    # res = models.User.objects.order_by('name')
    # res = models.User.objects.order_by('-name')
    # print(res)

    # < 6 > reverse(): 對查詢結果反向排序 >> > 前面要先有排序才能反向
    # res = models.User.objects.order_by('age').reverse()
    # print(res)

    # < 7 > count(): 返回數據庫中匹配查詢(QuerySet) 的對象數量。
    # res = models.User.objects.count()
    # res = models.User.objects.all().count()
    # print(res)

    # < 8 > first(): 返回第一條記錄
    # res = models.User.objects.all().first()
    # res = models.User.objects.all()[0]  # 不支持負數的索引取值
    # print(res)

    # < 9 > last(): 返回最后一條記錄
    # res = models.User.objects.all().last()
    # print(res)

    # < 10 > exists(): 如果QuerySet包含數據，就返回True，否則返回False
    # res = models.User.objects.all().exists()
    # res1 = models.User.objects.filter(name='jason',age=3).exists()
    # print(res,res1)

    # < 11 > values(*field): 返回一個ValueQuerySet——一個特殊的QuerySet，運行后得到的並不是一系列
    # model的實例化對象，而是一個可迭代的字典序列
    # res = models.User.objects.values('name')  # 列表套字典
    # res = models.User.objects.values('name','age')  # 列表套字典
    # print(res)

    # < 12 > values_list(*field): 它與values()
    # 非常相似，它返回的是一個元組序列，values返回的是一個字典序列
    # res = models.User.objects.values_list('name','age')  # 列表套元祖
    # print(res)

    # < 13 > distinct(): 從返回結果中剔除重復紀錄  去重的對象必須是完全相同的數據才能去重
    # res = models.User.objects.values('name','age').distinct()
    # print(res)


    # 神奇的雙下划線查詢

    # 查詢年輕大於44歲的用戶
    # res = models.User.objects.filter(age__gt=44)
    # print(res)
    # 查詢年輕小於44歲的用戶
    # res = models.User.objects.filter(age__lt=44)
    # print(res)
    # 查詢年輕大於等於44歲的用戶
    # res = models.User.objects.filter(age__gte=44)
    # print(res)
    # 查詢年輕小於等於44歲的用戶
    # res = models.User.objects.filter(age__lte=44)
    # print(res)

    # 查詢年齡是44或者22或者73的用戶
    # res = models.User.objects.filter(age__in=[44,22,73])
    # print(res)

    # 查詢年齡在22到44范圍內
    # res = models.User.objects.filter(age__range=[22,44])
    # print(res)


    # 用的是mysql數據庫
    # 查詢年份
    # res = models.Book.objects.filter(publish_date__year=2019)
    # print(res)


    # 查詢名字中包含字母n的用戶  sqlite數據庫演示不出來大小寫的情況！！！
    # res = models.Author.objects.filter(name__contains='n')
    # res = models.Author.objects.filter(name__icontains='n')
    # print(res)
    # res = models.User.objects.filter(name__icontains='e')  # 無視大小寫
    # print(res)

    # 查詢名字以j開頭的用戶
    # res = models.User.objects.filter(name__startswith='j')
    # print(res)
    # 查詢名字以n結尾的用戶
    # res = models.User.objects.filter(name__endswith='n')
    # print(res)

    # 查詢注冊是在2017年的用戶
    # res = models.User.objects.filter(register_time__year=2017)  # sqlite對日期格式不太精准
    # print(res)

單表查詢操作演示表2

 

class Book(models.Model):
      name = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=8,decimal_place=2)
    publish = models.CharField(max_length=32)
    author = models.CharField(max_length=32)
    create_time = models.DateField(null=True)
    # 配置auto_now_add=True，創建數據記錄的時候會把當前時間添加到數據庫。
    # 配置上auto_now=True，每次更新數據記錄的時候會更新該字段。

 

新增數據

            # 第一種：有返回值，並且就是當前被創建的數據對象
        modles.Book.objects.create(name='',price='',publish='',author='',create_time='2019-5-1')
        # 第二種：先實例化產生對象，然后調用save方法保存
        book_obj = models.Book(name='',price='',publish='',author='',create_time='2019-5-1')
        book_obj.save()
        # 2.驗證時間格式字段即可以傳字符串也可以傳時間對象
        import datetime
        ctime = datetime.datetime.now()
        book = models.Book.objects.create(name='',price='',author='',create_time=ctime)

刪除數據

            """刪除數據"""
        # 1.刪除書名為xxx的這本書  queryset方法
        res = models.Book.objects.filter(name='').delete()
        print(res)
        # 2.刪除書名為xxx的這本書  queryset方法
        res = models.Book.objects.filter(name='').first()
        res.delete()

修改數據

            # 1.queryset修改
        models.Book.objects.filter(name='').update(price='')
        # 2.對象修改
        book = models.Book.objects.filter(name='').first()
        book.price = 66.66
        book.save()  # 對象只有保存方法 這樣也能實現修改需求

查詢數據

            <1> all():                  查詢所有結果
        <2> filter(**kwargs):       它包含了與所給篩選條件相匹配的對象
        <3> get(**kwargs):          返回與所給篩選條件相匹配的對象，返回結果有且只有一個，如果符合篩選條件的對象超過一個或者沒有都會拋出錯誤。（源碼就去摟一眼～詮釋為何只能是一個對象）
        <4> exclude(**kwargs):      它包含了與所給篩選條件不匹配的對象
        <5> order_by(*field):       對查詢結果排序('-id')/('price')
        
        <6> reverse():              對查詢結果反向排序     >>>前面要先有排序才能反向
        <7> count():                返回數據庫中匹配查詢(QuerySet)的對象數量。
        <8> first():                返回第一條記錄
        <9> last():                返回最后一條記錄
        <10> exists():              如果QuerySet包含數據，就返回True，否則返回False
        <11> values(*field):        返回一個ValueQuerySet——一個特殊的QuerySet，運行后得到的並不是一系列                             model的實例化對象，而是一個可迭代的字典序列
        <12> values_list(*field):   它與values()非常相似，它返回的是一個元組序列，values返回的是一個字典序列
        <13> distinct():            從返回結果中剔除重復紀錄
    # ******************* 
           # 必須完全一樣才可以去重（意味着帶了id就沒有意義了）
           # res = models.Book.objects.all().values('name').distinct()  先查一個重復的值再去重

基於雙下划線的查詢

    # 價格 大於 小於 大於等於 小於等於
    filter(price__gt='90')
    filter(price__lt='90')
    filter(price_gte='90')
    filter(price_lte='90')
    
    # 存在與某幾個條件中
    filter(price__in=['11','22','33'])
    # 在某個范圍內
    filter(price__range=[50,90])
    
    # 模糊查詢
    filter(title__contains='西')
    filter(title__icontains='P')
    
    # 以什么開頭 以什么結尾
    
    # 按年查詢
    filter(create_time__year='2017')

多表查詢操作演示表

 

# 多表查詢表
class Book(models.Model):
    title = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=8,decimal_places=2)
    publish_date = models.DateField(auto_now_add=True)
    # 外鍵關系
    publish = models.ForeignKey(to='Publish')
    authors = models.ManyToManyField(to='Author')  # 虛擬字段， 信號字段

    def __str__(self):
        return '書籍對象的名字:%s'%self.title


class Publish(models.Model):
    name = models.CharField(max_length=32)
    addr = models.CharField(max_length=32)
    email = models.EmailField()  # 對應就是varchar類型

    def __str__(self):
        return '出版社對象的名字:%s'%self.name


class Author(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField()
    authordetail = models.OneToOneField(to='AuthorDetail')

    def __str__(self):
        return  '作者對象的名字:%s'%self.name


class AuthorDetail(models.Model):
    phone = models.CharField(max_length=32)
    addr = models.CharField(max_length=32)

    # 多表查詢
    # 新增
    # 直接寫id
    # models.Book.objects.create(title='紅樓夢',price=66.66,publish_id=1)
    # 傳數據對象
    # publish_obj = models.Publish.objects.filter(pk=2).first()
    # models.Book.objects.create(title='三國演義',price=199.99,publish=publish_obj)

    # 修改
    # queryset修改
    # models.Book.objects.filter(pk=1).update(publish_id=3)
    # publish_obj = models.Publish.objects.filter(pk=2).first()
    # models.Book.objects.filter(pk=1).update(publish=publish_obj)
    # 對象修改
    # book_obj = models.Book.objects.filter(pk=1).first()
    # book_obj.publish_id = 3  # 點表中真實存在的字段名
    # book_obj.save()
    # publish_obj = models.Publish.objects.filter(pk=2).first()
    # book_obj.publish = publish_obj  # 點orm中字段名 傳該字段對應的表的數據對象
    # book_obj.save()

    # 刪除
    # models.Book.objects.filter(pk=1).delete()
    # models.Publish.objects.filter(pk=1).delete()

    # book_obj = models.Book.objects.filter(pk=3).first()
    # book_obj.delete()


    # 給書籍綁定與作者之間的關系
    # 添加關系 add:add支持傳數字或對象，並且都可以傳多個
    # book_obj = models.Book.objects.filter(pk=3).first()
    # # book_obj.authors.add(1)
    # # book_obj.authors.add(2,3)
    # author_obj = models.Author.objects.filter(pk=1).first()
    # author_obj1 = models.Author.objects.filter(pk=3).first()
    # # book_obj.authors.add(author_obj)
    # book_obj.authors.add(author_obj,author_obj1)

    # 修改書籍與作者的關系  set()  set傳的必須是可迭代對象！！！
    # book_obj = models.Book.objects.filter(pk=3).first()
    # 可以傳數字和對象，並且支持傳多個
    # book_obj.authors.set((1,))
    # book_obj.authors.set((1,2,3))
    #
    # author_list = models.Author.objects.all()
    # book_obj = models.Book.objects.filter(pk=3).first()
    # book_obj.authors.set(author_list)


    # 刪除書籍與作者的綁定關系
    # book_obj = models.Book.objects.filter(pk=3).first()
    # # book_obj.authors.remove(1)
    # # book_obj.authors.remove(2,3)
    # # author_obj = models.Author.objects.all().first()
    # author_list = models.Author.objects.all()
    # # book_obj.authors.remove(author_obj)
    # book_obj.authors.remove(*author_list)  # 需要將queryset打散


    # 清空  clear()  清空的是你當前這個表記錄對應的綁定關系
    # book_obj = models.Book.objects.filter(pk=3).first()
    # book_obj.authors.clear()


    # 基於對象的表查詢
    # 正向
    # 查詢書籍是三國演義的出版社郵箱
    # book_obj = models.Book.objects.filter(title='三國演義').first()
    # print(book_obj.publish.email)
    # 查詢書籍是小王子的作者的姓名
    # book_obj = models.Book.objects.filter(title='小王子').first()
    # print(book_obj.authors)  # app01.Author.None
    # print(book_obj.authors.all())
    # 查詢作者為jason電話號碼
    # user_obj = models.Author.objects.filter(name='jason').first()
    # print(user_obj.authordetail.phone)

    # 反向
    # 查詢出版社是東方出版社出版的書籍                  一對多字段的反向查詢
    # publish_obj = models.Publish.objects.filter(name='東方出版社').first()
    # print(publish_obj.book_set)  # app01.Book.None
    # print(publish_obj.book_set.all())

    # 查詢作者jason寫過的所有的書                      多對多字段的反向查詢
    # author_obj = models.Author.objects.filter(name='jason').first()
    # print(author_obj.book_set)  # app01.Book.None
    # print(author_obj.book_set.all())

    # 查詢作者電話號碼是110的作者姓名                   一對一字段的反向查詢
    # authordetail_obj = models.AuthorDetail.objects.filter(phone=110).first()
    # print(authordetail_obj.author.name)

    # 基於雙下滑線的查詢
    # 正向
    # 查詢書籍為三國演義的出版社地址
    # res = models.Book.objects.filter(title='三國演義').values('publish__addr','title')
    # print(res)
    # 查詢書籍為小王子的作者的姓名
    # res = models.Book.objects.filter(title='小王子').values("authors__name",'title')
    # print(res)
    # 查詢作者為jason的家鄉
    # res = models.Author.objects.filter(name='jason').values('authordetail__addr')
    # print(res)

    # 反向
    # 查詢南方出版社出版的書名
    # res = models.Publish.objects.filter(name='南方出版社').values('book__title')
    # print(res)
    # 查詢電話號碼為120的作者姓名
    # res = models.AuthorDetail.objects.filter(phone=120).values('author__name')
    # print(res)
    # 查詢作者為jason的寫的書的名字
    # res = models.Author.objects.filter(name='jason').values('book__title')
    # print(res)
    # 查詢書籍為三國演義的作者的電話號碼
    # res = models.Book.objects.filter(title='三國演義').values('authors__authordetail__phone')
    # print(res)

    # 查詢jason作者的手機號
    # 正向
    # res = models.Author.objects.filter(name='jason').values('authordetail__phone')
    # print(res)
    # 反向
    # res = models.AuthorDetail.objects.filter(author__name='jason').values('phone')
    # print(res)

    # 查詢出版社為東方出版社的所有圖書的名字和價格
    # 正向
    # res = models.Publish.objects.filter(name='東方出版社').values('book__title','book__price')
    # print(res)
    # 反向
    # res = models.Book.objects.filter(publish__name='東方出版社').values('title','price')
    # print(res)

    # 查詢東方出版社出版的價格大於400的書
    # 正向
    # res = models.Publish.objects.filter(name="東方出版社",book__price__gt=400).values('book__title','book__price')
    # print(res)
    # 反向
    # res = models.Book.objects.filter(price__gt=400,publish__name='東方出版社').values('title','price')
    # print(res)



    # 聚合查詢  aggregate
    from django.db.models import Max,Min,Count,Sum,Avg
    # 查詢所有書籍的作者個數
    # res = models.Book.objects.filter(pk=3).aggregate(count_num=Count('authors'))
    # print(res)
    # 查詢所有出版社出版的書的平均價格
    # res = models.Publish.objects.aggregate(avg_price=Avg('book__price'))
    # print(res)  # 4498.636
    # 統計東方出版社出版的書籍的個數
    # res = models.Publish.objects.filter(name='東方出版社').aggregate(count_num=Count('book__id'))
    # print(res)


    # 分組查詢(group_by)   annotate
    # 統計每個出版社出版的書的平均價格
    # res = models.Publish.objects.annotate(avg_price=Avg('book__price')).values('name','avg_price')
    # print(res)
    # 統計每一本書的作者個數
    # res = models.Book.objects.annotate(count_num=Count('authors')).values('title','count_num')
    # print(res)
    # 統計出每個出版社賣的最便宜的書的價格
    # res = models.Publish.objects.annotate(min_price=Min('book__price')).values('name','min_price')
    # print(res)
    # 查詢每個作者出的書的總價格
    # res = models.Author.objects.annotate(sum_price=Sum('book__price')).values('name','sum_price')
    # print(res)

 

創建圖書管理系統表(給作者表加一張作者詳情表為了一對一的查詢)，詮釋一對一關聯其實就是外健關聯再加一個唯一性約束而已

ForeignKey(unique=Ture) >>> OneToOneField()
# 即一對一可以用ForeignKey來做，但是需要設唯一性約束並且會報警告信息，不建議使用，建議用OneToOneField
# 用了OneToOneField和用ForeignKey會自動在字段后面加_id
# 用了ManyToMany會自動創建第三張表

 

一對多的書籍記錄增刪改查

# 針對外鍵關聯的字段 兩種添加方式
# 第一種通過publish_id
# 第二種通過publish傳出版社對象

# 刪除書籍直接查詢刪除即可，刪除出版社會級聯刪除

# 編輯數據也是兩種對應的方式(對象點的方式(這里能點publish和publish_id)最后點save(),queryset方式update())

多對多的書籍與作者的增刪改查

"""前提：先獲取書籍對象，再通過書籍對象點authors來進行書籍作者的增刪改查"""
# 1.給書籍新增作者add
# 1.add可以傳作者id，也可以直接傳作者對象，並且支持傳多個位置參數(不要混着用)

# 2.給書籍刪除作者remove
# 1.remove同樣可以傳id，對象，並且支持傳多個位置參數(不要混着用)

# 3.直接清空書籍對象所有的作者數據clear()不用傳任何參數

# 4.修改書籍對象所關聯的作者信息set，注意點set括號內必須傳可迭代對象，里面可以傳id，對象

"""總結:一對多增刪改，多對多add，remove，clear，set"""

正向反向概念

# 正向與方向的概念解釋

# 一對一
# 正向：author---關聯字段在author表里--->authordetail 按字段
# 反向：authordetail---關聯字段在author表里--->author 按表名小寫
# 查詢jason作者的手機號 正向查詢
# 查詢地址是 :山東 的作者名字 反向查詢

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

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

# 連續跨表
# 查詢圖書是三國演義的作者的手機號，先查書，再正向查到作者，在正向查手機號

# 總結：基於對象的查詢都是子查詢，這里可以用django配置文件自動打印sql語句的配置做演示

基於雙下划線的查詢

 

# 一對一
-連表查詢
-一對一雙下划線查詢
-正向:按字段,跨表可以在filter,也可以在values中
-反向:按表名小寫,跨表可以在filter,也可以在values中
# 查詢jason作者的手機號 正向查詢 跨表的話,按字段
# ret=Author.objects.filter(name='jason').values('authordetail__phone')
# 以authordetail作為基表 反向查詢,按表名小寫 跨表的話,用表名小寫
# ret=AuthorDetail.objects.filter(author__name='jason').values('phone')

# 查詢jason這個作者的性別和手機號
# 正向
# ret=Author.objects.filter(name='jason').values('sex','authordetail__phone')

 

# 查詢手機號是13888888的作者性別
# ret=Author.objects.filter(authordetail__phone='13888888').values('sex')
# ret=AuthorDetail.objects.filter(phone='13888888').values('author__sex')

"""
總結 其實你在查詢的時候先把orm查詢語句寫出來，再看用到的條件是否在當前表內，在就直接獲取，不在就按照正向按字段反向按表名來查即可
比如：
1.查詢出版社為北方出版社的所有圖書的名字和價格
res1 = Publish.objects.filter(name='').values('book__name','book__price')
res2 = Book.objects.filter(publish__name='').values('name','price')
2.查詢北方出版社出版的價格大於19的書
res1 = Publish.objects.filter(name='',book__price__gt=19).values('book__name','book__price)
"""

再次強調：

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

聚合查詢和分組查詢

聚合(利用聚合函數)

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")
這里需要注意的是annotate分組依據就是他前面的值，
如果前面沒有特點的字段，則默認按照ID分組，
這里有dept字段，所以按照dept字段分組

連表查詢的分組：

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

 

 總結

value里面的參數對應的是sql語句中的select要查找顯示的字段，

filter里面的參數相當於where或者having里面的篩選條件

annotate本身表示group by的作用，前面找尋分組依據，內部放置顯示可能用到的聚合運算式，后面跟filter來增加限制條件，最后的value來表示分組后想要查找的字段值

 最后的小總結

模型層ORM
ORM操作
   class User(models.Model):
      name = models.CharField(max_length=32)
      ...
      
      def save(self):
         # 在對象調用save保存到數據庫之前,在這里可以攔截進行相應的操作
         super().save()
      
      def delete(self):
         # 在對象調用delete刪除數據之前,在這里可以攔截進行相應的操作
         super().delete()
         
   單表操作
      增
         # 方式1：
         user_obj = models.User.objects.create(**kwargs)  # 注意create方法有返回值，並且就是新建數據對象本身
         # 方式2：
         user_obj = models.User(**kwargs)
         user_obj.save()
      查
         models.User.objects.filter(**kwargs)  # 多個過濾條件是and關系
         models.User.objects.get()  # 不推薦使用
         models.User.objects.all()  # 惰性查詢
      改
         models.User.objects.filter(**kwargs).update(**kwargs)  # 批量更新
         
         user_obj = models.User.objects.filter(**kwargs).first()
         user_obj.name = 'jason'
         user_obj.save()
         user_obj.update()  # 對象沒有點update的方法
      刪
         models.User.objects.filter(**kwargs).delete()  # 批量刪除
         
         user_obj = models.User.objects.filter(**kwargs).first()
         user_obj.delete()
   
   多表操作
      如何確立表關系:
         一個A能否有多個B   
         一個B能否有對個A
         
         如果兩者都能那么就是                 多對多
         如果只有一方可以                   一對多
         如果雙方都不可以但是兩者卻有關系      一對一
         
         
         
      表關系:
         一對一(OneToOneField):無論建在哪一方都可以，但是推薦建在查詢頻率較高的一方
         一對多(ForeignKey):建在多的那一方
         多對多(ManyToManyField):無論建在哪一方都可以，但是推薦建在查詢頻率較高的一方
         
         外鍵字段的增刪改查
            一對多字段的增刪改查(publish)
               增
                  models.Book.objects.create(publish_id=1)
                  
                  publish_obj = models.Publish.objects.filter(pk=1).first()
                  models.Book.objects.create(publish=publish_obj)
                  
                  
               改
                  book_obj = models.Book.objects.filter(pk=1).first()
                  book_obj.publish = new_publish_obj
                  
                  book_obj = models.Book.objects.filter(pk=1).update(publish_id=2)
                  book_obj = models.Book.objects.filter(pk=1).update(publish=publish_obj)
                  
               刪
                  刪除書籍正常刪除
                  刪除出版社那么會級聯刪除改出版社對應的所有的書籍
                  
            多對多字段增刪改查
               增
                  add()      
               改
                  set()
               刪
                  remove()
               
                  # 上面三個方法都可以支持傳多個數字或對象，set必須接收一個可迭代對象
               清空
                  clear()
      跨表表查詢
         正向反向
            關聯字段在你當前這表查詢另一張叫正向
            關聯字段不在你當前這表查詢另一張叫反向
         總結:正向查詢按字段，反向查詢按表名小寫(******)
         
         # 基於對象的跨表查詢(子查詢)
         # 基於雙下划線的跨表查詢(聯表查詢)
         
      基於對象
         book_obj = models.Book.objects.filter(pk=1).first()
         book_obj.publish.addr
         book_obj.publish.name
         book_obj.authors.all()
         
         publish_obj = models.Publish.objects.filter(pk=1).first()
         publish_obj.book_set.all() 
         
         
      基於雙下划線的跨表查詢
         res = models.Book.objects.filter(publish__name='東方出版社',title='小王子').values('title','publish__name','authors__authordetail__phone')
         
         
         
      settings文件配置
         直接拷貝使用即可
      
      queryset對象.query也能夠查看內部對應的sql語句
         all()
         filter()
         values()
         value_list()
         order_by()
         reverse()
         distinct()
         exclude()
         
         
         count()    計數
         exists()   布爾值
         get()     數據對象本身
         first()
         last()
      
                  
   聚合查詢
      from django.db.models import Max,Min,Sum,Count,Avg
         aggragate()
   
   分組查詢(group by)
      annotate()       group_concat()   concat()