一、创建对象模型
表和表之间的关系
一对一、多对一、多对多 ，用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表建立了多对多的关系:
|
1
2
3
4
5
|
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")
|
1
2
3
|
#删除记录和更新记录和单表都是一样的
models.Book.objects.
filter
(
id
=
1
).delete()
models.Book.objects.
filter
(
id
=
2
).update(price
=
998
)
|
一对一：
|
1
2
3
|
models.Author.objects.create(name
=
"超"
,age
=
30
,authorDetail_id
=
5
)
注意：一对一添加的authorDetail_id,在author中是唯一的,
|
|
1
2
3
|
#更新和删除
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值组合成两条记录添加到第三张表里面去
其他操作：
|
1
2
3
4
5
|
# 当前生成的书籍对象,要给哪个书添加作者就查找哪个书
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)
|
1
2
3
4
5
6
|
# 正向查询
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)
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
双下划线跨表查询：
比如书和作者这种多对多的关系:
`wusir写了哪些书`
正向查询:
`res
=
models.Book.objects.
filter
(author__name
=
"wusir"
).values(
"title"
)`
筛选条件：直接通过属性author__告诉orm将book表与author表连接到一起,然后找到所有记录中author.name
=
"wusir"
的记录, 最后查询select book.title的字段得到最后结果;<br>反向查找:
`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)
所有查询都要看给出的条件:
|
1
2
3
4
5
6
7
8
9
10
|
作者和书的关系|多对多
两张表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)
|
1
2
3
4
|
# 计算所有图书的平均价格
>>>
from
django.db.models
import
Avg
>>> Book.objects.
all
().aggregate(Avg(
'price'
))
#或者给它起名字：aggretate(a=Avg('price'))
{
'price__avg'
:
34.35
}
|
aggregate()是QuerySet 的一个终止子句，意思是说，它返回一个包含一些键值对的字典。键的名称是聚合值的标识符，值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的。如果你想要为聚合值指定一个名称，可以向聚合子句提供它。
|
1
2
|
>>> Book.objects.aggregate(average_price
=
Avg(
'price'
))
{
'average_price'
:
34.35
}
|
如果你希望生成不止一个聚合，你可以向aggregate()子句中添加另一个参数。所以，如果你也想知道所有图书价格的最大值和最小值，可以这样查询：
|
1
2
3
|
>>>
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查询
导入模块：
|
1
|
from
django.db.models
import
F,Q
|
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
2
3
4
|
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 对象。
|
1
2
|
from
django.db.models
import
Q
Q(title__startswith
=
'Py'
)
# title中以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
2
3
4
5
6
|
# 价格等于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 对象，它必须位于所有关键字参数的前面。例如：
|
1
2
3
|
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)
注意重点记：
查询：每个作者出版的所有书最高价格的那本书的名称
如果先分组,在取值,我们取的名字永远都是组内名字的第一个名字
|
1
2
3
|
连表后：
我们需要先按照价格从大到小进行排序,然后在分组取值,
因为排序后每个组内的价格最高的都是在第一位,这样在我们取值时即使取到的组内的第一位,也是分组内最大的值
|
先连表根据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;
