Django之模型---ORM 多表操作

多表操作

创建表模型

 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',)

作者详情模型和作者模型之间是一对一的关系（one-to-one）

书籍有书名和出版日期，一本书可能会有多个作者，一个作者也可以写多本书，所以作者和书籍的关系就是多对多的关联关系(many-to-many);

一本书只应该由一个出版商出版，所以出版商和书籍是一对多关联关系(one-to-many)。

注意：

• 对于外键字段，Django 会在字段名上添加"_id" 来创建数据库中的列名

• 外键字段 ForeignKey 有一个 null=True 的设置(它允许外键接受空值 NULL)，你可以赋给它空值 None 。

添加表记录

一对多

#方式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 对象添加到被关联对象集合中。
　　 #也可以添加对象的id  book_obj.authors.add(1,2) 或者写成 book_obj.authors.add(*[1,2])

　　多对多关系在添加时采用这样的方式，主要是因为ManyToMany关系自动生成了一张关系表，添加关系数据的时候无法直接调用这张表。

所以，修改关系表的数据的时候，也必须借助这样的函数进行处理。当修改数据的时候有两种方法：

1.先清除表关系remove（），或者直接清空clear（），然后重新生成add（）,这里注意参数形式，一般参数在实际应用中是list，那就得以   *list 为参数传入

2.set（），直接传入list，不需要 *

但是，如果多对多关系在创建时使用through自主创建关系表时，add（）和set（）是不能使用的，那时添加关系时可直接调用关系表create，修改时先清除表关系，然后再重新create关系数据。

基于对象的跨表查询

一对多查询（Publish 与 Book）

方法：正向查询按关系字段，反向查询按  表名小写_set.all()

正向查询：

# 查询主键为1的书籍的出版社所在的城市
book_obj=Book.objects.filter(pk=1).first()
# book_obj.publish 是主键为1的书籍对象关联的出版社对象
print(book_obj.publish.city) 　

反向查询：

#查询苹果出版社出版的所有图书
publish=Publish.objects.get(name="苹果出版社")
#publish.book_set.all() : 与苹果出版社关联的所有书籍对象集合
book_list=publish.book_set.all()
for book_obj in book_list:
       print(book_obj.title)

多对多查询 (Author 与 Book)

方法：同一对多

正向查询：

# 金瓶眉所有作者的名字以及手机号

book_obj=Book.objects.filter(title="金瓶眉").first()
authors=book_obj.authors.all()
for author_obj in authors:
     print(author_obj.name,author_obj.authorDetail.telephone)

反向查询：

# 查询egon出过的所有书籍的名字

    author_obj=Author.objects.get(name="egon")
    book_list=author_obj.book_set.all()        #与egon作者相关的所有书籍
    for book_obj in book_list:
        print(book_obj.title)

注意：

你可以通过在 ForeignKey() 和ManyToManyField的定义中设置 related_name 的值来覆写 FOO_set 的名称。例如，如果 Article model 中做一下更改：

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

那么接下来就可以这样用：

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

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

一对一查询(Author 与 AuthorDetail)

方法：正向查询按关系字段，反向查询按表名小写

正向查询：

egon=Author.objects.filter(name="egon").first()
print(egon.authorDetail.telephone)

反向查询：

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

authorDetail_list=AuthorDetail.objects.filter(addr="beijing")
for obj in authorDetail_list:
     print(obj.author.name)

基于双下划线的跨表查询

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

方法：正向查询按字段,反向查询按表名小写用来告诉ORM引擎join哪张表

一对多查询

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

    # 正向查询 按字段:publish

    queryResult=Book.objects
　　　　　　　　　　　　.filter(publish__name="苹果出版社")
　　　　　　　　　　　　.values_list("title","price")

    # 反向查询 按表名:book

    queryResult=Publish.objects
　　　　　　　　　　　　　　.filter(name="苹果出版社")
　　　　　　　　　　　　　　.values_list("book__title","book__price")

多对多查询

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

    # 正向查询 按字段:authors:
    queryResult=Book.objects
　　　　　　　　　　　　.filter(authors__name="yuan")
　　　　　　　　　　　　.values_list("title")

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

一对一查询

　　 # 查询alex的手机号

    # 正向查询
    ret=Author.objects.filter(name="alex").values("authordetail__telephone")

    # 反向查询
    ret=AuthorDetail.objects.filter(author__name="alex").values("telephone")

进阶练习------连续跨表

连续跨表同样遵循以上的方法，只是要找到关联字段才可以跨表查询

#练习: 查询人民出版社出版过的所有书籍的名字以及作者的姓名

    # 正向查询
    queryResult=Book.objects
　　　　　　　　　　　　.filter(publish__name="人民出版社")
　　　　　　　　　　　　.values_list("title","authors__name")
    # 反向查询
    queryResult=Publish.objects
　　　　　　　　　　　　　　.filter(name="人民出版社")
　　　　　　　　　　　　　　.values_list("book__title","book__authors__age","book__authors__name")

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

    # 方式1:
    queryResult=Book.objects
　　　　　　　　　　　　.filter(authors__authorDetail__telephone__regex="")
　　　　　　　　　　　　.values_list("title","publish__name")
    # 方式2:
    ret=Author.objects
              .filter(authordetail__telephone__startswith="")
              .values("book__title","book__publish__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") 

聚合查询---aggregate(*args, **kwargs)

# 计算所有图书的平均价格
    >>> from django.db.models import Avg
    >>> Book.objects.all().aggregate(Avg('price'))
    {'price__avg': 34.35}  # 返回值是一个字典

它返回一个包含一些键值对的字典。键的名称是聚合值的标识符，值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的。如果你想要为聚合值指定一个名称，可以向聚合子句提供它。

>>> 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'))
{'price__avg': 34.35, 'price__max': Decimal('81.20'), 'price__min': Decimal('12.99')}

分组

单表下分组查询

# 查询每一个出版社出版的图书平均价格
Book.objects.values('publish').annotate(avg=AVG('price'))

说明：分组以values（）里面的字段为依据，单表下按照主键分组没有意义。

多表下分组查询

示例1：查询每一个出版社的名称以及出版的书籍数

<1>Publish.objects.values('name').annotate(c=Count('book__title'))

<2>Publish.objects.values('nid').annotate(c=Count('book__title')).values('name','c')

示例2：查询每一个作者的名字以及出版过的书籍的最高价格

Author.objects.values('pk').annotate(max_price=Max('book__price')).values('name','c')

跨表分组的模型总结

1.  表模型.objects.values('pk').annotate(聚合函数（关联表__统计字段）).values('输出字段')

2.  表模型.objects.[all()].annotate(聚合函数（关联表__统计字段）).values('输出字段')