12.329 orm单表查询
import os
if __name__ == '__main__':
# 指定当前py脚本需要加载的Django项目配置信息
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "orm_demo.settings")
import django
django.setup() # 启动Django项目
from app01 import models #返回QuerySet对象的方法:
ret = models.Book.objects.all()
print(ret) # QuerySet类型:书籍对象的列表
ret = models.Book.objects.filter(title="围城") # QuerySet类型 --> 书籍对象的列表
# id值大于1
ret = models.Book.objects.filter(id__gt=1)
# id值小于3
ret = models.Book.objects.filter(id__lt=3)
# 出版日期是2017年的书
ret = models.Book.objects.filter(publisher_date__year=2017)
# 出版日期大于2017年
ret = models.Book.objects.filter(publisher_date__year__gt=2017)
# 书名中包含'曌'的书
ret = models.Book.objects.filter(title__contains="曌")
# 书名中包含'曌'的书并且出版年份是2018年
ret = models.Book.objects.filter(title__contains="曌", publisher_date__year=2018)
# get方法如果符合筛选条件的对象超过一个或者没有都会抛出错误。
#符合筛选条件的对象只有一个，则返回具体的类对象实例：书籍对象，而不是列表
ret = models.Book.objects.get(id=10)
print(ret) #报错
# 使用filter检索的时候没有满足条件的数据就返回一个空 QuerySet
ret = models.Book.objects.filter(id=10)
print(ret) #[]
# 将满足条件的去掉，留下不满足条件的
ret = models.Book.objects.exclude(id__in=[1,3,4])
print(ret)
# 按字段排序
ret = models.Book.objects.all().order_by("price") # QuerySet类型：根据price字段对所有数据排序
ret = models.Book.objects.all().order_by("-price")
#反转
ret = models.Book.objects.all().order_by("price").reverse()
# 按照出版时间排序后反转再去字段值 # QuerySet类型：字段及字段值的字典的列表
ret = models.Book.objects.all().order_by("publisher_date").reverse().values("title") #特殊的QuerySet:
#values() 取字段的值，以字典返回
ret = models.Book.objects.filter(publisher_date__year=2018).values("title", "publisher_date")
print(ret) # QuerySet类型：字段及字段值的字典的列表
#values_list() 取字段的值，以元组返回
ret = models.Book.objects.filter(publisher_date__year=2018).values_list("title", "publisher_date") # QuerySet类型：字段值的元祖的列表
# 连表查询
ret = models.Book.objects.all().values("publisher__name").distinct()
print(ret) # QuerySet类型：字段及字段值的字典的列表，并去重
#返回数字的方法
# count 计数
ret = models.Book.objects.all().count() # 数字：结果集中数据的个数
#返回具体对象
#first()和last()
ret = models.Book.objects.all().first() #结果集中的第一个对象
#get()
ret = models.Book.objects.get(id=1) #返回匹配到的对象，有且仅有一个
#返回布尔值的方法
# 判断结果集中是否有数据
ret = models.Book.objects.all().exists() # 布尔值：结果集中是否有数据
12.3210 orm多表查询(方式二)
ForeignKey操作:书籍表(Book表)外键关联出版社表(Publisher表)
正向查找:
1.基于对象(子查询)
book_obj = models.Book.objects.first() # 第一本书对象
print(book_obj.publisher) # 得到这本书关联的出版社对象
print(book_obj.publisher.name) # 得到出版社对象的名称
2.基于双下划线字段方法(联表查询)
print(models.Book.objects.values_list("publisher__name"))
反向查找：
1.基于对象(子查询)
publisher_obj = models.Publisher.objects.first() # 找到第一个出版社对象
books = publisher_obj.book_set.all() # 找到第一个出版社出版的所有书籍对象
titles = books.values_list("title") # 找到第一个出版社出版的所有书籍的书名
#如果设置了 related_name="books"
#publisher= models.ForeignKey(to="Publisher", related_name="books")
publisher_obj = models.Publisher.objects.first()
ret = publisher_obj.books.all()
print(ret)#<QuerySet [<Book: 西瓜物语>, <Book: 香蕉物语>]>
2.基于双下划线的字段方法(联表查询)
ret = models.Publisher.objects.filter(id=1).values_list("book__title")
print(ret)#<QuerySet [('西瓜物语',), ('香蕉物语',)]>
titles = models.Publisher.objects.values_list("book__title")
print(titles)#<QuerySet [('西瓜物语',), ('香蕉物语',), ('番茄物语',), (None,)]>
#如果related_query_name="books"或者 related_name="books"(如果两个同时出现，则以related_query_name为准)
titles = models.Publisher.objects.filter(id=1).values_list("books__title")
#<QuerySet [('西瓜物语',), ('香蕉物语',)]>
titles = models.Publisher.objects.filter(id=1).values("books__title")
#<QuerySet [{'books__title': '西瓜物语'}, {'books__title': '香蕉物语'}]>
ManyToManyField：(使用方式二：通过ManyToManyField自动创建第三张表)
models:
class Book(models.Model):
title = models.CharField(max_length=32)
publish_date = models.DateField(auto_now_add=True)
price = models.DecimalField(max_digits=5, decimal_places=2)
memo = models.TextField(null=True)
# 创建外键，关联publish
publisher = models.ForeignKey(to="Publisher", )
# 创建多对多关联author
author = models.ManyToManyField(to="Author")
class Author(models.Model):
name = models.CharField(max_length=32)
age = models.IntegerField()
phone = models.CharField(max_length=11)
detail = models.OneToOneField(to="AuthorDetail")
class RelatedManager:"关联管理器"是在一对多或者多对多的关联上下文中使用的管理器。
它存在于下面两种情况：外键关系的反向查询、多对多关联关系，简单来说就是当 "."后面的对象 可能存在多个的时候就可以使用以下的方法
create()：创建一个新的对象，保存对象，并将它添加到关联对象集之中，返回新创建的对象。
#models.Book.objects.first().author得到是一个class RelatedManager对象，使用.create操作author表和第三张表
1.正向创建author表数据
ret = models.Book.objects.first().author.create(name="张三",age=16,phone="18012xxxx",detail_id=4)
#做了两件事情：1. 创建了一个新的作者，2. 将新创建的作者和第一本书做关联
ret = models.Book.objects.first().author.all().values("id")
print(ret)#<QuerySet [{'id': 1}, {'id': 3}, {'id': 15}]>
2.反向创建book表数据
import datetime
models.Author.objects.first().book_set.create(title="番茄物语", publish_date=datetime.date.today())
add()：把指定的model对象或对象id添加到关联对象集中
#添加对象
author_objs = models.Author.objects.filter(id__lt=3)
models.Book.objects.first().author.add(*author_objs)
#添加id
models.Book.objects.first().author.add(*[1, 2])
models.Book.objects.first().author.add(1)
#第一本书关联的作者id
ret = models.Book.objects.first().author.all().values("id")
print(ret)#<QuerySet [{'id': 1}, {'id': 3}, {'id': 15}]>
set()：更新model对象的关联对象。
ret=models.Book.objects.first().author.set([2, 3])#设置第三张表的关联关系，给第一个book对象加上id=2和3
ret = models.Book.objects.first().author.all()
print(ret)#<QuerySet [<Author: 小仙女>, <Author: 大乌龟>, <Author: 张曌>]>
ret = models.Book.objects.first().author.all().values("id")
print(ret)#<QuerySet [{'id': 1}, {'id': 3}, {'id': 15}]>
remove()：从关联对象集中移除执行的model对象
models.Book.objects.first().author.remove(3)#找到第一个图书对象所对应的所有作者，到第三张表中删除它与id=3的作者的关联关系#<QuerySet [{'id': 1}, {'id': 15}，{'id'=3}]>
ret = models.Book.objects.first().author.all().values("id")
print(ret) #<QuerySet [{'id': 1}, {'id': 15}]>
clear():从关联对象集中移除一切对象。
#<QuerySet [{'id': 1}, {'id': 15}]>
models.Book.objects.first().author.clear()
ret = models.Book.objects.first().author.all().values("id")
print(ret)#<QuerySet []>
注意：对于ForeignKey对象，clear()和remove()方法仅在null=True时存在
all()：
ret = models.Book.objects.first().author.all()#得到第一本书对象对应的作者对象集
print(ret) #<QuerySet [Author object,Author object,Author object]>
12.3211 聚合查询
aggregate()是QuerySet 的一个终止子句，它返回一个包含一些键值对的字典。
键的名称是聚合值的标识符，值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的。
from django.db.models import Avg, Sum, Max, Min, Count
models.Book.objects.all().aggregate(Avg("price"))
#{'price__avg': 13.233333}
ret = models.Book.objects.aggregate(Sum("price"))
#{'price__sum': Decimal('13.10')
ret = models.Book.objects.aggregate(total_price=Sum("price"))
#{'total_price': Decimal('13.10')}
ret = models.Book.objects.aggregate(avg_price=Avg("price"), max_price=Max("price"), min_price=Min("price"))
#{'avg_price': 4.366667, 'max_price': Decimal('12.00'), 'min_price': Decimal('0.10')}
12.3212 分组查询
单表查询分组：按照部门分组求平均工资
select dept,AVG(salary) from employee group by dept;
orm查询：
from django.db.models import Avg
models.Employee.objects.values("dept").annotate(avg=Avg("salary")
#<QuerySet [{'dept': '教学部', 'avg': 221.0}, {'dept': '销售部', 'avg': 21.0}, {'dept': '人事部', 'avg': 999.0}]>
models.Employee.objects.values("dept").annotate(avg=Avg("salary").values('dept', "avg")
#<QuerySet [{'dept': '教学部', 'avg': 221.0}, {'dept': '销售部', 'avg': 21.0}, {'dept': '人事部', 'avg': 999.0}]>
连表查询的分组：按照部门分组求平均工资
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")
models.Employee.objects.values("dept__name").annotate(avg=Avg("salary"))
#<QuerySet [{'dept__name': '垃圾部', 'avg': 221.0}, {'dept__name': '保安部', 'avg': 21.0}, {'dept__name': '教学部', 'avg': 999.0}]>
models.Employee.objects.values("dept__name").annotate(avg=Avg("salary")).values('dept', "avg")
#<QuerySet [{'dept__name': '垃圾部', 'avg': 221.0}, {'dept__name': '保安部', 'avg': 21.0}, {'dept__name': '教学部', 'avg': 999.0}]>
models.Employee.objects.values("dept__name")
#<QuerySet [{'dept__name': '垃圾部'}, {'dept__name': '保安部'}, {'dept__name': '教学部'}]>
作者、图书、出版社表关系：
from django.db import models
# 出版社
class Publisher(models.Model):
name = models.CharField(max_length=32)
city = models.CharField(max_length=32)
# 书
class Book(models.Model):
title = models.CharField(max_length=32)
publish_date = models.DateField(auto_now_add=True)
price = models.DecimalField(max_digits=5, decimal_places=2)
# 创建外键，关联publish
publisher = models.ForeignKey(to="Publisher")
# 创建多对多关联author
author = models.ManyToManyField(to="Author")
# 作者
class Author(models.Model):
name = models.CharField(max_length=32)
示例：
1.统计每一本书的作者个数
(1):ret = models.Book.objects.annotate(autor_num=Count("author")).values("title", "autor_num")
#<QuerySet [{'title': '西瓜物语', 'autor_num': 0}, {'title': '香蕉物语', 'autor_num': 1}, {'title': '番茄物语', 'autor_num': 1}]>
(2):book_list = models.Book.objects.all().annotate(author_num=Count("author"))
print(book_list) #<QuerySet [<Book: 西瓜物语>, <Book: 香蕉物语>, <Book: 番茄物语>]>
for obj in book_list:
print(obj.author_num)#0 1 1
2.统计出每个出版社出版的最便宜的书的价格
(1):ret = models.Publisher.objects.annotate(min_price=Min("book__price")).values("name", "min_price")
#<QuerySet [{'name': '清华出版社', 'min_price': Decimal('0.10')}, {'name': '香江出版社', 'min_price': Decimal('12.00')},
{'name': '北大青鸟出版社', 'min_price': None}]>
(2):ret=models.Book.objects.values("publisher__name").annotate(min_price=Min("price"))
#<QuerySet [{'publisher__name': '清华出版社', 'min_price': Decimal('0.10')}, #{'publisher__name': '香江出版社', 'min_price': Decimal('12.00')}]>
(3):publisher_list = models.Publisher.objects.annotate(min_price=Min("book__price"))
print(publisher_list)
#<QuerySet [<Publisher: 清华出版社>, <Publisher: 香江出版社>, <Publisher: 北大青鸟出版社>]>
for obj in publisher_list:
print(obj.min_price)#0.10 12.00 None
3.统计不止一个作者的图书
models.Book.objects.annotate(author_num=Count("author")).filter(author_num__gt=1)#<QuerySet []>
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('1.00')}, {'name': '小魔女', 'sum_price': Decimal('12.00')},
#{'name': '大乌龟', 'sum_price': None}, {'name': '张san', 'sum_price': None}]>
12.3213 F查询
F() 的实例可以在查询中引用字段，来比较同一个 model 实例中两个不同字段的值。
商品表结构：
from django.db import models
class Product(models.Model):
name = models.CharField(max_length=32)
price = models.DecimalField(max_digits=6, decimal_places=2)
# 库存数
keep = models.IntegerField()
# 卖出数
sale = models.IntegerField()
def __str__(self):
return "{}:{}:{}:{}".format(self.name, self.price, self.keep, self.sale)
示例：
from django.db.models import F
1.查询出卖出数大于库存数的商品
models.Product.objects.filter(sale__gt=F("keep"))
#<QuerySet [<Product: 跟哪吒学诗歌:59.00:50:10000>, <Product: 跟苑局学三不:55.00:100:200>]>
2.Django支持F()对象之间以及F()对象和常数之间的加减乘除和取模的操作
models.Product.objects.filter(sale__gt=F('keep')*2)
#<QuerySet [<Product: 跟哪吒学诗歌:59.00:50:10000>]>
3.修改操作也可以使用F函数:比如将每个产品的价格提高50元
models.Product.objects.all().update(price=F("price")+50)
4.把所有商品名后面加上"新款"
from django.db.models.functions import Concat
from django.db.models import Value
models.Product.objects.all().update(name=Concat(F("name"), Value("新款")))
12.3214 Q查询
filter() 等方法中的关键字参数查询都是一起进行“AND” 的。 如果需要执行更复杂的查询（例如OR语句），可以使用Q对象
#卖出数大于100 并且 价格大于100块的
models.Product.objects.filter(sale__gt=100, price__gt=100)
#<QuerySet [<Product: 跟哪吒学诗歌新款:259.00:50:10000>, <Product: 跟苑局学三不新款:255.00:100:200>]>
示例：
from django.db.models import Q
1.查询卖出数大于100或者价格小于100的
models.Product.objects.filter(Q(sale__gt=100)|Q(price__lt=100)) #|:或
#<QuerySet [<Product: 跟哪吒学诗歌新款:259.00:50:10000>, <Product: 跟苑局学三不新款:255.00:100:200>]>
2.查询库存数是100并且卖出数不是0的产品
models.Product.objects.filter(Q(keep=100)&~Q(sale=0)) #&：与，~：非
models.Product.objects.filter(Q(kucun=100),~Q(maichu=0))
#<QuerySet [<Product: 跟苑局学三不新款:255.00:100:200>]>
models.Product.objects.filter(Q(kucun=100)&~Q(maichu=0)).values('name')
#<QuerySet [{'name': '跟苑局学三不新款'}]>
models.Product.objects.filter(Q(kucun=100)&~Q(maichu=0)).values_list('name')
#<QuerySet [('跟苑局学三不新款',)]>
查询函数可以混合使用Q 对象和关键字参数。所有提供给查询函数的参数（关键字参数或Q 对象）都将"AND”在一起。但是，如果出现Q 对象，它必须位于所有关键字参数的前面
#查询产品名包含新款， 并且库存数大于60或者价格小于100的产品
models.Product.objects.filter(Q(keep__gt=60)|Q(price__lt=100), name__contains="新款")
#<QuerySet [<Product: 跟苑局学三不新款:255.00:100:200>]>
12.3215 事务
开启一个事务可以包含一些sql语句，这些sql语句要么同时成功，要么都不成功，称之为事务的原子性 作用：事务用于将某些操作的多个SQL作为原子性操作，一旦有某一个出现错误，即可回滚到原来的状态，从而保证数据库数据完整性。
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))
12.3216 Django ORM执行原生SQL
很多情况下我们不需要将查询结果映射成模型，或者我们需要执行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()