ORM查询相关的操作

必知必会13条

import os

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "orm_practice.settings")
import django

django.setup()         #以上为脚本，可以在manage.py中获得

from app01 import models

# all   获取所有的数据   QuerySet   对象列表
# ret = models.Person.objects.all()


# get   获取某一条数据   对象    获取不到或者多个就报错
# ret = models.Person.objects.get(name='alex')


# filter   获取满足条件的所有对象   QuerySet   对象列表
# ret = models.Person.objects.filter(name='alex')


# exclude  获取不满足条件的所有对象  QuerySet   对象列表
ret = models.Person.objects.exclude(name='alex')

# values    获取数据字段名称和值    QuerySet   {}    
#  不指定字段  查询所有字段的值
#  指定字段    查询指定字段的值
ret = models.Person.objects.filter(name='alex').values('pid', 'name')   # 最后是以字典的形式显示

# values_list    获取数据字段的值    QuerySet   （值，值）       #最后是以元祖的形式显示
#  不指定字段  查询所有字段的值
#  指定字段    查询指定字段的值
# ret = models.Person.objects.filter(name='alex').values_list('pid', 'name')

#  order_by  排序   多个字段排序   - 降序排序
# ret = models.Person.objects.order_by('age','-pid' )
# print(ret)


# reverse 在已经排好序的基础在反转
# ret = models.Person.objects.all()
# print(ret)
# ret = ret.reverse()
# print(ret)


# distinct()  去重
# ret = models.Person.objects.values_list('name').distinct()
# print(ret)

# count 计数
ret = models.Person.objects.filter(name='alex').count()

# first last    取对象列表中的第一个 最后一个
ret = models.Person.objects.filter(pid=1000).first()
# ret = models.Person.objects.all().last()


# exists()  查询结果是否存在
ret = models.Person.objects.filter(pid=100).exists()
print(ret)

"""

单表的双下划线方法

import os

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "orm_practice.settings")

import django

django.setup()

from app01 import models

ret = models.Person.objects.filter(pk__gt=100)    #查询的是ID大于100的人

ret = models.Person.objects.filter(pk__lt=103)    查询的是ID小于103的人

ret = models.Person.objects.filter(pk__gte=100)   查询的是ID大于等于100的人

ret = models.Person.objects.filter(pk__lte=103)   查询的是ID小于等于103的人

ret = models.Person.objects.filter(pk__in=[100,103])   查询的是ID是【100,103】的人

ret = models.Person.objects.filter(pk__range=[100,103])  查询的是ID在100-103范围内人

ret = models.Person.objects.filter(name__contains='L')  查询的是name字段中包含L的人

ret = models.Person.objects.filter(name__icontains='L')  查询的是name字段中包含大小写L的人

ret = models.Person.objects.filter(name__startswith='x')   查询的是name字段中以x开头的人

ret = models.Person.objects.filter(name__istartswith='X')  查询的是name字段中以大小写x开头的人

ret = models.Person.objects.filter(name__endswith='x')    查询的是以什么结尾的
ret = models.Person.objects.filter(name__iendswith='X')   不区分大小写

ret = models.Person.objects.filter(birth__year='2019') 可以查询出生年份是2019年的人

ret = models.Person.objects.filter(age__isnull=False) print(ret)  可以判断某个字段是不是空

外键操作

import os

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "orm_practice.settings")
import django

django.setup()   #首先导入脚本

from app01 import models


book_obj = models.Book.objects.get(pk=3)
print(book_obj.publisher)      # 关联的对象
print(book_obj.publisher_id)   # 关联的对象id

不指定related_name  关联表的表名小写_set
ret = pub_obj.book_set.all()

指定related_name='books'  
ret = pub_obj.books.all()

基于字段的查询
ret = models.Book.objects.filter(publisher__name='**出版社')  #查出出版社名称是**出版社的书

不指定related_name
ret = models.Publisher.objects.filter(book__title='**的故事')

指定related_name = 'books'
ret = models.Publisher.objects.filter(books__title='**的故事')

指定related_query_name='book'  再改完名字的基础上，再一次改名字
ret = models.Publisher.objects.filter(book__title='**的故事')


pub_obj.books.remove(models.Book.objects.get(pk=3)) #表示删除ID为3的书与出版社的关系

pub_obj.books.clear()  #清空所有图书与数的关系

pub_obj.books.create(title='qqqq')   创建出版社对象与title=“qqqq”的书的关系

 多对多操作

import os

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "orm_practice.settings")
import django

django.setup()   # 导入测试脚本

from app01 import models


author_obj = models.Author.objects.get(pk=2)

set()  设置多对多关系    既能设置[id  ]也能设置 [ 对象 ]
author_obj.books.set([2,4])    设置作者ID为2的与书的ID为2和4的关系
author_obj.books.set(models.Book.objects.filter(id__in=[1,3]))   设置作者ID为2与书的ID为1和3的关系
反向设置
book_obj.author_set.set([3])  


add() 添加多对多关系
author_obj.books.add(1,2)
author_obj.books.add(models.Book.objects.get(pk=4))

remove() 删除多对多关系
author_obj.books.remove(1,2)
author_obj.books.remove(models.Book.objects.get(pk=4))

clear() 清空所有多对多关系
author_obj.books.clear()

create   创建多对多关系
author_obj.books.create(title='****',publisher_id=1)
book_obj.author_set.create(name='xxx')

聚合和分组

import os

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "orm_practice.settings")
import django
django.setup()   导入脚本进行测试

from app01 import models
from django.db.models import Max, Min, Sum, Count, Avg  导入聚合函数


aggregate()是QuerySet 的一个终止子句   表示聚合的意思
ret = models.Book.objects.all().aggregate(max=Max('price'), min=Min('price'))   #所有图书中最高价格与最低价格的书

ret = models.Book.objects.filter(publisher__name='**出版社').aggregate(max=Max('price'), min=Min('price'))  筛选出**出版社出版的书的最高与最低价格的书

统计每一本书的作者个数
ret = models.Book.objects.annotate(Count('author'))

统计出每个出版社买的最便宜的书的价格
ret = models.Publisher.objects.annotate(Min('book__price')).values()
ret = models.Book.objects.values('publisher__name').annotate(Min('price'))
ret = models.Book.objects.values('publisher').annotate(min=Min('price')).values('publisher__name', 'min', )
　统计不止一个作者的图书
ret = models.Book.objects.annotate(count=Count('author')).filter(count__gt=1)
　根据一本图书作者数量的多少对查询集 QuerySet进行排序
ret = models.Book.objects.annotate(count=Count('author')).order_by('-count')
 查询各个作者出的书的总价格
ret = models.Author.objects.annotate(Sum('books__price')).values()

F和Q

import os

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "orm_practice.settings")
import django

django.setup()  #导入脚本进行测试
 
from app01 import models
from django.db.models import F, Q  

F比较两个字段之间的关系
ret =models.Book.objects.filter(sale__gt=F('kucun')).values()   # 查询销量大于库存的图书
for i in ret:
     print(i)
#更新销量是原来的两倍
models.Book.objects.all().update(sale=F('sale') * 2)

#Q可以同时查询多个条件出来
 ~Q表示非的意思 
| 表示或的意思  
&表示and的意思
ret = models.Book.objects.filter(~Q(Q(id__lt=2) | Q(id__gt=4)) & Q(id__gt=3))

事务

import os

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "orm_practice.settings")
import django

django.setup()

from app01 import models
from django.db import transaction   导入事务

try:
    with transaction.atomic():   原子性操作，一个成功都成功，一个不成功都不成功
　　　　 models.User.objexts.filter(id__gt=3).select_for_update()
        models.Publisher.objects.create(name='**出版社')
        # models.Publisher.objects.create(name='**出版社')
        # models.Publisher.objects.create(name='**出版社')
        # models.Publisher.objects.create(name='**出版社')
except Exception as e:
    print(e)