Django 模型层(2)
多表操作：
创建模型：
作者模型：把作者的详情放到详情表，包含生日，手机号，家庭住址等信息。作者详情模型和作者模型之间是一对一的关系（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建立一对一关系 author_detail = models.OneToOneField(to='AuthorDetail',on_delete=models.CASCADE) class AuthorDetail(models.Model): nid = models.AutoField(primary_key=True) birthday = models.DateField() tel = models.IntegerField() addr = models.CharField(max_length=32) 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): title = models.CharField(max_length=32) pub_date = models.DateField() price = models.DecimalField(max_digits=6,decimal_places=2) # 与Publish建立一对多关系，外键建立在 多 的一方 publish = models.ForeignKey(to='Publish',to_field='nid',on_delete=models.CASCADE) # 与Author 建立多对多关系，ManyTOManyField 可以建在两个模型中的任意一个，将会自动建立第三个对应表。 authors = models.ManyToManyField(to='Author')
注意事项：
1，id 字段可以不写，django会自动生成主键id.
2，对于外键字段，django会在字段名上添加'_id'来创建数据库中的列名。例如：'publish' 会生成‘publish_id’。
3，外间字段ForeignKey 有一个 null = True 的设置（它允许外键接收空值 null）,你可以赋给它空值。
添加表记录：
一对多：
方式1: publish_obj=Publish.objects.get(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() # 在Author表中主键为2的纪录 egon=Author.objects.filter(name="alex").first() # 在Author表中主键为1的纪录 # 绑定多对多关系,即向关系表book_authors中添加纪录 book_obj.authors.add(yuan,egon) # 将某些特定的 model 对象添加到被关联对象集合中。 ======= book_obj.authors.add(*[])
多对多关系其他常用API：
book_obj.authors.remove() # 将某个特定的对象从被关联对象集合中去除。 ====== book_obj.authors.remove(*[]) book_obj.authors.clear() #清空被关联对象集合 book_obj.authors.set() #先清空再设置
基于对象的跨表查询：
一对多查询：（Publish 与 Book）
正向查询（按字段：publish）:关联属性在的类向关联的类查询的方向是正向，反之则是反向。
# 查询主键为5的书籍的出版社所在的城市 book_obj = Book.objects.filter(id=5).first() print(book_obj.publish.city) # 北京
反向查询（按表名(全部小写)：book_set）
# 查询是苹果出版社出的书的名字和价格 pub_obj = Publish.objects.filter(name='苹果出版社').first() # 记住记住，如果是单个信息这里一定是一个对象，而不是QuerySet. print(pub_obj.book_set.all().values('title','price')) # <QuerySet [{'title': '西游记', 'price': Decimal('128.00')}, {'title': '三国演义', 'price': Decimal('128.00')}]>
一对一查询：（Author 与 AuthorDetail）
由于是一对一查询，所以正反向都是一样的。
正向查询（按字段：author_detail）
# 查询作者egon的电话号码 egon = Author.objects.filter(name='egon').first() print(egon.author_detail.tel) # 911
反向查询：（按表名(小写):author）:
# 查询所有住址在北京的作者的姓名 add_obj = AuthorDetail.objects.filter(addr='北京') for i in add_obj: print(i.author.name)
# 注意注意：这里的反向查询并没有 _set
多对多查询：（Author 与 Book）
正向查询：（按字段：author_detail）
# 查询西游记所有作者的名字以及手机号 book_obj = Book.objects.filter(title='西游记').first() print(book_obj.authors.all().values('name','author_detail__tel')) # 这里获取手机号属于多表查询方法，后面会讲 # <QuerySet [{'name': 'alex', 'author_detail__tel': 110}, {'name': 'egon', 'author_detail__tel': 911}]>
反向查询：（按表名：boot_set）
# 查询egon出过的所有书籍的名字 egon = Author.objects.filter(name='egon').first() print(egon.book_set.all().values('title')) # <QuerySet [{'title': '西游记'}, {'title': '水浒传'}, {'title': '三国演义'}]>
注意：在通过ForeignKey() 和 ManyToManyField 的定义中设置的 related_name 的值来覆写 Foo_set 的名称。
例如：publish = ForeignKey(Book, related_name='bookList')
那么接下来就会如我们看到这般：
查询 人民出版社出版过的所有书籍：
publish=Publish.objects.get(name="人民出版社") book_list=publish.bookList.all() # 与人民出版社关联的所有书籍对象集合基于双下划线的跨表查询：
正向查询按字段，反向查询按表名小写来告诉ORM引擎join哪张表。
一对多查询：
# 练习: 查询苹果出版社出版过的所有书籍的名字与价格(一对多) # 正向查询: obj = Book.objects.filter(publish__name='苹果出版社').values('title','price') # 双下划线的跨表查询，正向直接按 字段__(双下划线)属性 # 最后用values取值 print(obj) # <QuerySet [{'title': '西游记', 'price': Decimal('128.00')}, {'title': '三国演义', 'price': Decimal('128.00')}]> # 反向查询： obj = Publish.objects.filter(name='苹果出版社').values('book__title','book__price') print(obj) # <QuerySet [{'book__price': Decimal('128.00'), 'book__title': '西游记'}, {'book__price': Decimal('128.00'), 'book__title': '三国演义'}]>
多对多查询：
# 练习: 查询alex出过的所有书籍的名字(多对多) # 正向查询：按字段 obj1 = Book.objects.filter(authors__name='alex').values('title') print(obj1) # < QuerySet[{'title': '西游记'}, {'title': '红楼梦'}, {'title': '三国演义'}] > # 反向查询：按表名 obj2 = Author.objects.filter(name='alex').values('book__title') print(obj2) # < QuerySet[{'book__title': '西游记'}, {'book__title': '红楼梦'}, {'book__title': '三国演义'}] >
一对一查询：
# 查询alex的手机号 # 正向查询： obj = Author.objects.filter(name='alex').values('author_detail__tel') print(obj) # < QuerySet[{'author_detail__tel': 110}] > # 反向查询： obj = AuthorDetail.objects.filter(author__name='alex').values('tel') print(obj) # < QuerySet[{'tel': 110}] >
连续跨表：
# 练习: 查询苹果出版社出版过的所有书籍的名字以及作者的姓名 # 正向查询： obj = Book.objects.filter(publish__name='苹果出版社').values('title','authors__name') print(obj) # < QuerySet[{'title': '西游记', 'authors__name': 'alex'}, {'title': '三国演义', 'authors__name': 'alex'}, {'title': '西游记', # 'authors__name': 'egon'}, { # 'title': '三国演义', 'authors__name': 'egon'}] > # 反向查询： obj = Publish.objects.filter(name='苹果出版社').values('book__title','book__authors__name') print(obj) # < QuerySet[{'book__title': '西游记', 'book__authors__name': 'alex'}, {'book__title': '三国演义', # 'book__authors__name': 'alex'}, { # 'book__title': '西游记', 'book__authors__name': 'egon'}, {'book__title': '三国演义', # 'book__authors__name': 'egon'}] > # 由于出版社和作者并没有联系，所以只能通过book来查询。
# 练习: 手机号为110的作者出版过的所有书籍名称以及出版社名称 # 正向查询: obj = Book.objects.filter(authors__author_detail__tel='110').values('title','publish__name') print(obj) # < QuerySet[{'title': '西游记', 'publish__name': '苹果出版社'}, {'title': '红楼梦', 'publish__name': '橘子出版社'}, {'title': '三国演义', # 'publish__name': '苹果出版社'}] > # 反向查询： obj = Publish.objects.filter(book__authors__author_detail__tel='110').values('book__title','name') print(obj) # <QuerySet [{'book__title': '西游记', 'name': '苹果出版社'}, {'book__title': '红楼梦', 'name': '橘子出版社'}, {'book__title': '三国演义', 'name': '苹果出版社'}]>
related_name:
反向查询时，如果定义了related_name，则用related_name替换表名，例如：
publish = ForeignKey(Blog,relate_name='booklist')
# 练习: 查询人民出版社出版过的所有书籍的名字与价格(一对多) # 反向查询 不再按表名:book,而是related_name:bookList queryResult=Publish.objects .filter(name="人民出版社") .values_list("bookList__title","bookList__price")
聚合查询与分组查询：
聚合：aggregate(*args,**kwargs)
# 计算所有图书的平均价格 from django.db.models import Avg ret = Book.objects.all().aggregate(avg_price=Avg('price')) print(ret) # 可以自己取变量名{'avg_price': 118.0}，若是不取会系统默认拼接变量名
aggregate() 是QuerySet 的一个终止子句，意思是说，它返回一个包含一些键值对的字典，键的名称是聚合值得标识符，值是计算出来的聚合值。键得名称是按照字段和聚合函数的名称自动生成出来的，也可以自定义名称。
如果你想生成不止一个聚合，可以在aggregate()子句中添加另一个参数。
from django.db.models import Avg,Max ret = Book.objects.all().aggregate(Avg('price'),Max('price')) print(ret) # {'price__avg': 118.0, 'price__max': Decimal('128.00')}
分组：
单表分组查询：
###################################－－单表分组查询－－####################################################### 查询每一个部门名称以及对应的员工数 emp: id name age salary dep 1 alex 12 2000 销售部 2 egon 22 3000 人事部 3 wen 22 5000 人事部 sql 语句： SELECT dep,count(1) from app01_emp GROUP BY dep; ORM： ret = Emp.objects.values('dep').annotate(c= Count(1)) # values里的字段，相当于对这个字段进行分组，annotate里使用函数， # 相当于在分组后的新表中添加一个新的字段，且必须起别名，如上：c(别名) = Count(1) print(ret) # < QuerySet[{'dep': '销售部', 'c': 1}, {'dep': '人事部', 'c': 2}] > # 结果是一个QuerySet类型的值
多表分组查询：
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 app01_dep.name,count(1) from app01_emp2 inner join app01_dep on app01_emp2.dep_id = app01_dep.id GROUP BY dep_id; ORM： ret = Dep.objects.values('id').annotate(c = Count('emp2__id')).values('name','c') # 多表查询annotate中的是要连表的表名。 print(ret) # <QuerySet [{'c': 1, 'name': '销售部'}, {'c': 2, 'name': '人事部'}]>
F查询与Q查询：
F查询：
在上面所有的例子中，我们构造的过滤器都只是将字段值与某个常量做比较。如果我们要对两个字段的值做比较，那该怎么做呢？
Django 提供 F() 来做这样的比较。F() 的实例可以在查询中引用字段，来比较同一个 model 实例中两个不同字段的值。
# 查询评论数大于收藏数的书籍 from django.db.models import F Book.objects.filter(commnetNum__lt=F('keepNum'))
Django 支持 F() 对象之间以及 F() 对象和常数之间的加减乘除和取模的操作。
# 查询评论数大于收藏数2倍的书籍 Book.objects.filter(commnetNum__lt=F('keepNum')*2)
修改操作也可以使用F函数,比如将每一本书的价格提高30元：
ret = Book.objects.all().update(price=F('price')+30) print(ret) return HttpResponse('query')
Q查询：
filter() 等方法中的关键字参数查询都是一起进行“AND” 的。 如果你需要执行更复杂的查询（例如OR 语句），你可以使用Q 对象。
from django.db.models import Q Q(title__startswith='Py')
Q 对象可以使用& 和 | 操作符组合起来。当一个操作符在两个Q 对象上使用时，它产生一个新的Q 对象。
bookList=Book.objects.filter(Q(authors__name="yuan")|Q(authors__name="egon"))
等同于下面的SQL WHERE 子句：
WHERE name ="yuan" OR name ="egon"
你可以组合& 和| 操作符以及使用括号进行分组来编写任意复杂的Q 对象。同时，Q 对象可以使用~ 操作符取反，这允许组合正常的查询和取反(NOT) 查询：
bookList=Book.objects.filter(Q(authors__name="yuan") & ~Q(publishDate__year=2017)).values_list("title")
查询函数可以混合使用Q 对象和关键字参数。所有提供给查询函数的参数（关键字参数或Q 对象）都将"AND”在一起。但是，如果出现Q 对象，它必须位于所有关键字参数的前面。例如：
bookList=Book.objects.filter(Q(publishDate__year=2016) | Q(publishDate__year=2017), title__icontains="python" )
