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) #

　　反向查询：（按表名(小写):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='').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='').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"
                             )