Django（多表查询操作）

首先了解一下 mysql中的表之间的关系，一对一，一对多，多对一，多对多。

一对多关系、多对一关系、一对一关系

至少都有一侧是单个实体，所以记录之间的联系通过外键实现，让外键指向这个实体。

实现这种关系时，要在“多”这一侧加入一个外键，指向“一”这一侧联接的记录。

多对多关系

解决方法是添加第三个表，这个表称为关联表。

多对多关系可以分解成原表和关联表之间的两个一对多关系

多对多关系例子

查询多对多关系要分成两步。

若想知道某位学生选择了哪些课程，要先从学生和注册之间的一对多关系开始，获取这位学生在 registrations 表中的所有记录。

然后再按照多到一的方向遍历课程和注册之间的一对多关系，找到这位学生在 registrations 表中各记录所对应的课程。

同样，若想找到选择了某门课程的所有学生，你要先从课程表中开始，获取其在 registrations 表中的记录，再获取这些记录联接的学生。

自引用关系也是多对多的一种特殊情况

如果关系中的两侧都在同一个表中，这种关系称为自引用关系。在关注中，关系的左侧是用户实体，可以称为“关注者”；关系的右侧也是用户实体，但这些是“被关注者”。

创建一个多表之间关系的例子

实例：我们来假定下面这些概念，字段和关系
作者模型：一个作者有姓名和年龄。
作者详细模型：把作者的详情放到详情表，包含生日，手机号，家庭住址等信息。作者详情模型和作者模型之间是一对一的关系（one-to-one）
出版商模型：出版商有名称，所在城市以及email。
书籍模型：书籍有书名和出版日期，一本书可能会有多个作者，一个作者也可以写多本书，所以作者和书籍的关系就是多对多的关联关系(many-to-many);一本书只应该由一个出版商出版，所以出版商和书籍是一对多关联关系(one-to-many)。
模型建立如下：

from django.db import models

# Create your models here.

class Author(models.Model):

    nid = models.AutoField(primary_key=True)

    name = models.CharField(max_length=32)

    age = models.IntegerField()

    # 与AuthorDetail建立一对一的关系

    authorDetail = models.OneToOneField(to="AuthorDetail", on_delete=models.CASCADE)

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)

    # 与Publish建立一对多的关系,外键字段建立在多的一方

    publish = models.ForeignKey(to="Publish", to_field="nid", on_delete=models.CASCADE)

    # 与Author表建立多对多的关系,ManyToManyField可以建在两个模型中的任意一个，自动创建第三张表

    authors = models.ManyToManyField(to='Author', )

添加记录

#方式一:如果是这样直接指定publish_id字段去添加值，前提是你的主表里面必须有数据

# 主表：没有被关联的（因为book表是要依赖于publish这个表的）也就是publish表

# 子表：关联的表

book_obj = Book.objects.create(title='小猪猪', publishDate='2012-12-12', price=200, publish_id=1)

#方式二 建议

pub_obj = Publish.objects.filter(name='西瓜出版社')[0])

Book.objects.create(title='神雕侠侣',publishDate='2013-12-12',price=188,publish=pub_obj)
#第二种方法可以避免出版社不存在的问题

多对多添加记录：

　　书和作者是多对多的关系：一个书可以有多个作者，一个作者可以出版多本书

　　步骤：先找到书对象

　　　　　再找到需要的作者对象

　　　　　给书对象绑定作者对象（用add方法），也就是绑定多对多的关系.

#方式一
#查找作者id

xiaojiu =Author.objects.filter(name='xiaojiu').first()

zhang = Author.objects.filter(name='zhang').first()

#给书籍绑定作者

book_obj.authors.add(zhang,xiaojiu)

#方式二

　　pub_obj = Publish.objects.filter(name='苹果出版社').first()
　　book_obj = Book.objects.create(title='苹果书',publishDate='2012-2-2',price=188,publish=pub_obj)
　　authers = Author.objects.all()

　　绑定多对多的关系
　　book_obj.authors.add(*authers)

解除绑定：remove

# 将某个特定的对象从被关联对象集合中去除。 ====== book_obj.authors.remove(*[])

    book_obj = Book.objects.filter(title='小猪猪5').last() #找到对象

    authers = Author.objects.filter(nid__lt=3)#找到符合作者的对象

    book_obj.authors.remove(*authers) #因为是多个所以要加*

清除绑定：clear” `#清空被关联对象集合。`

  book_obj = Book.objects.filter(title='小猪猪4')#找到对象

    for book_obj_item in book_obj: #循环赋值

        book_obj_item.authors.clear()#清空关联对象

总结：remove和clear的区别
　　remove：得吧你要清除的数据筛选出来，然后移除
　　clear：不用查，直接就把数据都清空了。
　　各有应用场景

一对一查询

author和authordetile是一对一的关系

正向查询（按字段author）

反向查询（按表名authordeital）：因为是一对一的关系了，就不用_set了。

    #一对一查询

    #正向查询: 手机号为110的作者姓名

    deital_obj = AuthorDetail.objects.filter(telephone=110).first()

    print(deital_obj.author.name)

    #反向查询：查询作者的手机号

    xiaojiu_obj = Author.objects.filter(name='xiaojiu').first()

    print(dir(xiaojiu_obj)) #如果找不到方法，用dir 看看这个对象都有什么方法

    print(xiaojiu_obj.authorDetail.telephone)

一对多查询

正向查询(按字段：publish)：

反向查询(按表名：book_set)：

    #正向查询：查询 小红帽这本书的出版社地址

    book_obj = Book.objects.filter(title='小红帽')[0] #拿到书对象

    print('=======',book_obj.publish)

    print(book_obj.publish.city)

    #反向查询：查询苹果出版社都初版过哪本书和价格

    pub_obj = Publish.objects.filter(name='苹果出版社')[0]

    book_dic = pub_obj.book_set.all().values('price','title')[0]

    print(book_dic)

    print(book_dic['price'])

    #查询出版过的所有书籍

    book_list = pub_obj.book_set.all()

    for book_obj in book_list:

        print(book_obj.title,book_obj.price)

庄杰大佬解答了我的疑惑，在这里谢谢大佬，小弟甘拜下风

多对多查询

正向查询（按字段authorlist）

反向查询（按表名book_set）

    #多对多查询

    #正向查询：查询小红帽这本书的所有作者的姓名和年龄

    book_obj = Book.objects.filter(title='小猪猪3')[0]

    print(book_obj.authors.all().values('name','age'))

    #反向查询 : 查询作者是xiaojiu的 出了那几本书

    #方法一： 使用book_set.all

    xiaojiu_obj = Author.objects.filter(name='zhang').first()

    alls= (xiaojiu_obj.book_set.all())

    for i in alls:

        print(i.title)

    #方法二：使用values

    author_list = xiaojiu_obj.book_set.all().values('title')

    for i in author_list:

        print(i.get('title'))

你可以通过在 ForeignKey() 和ManyToManyField的定义中设置 related_name 的值来覆写 FOO_set 的名称。例如，如果 Article model 中做一下更改： publish = ForeignKey(Blog, related_name='bookList')，那么接下来就会如我们看到这般

# 查询 人民出版社出版过的所有书籍

   publish=Publish.objects.get(name="人民出版社")

   book_list=publish.bookList.all()  # 与人民出版社关联的所有书籍对象集合

基于双下划线的查询

Django 还提供了一种直观而高效的方式在查询(lookups)中表示关联关系，它能自动确认 SQL JOIN 联系。要做跨关系查询，就使用两个下划线来链接模型(model)间关联字段的名称，直到最终链接到你想要的 model 为止。(相当于用sql语句用join连接的方式，可以在settings里面设置，可查看sql语句)

一对多查询

#练习1、苹果出版社出版过的所有的书的价格和名字

    #基于双下划线的查询方式

    #第一种查法

    ret = Publish.objects.filter(name='苹果出版社').values('book__title','book__price')

    # #先找到苹果出版社这个对象，之后再通过vlaues取值，book表下的什么字段中间用__链接，固定写法

    print(ret)

    #第二种查法

    #对比第一种方法，这种方法就是先join publish表，之后再进行取值。

    ret2 = Book.objects.filter(publish__name='苹果出版社').values('title','price')

    print(ret2)

  #练习2、查询手机号以11开头的作者出版过的所有书的名称以及出版社的名称

    #方式1

    author_obj = AuthorDetail.objects.filter(telephone__startswith='11').first()#找到以11开头的电话号，获取AuthorDetail 主键对象

    print(author_obj.author.book_set.all().values('title','publish__name'))#获取该条件所对应的作者，获取所有书籍对象信息，通过values取值。

    #方式2

    ret =Book.objects.filter(authors__authorDetail__telephone__startswith='11').values('title','publish__name')

    print(ret)

聚合查询与分组查询（很重要！！！）

聚合查询：aggregate(*args, **kwargs)，只对一个组进行聚合

#查询 所有书籍价格的平均值

    print(Book.objects.all().aggregate(Avg('price')))

aggregate()是QuerySet 的一个终止子句（也就是返回的不再是一个QuerySet集合的时候），意思是说，它返回一个包含一些键值对的字典。键的名称是聚合值的标识符，值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的。如果你想要为聚合值指定一个名称，可以向聚合子句提供它。

    print(Book.objects.all().aggregate(avgprice =Avg('price')))

如果你希望生成不止一个聚合，你可以向aggregate()子句中添加另一个参数。所以，如果你也想知道所有图书价格的最大值和最小值，可以这样查询：

print(Book.objects.all().aggregate(Avg('price'),Max("price"),Min("price")))

#输出

{'price__avg': 186.222222, 'price__max': Decimal('200.00'), 'price__min': Decimal('100.00')}

分组查询 :

annotate()：为QuerySet中每一个对象都生成一个独立的汇总值。

是对分组完之后的结果进行的聚合

    #统计每一本书的作者数量

    #方式一

    print(Book.objects.all().annotate(authorNum = Count('authors__name')).values('authorNum'))

    #方式二

    book_list = Book.objects.all().annotate(authorNum = Count('authors__name'))

    for book_obj in book_list:

        print(book_obj.title,book_obj.authorNum)

#统计每一个出版社最便宜的书

  #方式一

    print(Book.objects.values('publish__name').annotate(MinPrice=Min('price')))

    #方式二

    print(Publish.objects.all().annotate(minprice=Min('book__price')).values('name','minprice'))

    #方式三

    publishlist = Publish.objects.annotate(minprice =Min('book__price'))

    for pub_obj  in publishlist:

        print(pub_obj.name,pub_obj.minprice)

#打印以py开头的书籍对应的作者个数

   print(Book.objects.filter(title__startswith='py').annotate(au_count = Count('authors__name')).values('au_count'))

#根据一本书的作者数量多少对查询集QuuerySet进行排序

    print(Book.objects.all().annotate(Num=Count('authors__name')).order_by('Num').values('title'))

　　#获取book所有对象,创建分组Num 统计作者的数量，通过order_by进行排序， values取值

#查询各个作者出的书的总价格

#方式一
print(Author.objects.all().annotate(pricesum = Sum('book__price')).values('name','pricesum'))
#方式二
print(Book.objects.values('authors__name').annotate(pricesum = Sum('price')).values('authors__name','pricesum'))

F与Q查询

F查询：

在上面所有的例子中，我们构造的过滤器都只是将字段值与某个常量做比较。如果我们要对两个字段的值做比较，那该怎么做呢？

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

#查询书籍价格小于100元并且作者年龄=2017的书

print(Book.objects.filter(Q(price__lt='100')&Q(authors__authorDetail__birthday__year=2017)).values('title'))

#修改也可以使用F函数，比如说书籍ID为4的书籍价格上涨100元

 print(Book.objects.filter(nid=4).update(price=F('price')+100))

#Django 支持 F() 对象之间以及 F() 对象和常数之间的加减乘除和取模的操作。

#查询书记价格小于作者年龄*2的书籍

    print(Book.objects.filter(price__lt=F('authors__age')*2).values('title'))

Q查询：

filter() 等方法中的关键字参数查询都是一起进行“AND” 的。如果你需要执行更复杂的查询（例如OR 语句），你可以使用Q 对象。

# 查询书籍价格小于100元并且作者年份等于2017的书

print(Book.objects.filter(Q(price__lt='100')&Q(authors__authorDetail__birthday__year=2017)).values('title'))

#查询评论数大于100或者阅读数小于200的书

print(models.Book.objects.filter(Q(commentNum__gt=100)|Q(readNum__lt=200)))

Q 对象可以使用& 和| 操作符组合起来。当一个操作符在两个Q 对象上使用时，它产生一个新的Q 对象。

#查询年份等于2017年或者价格大于200的书

 print(models.Book.objects.filter(Q(publishDdata__year=2017)|Q(price__gt=200)))

#查询年份不是2017年或者价格大于200的书

print(models.Book.objects.filter(~Q(publishDdata__year=2017)&Q(price__gt=200)))

与：&Q

或：|Q

非：~Q

注意：

  bookList=models.Book.objects.filter(Q(publishDate__year=2016) | Q(publishDate__year=2017),

                                  title__icontains="python"

                                 )

查询函数可以混合使用Q 对象和关键字参数。所有提供给查询函数的参数（关键字参数或Q 对象）都将"AND”在一起。但是，如果出现Q 对象，它必须位于所有关键字参数的前面。例如：