Web框架开发-django模型层(多表操作)

一、创建模型

实例：

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

作者详细模型：把作者的详情放到详情表，包含生日，手机号，家庭住址等信息。作者详情模型和作者模型之间是一对一的关系（one-to-one）

出版商模型：出版商有名称，所在城市以及email。

书籍模型： 书籍有书名和出版日期，一本书可能会有多个作者，一个作者也可以写多本书，所以作者和书籍的关系就是多对多的关联关系(many-to-many);一本书只应该由一个出版商出版，所以出版商和书籍是一对多关联关系(one-to-many)。

模型建立如下：

class Book(models.Model):

    id = 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="id", on_delete=models.CASCADE)
    # 与Author建立多对多的关系，ManyTOManyField可以建在两个模型中的任意一个，自动创建第三张表
    authors = models.ManyToManyField(to='Author',)


class Author(models.Model):
    id = 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 Publish(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32)
    city = models.CharField(max_length=32)
    email = models.EmailField()


class AuthorDetail(models.Model):
    id = models.AutoField(primary_key=True)
    birthday = models.DateField()
    telephone = models.BigIntegerField()
    addr = models.CharField(max_length=64)

　　

生成表如下：

注意事项：

•  表的名称myapp_modelName，是根据 模型中的元数据自动生成的，也可以覆写为别的名称　　
•  id 字段是自动添加的
•  对于外键字段，Django 会在字段名上添加"_id" 来创建数据库中的列名
•  这个例子中的CREATE TABLE SQL 语句使用PostgreSQL 语法格式，要注意的是Django 会根据settings 中指定的数据库类型来使用相应的SQL 语句。
•  定义好模型之后，你需要告诉Django _使用_这些模型。你要做的就是修改配置文件中的INSTALL_APPSZ中设置，在其中添加models.py所在应用的名称。
• 外键字段 ForeignKey 有一个 null=True 的设置(它允许外键接受空值 NULL)，你可以赋给它空值 None 。

字段选项

每个字段有一些特有的参数，例如，CharField需要max_length参数来指定VARCHAR数据库字段的大小。还有一些适用于所有字段的通用参数。 这些参数在文档中有详细定义，这里我们只简单介绍一些最常用的：

1)null

如果为True，Django 将用NULL 来在数据库中存储空值。 默认值是 False.

(1)blank

如果为True，该字段允许不填。默认为False。
要注意，这与 null 不同。null纯粹是数据库范畴的，而 blank 是数据验证范畴的。
如果一个字段的blank=True，表单的验证将允许该字段是空值。如果字段的blank=False，该字段就是必填的。

(2)default

字段的默认值。可以是一个值或者可调用对象。如果可调用 ，每有新对象被创建它都会被调用。

(3)primary_key

如果为True，那么这个字段就是模型的主键。如果你没有指定任何一个字段的primary_key=True，
Django 就会自动添加一个IntegerField字段做为主键，所以除非你想覆盖默认的主键行为，
否则没必要设置任何一个字段的primary_key=True。

(4)unique

如果该值设置为 True, 这个数据字段的值在整张表中必须是唯一的

(5)choices
由二元组组成的一个可迭代对象（例如，列表或元组），用来给字段提供选择项。 如果设置了choices ，
默认的表单将是一个选择框而不是标准的文本框，而且这个选择框的选项就是choices 中的选项。

这是一个关于 choices 列表的例子：

YEAR_IN_SCHOOL_CHOICES = (
    ('FR', 'Freshman'),
    ('SO', 'Sophomore'),
    ('JR', 'Junior'),
    ('SR', 'Senior'),
    ('GR', 'Graduate'),
)
每个元组中的第一个元素，是存储在数据库中的值；第二个元素是在管理界面或 ModelChoiceField 中用作显示的内容。 
在一个给定的 model 类的实例中，想得到某个 choices 字段的显示值，就调用 get_FOO_display 方法(这里的 FOO 就是 choices 字段的名称 )。例如：

from django.db import models

class Person(models.Model):
    SHIRT_SIZES = (
        ('S', 'Small'),
        ('M', 'Medium'),
        ('L', 'Large'),
    )
    name = models.CharField(max_length=60)
    shirt_size = models.CharField(max_length=1, choices=SHIRT_SIZES)


>>> p = Person(name="Fred Flintstone", shirt_size="L")
>>> p.save()
>>> p.shirt_size
'L'
>>> p.get_shirt_size_display()
'Large

　　

二、添加表记录

一对多

 # 方式一：
    publish_obj = models.Publish.objects.get(id=1)
    book_obj = models.Book.objects.create(title="性能测试案例分析", publishDate="2010-12-12", price=100, publish=publish_obj)
    print(book_obj)

    # 方式二：
    models.Book.objects.create(title="Python全栈开发", publishDate="2015-05-05", price="150", publish_id=2)

    # 方式三：
    publish_obj = models.Publish.objects.get(name="邮电出版社")
    book_obj = models.Book(title="未来简史", publishDate="2010-10-10", price=200, publish=publish_obj)
    book_obj.save()

　　

多对多添加记录：

　　

书和作者是多对多的关系：一个书可以有多个作者，一个作者可以出版多本书

　　步骤：先找到书对象

　　　　　再找到需要的作者对象

　　　　　给书对象绑定作者对象（用add方法），也就是绑定多对多的关系

    # --------------多对多添加--------------
    # 方式一：
    authordetail_obj = models.AuthorDetail.objects.create(birthday="2012-08-12", telephone="15912245678",addr="北京")
    print(authordetail_obj)
    author_obj = models.Author.objects.create(name="jacke", age=30, authorDetail_id=3)
    print(author_obj)
    pub_obj=models.Publish.objects.filter(name="机械工业出版社").first()
    book_obj = models.Book.objects.create(title="人类简史",publishDate="2008-10-8", price="122", publish=pub_obj)
    # 通过作者的名字django默认找到id
    author_obj = models.Author.objects.filter(name="mike")[0]
    tom_obj = models.Author.objects.filter(name="tom")[0]
    jack_obj = models.Author.objects.filter(name="jacke")[0]
    book_obj.authors.add(author_obj, tom_obj, jack_obj)


    # 方式二：查出所有的作者
    pub_obj = models.Publish.objects.filter(name="邮电出版社").first()
    book_obj = models.Book.objects.create(title="零成本实现性能测试", publishDate="2018-08-08", price="225", publish=pub_obj)
    author_obj = models.Author.objects.all()
    # 绑定多对多关系
    book_obj.authors.add(*author_obj)

　　

解除绑定：remove： # 将某个特定的对象从被关联对象集合中去除。   

======   book_obj.authors.remove(*[]) 

 # 解除多对多的关系(remove)
    book_obj = models.Book.objects.filter(title="零成本实现性能测试").last()     # 找到书对象
    author_obj = models.Author.objects.filter(id__lt=3)     # 找到符合条件的作者对象
    book_obj.authors.remove(*author_obj)    # 因为清除是多条，得加*

　　

清除绑定：clear　　 #清空被关联对象集合。

# 清除关系方法（clear）
    book_obj = models.Book.objects.filter(title="人类简史")
    for book_obj_item in book_obj:
        book_obj_item.authors.clear()

总结：remove和clear的区别
　　remove：得吧你要清除的数据筛选出来，然后移除
　　clear：不用查，直接就把数据都清空了。
　　各有应用场景　　

三、基于对象的跨表查询（相当于sql语句的where子查询）

一对一查询记录：author和authordetail是一对一的关系

正向查询（按字段author）

反向查询（按表名authordetail）：因为是一对一的关系了，就不用set了

# 一对一的查询
    # 正向查询：手机好为15812345678的作者的姓名
    deital_obj = models.AuthorDetail.objects.filter(telephone="15812345678").first()
    print(deital_obj.author.name)

    # 反向查询：查询mike的手机号
    mike_obj = models.Author.objects.filter(name="mike").first()
    print(mike_obj.authorDetail.telephone)

　　

一对多查询记录：

正向查询（按字段：publish）：

反向查询（按表名：book_set):

# 一对多查询
    # 正向查询：查询“零成本实现性能测试”这本书的出版社的地址
    book_obj = models.Book.objects.filter(title="零成本实现性能测试")[0]     # 找对象
    print(book_obj.publish)     # 拿到的是关联出版社的对象
    print(book_obj.publish.city)

    # 反向查询：查询邮电出版社出版过的所有书的价格和名字
    pub_obj = models.Publish.objects.filter(name="邮电出版社")[0]
    book_dic = pub_obj.book_set.all().values("price", "title")[0]
    print(book_dic)
    print(book_dic["price"])

    # 查询邮电出版社出版过的所有书籍
    publish = models.Publish.objects.get(name="邮电出版社")      # get得到的直接是一个对象，不过get只能查看有一条记录
    book_list = publish.book_set.all()      # 与邮电出版社关联的所有书籍对象集合
    for book_obj in book_list:
        print(book_obj.title)

　　

多对多查询记录：

正向查询（按字段:authors）

反向查询（按表名：book_set)

 # 多对多查询
    # 正向查询：查询“人类简史”的这本书的所有作者的姓名和年龄
    book_obj = models.Book.objects.filter(title="人类简史").first()
    auth_list = book_obj.authors.all()
    for auth_obj in auth_list:
        print(auth_obj.name, auth_obj.age)

    # 反向查询：查询作者是Mike的这个人出了哪几本书的信息
    mike_obj = models.Author.objects.filter(name="mike").first()
    print(mike_obj.book_set.all().first().title)    # 与该作者关联的所有书对象的集合

　　

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

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

　　那么接下来就会如我们看到这般：

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

　　

四、基于双下划线的跨表查询

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

　一对多查询：

正向查询：按字段：publish

反向查询：按表名：book

练习1、查询邮电出版社出版过的所有的书的价格和名称

 # 第一种方法
    ret = models.Publish.objects.filter(name="机械工业出版社").values("book__price", "book__title")
    print(ret)

    # 第二种方法
    ret2 = models.Book.objects.filter(publish__name="邮电出版社").values("price", "title")
    print(ret2)

    # 查询某出版社出版过的所有的书籍
    ret2 = models.Book.objects.filter(publish__name="邮电出版社").all()　　

　

练习2、查询“人类简史”这本书的出版社的地址：filter先过滤，values显示要求的字段

  # 练习2、查询“人类简史”这本书的出版社的地址：filter先过滤，values显示要求的字段
    # 第一种方式
    ret = models.Book.objects.filter(title="人类简史").values("publish__city")
    print(ret)
    # 第二种方式
    ret2 = models.Publish.objects.filter(book__title="人类简史").values("city")
    print(ret2)　　

多对多查询

正向查询：按字段authors

反向查询：按表名：book

 # 练习1、查询mike出过的所有书的名字
    # 方式一
    ret = models.Author.objects.filter(name="mike").values("book__title")
    print(ret)
    # 方式二
    ret2 = models.Book.objects.filter(authors__name="mike").values("title")
    print(ret2)

　　

 # 练习2、查询手机号以158开头的作者出版过的所有书的名称以及出版社的名称
    # 方式一
    ret = models.AuthorDetail.objects.filter(telephone__startswith="158").first()
    print(ret.author.book_set.all().values("title", "publish__name"))
    print(ret)

    # 方式二
    ret = models.Book.objects.filter(authors__authorDetail__telephone__regex="158").values("title", "publish__name")
    print(ret)

　　连续跨表查询：

 # 练习3、查询邮电出版社出版过的所有书籍的名字以及作者的姓名
    # 正向查询
    ret = models.Book.objects.filter(publish__name='邮电出版社').values_list("title", "authors__name")
    print(ret)

    # 反向查询
    ret = models.Publish.objects.filter(name="邮电出版社").values_list("book__title", "book__authors__age", "book__authors__name")
    print(ret)

　　

related_name

反向查询时，如果定义了related_name,则用reated_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):只对一个组进行聚合

 # 计算所有图书的平均价格
    price_avg = models.Book.objects.all().aggregate(Avg('price'))
    print(price_avg)

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

print(models.Book.objects.aggregate(average_price=Avg('price')))
{'average_price': 174.625}

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

print(models.Book.objects.aggregate(Avg('price'), Max('price'), Min('price')))
{'price__avg': 174.625, 'price__max': Decimal('225'), 'price__min': Decimal('100')}

　　

分组：

##################### 单表分组查询 ############################

查询一个部门名称以及对应的员工数

sql语句：

select dep,Count(*) from emp group by dep;



ORM:

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

　　

##################### 多表分组查询 ############################

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 left 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成一张表，再按单表的思路进行分组查询。

查询练习：

(1) 练习：统计每一个出版社的最便宜的书

# 方式一
    print(models.Book.objects.values("publish__name").annotate(MinPrice=Min('price')))  # 注意：values内的字段即group by字段，也就是分组

    # 方式二
    print(models.Publish.objects.all().annotate(minprice=Min("book__price")).values("name", "minprice"))

    # 方式三
    publish_list = models.Publish.objects.annotate(MinPrice=Min("book__price"))
    for publish_obj in publish_list:
        print(publish_obj.name, publish_obj.MinPrice)

　　

(2) 练习：统计每一本书的作者个数

 # 方式一
    author_list = models.Book.objects.all().annotate(Count_author=Count("authors__name")).values("Count_author")
    print(author_list)


    # 方式二
    book_list = models.Book.objects.all().annotate(authorNum=Count("authors__name"))
    for book_obj in book_list:
        print(book_obj.title, book_obj.authorNum)

　　

(3)   统计每一本以py开头的书籍的作者个数

# (3)   统计每一本以py开头的书籍的作者个数：
    book_list = models.Book.objects.all().filter(title__startswith="Py").annotate(authorNum=Count("authors__name"))
    for book_obj in book_list:
        print(book_obj.title, book_obj.authorNum)

　　

(4) 统计不止一个作者的图书

author_obj = models.Book.objects.annotate(num_authors=Count('authors')).filter(num_authors__gt=1)
    print(author_obj)

　　

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

  author_boj = models.Book.objects.annotate(num_authors=Count('authors')).order_by('num_authors')
    print(author_boj)

　　

(6) 查询各个作者出的书的总价格:

ret = models.Author.objects.annotate(SumPrice=Sum("book__price")).values_list("name", "SumPrice")
    print(ret)

　　

六、F查询和Q查询

F查询

在上面所有的例子中，我们构造的过滤器都只是将字段值与某个常量做比较。如果我们要对两个字段的值做比较，那该怎么做呢？

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

1、查看评论数大于阅读数的书

 from django.db.models import F,Q
print(models.Book.objects.filter(commentNum__gt=F("readNum")))

　

2、修改操作也可以使用F函数,比如将id大于1的所有的书的价格涨价100元

print(models.Book.objects.filter(id__gt=1).update(price=F("price")+100))

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

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

　　

Q查询：

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

1、查询id大于1并且评论数大于100的书

 print(models.Book.objects.filter(nid__gt=1,commentNum__gt=100))
 print(models.Book.objects.filter(nid__gt=1).filter(commentNum__gt=100))
 print(models.Book.objects.filter(Q(nid__gt=1)&Q(commentNum__gt=100)))

2、查询评论数大于100或者阅读数小于200的书　　

print(models.Book.objects.filter(Q(commentNum__gt=100)|Q(readNum__lt=200)))
Q 对象可以使用& 和| 操作符组合起来。当一个操作符在两个Q 对象上使用时，它产生一个新的Q 对象。

3、查询年份等于2017年或者价格大于200的书

print(models.Book.objects.filter(Q(publishDate__year=2017)|Q(price__gt=200)))

4、查询年份不是2017年或者价格大于200的书

print(models.Book.objects.filter(~Q(publishDate__year=2017)&Q(price__gt=200)))

　　

注意：

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

 bookList=models.Book.objects.filter(Q(publishDate__year=2016) | Q(publishDate__year=2017),  title__icontains="python"  )