多表操作

多表操作

数据准备

class Publish(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32)
    addr=models.CharField(max_length=64)
    email=models.EmailField
    def __str__(self):
        return self.name

class Author(models.Model):
    id = models.AutoField(primary_key=True)
    name=models.CharField(max_length=32)
    sex=models.IntegerField()
    authordetail=models.OneToOneField(to='AuthorDetail',to_field='id')
    def __str__(self):
        return self.name

class AuthorDetail(models.Model):
    id=models.AutoField(primary_key=True)
    phone = models.CharField(max_length=32)
    addr = models.CharField(max_length=64)


class Book(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=5, decimal_places=2)
    create_time = models.DateField(null=True)

    publish=models.ForeignKey(to='Publish',to_field='id')
    authors=models.ManyToManyField(to='Author')
    def __str__(self):
        return self.name
-------------------------------------------------------    
# 一对一的关系:OneToOneField      模型表的字段,后面会自定加_id
# 一对多的关系:ForeignKey         模型表的字段,后面会自定加_id
# 多对多的关系:ManyToManyField    ManyToManyField会自动创建第三张表

一、一对多

1.添加数据

方式一：

pub=Publish.objects.get(pk=1)  #publish=出版社的对象,存到数据库,是一个id
Book.objects.create(name='金庸群侠传',price=100,create_time='2018-1-1',publish=pub)

方式二：

book=Book.objects.create(name='红楼梦',price=34.5,create_time='2017-1-1',publish_id=1)
#用了OneToOneField和ForeignKey,模型表的字段,后面会自定加_id

2.修改数据

方式一：

#修改出版社
book=Book.object.get(pk=1)
book.publish_id=2
book.save()

方式二：

book=Book.objects.filter(pk=1).update(publish_id=2)
或
pub=Publish.objects.get(pk=2)
book=Book.objects.filter(pk=1).update(publish=pub)

3.删除数据

同单表删除

方式一：

ret=models.Book.objects.filter(name='红楼梦').delete()
# ret返回的是被影响行数，queryset对象的.delete()方法
如果存在多本红楼梦将会被全部删除

方式二：

ret=models.Book.objects.filter(name='红楼梦').first()
ret.delete()
只删除一个

二、多对多

1.添加数据

a=Author.objects.filter(name='虚竹').first()
b=Author.objects.filter(name='段誉').first()
book=Book.objects.filter(name='天龙八部').first()
#添加过个作者对象
book.authors.add(a,b)
#或者   添加多个作者id
book.authors.add(1,2)

2.删除remove,可以传对象，可以传id，可以传多个，不要混着用

book.authors.remove(a)
book.authors.remove(1,2)

3.clear清空所有

book.authors.clear()

4.set,先清空所有，再新增，要传一个列表，列表内可以是id，也可以是对象

book.authors.set([a,b])

三、基于对象的跨表查询

基于对象的查询是子查询也就是多次查询

1.一对一

正向  author-----关联字段在author----->authordetail------>按字段
反向  authordetail----->关联字段在author---->author------>按表名小写

例子

正向查询：查询abc作者的手机号

author=Author.objects.filter(name='abc').first()
authordetail=author.authordetail
# author.authordetail 就是作者详情的对象----这里的authordetail是字段名
print(authordetail.phone)

反向查询：查询地址在上海的作者名字

authordetail=AuthorDetail.objects.filter(addr='上海').first()
author=authordetail.author
# authordetail.author  这是作者对象
print(author.name)

2.一对多

正向： book----关键字段在book--->publish---->按字段
反向: publish---->关键字段在book--->book---->按表名小写_set.all()

正向查询：查询红楼梦这本书的出版社地址

book=Book.objects.filter(name='红楼梦').first()
pub=book.publish
#book.publish  出版社对象
print(pub.addr)

反向查询：查询地址是上海的出版社的出版图书

pub=Publish.objects.filter(addr='上海').first()
books=pub.book_set.all()

3.多对多

正向： book---关联字段在book--->author--->按字段.all()
反向： author---关联字段在book--->book---->按表名小写_set.all()

正向查询：查询红楼梦这本书的所有作者

book=Book.objects.filter(name='红楼梦').first()
authors=book.authors.all()

反向查询：查询B写的所有书

b=Author.objects.filter(name='B').first()
books=b.book_set.all()

4.连续跨表

查询红楼梦这本书所有的作者的手机号

book=Book.objects.filter(name='红楼梦')
authors=book.author.all()
for author in authors:
    author_detail=author.authordetail
    print(authordetail.phone)

四、基于双下划线查询

1.一对一

-正向:按字段,跨表可以在filter,也可以在values中    按字段
-反向:按表名小写,跨表可以在filter,也可以在values中    按表名小写

正向查询：查询作者B的手机号

（以author表作为基表）

ret=Author.object.filter(name='B').values('authordetail__phone')
print(ret)

反向查询：

ret=AuthorDetail.object.filter(author__name='B').values('phone')

2.一对多

正向查询：

#查询出版社为北京出版社出版的所有图书的名字,价格
Book.objects.filter(publish_name='北京出版社').values('name','price')

反向查询：

Publish.objects.filter(name='北京出版社').values('book_name','book_price')

3.多对多

正向查询：

查询红楼梦的所有作者名字
Book.objects.filter(name='红楼梦').values('authors_name')

反向查询：

Author.objects.filter(book__name='红楼梦').values('name')

4.连续跨表

查询北京出版社出版过的所有书籍的名字以及作者的姓名

Publish.objects.filter('北京出版社').values('book__name','book_author__name')

Book.object.filter(publish__name='北京出版社').values('name','author__name')

五、聚合查询

aggregate(*args, **kwargs)

aggregate()是QuerySet 的一个终止子句,返回一个包含一些键值对的字典
可以向aggregate()子句中添加另一个参数,生成不止一个聚合

from django.db.models import Avg,Count,Max,Min,Sum
#1.计算所有图书的平均价格
Book.objects.all().aggregate(Avg('price'),Max('price'))

六、分组查询

annotate()为调用的QuerySet中每个对象生成独立的统计值。跨表分组查询本质就是将关联表join成一张表，再按单表的思路进行分组查询

#统计每一本书作者个数
Book.objects.all().annotate(s=Count('author')).values('name','c')

#查询所有作者写的书的总价格大于30的作者
Author.objects.value('pk')annotate(s=Sum('book_price')).filter(s_gt=30).values('name','s')
或者
Author.objects.annotate(s=Sum('book_price)).filter(s_gt=30).values('name''s') #默认按id主键分组

注：

values在annotate前表示分组，在后表示取值
filter在annotate前表示where条件，在后表示having

七、F查询

对两个字段的值做比较
F() 的实例可以在查询中引用字段，来比较同一个 model 实例中两个不同字段的值。

例如book的model中再添加两个字段，评论数和阅读数.

查询评论数大于阅读数的书

ret=Book.objects.all().filter(commit_num__gt=read_num) #错误
正确如下：
ret=Book.objects.all().filter(commit_num_gt=F('read_num'))

把所有书的评论数加1

ret=Book.objects.all().update(commit_num=F('commit_num')+1)

八、Q查询

filter()等方法进行的是'AND'，更复杂的查询需要Q查询
表示与& ,或 | ,非 ~

#查询是作者A也或者是作者B的书
Book.object.all().filter(Q(author_name='A')|Q(author_name='B'))

补充：

Blog.objects.filter(entry__headline__contains='Lennon').filter(entry__pub_date__year=2008)

把两个参数拆开，放在两个filter调用里面，Django在这种情况下，将两个filter之间的关系设计为-或“or”