9.django之多表操作
创建模型
表与表之间的关系
一对一 一对多 多对多
假设有作者模型,作者详细模型,出版社模型,书籍模型
作者模型与作者详细模型是一对一关系
出版社模型与书籍模型是一对多关系
作者模型与出版社模型是多对多关系
模型如下
from django.db import models # 作者模型 class Author(models.Model): nid = models.AutoField(primary_key=True) name = models.CharField(max_length=32) age = models.IntegerField() authorDetail = models.OneToOneField(to='AuthorDetail', to_field='nid', on_delete=models.CASCADE) # 就是foreignkey+unique，只不过不需要我们自己来写参数了，并且orm会自动帮你给这个字段名字拼上一个_id，数据库中字段名称为authorDetail_id #作者详细模型 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) #总长度为5,小数位位2 publish = models.ForeignKey(to='Publish',to_field='nid',on_delete=models.CASCADE) #foreignkey里面可以加很多的参数，to指向表，to_field指向你关联的字段，不写这个，默认会自动关联主键字段，on_delete级联删除 authors =models.ManyToManyField(to='Author')#注意不管是一对多还是多对多，写to这个参数的时候，最后后面的值是个字符串，不然你就需要将你要关联的那个表放到这个表的上面
第三张表
自己创建第三张表的
class Book(models.Model): title = models.CharField(max_length=32,verbose_name='书名') class Author(models.Model): name = models.CharField(max_length=32,verbose_name='作者姓名') #自己创建第三张表 class Author2Book(models.Model): author = models.ForeignKey(to='Author') book = models.ForeignKey(to='Book') class Meta: unique_together = ('author','book')
通过ManytoManyfField自动创建
class Book(models.Model): title = models.CharField(max_length=32,verbose_name='书名') #通过ORM自带的ManyToManyField自动创建第三张表 class Author(models.Model): name = models.CharField(max_length=32,verbose_name="作者姓名") books = models.ManyToManyField(to='Book',related_name='authors')
设置ManyToManyField并指向自行创建的第三张表
class Book(models.Model): title = models.CharField(max_length=32,verbose_name='书名') #自己创建第三张表,通过ManyToManyField指定关联 class Author(models.Model): name = models.CharField(max_length=32,verbose_name='作者姓名') books = models.ManyToManyField(to='Book',through='Author2Book',through_fields=('author','book')) #through_fields接收一个2元组('f1','f2'),其中f1是定义ManyToManyField的模型外键的名（author），f2是关联目标模型（book）的外键名。 class Author2Book(models.Model): author = models.ForeignKey(to='Author') book = models.ForeignKey(to='Book') class Meta: unique_together = ('author','book')
创建一对一时的一些参数
to #设置关联的表 to_field #设置关联的字段 on_delete #同ForeignKey字段
创建一对多时的一些参数
to #设置关联表 to_field #设置关联的字段 on_delete #同ForeignKey字段
创建多对多时的一些参数
to #设置关联表 related_name #同Foreignkey字段 related_query_name #同Foreignkey字段 through #在使用ManyToManyField字段时,Django将自动生成一张表来管理多对多的关联关系。手动创建第三张表时 through来指定第三张表的表名 through_fields #设置关联的字段 db_table #默认创建第三张表时,数据库中表名称
创建表时的一些元信息设置
db_table #ORM在数据库中默认是 app_类名,可以通过db_table重写类名 index_together #联合索引 unique_together #联合唯一索引 ordering #指定默认按什么字段排序 ,只有设置了属性才可以reverse()
on_delete参数
on_delete #当删除关联表中的数据时，当前表与其关联的行的行为。 models.CASCADE #删除关联数据，与之关联也删除 models.DO_NOTHING #删除关联数据，引发错误IntegrityError models.PROTECT #删除关联数据，引发错误ProtectedError models.SET_NULL #删除关联数据，与之关联的值设置为null（前提FK字段需要设置为可空） models.SET_DEFAULT #删除关联数据，与之关联的值设置为默认值（前提FK字段需要设置默认值） models.SET#删除关联数据， #a. 与之关联的值设置为指定值，设置：models.SET(值) #b. 与之关联的值设置为可执行对象的返回值，设置：models.SET(可执行对象)
添加表记录
一对多
方式1: publish_obj=Publish.objects.get(nid=1) #拿到nid为1的出版社对象 book_obj=Book.objects.create(title="金瓶眉",publishDate="2012-12-12",price=100,publish=publish_obj) 方式2: book_obj=Book.objects.create(title="金瓶眉",publishDate="2012-12-12",price=100,publish_id=1)
多对多
方式一： book_obj=Book.objects.create(title="追风筝的人",price=200,publishDate="2012-11-12",publish_id=1) yuan=Author.objects.filter(name="yuan").first() egon=Author.objects.filter(name="alex").first() book_obj.authors.add(yuan,egon) 方式二 book_obj.authors.add(1，2) book_obj.authors.add(*[1，2]) #这种方式用的最多，因为一般是给用户来选择，用户选择是多选的，选完给你发送过来的就是一堆的id值
多对多其他常用的API
book_obj.authors.remove() # 将某个特定的对象从被关联对象集合中去除 book_obj.authors.remove(*[1,2]) #将多对多的关系数据删除 book_obj.authors.clear() #清空被关联对象集合 book_obj.authors.set() #先清空后设置
基于对象的跨表查询
一对一查询
正向查询(按字段)
egon=Author.objects.filter(name="egon").first() print(egon.authorDetail.telephone)
反向查询(按表名 不需要_set,查询的就是一条记录)
authorDet=AuthorDetail.objects.filter(addr="北京")[0] print(authorDet.author.name)
一对多查询
正向查询(按字段)
# 查询id为1的书籍的出版社所在的城市 book_obj = Book.objects.filter(nid=1).first() print(book_obj.publish.city)
反向查询(按表名 book_set 加上_set是因为反向查询的时候，你查询出来的可能是多条记录的集合)
publish = Publish.objects.get(name='小钱出版社') book_list = publish.book_set.all() for book_obj in book_list: print(book_obj.title)
多对多查询
正向查询(按字段)
#查询三国演义所有作者的名字及手机号 book_obj = Book.objects.filter(title='三国演义').first() authors = book_obj.authors.all() for author_obj in authors: print(author_obj.name,author_obj.authorDetail.telephone)
反向查询(按表名)
# 查询alex出过的所有书籍的名字 author_obj=Author.objects.get(name="alex") book_list=author_obj.book_set.all() #与alex作者相关的所有书籍 for book_obj in book_list: print(book_obj.title)
注意
publish = ForeignKey(Book,related_name='bookList') #查询人民出版社出过的书 publish=Publish.objects.get(name='人民出版社') book_list=publish.bookList.all() 与人民出版社关联的所有书籍对象集合
基于双下划线的跨表查询
Django 还提供了一种直观而高效的方式在查询(lookups)中表示关联关系，它能自动确认 SQL JOIN 联系。要做跨关系查询，就使用两个下划线来链接模型(model)间关联字段的名称，直到最终链接到你想要的model 为止。
基于双下划线的查询就一句话：正向查询按字段,反向查询按表名小写
一对一查询
# 查询alex的手机号(一对一) # 正向查询 ret=Author.objects.filter(name="alex").values("authordetail__telephone") # 反向查询 ret=AuthorDetail.objects.filter(author__name="alex").values("telephone")
一对多查询
# 查询北京出版社出版过的所有书籍的名字与价格(一对多) # 正向查询 按字段publish book_obj = Book.objects.filter(publish__name = "北京出版社").values_list('title','price') # 反向查询 按表名book publish_obj = Publish.objects.filter(name='北京出版社').values_list('book__title','book__price')
多对多查询
# 查询alex出过的所有书籍的名字(多对多) #正向查询 按字段authors book_obj = Book.objects.filter(authors_name = 'alex' ).values_list('title') #反向查询按表名book author_obj = Author.objects.filter(name = 'alex').values_list('book_list','book_price')
related_name
反向查询时，如果定义了related_name ，则用related_name替换 表名
publish = ForeignKey(Book, related_name='bookList') # 练习: 查询人民出版社出版过的所有书籍的名字与价格(一对多) # 反向查询 不再按表名:book,而是related_name:bookList publish_obj = Publish.objects.filter(name='人民出版社').values_list('bookList__title','bookList__price')
聚合查询 分组查询 F查询和Q查询
聚合
aggregate(*args,**kwargs)
# 计算所有图书的平均价格 from django.db.models import Avg Book.objects.all().aggregate(Avg('price')) 或 Book.objects.aggregate(average_price=Avg('price'))
如果你希望生成不止一个聚合，你可以向aggregate()子句中添加另一个参数。所以，如果你也想知道所有图书价格的最大值和最小值，可以这样查询：
from django.db.models import Avg,Max,Min Book.object.aggregate(Avg('price'),Max('price'),Min('price')) #cpint('id'),count(1)都是统计个数 #输出{'price__avg': 34.35, 'price__max': Decimal('81.20'), 'price__min': Decimal('12.99')}
分组
单表分组查询
查询每一个部门名称以及对应的员工数 emp: id name age salary dep 1 alex 12 2000 销售部 2 egon 22 3000 人事部 3 wen 22 5000 人事部 sql语句 select dep,Count(*) from emp group by dep; ORM: emp.objects.values('dep').annotate(c=Count('id'))
多表分组查询
查询每一个部门名称以及对应的员工数 emp: id name age salary dep_id 1 alex 12 2000 1 2 egon 22 3000 2 3 wen 22 5000 2 dep id name 1 销售部 2 人事部 emp－dep: id name age salary dep_id id name 1 alex 12 2000 1 1 销售部 2 egon 22 3000 2 2 人事部 3 wen 22 5000 2 2 人事部 sql语句 select dep.name,Count(*) from emp left join dep on emp_id = dep.id group by dep.id ORM dep.objects.values('id').annotate(c=Count('emp')).values('name','c') ret = models.Emp.objects.values('dep_id','name').annotate(a=Count(1))
annotate()为调用的QuerySet中每一个对象都生成一个独立的统计值（统计方法用聚合函数
总结:跨表分组查询本质就是将关联表join成一张表，再按单表的思路进行分组查询,，既然是join连表，就可以使用咱们的双下划线进行连表了
class Emp(models.Model): name = models.CharField(max_length=32) age = models.IntegerField(max_length=32) salary = models.DecimalField(max_digits=8,decimal_places=2) dep = models.CharField(max_length=32) province = models.CharField(max_length=32) from django.db.models import Avg,Max,Count # 单表 #查询每一个部门的id以及对应员工的平均薪水 ret = models.Emp.objects.values('dep_id').annotate(s = Avg('salary')) #查询每个部门的id以及对对应的员工的最大年龄 ret = models.Emp.objects.values('dep_id').annotate(a = Max('age')) #连表 # 查询每个部门的名称以及对应的员工个数和员工最大年龄 ret = models.Emp.objects.values('dep_name').annotate(a = Count('id'),b =Max('age'))
annotate的返回值是querySet，如果不想遍历对象，可以用上value_list
练习题
#聚合查询 from django.db.models import Avg,Min,Max,F,Q,Count,Sum ret = models.Book.objects.all().aggregate(s=Avg('price')) ret = models.Book.ojects.aggregate(s=Avg('price')) ret ={'s':平均值} #分组查询 annotate(c=Count('id'),m=Max(),min=Min()) # 查询每个作者的姓名以及出版的书的最高价格 models.Author.objects.values('id','name').annotate(m=Max('book_price')) models.Author.objects.annotate(m=Max('book_price')).values('name','m') # values写在前面,直接就是筛选出结果字段,这些字段同时作为分组依据 # values写在后面,是通过调用者表的id进行分组,得到结果的结果是queryset(model对象),再通过values取值 # 查询作者id大于2作者的姓名以及出版的书的最高价格 models.Author.objects.filter(id__gt=2).values('id','name').annotate(m=Max('book_price')) models.Author.objects.filter(id__gt=2).annotate(m=Max('book_price')).values('name','m') # 查询作者(id大于2或者作者年龄大于等于20岁)的女作者的姓名以及出版的书的最高价格 models.Author.objects.filter(Q(id__gt=2)|Q(age__gt=20),sex='女').values('id','name').annotate(m=Max('book_price')) models.Author.objects.filter(Q(id__gt=2)|Q(age__gt=20),sex='女').annotate(m=Max('book_price')).values('m','name') # 查询每个作者出版的书的最高价格 的平均值 models.Author.objects.values('id','name').annotate(m=Max("book_price")).aggregate(a=Avg('m'))
F查询与Q查询
F查询
# 我们在book表里面加上两个字段：评论数：commentNum，收藏数：KeepNum # 查询评论数大于收藏数的书籍 from django.db.models import F,Q Book.objects.filter(commentNum__lt=F('keepNum')) # 查询评论数大于收藏数2倍的书籍 Book.objects.filter(commentNum__lt=F('keepNum')*2) # 修改操作也可以使用F函数,比如将每一本书的价格提高30元 Book.objects.all().update(price = F('price')+30)
Q查询
filter() 等方法中的关键字参数查询都是一起进行“and” 的
from django.db.models import Q Q(title_startswitch='Py') # Q 对象可以使用&(与) 、|（或）、~（非） 操作符组合起来。 book_obj = Book.objects.filter(Q(authors__name='alex')|Q(authors__name='wusir')) # Q对象可以使用~取反 book_obj = Book.objects.filter(Q(authors__name='alex')&~Q(authors__name='wusir')) # 如果出现Q 对象，它必须位于所有关键字参数的前面 bo
ORM执行原生sql语句
raw()管理器方法用于原始的SQL查询，并返回模型的实例
注意：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注入！
执行自定义SQL
from django.db import connection,connections cursor = connection.cursor() cursor.execute('''select * from auth_user where id = %s''',params = [1,]) ret = cursor.fetchone()
python脚本调用Django环境
import os if __name__ == '__main__': os.environ.setdefault("DJANGO_SETTINGS_MODULE", "moxing.settings") import django django.setup() from app01 import models books = models.Book.objects.all() print(books)
