Django ORM-02

6.ForeignKey 相关操作

1.正向查找

正向查找：那么什么是正向查找，我们知道对于一对多或者多对一的情况，我们一般将ForeignKey设置在多的一边，比如我们的书籍与出版社一般是多对一的，所以当书籍去找出版社的时候就是正向查找.

正向查找分为: 对象查找 字段查找

1.对象查找

#语法：对象.关联字段.字段  ----->对象加关联字段再加上字段

book_obj = models.Book.objects.first()  # 第一本书对象，先拿到对象。
print(book_obj.publisher)  # 得到这本书关联的出版社对象，拿到关联的字段，也就是publisher。
print(book_obj.publisher.name)  # 得到出版社对象的名称，其实拿到关联字段之后就相当于拿到了publisher这个对象，然后再通过name字段取我们的publisher中的出版社name。

2.字段查找(常用)

# 关联字段__字段  通过关联字段其实拿到我们要查询的表，然后通过双下划綫“__”加上要查询表的字段name。

print(models.Book.objects.values_list("publisher__name")) #这里双下划线其实类似于一个桥梁，连接起来两个表。

2.反向查找

反向查找：是与正向查找相反的，也就是说他是基于出版社来查找我们的书籍表。

1.对象查找

#  obj.表名_set -->  先拿到我们当前表的第一个对象，然后通过对象表名加“__”双下划綫的形式，找到对应的所有记录。

publisher_obj = models.Publisher.objects.first()  # 找到第一个出版社对象
books = publisher_obj.book_set.all()  # 找到第一个出版社出版的所有书
titles = books.values_list("title")  # 找到第一个出版社出版的所有书的书名

2.字段查找

#  表名__字段 --> 直接对象表名加“__”加上需要查询的字段的名字。
titles = models.Publisher.objects.values_list("book__title")

7.ManyToManyField

关联管理器"是在一对多或者多对多的关联上下文中使用的管理器

存在于下面两种情:

• 外键关系的反向查询
• 多对多关联关系

简单来说就是当 点后面的对象 可能存在多个的时候就可以使用以下的方法

方法

---

create()

# 创建一个新的对象，保存对象，并将它添加到关联对象集之中，返回新创建的对象
import datetime

author_obj = models.Author.objects.first().book_set.create(title="番茄物语", publish_date=datetime.date.today())


# book_set  后面的 create 就是创建了一个  book对象实例

add()

# 把指定的model对象添加到关联对象集中


author_objs = models.Author.objects.filter(id__lt=3)  # 多个对象

models.Book.objects.first().authors.add(*author_objs)

#  添加ID list

models.Book.objects.first().authors.add(*[1, 2])

set()

更新model对象的关联对象  删除所有的关系 添加新的关系
book_obj = models.Book.objects.first()
book_obj.authors.set([2, 3])

remove()

# 从关联对象集中移除执行的model对象

book_obj = models.Book.objects.first()

# 把 book_obj的author 所有对象中 移除id = 3 的author对象
book_obj.authors.remove(3)

clear()

#  从关联对象集中移除一切对象

book_obj = models.Book.objects.first()
book_obj.authors.clear()  #  移除全部authors 对象

注意:

对于ForeignKey对象，clear()和remove()方法仅在null=True时存在

example

#  没有设置null = True 的时候
class Book(models.Model):
    title = models.CharField(max_length=32)
    publisher = models.ForeignKey(to=Publisher)
# 没有clear()和remove()方法

>>> models.Publisher.objects.first().book_set.clear()
Traceback (most recent call last):
  File "<input>", line 1, in <module>
AttributeError: 'RelatedManager' object has no attribute 'clear'


# 当ForeignKey字段设置null=True时

class Book(models.Model):
    name = models.CharField(max_length=32)
    publisher = models.ForeignKey(to=Class, null=True)


# 此时就有clear()和remove()方法    
>>> models.Publisher.objects.first().book_set.clear()
##  OK

注意

对于所有类型的关联字段，add()、create()、remove()和clear(),set()都会马上更新数据库。换句话说，在关联的任何一端，都不需要再调用save()方法

8.聚合查询和分组查询

聚合：使用聚合函数对我们查询的结果进行进一步操作

简单的使用

• 聚合其实类似于我们的SQL语句，其中在链表查询的时候也用到了聚合函数。

• aggregate()是QuerySet 的一个终止子句，意思是说，它返回一个包含一些键值对的字典。

• 键的名称是聚合值的标识符，值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的。

• 用到的内置函数

from django.db.models import Avg, Sum, Max, Min, Count

example

from django.db.models import Avg, Sum, Max, Min, Count
models.Book.objects.all().aggregate(Avg("price"))

{'price__avg': 13.233333}

如果你想要为聚合值指定一个名称，可以向聚合子句提供它。

models.Book.objects.aggregate(average_price=Avg('price'))

{'average_price': 13.233333}

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

models.Book.objects.all().aggregate(Avg("price"), Max("price"), Min("price"))
{'price__avg': 13.233333, 'price__max': Decimal('19.90'), 'price__min': Decimal('9.90')}

9.分组查询

#  统计每一本书的作者个数
book_list = models.Book.objects.all().annotate(author_num=Count("author"))
for obj in book_list:
    print(obj.author_num)  # 打印每一本书的作者个数





#  统计出每个出版社买的最便宜的书的价格

1.
publisher_list = models.Publisher.objects.annotate(min_price=Min("book__price"))
for obj in publisher_list:
    print(obj.min_price)
    
    
2.      
models.Book.objects.values("publisher__name").annotate(min_price=Min("price"))
 
<QuerySet [{'publisher__name': '沙河出版社', 'min_price': Decimal('9.90')}, {'publisher__name': '人民出版社', 'min_price': Decimal('19.90')}]>  


#  统计不止一个作者的图书

models.Book.objects.annotate(author_num=Count("author")).filter(author_num__gt=1)
<QuerySet [<Book: 番茄物语>]>

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

 models.Book.objects.annotate(author_num=Count("author")).order_by("author_num")
 
<QuerySet [<Book: 香蕉物语>, <Book: 橘子物语>, <Book: 番茄物语>]>

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

models.Author.objects.annotate(sum_price=Sum("book__price")).values("name", "sum_price")
<QuerySet [{'name': '小精灵', 'sum_price': Decimal('9.90')}, {'name': '小仙女', 'sum_price': Decimal('29.80')}, 
{'name': '小魔女', 'sum_price': Decimal('9.90')}]>