一、创建对象模型
表和表之间的关系
一对一、多对一、多对多 ，用book表和publish表自己来想想关系，想想里面的操作，加外键约束和不加外键约束的区别，一对一的外键约束是在一对多的约束上加上唯一约束。
实例：我们来假定下面这些概念，字段和关系
作者模型：一个作者有姓名和年龄。
作者详细模型：把作者的详情放到详情表，包含生日，手机号，家庭住址等信息。作者详情模型和作者模型之间是一对一的关系（one-to-one）
出版社模型：出版社有名称，所在城市。
书籍模型： 书籍有书名和价钱，一本书可能会有多个作者，一个作者也可以写多本书，所以作者和书籍的关系就是多对多的关联关系(many-to-many);
一本书只应该由一个出版社出版，所以出版社和书籍是一对多关联关系(one-to-many)。
模型建立：
# 作者 class Author(models.Model): name = models.CharField(max_length=32) age = models.IntegerField() # 与作者信息表建立一对一的关系 authorDetail = models.OneToOneField(to="AuthorDetail") # 作者的详细信息 class AuthorDetail(models.Model): birthday = models.DateField() telephone = models.BigIntegerField() addr = models.CharField(max_length=64) # 出版社 class Publish(models.Model): name=models.CharField( max_length=32) city=models.CharField( max_length=32) # 书籍 class Book(models.Model): title = models.CharField( max_length=32) price=models.DecimalField(max_digits=5,decimal_places=2) # 与出版社建立一对多的关系 publish = models.ForeignKey(to="Publish") # 与作者建立多对多的关系 author = models.ManyToManyField(to="Author")
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 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=models.ForeignKey(to="Publish",to_field="nid",on_delete=models.CASCADE) #foreignkey里面可以加很多的参数，都是需要咱们学习的，慢慢来，to指向表，to_field指向你关联的字段，不写这个，默认会自动关联主键字段，on_delete级联删除 字段名称不需要写成publish_id，orm在翻译foreignkey的时候会自动给你这个字段拼上一个_id,这个字段名称在数据库里面就自动变成了publish_id # 与Author表建立多对多的关系,ManyToManyField可以建在两个模型中的任意一个，自动创建第三张表，并且注意一点，你查看book表的时候，你看不到这个字段，因为这个字段就是创建第三张表的意思，不是创建字段的意思，所以只能说这个book类里面有authors这个字段属性 authors=models.ManyToManyField(to='Author',) #注意不管是一对多还是多对多，写to这个参数的时候，最后后面的值是个字符串，不然你就需要将你要关联的那个表放到这个表的上面
写入数据顺序：
1、先将作者详细信息数据写入数据库
authorDetail表：
2、在写入作者信息并关联authorDetail表(一对一)：
author表:
3、写入出版社数据(因为书籍表需要关联出版社,所以先要写入出版社数据):
publish表:
4、写入书籍数据(并与出版社建立多对一的关系):
5、因为我们在创建book表时与author表建立了多对多的关系:
author = models.ManyToManyField(to="Author") orm会自动帮我们创建第三张表: 表名:应用名_book_author 字段名:book_id author_id
二、数据的增删改
多对一：
from app01 import models def index(request): # 西瓜出版社出版了 天龙八部和倚天屠龙记这两本书 # 分别用两种方法添加数据 # 方法一 拿到出版社的model对象,作为值传给了publish,其实就是将publish字段自动变成了publish_id,然后将publish_obj取出来的结果赋给了变形后的publish也就是publish_id publish_obj = models.Publish.objects.get(name="西瓜出版社") book_obj = models.Book.objects.create(title="天龙八部",price=700,publish=publish_obj) # 方法二 直接指定出版社id book_obj = models.Book.objects.create(title="倚天屠龙记",price=700,publish_id=2) return HttpResponse("ok")
#删除记录和更新记录和单表都是一样的 models.Book.objects.filter(id=1).delete() models.Book.objects.filter(id=2).update(price=998)
一对一：
models.Author.objects.create(name="超",age=30,authorDetail_id=5) 注意：一对一添加的authorDetail_id,在author中是唯一的,
#更新和删除 models.Author.objects.filter(id=3).update(age=66) models.Author.objects.filter(id=3).delete()
多对多：
方式一：
# 绑定多对多关系,即向关系表book_author中添加纪录,给id=8的书添加两个作者,下面的语法就是告诉orm给第三张表添加两条数据 book_obj = models.Book.objects.get(id=8) # 列表中的是作者的id book_obj.author.add(*[1,3])
方式二：
# 当前生成的书籍对象 book_obj = models.Book.objects.get(id=3)
# 为书籍绑定的做作者对象,在Author表中主键为3/4的纪录，注意取的是author的model对象 chao = models.Author.objects.filter(id=3).first() eva = models.Author.objects.filter(id=4).first()
# 将某些特定的 model 对象添加到被关联对象集合中 book_obj.author.add(chao,eva) # 其实orm就是先通过book_obj的authors属性找到第三张表，然后将book_obj的id值和两个作者对象的id值组合成两条记录添加到第三张表里面去
其他操作：
# 当前生成的书籍对象,要给哪个书添加作者就查找哪个书
book_obj = models.Book.objects.get(id=3)
book_obj.author.remove(*[3,4]) # 删除不存在的关联也不会报错
book_obj.authors.clear() # 全部清除
book_obj.author.set(['3','6']) # 清空所有的book_id为3的第三张表里面的所有记录,再重新写上book_id为3的对应的author_id为3/6的关系记录
三、基于对象的跨表查询
正反查询：关联属性字段所在的表查询被关联表的记录就是正向查询，反之就是反向查询
一对多：
# 正向查询, 查询book id为2的书籍的出版社所在的城市 book_obj = models.Book.objects.get(id=2) # 直接通过点类属性找到第三张表 在点第三张表里的字段名 ret = book_obj.publish.city print(ret) # 沙河
# 反向查询 红浪漫出版社出版过哪些书籍 publish_obj =models.Publish.objects.filter(name="红浪漫出版社").first() # 小写的类名_set book_list = publish_obj.book_set.all() # 得到queryset对象 print(book_list) # <QuerySet [<Book: c>, <Book: 倚天屠龙记>]>
一对一：
# 正向查询 wusir是哪个城市的, author_obj = models.Author.objects.get(name="wusir") ad = author_obj.authorDetail.addr print(ad) # 沙河
# 反向查询 看看谁在于辛庄 addr = models.AuthorDetail.objects.get(addr="于辛庄") # 一对一查询直接小写类名.属性 name = addr.author.name print(name)
多对多：
# 正向查询的: python的作者是谁 book_obj = models.Book.objects.filter(title="go")[0] author_obj = book_obj.author.all() for i in author_obj: print(i.name)
# 反向查询: wusir写了哪些书 author_obj = models.Author.objects.filter(name="wusir")[0] book_list = author_obj.book_set.all() for i in book_list: print(i.title)
小结：
# 正向查询都是通过点关系字段来查找到另一个表的 # 反向查询是通过点小写的类名_set,只有一对一才不用set,因为一对一查询只有一条数据 # 一对多和多对多 正向查询 对象.关系字段.all()或字段名 # 反向查询 对象.小写类名_set.all() # 一对一 正向查询 对象.关系字段.字段名 # 反向查询 对象.关系字段.字段名
四、基于双下划线的跨表查询
Django 还提供了一种直观而高效的方式在查询(lookups)中表示关联关系，它能自动确认 SQL JOIN 联系。要做跨关系查询，就使用两个下划线来链接模型(model)间关联字段的名称，直到最终链接到你想要的model 为止。
''' 基于双下划线的查询就一句话：正向查询按字段,反向查询按表名小写用来告诉ORM引擎join哪张表,一对一、一对多、多对多都是一个写法，注意，我们写orm查询的时候，哪个表在前哪个表在后都没问题，因为走的是join连表操作。 '''
一对一
# 一对一 # 查看alex地址在哪 # 正向查询 ret = models.Author.objects.filter(name="alex").values("authorDetail__addr") # <QuerySet [{'authorDetail__addr': '汇德商厦'}]> # 反向查询 res = models.AuthorDetail.objects.filter(author__id=1).values("addr") # <QuerySet [{'addr': '汇德商厦'}]> print(ret) print(res)
一对多
# 多对一 # 查看python是由哪个出版社出版的 # 正向查询 ret = models.Book.objects.filter(title="python").values("publish__name") # <QuerySet [{'publish__name': '小苹果出版社'}]> print(ret) # 反向查询 res = models.Publish.objects.filter(book__title="python").values("name") # <QuerySet [{'name': '小苹果出版社'}]> print(res) # ----------------------------------------------------------------------------- # 一对多 # 老男孩出版社出了哪些书 # 反向查询 ret = models.Publish.objects.filter(name="老男孩出版社").values("book__title") # <QuerySet [{'book__title': 'linux'}, {'book__title': 'go'}, {'book__title': 'java'}, {'book__title': '唐伯虎点秋香'}]> print(ret) # 正向查询 res = models.Book.objects.filter(publish__name="老男孩出版社").values("title") # <QuerySet [{'title': 'linux'}, {'title': 'go'}, {'title': 'java'}, {'title': '唐伯虎点秋香'}]> #通过__告诉orm将book表和publish表进行join，然后找到所有记录中publish.name='老男孩出版社'的记录（注意publish是属性名称），然后select book.title的字段值 print(res)
多对多
# 多对多 # wusir写了哪些书 # 反向查询 ret = models.Author.objects.filter(name="wusir").values("book__title") # <QuerySet [{'book__title': 'linux'}, {'book__title': 'c'}, {'book__title': 'java'}]> print(ret) # 正向查询 res = models.Book.objects.filter(author__name="wusir").values("title") # <QuerySet [{'title': 'linux'}, {'title': 'c'}, {'title': 'java'}]> print(res)
# 正向查询
res = models.Book.objects.filter(publish__name="老男孩出版社").values("title")
# <QuerySet [{'title': 'linux'}, {'title': 'go'}, {'title': 'java'}, {'title': '唐伯虎点秋香'}]>
# 通过__告诉orm将book表和publish表进行join，然后找到所有记录中publish.name='老男孩出版社'的记录（注意publish是属性名称），然后select book.title的字段值
print(res)
双下划线跨表查询：
比如书和作者这种多对多的关系:
`wusir写了哪些书`
正向查询:
`res = models.Book.objects.filter(author__name="wusir").values("title")`
筛选条件：直接通过属性author__告诉orm将book表与author表连接到一起,然后找到所有记录中author.name="wusir"的记录, 最后查询select book.title的字段得到最后结果;
反向查找:
`ret = models.Author.objects.filter(name="wusir").values("book__title")`
筛选条件：先通过条件进行筛选,然后通过小写的表名__，将Author表与book表连接,最后通过连接后的表取book.title;正向查询按字段,反向查询按小写表名
连续跨表
# 连续跨表 # 查询红浪漫出版社出版过的所有书籍的名字以及作者的姓名 # 反向查询 ret = models.Publish.objects.filter(name="红浪漫出版社").values("book__title","book__author__name") # <QuerySet [{'book__title': 'c', 'book__author__name': 'wusir'}, # {'book__title': '倚天屠龙记', 'book__author__name': 'alex'}, # {'book__title': '倚天屠龙记', 'book__author__name': 'chao'}]> # 倚天屠龙记是alex和chao一起写的 print(ret) # 正向查询 ret = models.Book.objects.filter(publish__name="红浪漫出版社").values("title","author__name") # <QuerySet [{'title': 'c', 'author__name': 'wusir'}, ] # {'title': '倚天屠龙记', 'author__name': 'alex'}, # {'title': '倚天屠龙记', 'author__name': 'chao'}]> print(ret)
所有查询都要看给出的条件:
作者和书的关系|多对多
两张表book和author
关系字段在book表中,关联着author表
条件：chao写了哪些书？
分析：
如果我们从book表中开始查找：
因为chao不在Book表中,所以我们需要先连表后才能取到title,这里的author是存在Book表中属性,不是类名
res = models.Book.objects.filter(author__name="chao").values("title")
related_name
反向查询时，如果定义了related_name ，则用related_name替换 表名，例如： publish = ForeignKey(Blog, related_name='bookList')
五、聚合查询、分组查询、F查询和Q查询
聚合
aggregate(*args, **kwargs)
# 计算所有图书的平均价格
>>> from django.db.models import Avg
>>> Book.objects.all().aggregate(Avg('price')) #或者给它起名字：aggretate(a=Avg('price'))
{'price__avg': 34.35}
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')}
F查询和Q查询
导入模块：
from django.db.models import F,Q
F查询
在上面所有的例子中，我们构造的过滤器都只是将字段值与某个常量做比较。如果我们要对两个字段的值做比较，那该怎么做呢？我们在book表里面加上两个字段：评论数：commentNum，收藏数：KeepNum
Django 提供 F() 来做这样的比较。F() 的实例可以在查询中引用字段，来比较同一个 model 实例中两个不同字段的值。
# 查询评论数大于收藏数的书籍
from django.db.models import F
Book.objects.filter(commentNum__lt=F('keepNum'))
Django 支持 F() 对象之间以及 F() 对象和常数之间的加减乘除和取模的操作。
# 查询评论数大于收藏数2倍的书籍
Book.objects.filter(commentNum__lt=F('keepNum')*2)
修改操作也可以使用F函数,比如将每一本书的价格提高30元：
Book.objects.all().update(price=F("price")+30)
# 将价钱大于50的价格减去20
models.Book.objects.filter(price__gt=50).update(price = F("price")-20)
Q查询
filter() 等方法中的关键字参数查询都是一起进行“AND” 的。 如果你需要执行更复杂的查询（例如OR 语句），你可以使用Q 对象。
from django.db.models import Q Q(title__startswith='Py') # title中以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) 查询：
# 价格等于50且评论数等于20 ret = models.Book.objects.filter(Q(price__gt=50)&Q(comment__gt=20)) # 价格大于50或评论数大于20 ret = models.Book.objects.filter(Q(price__gt=50)|Q(comment__gt=20)) # 价格大于50或评论数小于20 ret = models.Book.objects.filter(Q(price__gt=50)|~Q(comment__gt=20))
查询函数可以混合使用Q 对象和关键字参数。所有提供给查询函数的参数（关键字参数或Q 对象）都将"AND”在一起。但是，如果出现Q 对象，它必须位于所有关键字参数的前面。例如：
bookList=Book.objects.filter(Q(publishDate__year=2016) | Q(publishDate__year=2017),
title__icontains="python" #也是and的关系，但是Q必须写在前面
)
分组
查询条件中带每字的多数都需要分组
注意：values里的字段是分组依据,根据什么分组；annotate根据分组后进行统计；
annotate()为调用的QuerySet中每一个对象都生成一个独立的统计值（统计方法用聚合函数）。
跨表分组查询本质就是将关联表join成一张表，再按单表的思路进行分组查询,，既然是join连表，就可以使用咱们的双下划线进行连表了。
注意：annotate里面必须写个聚合函数，不然没有意义，并且必须有个别名=，别名随便写，但是必须有，用哪个字段分组，values里面就写哪个字段,annotate其实就是对分组结果的统计，统计你需要什么。
单表分组
from django.db.models import Min # 分组查询 ret = models.Book.objects.values("title").annotate(c=Min("price")) """ <QuerySet [{'title': 'python', 'c': Decimal('180.00')}, {'title': 'linux', 'c': Decimal('32.00')}, {'title': 'go', 'c': Decimal('50.00')}, {'title': 'c', 'c': Decimal('3.00')}, {'title': 'web', 'c': Decimal('40.00')}, {'title': 'java', 'c': Decimal('9.00')}, {'title': '倚天屠龙记', 'c': Decimal('680.00')}, {'title': '唐伯虎点秋香', 'c': Decimal('313.00')}]> """ # values中写分组的字段，annotate中写需要统计的字段(必须写个聚合函数),annotate根据values分组后进行统计 print(ret)
多表分组
# 查询出版社的名称,和每个出版社出版的书的最高价格 from django.db.models import Max,Min # 正向查询：根据出版社的名字进行分组,因为出版社的名字的字段不在Book里所以需要先连表 ret = models.Book.objects.values("publish__name").annotate(a = Max("price")) """ <QuerySet [{'publish__name': '老男孩出版社', 'a': Decimal('313.00')}, {'publish__name': '红浪漫出版社', 'a': Decimal('680.00')}, {'publish__name': '小苹果出版社', 'a': Decimal('180.00')}, {'publish__name': '西瓜出版社', 'a': Decimal('40.00')}]> """ print(ret) # 反向查询:根据出版社的名字进行分组,因为出版社的名字的字段在publish里,所以直接通过名字进行分组,分组后在连表在book里取price字段的值 ret = models.Publish.objects.values("name").annotate(a = Max("book__price")) """ <QuerySet [{'publish__name': '老男孩出版社', 'a': Decimal('313.00')}, {'publish__name': '红浪漫出版社', 'a': Decimal('680.00')}, {'publish__name': '小苹果出版社', 'a': Decimal('180.00')}, {'publish__name': '西瓜出版社', 'a': Decimal('40.00')}]> """ print(ret)
特殊分组不带values：
# 特殊分组 # 统计出每一个出版社最贵的书 ret = models.Publish.objects.annotate(p=Max("book__price")).values("name","p") print(ret) # 先将publish和book连接起来然后根据publish的主键进行分组,分组后进行统计;取值取的是统计后的值 """ <QuerySet [{'name': '老男孩出版社', 'p': Decimal('313.00')}, {'name': '红浪漫出版社', 'p': Decimal('680.00')}, {'name': '小苹果出版社', 'p': Decimal('180.00')}, {'name': '西瓜出版社', 'p': Decimal('40.00')}]> """
凡是遇到表名__都是先连表后操作：
六、ORM执行原生SQL语句的两种方法
在模型查询API不够用的情况下，我们还可以使用原始的SQL语句进行查询。
Django 提供两种方法使用原始SQL进行查询：一种是使用raw()方法，进行原始SQL查询并返回模型实例；另一种是完全避开模型层，直接执行自定义的SQL语句。
执行原生查询-----都是在views中执行
raw()管理器方法用于原始的SQL查询，并返回模型的实例：
注意：raw()语法查询必须包含主键。
这个方法执行原始的SQL查询，并返回一个django.db.models.query.RawQuerySet 实例。 这个RawQuerySet 实例可以像一般的QuerySet那样，通过迭代来提供对象实例。
举个例子：
class Person(models.Model):
first_name = models.CharField(...)
last_name = models.CharField(...)
birth_date = models.DateField(...)
可以像下面这样执行原生SQL语句
>>> for p in Person.objects.raw('SELECT * FROM myapp_person'):
... print(p)
raw()查询可以查询其他表的数据。
举个例子：
ret = models.Student.objects.raw('select id, tname as hehe from app02_teacher')
for i in ret:
print(i.id, i.hehe)
raw()方法自动将查询字段映射到模型字段。还可以通过translations参数指定一个把查询的字段名和ORM对象实例的字段名互相对应的字典
d = {'tname': 'haha'}
ret = models.Student.objects.raw('select * from app02_teacher', translations=d)
for i in ret:
print(i.id, i.sname, i.haha)
原生SQL还可以使用参数，注意不要自己使用字符串格式化拼接SQL语句，防止SQL注入！
d = {'tname': 'haha'}
ret = models.Student.objects.raw('select * from app02_teacher where id > %s', translations=d, params=[1,])
for i in ret:
print(i.id, i.sname, i.haha)
直接执行自定义SQL
有时候raw()方法并不十分好用，很多情况下我们不需要将查询结果映射成模型，或者我们需要执行DELETE、 INSERT以及UPDATE操作。在这些情况下，我们可以直接访问数据库，完全避开模型层。
我们可以直接从django提供的接口中获取数据库连接，然后像使用pymysql模块一样操作数据库。
from django.db import connection cursor = connection.cursor() sql = "select title from app01_book;" cursor.execute(sql) ret = cursor.fetchall() print(ret) # (('python',), ('linux',), ('go',), ('c',), ('web',), ('java',), ('倚天屠龙记',), ('唐伯虎点秋香',))
七、Python脚本中调用Django环境(django外部脚本使用models)
如果你想通过自己创建的python文件在django项目中使用django的models，那么就需要调用django的环境：
import os if __name__ == '__main__': os.environ.setdefault("DJANGO_SETTINGS_MODULE", "orm_multi.settings") import django django.setup() from app01 import models #引入也要写在上面三句之后 books = models.Book.objects.all() print(books)
注意重点记：
查询：每个作者出版的所有书最高价格的那本书的名称
如果先分组,在取值,我们取的名字永远都是组内名字的第一个名字
连表后： 我们需要先按照价格从大到小进行排序,然后在分组取值, 因为排序后每个组内的价格最高的都是在第一位,这样在我们取值时即使取到的组内的第一位,也是分组内最大的值
先连表根据book_price进行从大到小排序：
select * from app01_author INNER JOIN app01_book_author on app01_author.id = app01_book_author.author_id INNER JOIN app01_book on app01_book.id=app01_book_author.book_id ORDER BY app01_book.price desc;
取出我们想要的内容：
select app01_author.id,app01_book.title,app01_book.price from app01_author INNER JOIN app01_book_author on app01_author.id = app01_book_author.author_id INNER JOIN app01_book on app01_book.id=app01_book_author.book_id ORDER BY app01_book.price desc;
最后进行分组取出最高价格那本书的名称
select title,price from (select app01_author.id,app01_book.title,app01_book.price from app01_author INNER JOIN app01_book_author on app01_author.id = app01_book_author.author_id INNER JOIN app01_book on app01_book.id=app01_book_author.book_id ORDER BY app01_book.price desc) as b GROUP BY id;
