06 Django之模型层---多表操作

一 创建模型

　　表和表之间的关系

　　　　一对一、多对一、多对多　，用book表和publish表自己来想想关系，想想里面的操作，加外键约束和不加外键约束的区别，一对一的外键约束是在一对多的约束上加上唯一约束。

　　实例：我们来假定下面这些概念，字段和关系

　　作者模型：一个作者有姓名和年龄。

　　作者详细模型：把作者的详情放到详情表，包含生日，手机号，家庭住址等信息。作者详情模型和作者模型之间是一对一的关系（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",to_field="nid",on_delete=models.CASCADE) #就是foreignkey+unique，
只不过不需要我们自己来写参数了，并且orm会自动帮你给这个字段名字
拼上一个_id，数据库中字段名称为authorDetail_id

calss AuthorDetail(models.Model):#放置不常用的字段
      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()

#多对多的表关系,我们学mysql的时候是手动创建第三张表,然后写上两个字段,每个字段作为外键关联到另外两张多对多关系的表,
orm的manytomany自动帮我们创建第三张表,两种创建方式都可以,以后用orm自动创建第三张表,
因为手动创建第三张表我们进行orm操作的时候,很多关于多对多的表之间的orm语句方法无法使用
#如果想删除某张表,只需要将这个表注销掉,然后执行那两个数据库创建的同步指令就好了,自动删除了就.
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如果是外键字段,那么它自动是int类型
publish 指向你关联的字段,不写这个,默认会自动关联主键字段,on_delete级联删除
    字段名称不需要写成publish_id,orm在线翻译foreignkey的时候会自动给你这个字段拼上一个_id,
这个字段名称在数据库里面就自动变成publish_id
#与Author表建立多对多的关系,ManeyToManeyFiled可以建立在两个模型中的任意一个,自动创建第三张表,并且注意一点,
你查看book表的时候,你看不到这个字段,
因为这个字段就是创建第三章标的意思,不是创建字段的意思,所以只能说这个book类里面有authors这个字段属性.
    authors = models.MoneyToMoneyFiled(to='Author)   #注意不管是一对多还是多对多,写to这个参数的时候,
最后后面的值是个字符串,不然你就需要将你要关联的那个表放到这个表的上

二 添加表记录

　　操作前先简单的录入一些数据,还是create和save连个方法,和单表的区别是看看怎么添加关联字段的数据

　　一对多

方式一:
    publish_obj = Publish.objects.get(nid=1) #拿到nid为1的出版社对象
    book_obj = Book.objects.create(title = "武林外传",publishData="2012-12-12",
price=100,publish=publish_obj)  #出版社对象作为值传给publish,其实就是自动将publish
字段变成publish_id,然后将publish_obj的id给取出来赋值给publish_id字段,一定要是
publish类的对象,否则报错.

方拾二:

    book_obj = Book.objects.create(title="武林外传",publishData='2010-12-12',
price=1000,publish_id=1)   #直接写上id的值,这个是publish_id = xxx  
方式一是publish=xxx(类对象)

　

上边一段话的核心就是  publish后边写的是publish的类对象,而publish_id 写的是一个具体的值.

多对多

方式一:  多对多一般在前端页面上使用的时候是多选下拉框的样子来给用户选择多个数据,这可以让用户
选择多个书籍,多个作者.
    #当前生成的书籍对象
        book_obj = Book.objects.create(title='追风筝的人',price=200,publishData=
'2010-12-12',publish_id = 1)
    #为书籍绑定的作者对象
        yuan=Author.objects.filter(name="yuan").first()  #在Author表中主键为2的记录,
注意取的是author的model对象
       egon = Author.objects.filter(name='alex').first()  #在Author表中的主键为1 的记录
      #有人会说,我们可以直接给第三张表中添加数据啊,这个自动生成的第三张表你能通过models获取到吗,
是获取不到的,用不了的当然如果知道这个表的名字,name你通过原生的sql语句可以进行书的添加,所以要通过
orm间接地给第三张表添加数据,如果是你手动添加的第三张表你是可以直接给第三张表添加数据的
        #绑定多对多关系,既向关系表book_author中添加记录,给书添加两个作者,下面的语法就是告诉orm
给第三张表添加两条数据.
        book_obj.authors add(yuan,egon)  #将某些特定的model对象添加到被关联到对象集合中. 
 =======book_obj是数据对象,authors是book表里面那个多对多的关系字段名称.
        #其实orm就是先通过book_obj的authors属性找到第三张表,然后将book_obj的id值和两个作者
对象的id值组合成两条记录添加到第三张表里面去

方式二:
    book_obj.authors.add(1,2)
    book_obj.authors.add(*[1,2])  #这种方式用的最多,因为一般是给用户选择,用户选择的是多选,
选完后给你发送过来的就是一堆的id值

　　上边这一段的核心是book_obj.authors.all()是什么?

　　多对多关系常用的API:

book_obj.authors.remove()   #将某个特定的对象从被关联对象集合中去除.  =====
 book_obj.authors.remove(*[1,2])#将多对多的关系数据删除
book_obj.authors.clear()   #清空被关联对象集合
book_obj.authors.set()  #先清空再设置   =====

　　删除示例:

book_obj = models.Book.objects.filter(nid=4)[0]
#book_obj.authors.remove(2)  #将第三张表中的这个book_obj对象对应的那个作者id为2 的那条记录
删除
#book_obj.author.clear()
#book_obj.author.set('2')  #先清除掉所有的关系数据,然后只给这个书对象绑定这个id为2的作者,
所以只剩一条记录  3--2,比如用户编辑数据的时候,
选择作者发生了变化,那么需要重新选择,所以我们就要先清空,然后再重新绑定关系数据,注意这里写的是字符串
,数字类型不可以
book_obj.authors.set(['1',])  #这么写也可以,但是注意列表中的元素是字符串,列表前面没有*　　

一对一的和一对多的删改和单表的删改是一样的,别忘了删表的时候,我们是做了级联删除的.

更新:
 book_obj = models.Book.objects.get(id=1) #获取一个书籍对象
data = {'title':'xxx','price':100}  #这个书籍对象更新后的数据
models.Book.objects.filter(id=n).update(**data)  #将新数据更新到原来的记录中
book_obj.authors.set(author_list)  #将数据和作者的多对多关系加上  #将数据和作者的多对多关系加上
models.Book.objects.filter(id=1).delete()

三 基于对象的跨表查询

　跨表查询是分组查询的基础,F和Q查询是最简单的

　　一对多查询(publish与Book)

　正向查询(按字段:publish): 关联属性字段所在的表查询被关联表的记录就是正向查询,反之就是反向查询

查询主键为一的书籍的出版社所在的 城市
book_obj = models.Book.objects.filter(pk=1).first()
#book_obj.publish是主键为1 的书籍对象关联的出版社对象,book对象.外键字段名称
print(book_obj.publish.city)

反向查询(按表明:book_set,因为加上_set就是反向查询的意思,查询出来的结果可能是多条记录的集合):

publish=Publish.objects.get(name="苹果出版社")
#publish.book_set.all()  :与苹果书籍相关的所有书籍的对象集合,写法:
小写的表明_set.all(),得到的queryset类型数据
book_list=publish.book_set.all()
for book_obj in book_list:
    print(book_obj.title)

　　一对一查询(Author与authorDtail)

　　　　正向查询(按字段:authorDetail):

egon = Author.objects.filter(name='egon').first()
print(egon.authorDetail.telephone)  egon.authorDetail就拿到这个对象,因为一对一找的
就是一条记录,注意写法:作者对象.字段名,就拿到了这个关联对象

　　　　反向查询(按表名：author)：不需要_set，因为一对一正向反向都是找到一条记录

# 查询所有住址在北京的作者的姓名

authorDet=AuthorDetail.objects.filter(addr="beijing")[0]
authorDet.author.name

　　在这里我们补充一点，因为你很快就要接触到了，那就是form表单里面的button按钮和form表单外面的button按钮的区别，form表单里面的button按钮其实和input type='submit'的标签是有同样的效果的，都能够提交form表单的数据，但是如果放在form表单外面的button按钮，那就只是个普通的按钮了。<button>提交</button>，还有一点，input type='submit'按钮放到form表单外面那就成了一个普通的按钮。

四 基于双下划线的跨表查询(基于JOIN实现)

　　Django还提供了一种直观而高效的方式在查询(lookups)中表示关联关系,她能自动确认SQL JOIN练习.要做跨关系查询,就是用两个下划线来链接模型(model)之间关联字段的名称,直到连接到你想要的model为止.

'''
基于双下划线的查询就一句话:正向查询该字段,反向查询按表名大小写用来告诉ORM引擎join哪张表,一对一,
一对多,多对多都是一个写法,注意,我们写orm查询的时候,哪个表在前在后都没问题,因为走的是join连表操作.
'''　　

一对多查询

#练习:查询苹果出版社出版过的所有书籍的名字与价格(一对多)

#正向查询 按字段:publish

queryResult = Book.objects.filter(publish__name="苹果出版社")  #通过__orm将book表
和publish表进行join,然后找到所有记录中publish.name='苹果出版社'的记录(注意publish是属性名称)
,然后select book.title,book.price的字段值
 .values_list("title","price")  #values或者values_list

#反向查询  按表名:book
queryResult = Publish.objects.filter(name='苹果出版社')
　　　　　　　　　　　　　　　　　　　　　　　　.value_list('book__title','book__price')　　

多对多查询

#练习:查询yuan出过的所有书籍的名字(多对多)

　　#正向查询  按字段:authors:

　　queryResult = Book.objects.filter(authors__name="yuan")
　　#反向查询 按表名:book
　　queryResult=Author.objects.filter(name="yuan")
　　　　　　　　　　　　　　　　　　　　　　　　　.values_list("book__title","book_price")

一对一查询

#查询yuan的手机号
#正向查询
ret = Author.objects.filter(name="yuan").values("authordetail__telephon")
#反向查询
ret=AuthorDetail.objects.filter(author__name='yuan').values("telephone")进阶

进阶练习(连续跨表)

练习:查询人民出版社出版过的所有书籍的名字以及作者的姓名
    #正向查询
    queryResult=Book.object.filter(publish__name='人民出版社').values_list('title',
authors__name)
    #反向查询
    queryResult=Publish.objects.filer(name='人民出版社').values_list('book_title',
'book_authors_age','book_authors__name')

练习: 手机号以151开头的作者出版过的书籍名称以及出版社名称

    #方式1
        queryResult = Book_objects.fiter
(authors__authordetail__tel__startswith='151').value("title",publisher__name)
    #方式二
ret = Author.objects.filter(authordetail__tel__startswith='151').
values("book__title","book__publisher__name")

related_name

反向查询时,如果定义了related_name,则用related_name替换表名

publish = ForeignKey(Blog,related_name='bookList')

# 练习: 查询人民出版社出版过的所有书籍的名字与价格(一对多)

# 反向查询 不再按表名:book,而是related_name:bookList

    queryResult=Publish.objects
　　　　　　　　　　　　　　.filter(name="人民出版社")
　　　　　　　　　　　　　　.values_list("bookList__title","bookList__price") 

五 聚合查询  分组查询  F查询和Q查询

聚合

aggregate(*arges,**kwarges)

#计算所有图书的平均价格
from django.db.models import Avg
Book.objects.all().aggregate(Avg('price'))  #或者起名字aggretate(a=Avg('price'))

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

Book.objects.aggregate(average_price=Avg('price'))
{'average_price':34.35}

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

from django.db.models import Avg,Max,Min
Book.objects.aggregate(Avg('price'),Max('price'),Min('price')})
#count('id'),count(1)也可以统计个数,Book.objects.all().aggregete和
Book.objects.aggregate()，都可以

{'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"))  #注意
annotate里面必须写个聚合函数,不然没有意义,并且必须有个别名=,别名随便写
,但是必须要有,用哪个字段分组,values里面就写哪个字段,annotate其实就是对分组结果的统计
,统计你需要什么
'''
　　select dep,count('id') as c from emp grouby dep;  #原生sql语句中的as c，不是必须有的
'''

多表分组查询
查询每个部门名称以及对应的员工数

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 inner join dep on emp.dep_id = dep.id 
group by dep.id
'''
ORM:

dep.objects.values('id').annotate(c=Count("emp")).values("name","c")

#注意如果写了其他字段,那么只有这两个字段重复,才算一组,合并到一起来统计个数

　　

annotate()掉用的是QuerySet中每一个对象都生成一个独立的统计值(统计方法用聚合函数).

总结: 跨表分组查询本质就是将关联表join成一张表,再按单表的思路进行分组查询,既然是join连表,就可以使用咱们的双下划线进行连表了

#单表：
    #查询每一个部门的id以及对应员工的平均薪水
    ret = models.Emp.objects.values('dep_id').annotate(s=Avg('salary'))
    #查询每个部门的id以及对对应的员工的最大年龄
    ret = models.Emp.objects.values('dep_id').annotate(a=Max('age'))
    #Emp表示表，values中的字段表示按照哪个字段group by，annotate里面是显示分组统计的是什么

#连表：
    # 查询每个部门的名称以及对应的员工个数和员工最大年龄
    ret = models.Emp.objects.values('dep__name').annotate(a=Count('id')
,b=Max('age')) #注意，正向与反向的结果可能不同，如果反向查的时候，有的部门还没有员工，
那么他的数据也会被统计出来，只不过值为0，但是正向查的话只能统计出来有员工的部门的相关数据，
因为通过你是员工找部门，而不是通过部门找员工，结果集里面的数据个数不同，但是你想要的统计结果是一样的
    #<QuerySet [{'a': 1, 'dep__name': '销售部', 'b': 12}, 
{'a': 3, 'dep__name': '人事部', 'b': 22}]>
    #使用双下划线进行连表，然后按照部门名称进行分组，然后统计员工个数和最大年龄，
最后结果里面显示的是部门名称、个数、最大年龄。
#注意：如果values里面有多个字段的情况：
ret = models.Emp.objects.values('dep__name','age').annotate(a=Count('id'),
b=Max('age')) #是按照values里面的两个字段进行分组，两个字段同时相同才算是一组，看下面的sql语句
'''
    SELECT `app01_dep`.`name`, `app01_emp`.`age`, COUNT(`app01_emp`.`id`) 
AS `a`, MAX(`app01_emp`.`age`) AS `b` FROM `app01_emp` INNER JOIN `app01_dep` 
ON (`app01_emp`.`dep_id` = `app01_dep`.`id`) GROUP BY `app01_dep`.`name`, 
`app01_emp`.`age`;
'''

　

F查询

　　在上面所有的例子中，我们构造的过滤器都只是将字段值与某个常量做比较。如果我们要对两个字段的值做比较，那该怎么做呢？我们在book表里面加上两个字段：评论数：commentNum，收藏数：KeepNum

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

1 2 3 4

# 查询评论数大于收藏数的书籍      from django.db.models import F    Book.objects.filter(commentNum__lt=F('keepNum'))

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

1 2	# 查询评论数大于收藏数2倍的书籍     Book.objects.filter(commentNum__lt=F('keepNum')*2)

　　修改操作也可以使用F函数,比如将每一本书的价格提高30元：

1	Book.objects.all().update(price=F("price")+30)

Q查询

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

1 2	from django.db.models import Q Q(title__startswith='Py')

　　Q 对象可以使用&(与) 、|（或）、~（非） 操作符组合起来。当一个操作符在两个Q 对象上使用时，它产生一个新的Q 对象。

1	bookList=Book.objects.filter(Q(authors__name="yuan")|Q(authors__name="egon"))

　　等同于下面的SQL WHERE 子句：

1	WHERE name ="yuan" OR name ="egon"

　　你可以组合& 和|  操作符以及使用括号进行分组来编写任意复杂的Q 对象。同时，Q 对象可以使用~ 操作符取反，这允许组合正常的查询和取反(NOT) 查询：

1	bookList=Book.objects.filter(Q(authors__name="yuan") & ~Q(publishDate__year=2017)).values_list("title") bookList=Book.objects.filter(Q(Q(authors__name="yuan") & ~Q(publishDate__year=2017))&Q(id__gt=6)).values_list("title") #可以进行Q嵌套，多层Q嵌套等，其实工作中比较常用

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

1 2 3

bookList=Book.objects.filter(Q(publishDate__year=2016) | Q(publishDate__year=2017),                               title__icontains="python"  #也是and的关系，但是Q必须写在前面                              )